├── Analisi PCA e Kmeans del dataset Iris.ipynb ├── Analisi dei dati con Apache Hive e Pig.ipynb ├── Analisi dei dati in PySpark.ipynb ├── Apriori e sue varianti.ipynb ├── Configurazione dell'ambiente Python.ipynb ├── Data Cubes.ipynb ├── Data ├── .ipynb_checkpoints │ └── tutorial_model-checkpoint.json ├── IBRD_Balance_Sheet__FY2010.csv ├── IMDB-Movie-Data.csv ├── SalesJan2009.csv ├── Spark-ML │ ├── test.csv │ └── train.csv ├── anagrafica.csv ├── dischi.csv ├── dischi.json ├── example.log ├── galaxy.jpg ├── myoutput.txt ├── persone.csv ├── persone.json ├── persone1.csv ├── titanic.csv └── tutorial_model.json ├── Deep Learning con Keras TF.ipynb ├── Esercitazione CNN ├── CDK1.csv ├── applicazioni reti convoluzionali.pdf ├── esercitazione_151222.ipynb └── esercitazione_MOL_1512.txt ├── Esercitazione NLP Transformer ├── Esercitazione_classificazione.ipynb ├── Esercitazione_pre_processing.ipynb ├── RNN and Trasformers in NLP.pdf ├── TRAIN_FILE-SemEval.TXT └── bbc-text.csv ├── Esercitazioni Hadoop ├── .DS_Store ├── SurvivedPassengers │ ├── .DS_Store │ ├── .vscode │ │ └── settings.json │ ├── README.md │ ├── SurvivedPassengers.jar │ └── src │ │ ├── .DS_Store │ │ └── survivedpassengers │ │ ├── SurvivedPassengersDriver.java │ │ ├── SurvivedPassengersMap.java │ │ └── SurvivedPassengersReduce.java ├── csv transform.hql ├── percentage_pig.js ├── percentage_pig.py └── survived_passengers.pig ├── Integrazione Kafka Spark.ipynb ├── Introduzione a Pandas.ipynb ├── LICENSE ├── Lezioni teoriche ├── .ipynb_checkpoints │ └── 2. Richiami di Teoria della Probabilita'-checkpoint.pdf ├── 0. Introduzione al corso.pdf ├── 1. Introduzione al Data Processing.pdf ├── 10. MongoDB.pdf ├── 11. Cassandra.pdf ├── 12. Hadoop.pdf ├── 13. Spark.pdf ├── 14. Introduzione al ML.pdf ├── 15. Clustering.pdf ├── 16. Classificatori.pdf ├── 16.bis. Mining Web Data.pdf ├── 17. Introduzione al Deep Learning.pdf ├── 2. Richiami di Teoria della Probabilità.pdf ├── 3. Preparazione dei Dati.pdf ├── 4. Misure di Similarita'.pdf ├── 5. Stimatori, Stima e Campionamento.pdf ├── 6. Mining di Pattern frequenti.pdf ├── 7. Data Warehousing.pdf ├── 8. Introduzione a HDFS.pdf └── 9. Database NoSQL.pdf ├── Libri di testo └── README.md ├── Machine Learning in Spark.ipynb ├── Map Reduce in MongoDB.ipynb ├── Multivariate Gaussian and Covariance matrix.ipynb ├── NumPy e Matplotlib.ipynb ├── Operazioni CRUD MongoDB.ipynb ├── Operazioni CRUD in Cassandra.ipynb ├── Progetti di esame ├── Descrizione del progetto 2019-2020 invernale.docx └── Descrizione del progetto di esame 2020-2021.md ├── Python programming 1.ipynb ├── Python programming 2.ipynb ├── Python programming 3.ipynb ├── Python programming 4.ipynb ├── Python programming 5.ipynb ├── Python programming ├── hello.py ├── linear_merge.py ├── mymodule.py ├── mypackage │ ├── .ipynb_checkpoints │ │ ├── __init__-checkpoint.py │ │ └── module1-checkpoint.py │ ├── __init__.py │ ├── __pycache__ │ │ ├── __init__.cpython-37.pyc │ │ └── module1.cpython-37.pyc │ ├── module1.py │ └── mysubpackage │ │ ├── .ipynb_checkpoints │ │ ├── __init__-checkpoint.py │ │ └── module2-checkpoint.py │ │ ├── __init__.py │ │ ├── __pycache__ │ │ ├── __init__.cpython-37.pyc │ │ └── module2.cpython-37.pyc │ │ └── module2.py ├── tail.py └── test.py ├── README.md ├── Stima e campionamento.ipynb ├── Uso di HDFS.ipynb ├── Widget example.ipynb ├── kafka_python ├── consumer.py ├── producer.py ├── spark_batch_processing.py └── spark_stream_processing.py ├── mnist_logistic_regression.ipynb ├── mnist_logistic_regression_tf1.ipynb └── tensorflow.ipynb /Configurazione dell'ambiente Python.ipynb: -------------------------------------------------------------------------------- 1 | { 2 | "cells": [ 3 | { 4 | "cell_type": "markdown", 5 | "metadata": { 6 | "pycharm": { 7 | "is_executing": false, 8 | "name": "#%% md\n" 9 | } 10 | }, 11 | "source": [ 12 | "# Installazione e configurazione dell'ambiente Python\n", 13 | "\n", 14 | "Il linguaggio Python è un linguaggio orientato agli oggetti molto versatile ed orientato alle applicazioni di _Data Science_ e _Machine Learning_. Storicamente si è evoluto in due versioni, Python 2 e Python 3, le quali hanno leggere \n", 15 | " di sintassi, ma sono entrqmbe ancora supportate per motivi di compatibilità con i pacchetti software costruiti su tale linguaggio. Nel nostro corso adotteremo Python 3 per cui le istruzioni seguenti valgono per questo linguaggio.\n", 16 | "\n", 17 | "## Installazione\n", 18 | "\n", 19 | "Python si installa in maniera differente per i diversi sistemi operativi, ma la distribuzione segue fondamentalmente i canoni di un pacchetto Linux.\n", 20 | "\n", 21 | "- **Windows**: \n", 22 | " - Scaricare la versione di Python 3 più recente dal [sito di Python](https://www.python.org/downloads/windows/)\n", 23 | " - Estrarre il pacchetto ed eseguire l'installer, facendo attenzione ad attivare le caselle di spunta che chiedono di aggiungere la cartella che contiene l'eseguibile al `PATH` di sistema e di installare Python per tutti gli utenti\n", 24 | " - La distribuzione si troverà di default in `C:\\Users\\[username]\\AppData\\Local\\Programs\\Python\\Python3X` dove `X` si riferisce alla sub-versione di Python 3; in questa cartella si troverà anche il gestore di pacchetti `pip`\n", 25 | "\n", 26 | "- **Linux**:\n", 27 | " - Utlizzare `apt` come utente amministratore e digitare:\n", 28 | " ```\n", 29 | " sudo apt update\n", 30 | " sudo apt install python3 python3-pip\n", 31 | " ```\n", 32 | " ovviamente verranno installate diverse dipendenze che dovranno essere accettate\n", 33 | "- **MacOS**:\n", 34 | " - Installare il gestore di pacchetti `brew` dal suo repository `Git`, ove non sia già installato:\n", 35 | " ```\n", 36 | " /usr/bin/ruby -e \"$(curl -fsSL https://raw.githubusercontent.com/Homebrew/install/master/install)\"\n", 37 | " ```\n", 38 | " - Installare `python` con `pip` e `setuptools` digitando:\n", 39 | "```\n", 40 | "brew install python\n", 41 | "```\n", 42 | "Il pacchetto `python` si riferisce direttamente a Python 3; per l'installazione di Python 2 usare `brew install python2`.\n", 43 | "\n", 44 | "### Breve nota su `brew` per MacOS \n", 45 | "\n", 46 | "`brew` è un potente gestore di pacchetti Linux, in generale non direttamente disponibili per MacOS, il quale gestisce una propria struttura di cartelle, ma installa dei link simbolici alle applicazioni e/o librerie in `/usr/local`, cioè all'interno del `PATH` di sistema: ciò è comodo per le applicazioni che utilizzano tali pacchetti. \n", 47 | "\n", 48 | "Alcuni comandi di base:\n", 49 | "\n", 50 | " - `brew install ` installa il pacchetto\n", 51 | " - `brew search ` ricerca informazioni sul pacchetto\n", 52 | "\n", 53 | "Per approfondimenti si consulti il [sito di brew](https://brew.sh/)\n", 54 | "\n", 55 | "## Utilizzo dell'ambiente Python\n", 56 | "\n", 57 | "L'ambiente Python così installato consente di eseguire script Python in forma interattiva da terminale digitando:\n", 58 | "```\n", 59 | "$ python .py [argomenti]\n", 60 | "```\n", 61 | "In alternativa si può accedere alla console interattiva digitando semplicemente il comando `python` alprompt e ricevendo una risposta del tipo:\n", 62 | "```\n", 63 | "Python 3.7.3 | packaged by conda-forge | (default, Jul 1 2019, 14:38:56) \n", 64 | "[Clang 4.0.1 (tags/RELEASE_401/final)] :: Anaconda, Inc. on darwin\n", 65 | "Type \"help\", \"copyright\", \"credits\" or \"license\" for more information.\n", 66 | ">>> \n", 67 | "```\n", 68 | "Nella console interattiva è possibile scrivere ed eseguire singoli comandi o interi script\n", 69 | "```\n", 70 | ">>> 3+2\n", 71 | "5\n", 72 | ">>> a=3\n", 73 | ">>> a+5\n", 74 | "8\n", 75 | ">>> w=a**3\n", 76 | ">>> print(w)\n", 77 | "27\n", 78 | ">>> x=[1,2,3]\n", 79 | ">>> print(x)\n", 80 | ">>> [1,2,3]\n", 81 | ">>> def raiseToPower(x,y):\n", 82 | "... res = []\n", 83 | "... for i in x:\n", 84 | "... res.append(i**y)\n", 85 | "... return res\n", 86 | "... \n", 87 | ">>> raiseToPower([3,4,5],2)\n", 88 | "[9, 16, 25]\n", 89 | ">>> \n", 90 | "```\n", 91 | "L'ambiente è completato dal gestore di pacchetti `pip` che utilizza il repository [Python Package Index (PyPI)](https://pypi.org/). Di seguito alcuni comandi di base per l'utilizzo di `pip`:\n", 92 | "\n", 93 | "- `pip install [version_expr]` installa il pacchetto richiesto alla versione che risulta dalla valutazione di `version_expr`; se quest'ultima non è presente, viene installata l'ultima versione, altrimenti alcune possibilità sono\n", 94 | " - `==X.Y.Z` installa la versione X.Y.Z\n", 95 | " - `>=X.Y.Z` installa una versione superiore o uguale a X.Y.Z\n", 96 | " - `>=X.Y.Z,` aggiorna il pacchetto\n", 99 | "- `pip uninstall ` disinstalla il pacchetto\n", 100 | "- `pip list [opzioni]` elenca i pacchetti installati; tra le opzioni possibili ci sono: `--outdated --uptodate` \n", 101 | "- `pip show [-f|--files] ...` mostra le informazioni su un pacchetto installato ed eventualmente i file che lo compongono\n", 102 | "- `pip search ` ricerca nel repository tutti i pacchetti che contengono `` nel nome.\n", 103 | "\n", 104 | "L'altra caratteristica importante dell'ambiente Python è l'uso dei _virtual environment_ e cioè ambienti di esecuzione separati per ogni progetto software, con interprete Python e pacchetti installati differenti. Il sistema dei virtual environment gestisce l'insieme dei pacchetti installati per l'intero sistema creando una struttura di cartelle e di alias differenziati per ogni ambiente. Ad ogni modo è possibile installare nuovi pacchetti diversi per un virtual environment che non si ritroveranno negli altri.\n", 105 | " \n", 106 | "L'installazione si eseguirà con `pip`:\n", 107 | " ```bash\n", 108 | "$ pip install virtualenv\n", 109 | "```\n", 110 | "\n", 111 | "Un virtual environment si crea con:\n", 112 | "```bash\n", 113 | "$ virtualenv ENV\n", 114 | "```\n", 115 | "\n", 116 | "ciò crea tutta la struttura di cartelle al di sotto della cartella `ENV`:\n", 117 | "- `bin`\n", 118 | "- `lib`\n", 119 | "- `include`\n", 120 | "- `lib/pythonX.Y/site-packages`\n", 121 | "\n", 122 | "installa `python`, `pip` e `setuptools`. Il virtual environment si attiva con:\n", 123 | "```bash\n", 124 | "$ source /percorso/di/ENV/bin/activate\n", 125 | "```\n", 126 | "In questo modo il percorso verso la cartella `bin` dell'ambiente viene aggiunto in cima al `PATH` di sistema. Il virtual environment si disattiva semplicemente con:\n", 127 | "```bash\n", 128 | "$ deactivate\n", 129 | "```\n", 130 | "\n", 131 | "### Conda\n", 132 | "In genere i progetti Python richiedono l'installazione di moltissimi pacchetti per gestirne le funzionalità. Ciò è oarticolarmente vero per i progetti legati al Machine Learning ed alla Data Science. L'uso di `virtualenv` comporta che l'utente debba installare ex novo tutti i pacchetti che gli servono ogni volta che crea un nuovo ambiente. `conda` risolve questo tipo di problemi perché integra un ambiente virtuale con un gestore di pacchetti. `conda` può essere ottenuto tramite due distribuzioni: Anaconda e Miniconda. Nek seguito faremo riferimento ad Anaconda perché offre già l'installazione di un virtual environment completo di tutti i pacchetti necessari per i nostri scopi.\n", 133 | "\n", 134 | "Anaconda va installato appositamente dal sito di riferimento per [Widows](https://www.anaconda.com/distribution/#windows), [Linux](https://www.anaconda.com/distribution/#linux) e [MacOS](https://www.anaconda.com/distribution/#macos) ed è possibile scegliere la versione per Python 3 o Python 2. Utilizzeremo la versione per Python 3. Una volta installato, viene creato subito un ambiente virtuale denominato `base` in cui si trovano `python`, `pip`, `numpy`, `scipy` e tutte gli altri principali pacchetti necessari. Anche in questo caso il percorso per raggiungere gli eseguibili, che è del tipo `/percorso/verso/anaconda3/bin:/percorso/verso/anaconda3/condabin`, viene inserito in testa al `PATH` di sistema e all'interno della cartella `anaconda3` si crea una struttura di cartelle analoga a quella di `virtualenv`. In particolare `/percorso/verso/anaconda3/condabin` contiene esplicitamente il comando `conda`. La struttura dei comandi di `conda` è del tipo: `conda ``\n", 135 | "\n", 136 | "Di seguito alcuni comandi di base:\n", 137 | "- `conda create --name [pacchetto_richiesto ...]` crea l'ambiente `` con la sua struttura di cartelle a partire da `/percorso/verso/anaconda3/envs/` e, se sono stati specificati dei pacchetti, calcola le dipendenze e installa tutto ciò che è necessario per quel pacchetto; tipicamente in questi casi si imposta l'unterprete Python voluto per l'ambiente virtuale.\n", 138 | "- `conda activate ` attiva l'ambiente, rimuove il percorso vergo gli eseguibili dell'ambiente `base` e inserisce in testa al `PATH` di sistema la cartella `/percorso/verso/anaconda3/envs//bin` con gli eseguibili di ``.\n", 139 | "- `conda deactivate` disattiva l'ambiente corrente.\n", 140 | "- `conda info --envs` oppure `conda list envs` riporta l'elenco degli ambienti installati e segna con un '*' quello attivo.\n", 141 | "- `conda list` fornisce l'elenco dei pacchetti installati nell'ambiente attivo\n", 142 | "\n", 143 | "\n", 144 | "`conda` consente di gestire diversi ***canali*** di installazione dei pacchetti e cioè differenti repository. In automatico è presente il canale `defaults` già corrispondente al repository di Anaconda per il sistema operativo utilizzato, ma molti pacchetti di nostro interesse si trovano su un altro canale generalista denominato `conda-forge`. Per cui di seguito si riportano le istruzioni per installare un altro canale, renderlo il primo utilizzabile e installare i pacchetti dal canale prescelto:\n", 145 | "\n", 146 | "- `conda config add ` aggiunge un nuovo canale in testa alla lista dei canali e lo rende automaticamente quello a più elevata priorità di consultazione per installare i pacchetti.\n", 147 | "- `conda install [-n | --name ] [-c | --channel ] pacchetto [pacchetto ...]` installa uno o più pacchetti nell'ambiente attivo ed usando la lista di canali predisposta, ma può forzare l'installazione in un ambiente diverso e/o a partire da un canale voluto dall'utente.\n", 148 | "- `conda search [-c ] pacchetto[] [--info]` ricerca un pacchetto su tutti i canali disponibili, ovvero solo su quello richiesto ed eventualmente gestendo le versioni richieste; `--info` fornisce informazioni dettagliate sul pacchetto.\n", 149 | "- `conda update ` aggiorna all'ultima versione disponibile; anche in questo caso si possono usare le _version expression_.\n", 150 | "\n", 151 | "Per i pacchetti non presenti nei canali di Conda si può utilizzare `pip` installandolo prima nell'ambiente ove non lo sia già. Le chiamate a `conda list` elencheranno nell'ambiente anche i pacchetti installati via `pip`.\n", 152 | "\n", 153 | "\n", 154 | "### Jupyter\n", 155 | "\n", 156 | "Jupyter è l'ambiente interattivo via web che consente di eseguire interattivamente i cosiddetti _notebook_ ovvero dei documenti interattivi organizzati in blocchi detti \"celle\" i quali possono contenere codice che può essere eseguito immediatamente ovvero testo semplice oppure testo formattato in un mix di HTML, LaTeX (per le formule matematiche) e soprattutto ***Markdown*** che è un linguaggio molto semplificato per generare HTML con stile in maniera velocissima.\n", 157 | "\n", 158 | "Le celle che contengono codice, creano un ambiente unico e, se eseguite in successione, la valutazione delle celle precedenti è visibile alle celle successive. L'esecuzione può avvenire secondo diversi _kernel_: Python, R, C++ etc. Un esempio on line è reperibile il sito [juyter.org](https://jupyter.org/try).\n", 159 | "\n", 160 | "Jupyter viene utilizzato nella sua forma di _Notebook_ o di _Lab_. Il primo è un semplice esecutore di singoli notebook con un'intefaccia web di tipo a cartelle, mentre il secondo è un vero e proprio IDE.\n", 161 | "\n", 162 | "L'installazione di Anaconda comporta già l'installazione del pacchetto `jupyter`, ma si può installare alternativamente con `pip`. Jupyter Lab si installa da conda-forge digitando:\n", 163 | "```bash\n", 164 | "$ conda install -c conda-forge jupyterlab\n", 165 | "```\n", 166 | "\n", 167 | "L'invocazione di `jupyter [lab|notebook] [--no-browser]` attiva il server che interagisce via web su localhost alla porta 8088. L'opzione `--no-browser` è usata per invocare il server dall'interno di un IDE. La documetazione si trova sui portali di [Jupyter Lab](https://jupyterlab.readthedocs.io/en/stable/) e [Jupyter](https://jupyter.readthedocs.io/en/latest/index.html).\n" 168 | ] 169 | }, 170 | { 171 | "cell_type": "markdown", 172 | "metadata": {}, 173 | "source": [] 174 | } 175 | ], 176 | "metadata": { 177 | "interpreter": { 178 | "hash": "aee8b7b246df8f9039afb4144a1f6fd8d2ca17a180786b69acc140d282b71a49" 179 | }, 180 | "kernelspec": { 181 | "display_name": "Python 3.9.6 64-bit", 182 | "name": "python3" 183 | }, 184 | "language_info": { 185 | "codemirror_mode": { 186 | "name": "ipython", 187 | "version": 3 188 | }, 189 | "file_extension": ".py", 190 | "mimetype": "text/x-python", 191 | "name": "python", 192 | "nbconvert_exporter": "python", 193 | "pygments_lexer": "ipython3", 194 | "version": "3.9.7" 195 | }, 196 | "pycharm": { 197 | "stem_cell": { 198 | "cell_type": "raw", 199 | "metadata": { 200 | "collapsed": false 201 | }, 202 | "source": [] 203 | } 204 | } 205 | }, 206 | "nbformat": 4, 207 | "nbformat_minor": 4 208 | } 209 | -------------------------------------------------------------------------------- /Data/.ipynb_checkpoints/tutorial_model-checkpoint.json: -------------------------------------------------------------------------------- 1 | { 2 | "dimensions": [ 3 | { 4 | "name":"item", 5 | "levels": [ 6 | { 7 | "name":"category", 8 | "label":"Category", 9 | "attributes": ["category", "category_label"] 10 | }, 11 | { 12 | "name":"subcategory", 13 | "label":"Sub-category", 14 | "attributes": ["subcategory", "subcategory_label"] 15 | }, 16 | { 17 | "name":"line_item", 18 | "label":"Line Item", 19 | "attributes": ["line_item"] 20 | } 21 | ] 22 | }, 23 | {"name":"year", "role": "time"} 24 | ], 25 | "cubes": [ 26 | { 27 | "name": "ibrd_balance", 28 | "dimensions": ["item", "year"], 29 | "measures": [{"name":"amount", "label":"Amount"}], 30 | "aggregates": [ 31 | { 32 | "name": "amount_sum", 33 | "function": "sum", 34 | "measure": "amount" 35 | }, 36 | { 37 | "name": "record_count", 38 | "function": "count" 39 | } 40 | ], 41 | "mappings": { 42 | "item.line_item": "line_item", 43 | "item.subcategory": "subcategory", 44 | "item.subcategory_label": "subcategory_label", 45 | "item.category": "category", 46 | "item.category_label": "category_label" 47 | }, 48 | "info": { 49 | "min_date": "2010-01-01", 50 | "max_date": "2010-12-31" 51 | } 52 | } 53 | ] 54 | } 55 | -------------------------------------------------------------------------------- /Data/IBRD_Balance_Sheet__FY2010.csv: -------------------------------------------------------------------------------- 1 | Category Code,Category,Subcategory Code,Subcategory,Line Item,Fiscal Year,"Amount (US$, Millions)" 2 | a,Assets,dfb,Due from Banks,Unrestricted currencies,2010,1581 3 | a,Assets,dfb,Due from Banks,Unrestricted currencies,2009,2380 4 | a,Assets,dfb,Due from Banks,Currencies subject to restriction,2010,222 5 | a,Assets,dfb,Due from Banks,Currencies subject to restriction,2009,664 6 | a,Assets,i,Investments,Trading,2010,36012 7 | a,Assets,i,Investments,Trading,2009,41012 8 | a,Assets,s,Securities,Securities purchased under resale agreements,2010,289 9 | a,Assets,s,Securities,Securities purchased under resale agreements,2009,33 10 | a,Assets,nn,Nonnegotiable,"Nonnegotiable, nonintrest-bearing demand obligations on account of subscribed capital",2010,1123 11 | a,Assets,nn,Nonnegotiable,"Nonnegotiable, nonintrest-bearing demand obligations on account of subscribed capital",2009,1202 12 | a,Assets,da,Derivative Assets,Investments,2010,13249 13 | a,Assets,da,Derivative Assets,Investments,2009,18467 14 | a,Assets,da,Derivative Assets,Client operations,2010,17633 15 | a,Assets,da,Derivative Assets,Client operations,2009,19559 16 | a,Assets,da,Derivative Assets,Borrowings,2010,87457 17 | a,Assets,da,Derivative Assets,Borrowings,2009,82793 18 | a,Assets,da,Derivative Assets,Other,2010,3287 19 | a,Assets,da,Derivative Assets,Other,2009,2246 20 | a,Assets,rcv,Receivables,Receivables to maintain value of currency holdings on account of subscribed capital,2010,171 21 | a,Assets,rcv,Receivables,Receivables to maintain value of currency holdings on account of subscribed capital,2009,176 22 | a,Assets,orcv,Other Receivables,Receivables from investment securities traded,2010,47 23 | a,Assets,orcv,Other Receivables,Receivables from investment securities traded,2009,95 24 | a,Assets,orcv,Other Receivables,Accrued income on loans,2010,764 25 | a,Assets,orcv,Other Receivables,Accrued income on loans,2009,889 26 | a,Assets,lo,Loans Outstanding,Net loans outstanding,2010,118104 27 | a,Assets,lo,Loans Outstanding,Net loans outstanding,2009,103657 28 | a,Assets,oa,Other Assets,Assets under retirement benefit plans,2010,0 29 | a,Assets,oa,Other Assets,Assets under retirement benefit plans,2009,325 30 | a,Assets,oa,Other Assets,Premises and equipment (net),2010,635 31 | a,Assets,oa,Other Assets,Premises and equipment (net),2009,625 32 | a,Assets,oa,Other Assets,Miscellaneous,2010,2436 33 | a,Assets,oa,Other Assets,Miscellaneous,2009,1297 34 | l,Liabilities,b,Borrowings,All,2010,128577 35 | l,Liabilities,b,Borrowings,All,2009,110040 36 | l,Liabilities,sol,Sold or Lent,"Securities Sold under Repurchase Agreements, Securities Lent under Securities Lending Agreements, and Payable for Cash Collateral Received",2010,998 37 | l,Liabilities,sol,Sold or Lent,"Securities Sold under Repurchase Agreements, Securities Lent under Securities Lending Agreements, and Payable for Cash Collateral Received",2009,2323 38 | l,Liabilities,dl,Derivative Liabilities,Investments,2010,13360 39 | l,Liabilities,dl,Derivative Liabilities,Investments,2009,18923 40 | l,Liabilities,dl,Derivative Liabilities,Client Operations,2010,17623 41 | l,Liabilities,dl,Derivative Liabilities,Client Operations,2009,19551 42 | l,Liabilities,dl,Derivative Liabilities,Borrowings,2010,78655 43 | l,Liabilities,dl,Derivative Liabilities,Borrowings,2009,76321 44 | l,Liabilities,dl,Derivative Liabilities,Other,2010,780 45 | l,Liabilities,dl,Derivative Liabilities,Other,2009,847 46 | l,Liabilities,o,Other,Payable to Maintain Value of Currency Holdings on Account of Subscribed Capital,2010,8 47 | l,Liabilities,o,Other,Payable to Maintain Value of Currency Holdings on Account of Subscribed Capital,2009,57 48 | l,Liabilities,ol,Other Liabilities,Payable for investment securities purchased,2010,307 49 | l,Liabilities,ol,Other Liabilities,Payable for investment securities purchased,2009,2457 50 | l,Liabilities,ol,Other Liabilities,Accrued charges on borrowings,2010,1190 51 | l,Liabilities,ol,Other Liabilities,Accrued charges on borrowings,2009,1495 52 | l,Liabilities,ol,Other Liabilities,Liabilities under retirement benefit plans,2010,1164 53 | l,Liabilities,ol,Other Liabilities,Liabilities under retirement benefit plans,2009,662 54 | l,Liabilities,ol,Other Liabilities,Accounts payable and misc liabilities,2010,2793 55 | l,Liabilities,ol,Other Liabilities,Accounts payable and misc liabilities,2009,2707 56 | e,Equity,cs,Capital Stock,Paid-in capital,2010,11492 57 | e,Equity,cs,Capital Stock,Paid-in capital,2009,11491 58 | e,Equity,da,Deferred Amounts,Deferred Amounts to Maintain Value of Currency Holdings,2010,313 59 | e,Equity,da,Deferred Amounts,Deferred Amounts to Maintain Value of Currency Holdings,2009,359 60 | e,Equity,re,Retained Earnings,Retained Earnings,2010,28793 61 | e,Equity,re,Retained Earnings,Retained Earnings,2009,29870 62 | e,Equity,oe,Other,Accumulated Other Comorehensive Loss,2010,-3043 63 | e,Equity,oe,Other,Accumulated Other Comorehensive Loss,2009,-1683 64 | -------------------------------------------------------------------------------- /Data/anagrafica.csv: -------------------------------------------------------------------------------- 1 | "Cognome e Nome";"Data di nascita";"Luogo di nascita";"Provincia";"CF" 2 | "Mario Rossi";"03/08/1933";"Palermo";"PA";"XXXTTT33R44R675E" 3 | "Giuseppe Verdi";"12/05/1971";"Monza";"MI";"GGGVVV44U66M456P" 4 | "Carlo Bianchi";"30/09/2000";"Macerata";"MC";"CCCBBB89R12O984F" 5 | -------------------------------------------------------------------------------- /Data/dischi.csv: -------------------------------------------------------------------------------- 1 | "Quantità";"Artista";"Reparto" 2 | "21";"Boy George";"Pop" 3 | "56";"Genesis";"Rock" 4 | "32";"W.A. Mozart";"Classica" 5 | -------------------------------------------------------------------------------- /Data/dischi.json: -------------------------------------------------------------------------------- 1 | { 2 | "dischi": [{"Artista": "John Bon Jovi", "Generi": ["Rock","Pop"], "Quantità": 34}, 3 | {"Artista": "Elton John", "Generi": ["Pop", "Funky"], "Quantità": 12}, 4 | {"Artista": "George Benson", "Generi": ["Blues","Jazz", "Pop"], "Quantità": 22}] 5 | } -------------------------------------------------------------------------------- /Data/example.log: -------------------------------------------------------------------------------- 1 | INFO:root:Run #1: "add" is called with arguments (3, 3) 2 | INFO:root:Run #2: "add" is called with arguments (4, 5) 3 | INFO:root:Run #1: "sub" is called with arguments (10, 5) 4 | INFO:root:Run #2: "sub" is called with arguments (20, 10) 5 | INFO:root:Run #1: "cos" is called with arguments (3.141592653589793,) 6 | -------------------------------------------------------------------------------- /Data/galaxy.jpg: -------------------------------------------------------------------------------- https://raw.githubusercontent.com/fredffsixty/Big-Data/896430d4821c623d14fbf05beae34fe1afbd7a2d/Data/galaxy.jpg -------------------------------------------------------------------------------- /Data/myoutput.txt: -------------------------------------------------------------------------------- 1 | total 392 2 | drwxr-xr-x 17 pirrone staff 544B 3 Ott 17:06 . 3 | drwxr-xr-x 5 pirrone staff 160B 21 Set 11:27 .. 4 | -rw-r--r--@ 1 pirrone staff 12K 2 Ott 20:09 .DS_Store 5 | drwxr-xr-x 15 pirrone staff 480B 3 Ott 15:00 .git 6 | drwxr-xr-x 10 pirrone staff 320B 3 Ott 13:37 .idea 7 | drwxr-xr-x 9 pirrone staff 288B 3 Ott 10:39 .ipynb_checkpoints 8 | -rw-r--r-- 1 pirrone staff 14K 26 Set 15:19 Configurazione dell'ambiente Python.ipynb 9 | drwxr-xr-x 10 pirrone staff 320B 3 Ott 17:20 Data 10 | -rw-r--r-- 1 pirrone staff 1,0K 17 Ago 13:33 LICENSE 11 | drwxr-xr-x 5 pirrone staff 160B 21 Set 11:58 Libri di testo 12 | -rw-r--r-- 1 pirrone staff 27K 23 Set 13:46 Plot example.ipynb 13 | drwxr-xr-x 6 pirrone staff 192B 3 Ott 10:30 Python programming 14 | -rw-r--r-- 1 pirrone staff 35K 26 Set 17:02 Python programming 1.ipynb 15 | -rw-r--r-- 1 pirrone staff 20K 2 Ott 17:56 Python programming 2.ipynb 16 | -rw-r--r-- 1 pirrone staff 46K 3 Ott 17:06 Python programming 3.ipynb 17 | -rw-r--r-- 1 pirrone staff 290B 3 Set 14:15 README.md 18 | -rw-r--r-- 1 pirrone staff 22K 23 Set 13:47 Widget example.ipynb 19 | -------------------------------------------------------------------------------- /Data/persone.csv: -------------------------------------------------------------------------------- 1 | matricola, nome, reparto 2 | 1234, Jhon Doe, A 3 | 8976, Jack Russell, B 4 | 7732, Brian May, A 5 | 3344,ZZ Top,D 6 | 3344,ZZ Top,D 7 | -------------------------------------------------------------------------------- /Data/persone.json: -------------------------------------------------------------------------------- 1 | [{"Cognome e Nome": "Mario Rossi", "Data di nascita": "03/08/1933", "Luogo di nascita": "Palermo", "Provincia": "PA", "CF": "XXXTTT33R44R675E"}, {"Cognome e Nome": "Giuseppe Verdi", "Data di nascita": "12/05/1971", "Luogo di nascita": "Monza", "Provincia": "MI", "CF": "GGGVVV44U66M456P"}, {"Cognome e Nome": "Carlo Bianchi", "Data di nascita": "30/09/2000", "Luogo di nascita": "Macerata", "Provincia": "MC", "CF": "CCCBBB89R12O984F"}] -------------------------------------------------------------------------------- /Data/persone1.csv: -------------------------------------------------------------------------------- 1 | matricola; nome; reparto 2 | 1234; "Jhon Doe"; A 3 | 8976; "Jack Russel"; B 4 | 7732; "Brian May"; A 5 | -------------------------------------------------------------------------------- /Data/tutorial_model.json: -------------------------------------------------------------------------------- 1 | { 2 | "dimensions": [ 3 | { 4 | "name":"item", 5 | "levels": [ 6 | { 7 | "name":"category", 8 | "label":"Category", 9 | "attributes": ["category", "category_label"] 10 | }, 11 | { 12 | "name":"subcategory", 13 | "label":"Sub-category", 14 | "attributes": ["subcategory", "subcategory_label"] 15 | }, 16 | { 17 | "name":"line_item", 18 | "label":"Line Item", 19 | "attributes": ["line_item"] 20 | } 21 | ] 22 | }, 23 | {"name":"year", "role": "time"} 24 | ], 25 | "cubes": [ 26 | { 27 | "name": "ibrd_balance", 28 | "dimensions": ["item", "year"], 29 | "measures": [{"name":"amount", "label":"Amount"}], 30 | "aggregates": [ 31 | { 32 | "name": "amount_sum", 33 | "function": "sum", 34 | "measure": "amount" 35 | }, 36 | { 37 | "name": "record_count", 38 | "function": "count" 39 | } 40 | ], 41 | "mappings": { 42 | "item.line_item": "line_item", 43 | "item.subcategory": "subcategory", 44 | "item.subcategory_label": "subcategory_label", 45 | "item.category": "category", 46 | "item.category_label": "category_label" 47 | }, 48 | "info": { 49 | "min_date": "2010-01-01", 50 | "max_date": "2010-12-31" 51 | } 52 | } 53 | ] 54 | } 55 | -------------------------------------------------------------------------------- /Esercitazione CNN/applicazioni reti convoluzionali.pdf: -------------------------------------------------------------------------------- https://raw.githubusercontent.com/fredffsixty/Big-Data/896430d4821c623d14fbf05beae34fe1afbd7a2d/Esercitazione CNN/applicazioni reti convoluzionali.pdf -------------------------------------------------------------------------------- /Esercitazione CNN/esercitazione_MOL_1512.txt: -------------------------------------------------------------------------------- 1 | import json 2 | import torch 3 | import numpy as np 4 | import pandas as pd 5 | from tqdm import tqdm 6 | from rdkit import Chem 7 | from rdkit.Chem import DataStructs 8 | from rdkit.Chem import rdMolDescriptors 9 | from rdkit.Chem import MACCSkeys, AllChem 10 | from rdkit.Chem.AtomPairs import Pairs, Torsions 11 | from Package.DataProcessing import DataProcessing 12 | from rdkit.Avalon import pyAvalonTools as fpAvalon 13 | from rdkit.Chem.Fingerprints import FingerprintMols 14 | from sklearn.model_selection import train_test_split 15 | from rdkit.Chem.ChemicalFeatures import BuildFeatureFactory 16 | 17 | 18 | device = torch.device("cuda" if torch.cuda.is_available() else "cpu") 19 | 20 | 21 | df = pd.read_csv("/home/scontino/python/graph_vae/CDK1.csv") 22 | smiles = df["Smiles"].values 23 | labels = df["Class"].values 24 | x_train, x_test, y_train, y_test = train_test_split(smiles, labels, test_size=0.1, random_state=17) 25 | 26 | 27 | 28 | class generateFingerprints(): 29 | def __init__(self, data): 30 | self.nbits = 1024 31 | self.data = data 32 | # self.data = Chem.MolFromSmiles(smiles) 33 | self.list_smiles, self.list_molecule = [], [] 34 | 35 | 36 | def __checkDataInput__(self): 37 | if len(self.data) > 1: 38 | if isinstance(self.data, pd.Series): 39 | self.list_smiles = self.data.values() 40 | return self.list_smiles 41 | elif isinstance(self.data, np.ndarray): 42 | self.list_smiles = self.data 43 | return self.list_smiles 44 | elif isinstance(self.data, dict): 45 | if len(self.data.keys()) > 1: 46 | for chiavi in self.data.keys(): 47 | self.list_smiles.append(self.data[chiavi]) 48 | return self.list_smiles 49 | else: 50 | if isinstance(self.data, dict): 51 | chiave = list(self.data.keys()) 52 | if len(self.data[chiave[0]]) == 1: 53 | self.smiles = self.data[chiave[0]] 54 | print("self. smiles è:", self.smiles[0]) 55 | return self.smiles[0] 56 | else: 57 | for stringa in self.data[chiave[0]]: 58 | self.list_smiles.append(stringa) 59 | return self.list_smiles 60 | elif isinstance(self.data, str): 61 | self.smiles = self.data 62 | return self.smiles 63 | 64 | def __smilesGen__(self): 65 | if len(self.list_smiles) == 0: 66 | self.smiles = Chem.MolFromSmiles(self.smiles[0]) 67 | return self.smiles 68 | else: 69 | for string in self.list_smiles: 70 | print(string) 71 | self.list_molecule.append(Chem.MolFromSmiles(string)) 72 | print(self.list_molecule) 73 | 74 | return self.list_molecule 75 | 76 | def __create__(self): 77 | if len(self.list_molecule) == 0: 78 | #/ creo un array vuoto 79 | rdkit_fing = np.zeros(shape=(0, ), dtype=np.int8) 80 | morgan_fing = np.zeros(shape=(0,), dtype=np.int8) 81 | atompair_fing = np.zeros(shape=(0,), dtype=np.int8) 82 | torsion_fing = np.zeros(shape=(0,), dtype=np.int8) 83 | layered_fing = np.zeros(shape=(0,), dtype=np.int8) 84 | featmorgan_fing = np.zeros(shape=(0,), dtype=np.int8) 85 | ecfp4_fing = np.zeros(shape=(0,), dtype=np.int8) 86 | #/genero le fingerprints 87 | rdkit = Chem.rdmolops.RDKFingerprint(self.smiles, maxPath=7, fpSize=self.nbits, nBitsPerHash=2) 88 | morgan = AllChem.GetMorganFingerprintAsBitVect(self.smiles, 2, nBits=self.nbits) 89 | atompair = rdMolDescriptors.GetHashedAtomPairFingerprintAsBitVect(self.smiles, nBits=self.nbits) 90 | torsion = rdMolDescriptors.GetHashedTopologicalTorsionFingerprintAsBitVect(self.smiles, nBits=self.nbits) 91 | layered = Chem.rdmolops.LayeredFingerprint(self.smiles, fpSize=self.nbits) 92 | featmorgan = AllChem.GetMorganFingerprintAsBitVect(self.smiles, 2, nBits=self.nbits, useFeatures=True) 93 | ecfp4 = AllChem.GetMorganFingerprintAsBitVect(self.smiles, 2, nBits=self.nbits) 94 | 95 | #/creo i vettori bit 96 | DataStructs.ConvertToNumpyArray(rdkit, rdkit_fing), 97 | DataStructs.ConvertToNumpyArray(morgan, morgan_fing), 98 | DataStructs.ConvertToNumpyArray(atompair, atompair_fing), 99 | DataStructs.ConvertToNumpyArray(torsion, torsion_fing), 100 | DataStructs.ConvertToNumpyArray(layered, layered_fing), 101 | DataStructs.ConvertToNumpyArray(featmorgan, featmorgan_fing), 102 | DataStructs.ConvertToNumpyArray(ecfp4, ecfp4_fing) 103 | 104 | lista_fing = [ 105 | rdkit_fing, 106 | morgan_fing, 107 | atompair_fing, 108 | torsion_fing, 109 | layered_fing, 110 | featmorgan_fing, 111 | ecfp4_fing 112 | ] 113 | 114 | return lista_fing 115 | 116 | else: 117 | list_of_list = [] 118 | print(self.list_molecule) 119 | for idx, smiles in enumerate(self.list_molecule): 120 | print(smiles) 121 | rdkit_fing = np.zeros(shape=(0, ), dtype=np.int8) 122 | morgan_fing = np.zeros(shape=(0,), dtype=np.int8) 123 | atompair_fing = np.zeros(shape=(0,), dtype=np.int8) 124 | torsion_fing = np.zeros(shape=(0,), dtype=np.int8) 125 | layered_fing = np.zeros(shape=(0,), dtype=np.int8) 126 | featmorgan_fing = np.zeros(shape=(0,), dtype=np.int8) 127 | ecfp4_fing = np.zeros(shape=(0,), dtype=np.int8) 128 | #/ creo un array vuoto 129 | #/genero le fingerprints 130 | rdkit = Chem.rdmolops.RDKFingerprint(smiles, maxPath=7, fpSize=self.nbits, nBitsPerHash=2) 131 | morgan = AllChem.GetMorganFingerprintAsBitVect(smiles, 2, nBits=self.nbits) 132 | atompair = rdMolDescriptors.GetHashedAtomPairFingerprintAsBitVect(smiles, nBits=self.nbits) 133 | torsion = rdMolDescriptors.GetHashedTopologicalTorsionFingerprintAsBitVect(smiles, nBits=self.nbits) 134 | layered = Chem.rdmolops.LayeredFingerprint(smiles, fpSize=self.nbits) 135 | featmorgan = AllChem.GetMorganFingerprintAsBitVect(smiles, 2, nBits=self.nbits, useFeatures=True) 136 | ecfp4 = AllChem.GetMorganFingerprintAsBitVect(smiles, 2, nBits=self.nbits) 137 | 138 | #/creo i vettori bit 139 | DataStructs.ConvertToNumpyArray(rdkit, rdkit_fing), 140 | DataStructs.ConvertToNumpyArray(morgan, morgan_fing), 141 | DataStructs.ConvertToNumpyArray(atompair, atompair_fing), 142 | DataStructs.ConvertToNumpyArray(torsion, torsion_fing), 143 | DataStructs.ConvertToNumpyArray(layered, layered_fing), 144 | DataStructs.ConvertToNumpyArray(featmorgan, featmorgan_fing), 145 | DataStructs.ConvertToNumpyArray(ecfp4, ecfp4_fing) 146 | 147 | lista_fing = [ 148 | rdkit_fing, 149 | morgan_fing, 150 | atompair_fing, 151 | torsion_fing, 152 | layered_fing, 153 | featmorgan_fing, 154 | ecfp4_fing 155 | ] 156 | 157 | list_of_list.append(lista_fing) 158 | 159 | return list_of_list 160 | 161 | def __execute__(self): 162 | self.__checkDataInput__() 163 | self.__smilesGen__() 164 | lista = self.__create__() 165 | return lista 166 | 167 | 168 | gen_fing_train = generateFingerprints(data=x_train) 169 | gen_fing_test = generateFingerprints(data=x_test) 170 | #/genero le fingerprints 171 | list_fing_train = gen_fing_train.__execute__() 172 | list_fing_test = gen_fing_test.__execute__() 173 | 174 | def stuckFing(rdkit=None, morgan=None, atompair=None, torsion=None, layered=None, featmorgan=None, ecfp4=None): 175 | """ 176 | Function that create a matrix of fingerprints. 177 | 178 | # Args: 179 | * rdkit ([type], optional): RDKit fingeprint vector. Defaults to None. 180 | * morgan ([type], optional): Morgan fingeprint vector. Defaults to None. 181 | * atompair ([type], optional): AtomPair fingeprint vector. Defaults to None. 182 | * torsion ([type], optional): Torsion fingeprint vector. Defaults to None. 183 | * layered ([type], optional): Layered fingeprint vector. Defaults to None. 184 | * featmorgan ([type], optional): FeatMorgan fingeprint vector. Defaults to None. 185 | * ecfp4 ([type], optional): ECFP4 fingerprint vector. Defaults to None. 186 | 187 | # Returns: 188 | A matrix of fingeprints is returned. 189 | """ 190 | 191 | fingerprintsList = [] 192 | if rdkit is None: 193 | print("rdkit parameter is not passed") 194 | else: 195 | fingerprintsList.append(rdkit) 196 | 197 | if morgan is None: 198 | print("morgan parameter is not passed") 199 | else: 200 | fingerprintsList.append(morgan) 201 | 202 | if atompair is None: 203 | print("atompair parameter is not passed") 204 | else: 205 | fingerprintsList.append(atompair) 206 | 207 | if torsion is None: 208 | print("torsion parameter is not passed") 209 | else: 210 | fingerprintsList.append(torsion) 211 | 212 | if layered is None: 213 | print("layered parameter is not passed") 214 | else: 215 | fingerprintsList.append(layered) 216 | 217 | if featmorgan is None: 218 | print("featmorgan parameter is not passed") 219 | else: 220 | fingerprintsList.append(featmorgan) 221 | 222 | if ecfp4 is None: 223 | print("ecfp4 parameter is not passed") 224 | else: 225 | fingerprintsList.append(ecfp4) 226 | 227 | fingerprintsList = np.array(fingerprintsList) 228 | 229 | if len(fingerprintsList.shape) <= 2: 230 | dim1 = fingerprintsList.shape[0] 231 | dim2 = fingerprintsList.shape[1] 232 | inputs = np.empty(shape=(dim1, dim2)) 233 | for i in tqdm(range(dim1)): 234 | for idxFingList in range(dim2): 235 | inputs[i][idxFingList] = fingerprintsList[i][idxFingList] 236 | elif len(fingerprintsList.shape) == 3: 237 | dim1 = len(fingerprintsList) 238 | dim2 = len(fingerprintsList[0]) 239 | dim3 = len(fingerprintsList[0][0]) 240 | inputs = np.empty(shape=(dim1, dim2, dim3)) 241 | for i in tqdm(range(dim1)): 242 | for idxFingList in range(dim2): 243 | inputs[i][idxFingList] = fingerprintsList[idxFingList][i] 244 | 245 | return inputs 246 | 247 | list_fing_train = np.array(list_fing_train) 248 | list_fing_test = np.array(list_fing_test) 249 | 250 | stucked_fing_train = [] 251 | for lung_train in range(len(list_fing_train)): 252 | stucked_fing_train.append(stuckFing( 253 | rdkit=list_fing_train[lung_train][0], morgan=list_fing_train[lung_train][1], atompair=list_fing_train[lung_train][2], 254 | torsion=list_fing_train[lung_train][3], layered=list_fing_train[lung_train][4], featmorgan=list_fing_train[lung_train][5], ecfp4=list_fing_train[lung_train][6] 255 | )) 256 | 257 | stucked_fing_test = [] 258 | for lung_test in range(len(list_fing_test)): 259 | stucked_fing_test.append(stuckFing( 260 | rdkit=list_fing_test[lung_test][0], morgan=list_fing_test[lung_test][1], atompair=list_fing_test[lung_test][2], 261 | torsion=list_fing_test[lung_test][3], layered=list_fing_test[lung_test][4], featmorgan=list_fing_test[lung_test][5], ecfp4=list_fing_train[lung_train][6] 262 | )) 263 | 264 | x_train = torch.Tensor(stucked_fing_train) 265 | x_test = torch.Tensor(stucked_fing_test) 266 | y_train = torch.Tensor(y_train) 267 | y_test = torch.Tensor(y_test) 268 | 269 | import torch.nn as nn 270 | 271 | class SeparableConv2d(nn.Module): 272 | def __init__(self,in_channels,out_channels,kernel_size=1,stride=1,padding=0,dilation=1,bias=False): 273 | super(SeparableConv2d,self).__init__() 274 | 275 | self.conv1 = nn.Conv2d(in_channels,in_channels,kernel_size,stride,padding,dilation,groups=in_channels,bias=bias) 276 | self.pointwise = nn.Conv2d(in_channels,out_channels,1,1,0,1,1,bias=bias) 277 | 278 | def forward(self,x): 279 | x = self.conv1(x) 280 | x = self.pointwise(x) 281 | return x 282 | 283 | 284 | class CNN(nn.Module): 285 | def __init__(self, inchannels, num_classes, output_activation='sigmoid'): 286 | super(CNN, self).__init__() 287 | 288 | self.inchannels= inchannels 289 | self.classes=num_classes 290 | 291 | self.pool = nn.MaxPool2d(kernel_size=2, stride=2, padding=0,ceil_mode=False) 292 | self.cs= nn.ModuleList([ 293 | SeparableConv2d(self.inchannels, 16, 1, stride=2, padding=0), 294 | SeparableConv2d(16, 32, (3, 1), stride=2, padding=0), 295 | SeparableConv2d(32, 64, (3, 1), stride=2, padding=0), 296 | SeparableConv2d(64, 128, (3, 1), stride=2, padding=0), 297 | SeparableConv2d(128, 128, (3, 1), stride=2, padding=0), 298 | SeparableConv2d(128, 64, (3, 1), stride=2, padding=0), 299 | SeparableConv2d(64, 32, (3, 1), stride=2, padding=0), 300 | SeparableConv2d(32, 16, (3, 1), stride=2, padding=0), 301 | ]) 302 | self.relu= nn.ReLU(inplace=True) 303 | 304 | self.classifier= nn.Sequential( 305 | nn.LazyLinear(out_features=512, bias=True) 306 | ,nn.ReLU(inplace=True) 307 | ,nn.Dropout(p=0.2, inplace=False) 308 | ,nn.Linear(in_features=512, out_features=64, bias=True) 309 | ,nn.ReLU(inplace=True) 310 | ,nn.Dropout(p=0.2, inplace=False) 311 | ,nn.Linear(in_features=64, out_features=64, bias=True) 312 | ,nn.ReLU(inplace=True) 313 | ,nn.Dropout(p=0.2, inplace=False) 314 | ,nn.Linear(in_features=64, out_features=self.classes, bias=True), 315 | nn.Sigmoid() 316 | ) 317 | 318 | 319 | def forward(self, x): 320 | batch = x.shape[0] 321 | for idx in range(len(self.cs)): 322 | x = self.relu(self.cs[idx](x)) 323 | 324 | flatten= x.view(batch,-1) 325 | out= self.classifier(flatten) 326 | 327 | return out 328 | 329 | 330 | model = CNN(inchannels=7, num_classes=1) 331 | print(model) 332 | 333 | 334 | def fitPytorch(model, num_epochs, train_x, train_y, batch_size, device, optimizer, 335 | loss_function="binary_crossentropy", classWeight=None): 336 | num_epochs = num_epochs 337 | batch_size = batch_size 338 | loss_train_batch, accuracy_train_batch = [], [] 339 | for epoch in range(num_epochs): 340 | print(f'Epochs n:{epoch+1}/{num_epochs}') 341 | loss_train, acc_train = [], [] 342 | #/ Dico al modello che stiamo facendo train 343 | model.train() 344 | for i in tqdm(range(0, len(train_x), batch_size)): 345 | #/ Forward pass 346 | batch_x = train_x[i:i+batch_size].view(-1, 7, 1024, 1).to(device) 347 | batch_y = train_y[i:i+batch_size].view(-1, 1*1).to(device) 348 | #/ predizione del modello 349 | outputs = model(batch_x).to(device) 350 | #/ select a loss function 351 | if loss_function == "binary_crossentropy": 352 | loss = nn.functional.binary_cross_entropy(outputs, batch_y, weight=classWeight) 353 | del batch_x 354 | #/ Backward and optimize 355 | optim = optimizer 356 | optim.zero_grad() 357 | loss.backward() #/ esegue la backpropagation per noi 358 | optim.step() #/ ottimizza i pesi ad ogni step 359 | 360 | if (i+batch_size) % batch_size == 0: 361 | a = loss.item() 362 | loss_train.append(a) 363 | torch.cuda.empty_cache() 364 | #/ val accuracy calculation 365 | correct_train = 0 366 | total_train = 1 367 | out_maxes = [torch.round(i) for i in outputs] 368 | target_maxes = [i for i in batch_y] 369 | for i_n,j_n in zip(out_maxes, target_maxes): 370 | if torch.equal(i_n, j_n): 371 | correct_train += 1 372 | total_train += 1 373 | train_acc = round(correct_train/total_train, 5) 374 | acc_train.append(train_acc) 375 | print("lunghezza accuracy list train:", len(acc_train)) 376 | lunghezz_train = len(acc_train) 377 | #/ print accuracy e loss train 378 | loss_train_batch.append(sum(loss_train)/lunghezz_train) 379 | accuracy_train_batch.append(sum(acc_train)/lunghezz_train) 380 | print(f"Training Loss:\t{loss_train_batch[-1]}\nTRaining Accuracy:\t{accuracy_train_batch[-1]}") 381 | del acc_train, loss_train 382 | 383 | return loss_train_batch, model 384 | 385 | 386 | 387 | #/Optimizer 388 | optim = torch.optim.Adamax(model.parameters(), lr=0.0002) 389 | #/ Addestro il modello 390 | loss, trained_model = fitPytorch(model=model.to(device), num_epochs=100, train_x=x_train, train_y=y_train, batch_size=16, device=device, optimizer=optim) 391 | -------------------------------------------------------------------------------- /Esercitazione NLP Transformer/Esercitazione_classificazione.ipynb: -------------------------------------------------------------------------------- 1 | { 2 | "cells": [ 3 | { 4 | "cell_type": "code", 5 | "execution_count": 1, 6 | "metadata": {}, 7 | "outputs": [], 8 | "source": [ 9 | "# Dataset https://www.kaggle.com/datasets/sainijagjit/bbc-dataset?resource=download" 10 | ] 11 | }, 12 | { 13 | "cell_type": "code", 14 | "execution_count": 2, 15 | "metadata": {}, 16 | "outputs": [], 17 | "source": [ 18 | "import pandas as pd\n", 19 | "import torch\n", 20 | "import numpy as np\n", 21 | "from transformers import BertTokenizer, BertModel\n", 22 | "from torch import nn\n", 23 | "from torch.optim import Adam\n", 24 | "from tqdm import tqdm" 25 | ] 26 | }, 27 | { 28 | "cell_type": "code", 29 | "execution_count": 3, 30 | "metadata": {}, 31 | "outputs": [ 32 | { 33 | "data": { 34 | "text/html": [ 35 | "
\n", 36 | "\n", 49 | "\n", 50 | " \n", 51 | " \n", 52 | " \n", 53 | " \n", 54 | " \n", 55 | " \n", 56 | " \n", 57 | " \n", 58 | " \n", 59 | " \n", 60 | " \n", 61 | " \n", 62 | " \n", 63 | " \n", 64 | " \n", 65 | " \n", 66 | " \n", 67 | " \n", 68 | " \n", 69 | " \n", 70 | " \n", 71 | " \n", 72 | " \n", 73 | " \n", 74 | " \n", 75 | " \n", 76 | " \n", 77 | " \n", 78 | " \n", 79 | " \n", 80 | " \n", 81 | " \n", 82 | " \n", 83 | " \n", 84 | "
categorytext
0techtv future in the hands of viewers with home th...
1businessworldcom boss left books alone former worldc...
2sporttigers wary of farrell gamble leicester say ...
3sportyeading face newcastle in fa cup premiership s...
4entertainmentocean s twelve raids box office ocean s twelve...
\n", 85 | "
" 86 | ], 87 | "text/plain": [ 88 | " category text\n", 89 | "0 tech tv future in the hands of viewers with home th...\n", 90 | "1 business worldcom boss left books alone former worldc...\n", 91 | "2 sport tigers wary of farrell gamble leicester say ...\n", 92 | "3 sport yeading face newcastle in fa cup premiership s...\n", 93 | "4 entertainment ocean s twelve raids box office ocean s twelve..." 94 | ] 95 | }, 96 | "execution_count": 3, 97 | "metadata": {}, 98 | "output_type": "execute_result" 99 | } 100 | ], 101 | "source": [ 102 | "PATH = '/home/isiragusa/irene/NLP General/Esercitazione/'\n", 103 | "df = pd.read_csv(PATH+\"bbc-text.csv\")\n", 104 | "df.head()" 105 | ] 106 | }, 107 | { 108 | "cell_type": "code", 109 | "execution_count": 4, 110 | "metadata": {}, 111 | "outputs": [ 112 | { 113 | "data": { 114 | "text/plain": [ 115 | "" 116 | ] 117 | }, 118 | "execution_count": 4, 119 | "metadata": {}, 120 | "output_type": "execute_result" 121 | }, 122 | { 123 | "data": { 124 | "image/png": "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", 125 | "text/plain": [ 126 | "
" 127 | ] 128 | }, 129 | "metadata": { 130 | "needs_background": "light" 131 | }, 132 | "output_type": "display_data" 133 | } 134 | ], 135 | "source": [ 136 | "df.groupby(['category']).size().plot.bar()" 137 | ] 138 | }, 139 | { 140 | "cell_type": "code", 141 | "execution_count": 5, 142 | "metadata": {}, 143 | "outputs": [], 144 | "source": [ 145 | "tokenizer = BertTokenizer.from_pretrained('bert-base-cased')\n", 146 | "labels = {'business':0,\n", 147 | " 'entertainment':1,\n", 148 | " 'sport':2,\n", 149 | " 'tech':3,\n", 150 | " 'politics':4\n", 151 | " }\n", 152 | "\n", 153 | "class Dataset(torch.utils.data.Dataset):\n", 154 | "\n", 155 | " def __init__(self, df):\n", 156 | "\n", 157 | " self.labels = [labels[label] for label in df['category']]\n", 158 | " self.texts = [tokenizer(text, \n", 159 | " padding='max_length', max_length = 512, truncation=True,\n", 160 | " return_tensors=\"pt\") for text in df['text']]\n", 161 | "\n", 162 | " def classes(self):\n", 163 | " return self.labels\n", 164 | "\n", 165 | " def __len__(self):\n", 166 | " return len(self.labels)\n", 167 | "\n", 168 | " def get_batch_labels(self, idx):\n", 169 | " # Fetch a batch of labels\n", 170 | " return np.array(self.labels[idx])\n", 171 | "\n", 172 | " def get_batch_texts(self, idx):\n", 173 | " # Fetch a batch of inputs\n", 174 | " return self.texts[idx]\n", 175 | "\n", 176 | " def __getitem__(self, idx):\n", 177 | "\n", 178 | " batch_texts = self.get_batch_texts(idx)\n", 179 | " batch_y = self.get_batch_labels(idx)\n", 180 | "\n", 181 | " return batch_texts, batch_y" 182 | ] 183 | }, 184 | { 185 | "cell_type": "code", 186 | "execution_count": 6, 187 | "metadata": {}, 188 | "outputs": [], 189 | "source": [ 190 | "class BertClassifier(nn.Module):\n", 191 | "\n", 192 | " def __init__(self, dropout=0.5):\n", 193 | " super(BertClassifier, self).__init__()\n", 194 | " self.bert = BertModel.from_pretrained('bert-base-cased')\n", 195 | " self.dropout = nn.Dropout(dropout)\n", 196 | " self.linear = nn.Linear(768, 5)\n", 197 | " self.relu = nn.ReLU()\n", 198 | "\n", 199 | " def forward(self, input_id, mask):\n", 200 | " _, pooled_output = self.bert(input_ids= input_id, attention_mask=mask,return_dict=False)\n", 201 | " dropout_output = self.dropout(pooled_output)\n", 202 | " linear_output = self.linear(dropout_output)\n", 203 | " final_layer = self.relu(linear_output)\n", 204 | " return final_layer" 205 | ] 206 | }, 207 | { 208 | "cell_type": "code", 209 | "execution_count": 7, 210 | "metadata": {}, 211 | "outputs": [], 212 | "source": [ 213 | "def train(model, train_data, val_data, learning_rate, epochs):\n", 214 | "\n", 215 | " train, val = Dataset(train_data), Dataset(val_data)\n", 216 | "\n", 217 | " train_dataloader = torch.utils.data.DataLoader(train, batch_size=2, shuffle=True)\n", 218 | " val_dataloader = torch.utils.data.DataLoader(val, batch_size=2)\n", 219 | "\n", 220 | " use_cuda = torch.cuda.is_available()\n", 221 | " device = torch.device(\"cuda\" if use_cuda else \"cpu\")\n", 222 | "\n", 223 | " criterion = nn.CrossEntropyLoss()\n", 224 | " optimizer = Adam(model.parameters(), lr= learning_rate)\n", 225 | "\n", 226 | " if use_cuda:\n", 227 | " model = model.cuda()\n", 228 | " criterion = criterion.cuda()\n", 229 | "\n", 230 | " for epoch_num in range(epochs):\n", 231 | "\n", 232 | " total_acc_train = 0\n", 233 | " total_loss_train = 0\n", 234 | "\n", 235 | " for train_input, train_label in tqdm(train_dataloader):\n", 236 | "\n", 237 | " train_label = train_label.to(device)\n", 238 | " mask = train_input['attention_mask'].to(device)\n", 239 | " input_id = train_input['input_ids'].squeeze(1).to(device)\n", 240 | "\n", 241 | " output = model(input_id, mask)\n", 242 | " \n", 243 | " batch_loss = criterion(output, train_label.long())\n", 244 | " total_loss_train += batch_loss.item()\n", 245 | " \n", 246 | " acc = (output.argmax(dim=1) == train_label).sum().item()\n", 247 | " total_acc_train += acc\n", 248 | "\n", 249 | " model.zero_grad()\n", 250 | " batch_loss.backward()\n", 251 | " optimizer.step()\n", 252 | " \n", 253 | " total_acc_val = 0\n", 254 | " total_loss_val = 0\n", 255 | "\n", 256 | " with torch.no_grad():\n", 257 | "\n", 258 | " for val_input, val_label in val_dataloader:\n", 259 | "\n", 260 | " val_label = val_label.to(device)\n", 261 | " mask = val_input['attention_mask'].to(device)\n", 262 | " input_id = val_input['input_ids'].squeeze(1).to(device)\n", 263 | "\n", 264 | " output = model(input_id, mask)\n", 265 | "\n", 266 | " batch_loss = criterion(output, val_label.long())\n", 267 | " total_loss_val += batch_loss.item()\n", 268 | " \n", 269 | " acc = (output.argmax(dim=1) == val_label).sum().item()\n", 270 | " total_acc_val += acc\n", 271 | " \n", 272 | " print(\n", 273 | " f'Epochs: {epoch_num + 1} | Train Loss: {total_loss_train / len(train_data): .3f} | Train Accuracy: {total_acc_train / len(train_data): .3f} | Val Loss: {total_loss_val / len(val_data): .3f} | Val Accuracy: {total_acc_val / len(val_data): .3f}')\n", 274 | " " 275 | ] 276 | }, 277 | { 278 | "cell_type": "code", 279 | "execution_count": 8, 280 | "metadata": {}, 281 | "outputs": [], 282 | "source": [ 283 | "def evaluate(model, test_data):\n", 284 | "\n", 285 | " test = Dataset(test_data)\n", 286 | "\n", 287 | " test_dataloader = torch.utils.data.DataLoader(test, batch_size=2)\n", 288 | "\n", 289 | " use_cuda = torch.cuda.is_available()\n", 290 | " device = torch.device(\"cuda\" if use_cuda else \"cpu\")\n", 291 | "\n", 292 | " if use_cuda:\n", 293 | "\n", 294 | " model = model.cuda()\n", 295 | "\n", 296 | " total_acc_test = 0\n", 297 | " with torch.no_grad():\n", 298 | "\n", 299 | " for test_input, test_label in test_dataloader:\n", 300 | "\n", 301 | " test_label = test_label.to(device)\n", 302 | " mask = test_input['attention_mask'].to(device)\n", 303 | " input_id = test_input['input_ids'].squeeze(1).to(device)\n", 304 | "\n", 305 | " output = model(input_id, mask)\n", 306 | "\n", 307 | " acc = (output.argmax(dim=1) == test_label).sum().item()\n", 308 | " total_acc_test += acc\n", 309 | " \n", 310 | " print(f'Test Accuracy: {total_acc_test / len(test_data): .3f}')" 311 | ] 312 | }, 313 | { 314 | "cell_type": "code", 315 | "execution_count": 9, 316 | "metadata": {}, 317 | "outputs": [ 318 | { 319 | "name": "stdout", 320 | "output_type": "stream", 321 | "text": [ 322 | "1780 222 223\n" 323 | ] 324 | } 325 | ], 326 | "source": [ 327 | "np.random.seed(112)\n", 328 | "df_train, df_val, df_test = np.split(df.sample(frac=1, random_state=42), \n", 329 | " [int(.8*len(df)), int(.9*len(df))])\n", 330 | "\n", 331 | "print(len(df_train),len(df_val), len(df_test))\n" 332 | ] 333 | }, 334 | { 335 | "cell_type": "code", 336 | "execution_count": 11, 337 | "metadata": {}, 338 | "outputs": [ 339 | { 340 | "name": "stderr", 341 | "output_type": "stream", 342 | "text": [ 343 | "Some weights of the model checkpoint at bert-base-cased were not used when initializing BertModel: ['cls.predictions.transform.LayerNorm.weight', 'cls.predictions.decoder.weight', 'cls.seq_relationship.weight', 'cls.predictions.transform.dense.weight', 'cls.predictions.transform.LayerNorm.bias', 'cls.seq_relationship.bias', 'cls.predictions.bias', 'cls.predictions.transform.dense.bias']\n", 344 | "- This IS expected if you are initializing BertModel from the checkpoint of a model trained on another task or with another architecture (e.g. initializing a BertForSequenceClassification model from a BertForPreTraining model).\n", 345 | "- This IS NOT expected if you are initializing BertModel from the checkpoint of a model that you expect to be exactly identical (initializing a BertForSequenceClassification model from a BertForSequenceClassification model).\n", 346 | "100%|██████████| 890/890 [01:58<00:00, 7.48it/s]\n" 347 | ] 348 | }, 349 | { 350 | "name": "stdout", 351 | "output_type": "stream", 352 | "text": [ 353 | "Epochs: 1 | Train Loss: 0.756 | Train Accuracy: 0.347 | Val Loss: 0.639 | Val Accuracy: 0.541\n" 354 | ] 355 | }, 356 | { 357 | "name": "stderr", 358 | "output_type": "stream", 359 | "text": [ 360 | "100%|██████████| 890/890 [01:54<00:00, 7.79it/s]\n" 361 | ] 362 | }, 363 | { 364 | "name": "stdout", 365 | "output_type": "stream", 366 | "text": [ 367 | "Epochs: 2 | Train Loss: 0.543 | Train Accuracy: 0.626 | Val Loss: 0.441 | Val Accuracy: 0.734\n" 368 | ] 369 | } 370 | ], 371 | "source": [ 372 | "EPOCHS = 2\n", 373 | "model = BertClassifier()\n", 374 | "LR = 1e-6\n", 375 | " \n", 376 | "train(model, df_train, df_val, LR, EPOCHS)" 377 | ] 378 | }, 379 | { 380 | "cell_type": "code", 381 | "execution_count": 12, 382 | "metadata": {}, 383 | "outputs": [ 384 | { 385 | "name": "stdout", 386 | "output_type": "stream", 387 | "text": [ 388 | "Test Accuracy: 0.785\n" 389 | ] 390 | } 391 | ], 392 | "source": [ 393 | "evaluate(model, df_test)" 394 | ] 395 | } 396 | ], 397 | "metadata": { 398 | "kernelspec": { 399 | "display_name": "NLPenv", 400 | "language": "python", 401 | "name": "python3" 402 | }, 403 | "language_info": { 404 | "codemirror_mode": { 405 | "name": "ipython", 406 | "version": 3 407 | }, 408 | "file_extension": ".py", 409 | "mimetype": "text/x-python", 410 | "name": "python", 411 | "nbconvert_exporter": "python", 412 | "pygments_lexer": "ipython3", 413 | "version": "3.7.11 (default, Jul 27 2021, 14:32:16) \n[GCC 7.5.0]" 414 | }, 415 | "orig_nbformat": 4, 416 | "vscode": { 417 | "interpreter": { 418 | "hash": "061448e7adbb17b76f973e82ffc9480264f4afb56d4e5f7841a3e51b709e605b" 419 | } 420 | } 421 | }, 422 | "nbformat": 4, 423 | "nbformat_minor": 2 424 | } 425 | -------------------------------------------------------------------------------- /Esercitazione NLP Transformer/Esercitazione_pre_processing.ipynb: -------------------------------------------------------------------------------- 1 | { 2 | "cells": [ 3 | { 4 | "cell_type": "code", 5 | "execution_count": 1, 6 | "metadata": {}, 7 | "outputs": [], 8 | "source": [ 9 | "#create python env\n", 10 | "\n", 11 | "#conda install pip\n", 12 | "#pip install transformers\n", 13 | "#https://huggingface.co/docs/transformers/installation\n", 14 | "#conda install -c anaconda pandas\n", 15 | "#conda install numpy\n", 16 | "#conda install -c conda-forge tqdm\n", 17 | "#conda install pytorch torchvision torchaudio cudatoolkit=11.3 -c pytorch\n", 18 | "#conda install -c conda-forge matplotlib\n", 19 | "\n", 20 | "#Dataset - SemEval 2010 task 8\n", 21 | "#https://semeval2.fbk.eu/semeval2.php?location=data\n" 22 | ] 23 | }, 24 | { 25 | "cell_type": "code", 26 | "execution_count": 2, 27 | "metadata": {}, 28 | "outputs": [], 29 | "source": [ 30 | "import re\n", 31 | "import numpy as np\n", 32 | "import pandas as pd\n", 33 | "from tqdm import tqdm\n", 34 | "import torch\n", 35 | "from torch import nn\n", 36 | "from torch.optim import Adam" 37 | ] 38 | }, 39 | { 40 | "cell_type": "code", 41 | "execution_count": 3, 42 | "metadata": {}, 43 | "outputs": [ 44 | { 45 | "name": "stdout", 46 | "output_type": "stream", 47 | "text": [ 48 | "Number of relations 19\n" 49 | ] 50 | } 51 | ], 52 | "source": [ 53 | "# create array with labels\n", 54 | "labels_names = [\n", 55 | " 'Cause-Effect(e1,e2)',\n", 56 | " 'Cause-Effect(e2,e1)',\n", 57 | " 'Instrument-Agency(e1,e2)',\n", 58 | " 'Instrument-Agency(e2,e1)',\n", 59 | " 'Product-Producer(e1,e2)',\n", 60 | " 'Product-Producer(e2,e1)',\n", 61 | " 'Content-Container(e1,e2)',\n", 62 | " 'Content-Container(e2,e1)',\n", 63 | " 'Entity-Origin(e1,e2)',\n", 64 | " 'Entity-Origin(e2,e1)',\n", 65 | " 'Entity-Destination(e1,e2)',\n", 66 | " 'Entity-Destination(e2,e1)',\n", 67 | " 'Component-Whole(e1,e2)',\n", 68 | " 'Component-Whole(e2,e1)',\n", 69 | " 'Member-Collection(e1,e2)',\n", 70 | " 'Member-Collection(e2,e1)',\n", 71 | " 'Message-Topic(e2,e1)',\n", 72 | " 'Message-Topic(e1,e2)',\n", 73 | " 'Other'\n", 74 | "]\n", 75 | "\n", 76 | "print(\"Number of relations \"+str(len(labels_names)))\n", 77 | "\n", 78 | "# Dataset dimentions\n", 79 | "\n", 80 | "N_SAMPLE_TRAIN = 7109\n", 81 | "N_SAMPLE_VAL = 891\n", 82 | "N_SAMPLE_TEST = 2717" 83 | ] 84 | }, 85 | { 86 | "cell_type": "code", 87 | "execution_count": 4, 88 | "metadata": {}, 89 | "outputs": [ 90 | { 91 | "name": "stdout", 92 | "output_type": "stream", 93 | "text": [ 94 | "Number of train phrases 7109\n", 95 | "Number of validation phrases 891\n" 96 | ] 97 | } 98 | ], 99 | "source": [ 100 | "# loading the training data\n", 101 | "PATH = '/home/isiragusa/irene/NLP General/'\n", 102 | "f = open(PATH+\"dataset/SemEval2010/TRAIN_FILE.TXT\", \"r\")\n", 103 | "line = f.readline()\n", 104 | "train_complete = []\n", 105 | "val_complete = []\n", 106 | "for i in range(N_SAMPLE_TRAIN + N_SAMPLE_VAL):\n", 107 | " if re.match(r'[0-9]', line) :\n", 108 | " phrase = line.split(\"\\t\")[1]\n", 109 | " phrase = phrase[1:-3]\n", 110 | "\n", 111 | " entities = []\n", 112 | "\n", 113 | " phs = re.search('(.+?)', phrase)\n", 114 | " if phs:\n", 115 | " entities.append(phs.group(1))\n", 116 | " phs = re.search('(.+?)', phrase)\n", 117 | " if phs:\n", 118 | " entities.append(phs.group(1))\n", 119 | "\n", 120 | " phrase = phrase.replace(\"\",\"\").replace(\"\",\"\").replace(\"\",\"\").replace(\"\",\"\")\n", 121 | "\n", 122 | " line = f.readline()\n", 123 | " rel = line[:-1]\n", 124 | " # indexing labels \n", 125 | " rel = labels_names.index(rel)\n", 126 | " # read comment \n", 127 | " line = f.readline()\n", 128 | " # read space between phrases\n", 129 | " line = f.readline()\n", 130 | " # append the extracted elements\n", 131 | " if i>= N_SAMPLE_TRAIN:\n", 132 | " val_complete.append((phrase, entities[0], entities[1], rel)) \n", 133 | " else:\n", 134 | " train_complete.append((phrase, entities[0], entities[1], rel)) \n", 135 | " # preparing for next block\n", 136 | " line = f.readline()\n", 137 | "\n", 138 | "print(\"Number of train phrases \"+str(len(train_complete)))\n", 139 | "print(\"Number of validation phrases \"+str(len(val_complete)))" 140 | ] 141 | }, 142 | { 143 | "cell_type": "code", 144 | "execution_count": 5, 145 | "metadata": {}, 146 | "outputs": [ 147 | { 148 | "name": "stdout", 149 | "output_type": "stream", 150 | "text": [ 151 | "Number of test phrases 2717\n" 152 | ] 153 | } 154 | ], 155 | "source": [ 156 | "# loading the test data\n", 157 | "f = open(PATH+\"dataset/SemEval2010/TEST_FILE.TXT\", \"r\")\n", 158 | "line = f.readline()\n", 159 | "phrases_test = []\n", 160 | "labels_test = []\n", 161 | "id_test = []\n", 162 | "test_complete = []\n", 163 | "for i in range(N_SAMPLE_TEST):\n", 164 | " if re.match(r'[0-9]', line) :\n", 165 | " phrase = line.split(\"\\t\")\n", 166 | " id = phrase[0]\n", 167 | " phrase = phrase[1]\n", 168 | " phrase = phrase[1:-3]\n", 169 | " entities = []\n", 170 | "\n", 171 | " phs = re.search('(.+?)', phrase)\n", 172 | " if phs:\n", 173 | " entities.append(phs.group(1))\n", 174 | " phs = re.search('(.+?)', phrase)\n", 175 | " if phs:\n", 176 | " entities.append(phs.group(1))\n", 177 | "\n", 178 | " phrase = phrase.replace(\"\",\"\").replace(\"\",\"\").replace(\"\",\"\").replace(\"\",\"\")\n", 179 | " \n", 180 | " line = f.readline()\n", 181 | " rel = line[:-1]\n", 182 | " # indexing labels \n", 183 | " rel = labels_names.index(rel)\n", 184 | " # read comment \n", 185 | " line = f.readline()\n", 186 | " # read space between phrases\n", 187 | " line = f.readline()\n", 188 | " # append the new tuple\n", 189 | " phrases_test.append([phrase])\n", 190 | " labels_test.append([rel])\n", 191 | " id_test.append(id)\n", 192 | " test_complete.append((phrase, entities[0], entities[1],rel)) \n", 193 | " # preparing for next block\n", 194 | " line = f.readline()\n", 195 | "\n", 196 | "print(\"Number of test phrases \"+str(len(test_complete)))" 197 | ] 198 | }, 199 | { 200 | "cell_type": "code", 201 | "execution_count": 6, 202 | "metadata": {}, 203 | "outputs": [], 204 | "source": [ 205 | "# create the dataframes\n", 206 | "df_train = pd.DataFrame.from_records(train_complete, columns = ['Phrase', 'E1', 'E2', 'Label'])\n", 207 | "df_val = pd.DataFrame.from_records(val_complete, columns = ['Phrase', 'E1', 'E2', 'Label'])\n", 208 | "df_test = pd.DataFrame.from_records(test_complete, columns = ['Phrase', 'E1', 'E2', 'Label'])\n", 209 | "\n", 210 | "df_train.to_csv(PATH+\"Esercitazione/train_cured.csv\", index = False)\n", 211 | "df_val.to_csv(PATH+\"Esercitazione/val_cured.csv\", index = False)\n", 212 | "df_test.to_csv(PATH+\"Esercitazione/test_cured.csv\", index = False)" 213 | ] 214 | }, 215 | { 216 | "cell_type": "code", 217 | "execution_count": 7, 218 | "metadata": {}, 219 | "outputs": [ 220 | { 221 | "name": "stderr", 222 | "output_type": "stream", 223 | "text": [ 224 | "Some weights of the model checkpoint at bert-base-uncased were not used when initializing BertModel: ['cls.seq_relationship.bias', 'cls.predictions.bias', 'cls.predictions.transform.LayerNorm.weight', 'cls.predictions.transform.LayerNorm.bias', 'cls.predictions.transform.dense.bias', 'cls.predictions.decoder.weight', 'cls.predictions.transform.dense.weight', 'cls.seq_relationship.weight']\n", 225 | "- This IS expected if you are initializing BertModel from the checkpoint of a model trained on another task or with another architecture (e.g. initializing a BertForSequenceClassification model from a BertForPreTraining model).\n", 226 | "- This IS NOT expected if you are initializing BertModel from the checkpoint of a model that you expect to be exactly identical (initializing a BertForSequenceClassification model from a BertForSequenceClassification model).\n" 227 | ] 228 | } 229 | ], 230 | "source": [ 231 | "from transformers import AutoConfig, AutoModel, AutoTokenizer\n", 232 | "\n", 233 | "model_name = \"bert-base-uncased\"\n", 234 | "config = AutoConfig.from_pretrained(model_name)\n", 235 | "tokenizer = AutoTokenizer.from_pretrained(model_name)\n", 236 | "model = AutoModel.from_pretrained(model_name, config=config)" 237 | ] 238 | }, 239 | { 240 | "cell_type": "code", 241 | "execution_count": 10, 242 | "metadata": {}, 243 | "outputs": [ 244 | { 245 | "name": "stdout", 246 | "output_type": "stream", 247 | "text": [ 248 | "Loading bert-base-uncased ...\n", 249 | "bert-base-uncased loaded\n" 250 | ] 251 | } 252 | ], 253 | "source": [ 254 | "print(\"Loading \"+model_name+\" ...\")\n", 255 | "if torch.cuda.is_available():\n", 256 | " device = torch.device(\"cuda:0\")\n", 257 | " model.to(device)\n", 258 | " print(model_name+\" loaded\")" 259 | ] 260 | }, 261 | { 262 | "cell_type": "code", 263 | "execution_count": 12, 264 | "metadata": {}, 265 | "outputs": [ 266 | { 267 | "name": "stdout", 268 | "output_type": "stream", 269 | "text": [ 270 | "People have been moving back into downtown\n", 271 | "['people', 'have', 'been', 'moving', 'back', 'into', 'downtown']\n", 272 | "{'input_ids': tensor([[2111, 2031, 2042, 3048, 2067, 2046, 5116]]), 'token_type_ids': tensor([[0, 0, 0, 0, 0, 0, 0]]), 'attention_mask': tensor([[1, 1, 1, 1, 1, 1, 1]])}\n", 273 | "{'input_ids': tensor([[ 101, 2111, 2031, 2042, 3048, 2067, 2046, 5116, 102]]), 'token_type_ids': tensor([[0, 0, 0, 0, 0, 0, 0, 0, 0]]), 'attention_mask': tensor([[1, 1, 1, 1, 1, 1, 1, 1, 1]])}\n" 274 | ] 275 | } 276 | ], 277 | "source": [ 278 | "i = 7\n", 279 | "sent = df_train['Phrase'][i]\n", 280 | "print(sent)\n", 281 | "tokens = tokenizer.tokenize(sent)\n", 282 | "print(tokens)\n", 283 | "tokens_ids = tokenizer(sent, add_special_tokens=False, return_tensors=\"pt\")\n", 284 | "print(tokens_ids)\n", 285 | "\n", 286 | "tokens_ids = tokenizer(sent, add_special_tokens=True, return_tensors=\"pt\")\n", 287 | "print(tokens_ids)" 288 | ] 289 | }, 290 | { 291 | "cell_type": "code", 292 | "execution_count": 13, 293 | "metadata": {}, 294 | "outputs": [], 295 | "source": [ 296 | "input = tokens_ids['input_ids'].to(device) \n", 297 | "att_mask = tokens_ids['attention_mask'].to(device) \n", 298 | "with torch.no_grad():\n", 299 | " last_hidden_states = model(input, attention_mask=att_mask)\n", 300 | "input = input.detach().cpu()\n", 301 | "att_mask = att_mask.detach().cpu()\n", 302 | "emb = last_hidden_states[0][0,0,:].detach().cpu()" 303 | ] 304 | }, 305 | { 306 | "cell_type": "code", 307 | "execution_count": null, 308 | "metadata": {}, 309 | "outputs": [], 310 | "source": [ 311 | "last_hidden_states" 312 | ] 313 | }, 314 | { 315 | "cell_type": "code", 316 | "execution_count": 15, 317 | "metadata": {}, 318 | "outputs": [ 319 | { 320 | "data": { 321 | "text/plain": [ 322 | "torch.Size([1, 9, 768])" 323 | ] 324 | }, 325 | "execution_count": 15, 326 | "metadata": {}, 327 | "output_type": "execute_result" 328 | } 329 | ], 330 | "source": [ 331 | "last_hidden_states[0].shape" 332 | ] 333 | }, 334 | { 335 | "cell_type": "code", 336 | "execution_count": 17, 337 | "metadata": {}, 338 | "outputs": [ 339 | { 340 | "data": { 341 | "text/plain": [ 342 | "torch.Size([768])" 343 | ] 344 | }, 345 | "execution_count": 17, 346 | "metadata": {}, 347 | "output_type": "execute_result" 348 | } 349 | ], 350 | "source": [ 351 | "emb.shape" 352 | ] 353 | }, 354 | { 355 | "cell_type": "code", 356 | "execution_count": null, 357 | "metadata": {}, 358 | "outputs": [], 359 | "source": [ 360 | "def gen_tokens_mask(df, tokenizer):\n", 361 | " phrases_list = [elem for elem in df['Phrase']]\n", 362 | " tokenized = []\n", 363 | " for i, doc in enumerate(tqdm(phrases_list, desc='generating tokens')):\n", 364 | " tokenized.append(tokenizer(doc, add_special_tokens=True, return_tensors=\"pt\"))\n", 365 | "\n", 366 | " return tokenized\n", 367 | "\n", 368 | "tokenized_train = gen_tokens_mask(df_train, tokenizer)\n", 369 | "tokenized_val = gen_tokens_mask(df_val, tokenizer)\n", 370 | "tokenized_test = gen_tokens_mask(df_test, tokenizer)\n", 371 | "\n", 372 | "def gen_embeddings_doc(tok_attention_mask, model, device):\n", 373 | " phrase_embeddings = []\n", 374 | " for i in tqdm(range(len(tok_attention_mask)), desc='gen embeddings phrases'): # for sentence\n", 375 | " input = torch.tensor(np.array(tok_attention_mask[i]['input_ids'])).to(device) \n", 376 | " att_mask = torch.tensor(np.array(tok_attention_mask[i]['attention_mask'])).to(device) \n", 377 | " with torch.no_grad():\n", 378 | " last_hidden_states = model(input, attention_mask=att_mask)\n", 379 | " input = input.detach().cpu()\n", 380 | " att_mask = att_mask.detach().cpu()\n", 381 | " emb = last_hidden_states[0][0,0,:].detach().cpu()\n", 382 | " phrase_embeddings.append(emb)\n", 383 | " \n", 384 | " return torch.stack(phrase_embeddings)\n", 385 | "\n", 386 | "embeddings_train = gen_embeddings_doc(tokenized_train, model, device)\n", 387 | "embeddings_val = gen_embeddings_doc(tokenized_val, model, device)\n", 388 | "embeddings_test = gen_embeddings_doc(tokenized_test, model, device)" 389 | ] 390 | } 391 | ], 392 | "metadata": { 393 | "kernelspec": { 394 | "display_name": "NLPenv", 395 | "language": "python", 396 | "name": "python3" 397 | }, 398 | "language_info": { 399 | "codemirror_mode": { 400 | "name": "ipython", 401 | "version": 3 402 | }, 403 | "file_extension": ".py", 404 | "mimetype": "text/x-python", 405 | "name": "python", 406 | "nbconvert_exporter": "python", 407 | "pygments_lexer": "ipython3", 408 | "version": "3.7.11 (default, Jul 27 2021, 14:32:16) \n[GCC 7.5.0]" 409 | }, 410 | "orig_nbformat": 4, 411 | "vscode": { 412 | "interpreter": { 413 | "hash": "061448e7adbb17b76f973e82ffc9480264f4afb56d4e5f7841a3e51b709e605b" 414 | } 415 | } 416 | }, 417 | "nbformat": 4, 418 | "nbformat_minor": 2 419 | } 420 | -------------------------------------------------------------------------------- /Esercitazione NLP Transformer/RNN and Trasformers in NLP.pdf: -------------------------------------------------------------------------------- https://raw.githubusercontent.com/fredffsixty/Big-Data/896430d4821c623d14fbf05beae34fe1afbd7a2d/Esercitazione NLP Transformer/RNN and Trasformers in NLP.pdf -------------------------------------------------------------------------------- /Esercitazioni Hadoop/.DS_Store: -------------------------------------------------------------------------------- https://raw.githubusercontent.com/fredffsixty/Big-Data/896430d4821c623d14fbf05beae34fe1afbd7a2d/Esercitazioni Hadoop/.DS_Store -------------------------------------------------------------------------------- /Esercitazioni Hadoop/SurvivedPassengers/.DS_Store: -------------------------------------------------------------------------------- https://raw.githubusercontent.com/fredffsixty/Big-Data/896430d4821c623d14fbf05beae34fe1afbd7a2d/Esercitazioni Hadoop/SurvivedPassengers/.DS_Store -------------------------------------------------------------------------------- /Esercitazioni Hadoop/SurvivedPassengers/.vscode/settings.json: -------------------------------------------------------------------------------- 1 | { 2 | "java.project.referencedLibraries": [ 3 | "lib/**/*.jar", 4 | "/usr/local/Cellar/hadoop/3.3.0/libexec/share/hadoop/common/**/*.jar", 5 | "/usr/local/Cellar/hadoop/3.3.0/libexec/share/hadoop/mapreduce/**/*.jar" 6 | ] 7 | } -------------------------------------------------------------------------------- /Esercitazioni Hadoop/SurvivedPassengers/README.md: -------------------------------------------------------------------------------- 1 | ## Getting Started 2 | 3 | Welcome to the VS Code Java world. Here is a guideline to help you get started to write Java code in Visual Studio Code. 4 | 5 | ## Folder Structure 6 | 7 | The workspace contains two folders by default, where: 8 | 9 | - `src`: the folder to maintain sources 10 | - `lib`: the folder to maintain dependencies 11 | 12 | ## Dependency Management 13 | 14 | The `JAVA DEPENDENCIES` view allows you to manage your dependencies. More details can be found [here](https://github.com/microsoft/vscode-java-pack/blob/master/release-notes/v0.9.0.md#work-with-jar-files-directly). 15 | -------------------------------------------------------------------------------- /Esercitazioni Hadoop/SurvivedPassengers/SurvivedPassengers.jar: -------------------------------------------------------------------------------- https://raw.githubusercontent.com/fredffsixty/Big-Data/896430d4821c623d14fbf05beae34fe1afbd7a2d/Esercitazioni Hadoop/SurvivedPassengers/SurvivedPassengers.jar -------------------------------------------------------------------------------- /Esercitazioni Hadoop/SurvivedPassengers/src/.DS_Store: -------------------------------------------------------------------------------- https://raw.githubusercontent.com/fredffsixty/Big-Data/896430d4821c623d14fbf05beae34fe1afbd7a2d/Esercitazioni Hadoop/SurvivedPassengers/src/.DS_Store -------------------------------------------------------------------------------- /Esercitazioni Hadoop/SurvivedPassengers/src/survivedpassengers/SurvivedPassengersDriver.java: -------------------------------------------------------------------------------- 1 | package survivedpassengers; 2 | 3 | import org.apache.hadoop.fs.Path; 4 | import org.apache.hadoop.io.*; 5 | import org.apache.hadoop.mapred.*; 6 | 7 | public class SurvivedPassengersDriver { 8 | public static void main(String[] args) { 9 | 10 | // Create a configuration object for the job 11 | JobConf conf = new JobConf(SurvivedPassengersDriver.class); 12 | 13 | // Set a name of the Job 14 | conf.setJobName("SurvivedPerClass"); 15 | 16 | // Specify data type of output key and value 17 | conf.setOutputKeyClass(IntWritable.class); 18 | conf.setOutputValueClass(Text.class); 19 | 20 | // Specify data type for mapper output key and value 21 | conf.setMapOutputKeyClass(IntWritable.class); 22 | conf.setMapOutputValueClass(Text.class); 23 | 24 | // Specify names of Mapper and Reducer Class 25 | conf.setMapperClass(survivedpassengers.SurvivedPassengersMap.class); 26 | conf.setReducerClass(survivedpassengers.SurvivedPassengersReduce.class); 27 | 28 | // Specify formats of the data type of Input and output 29 | conf.setInputFormat(TextInputFormat.class); 30 | conf.setOutputFormat(TextOutputFormat.class); 31 | 32 | // Set input and output directories using command line arguments, 33 | //arg[0] = name of input directory on HDFS, 34 | // and arg[1] = name of output directory to be created to store the output file. 35 | 36 | FileInputFormat.setInputPaths(conf, new Path(args[0])); 37 | FileOutputFormat.setOutputPath(conf, new Path(args[1])); 38 | 39 | try { 40 | // Run the job 41 | JobClient.runJob(conf); 42 | } catch (Exception e) { 43 | e.printStackTrace(); 44 | } 45 | } 46 | } 47 | -------------------------------------------------------------------------------- /Esercitazioni Hadoop/SurvivedPassengers/src/survivedpassengers/SurvivedPassengersMap.java: -------------------------------------------------------------------------------- 1 | package survivedpassengers; 2 | 3 | import java.io.IOException; 4 | 5 | import org.apache.hadoop.io.IntWritable; 6 | import org.apache.hadoop.io.LongWritable; 7 | import org.apache.hadoop.io.Text; 8 | import org.apache.hadoop.mapred.*; 9 | 10 | public class SurvivedPassengersMap extends MapReduceBase implements Mapper { 11 | 12 | 13 | public void map(LongWritable key, Text value, OutputCollector output, Reporter reporter) throws IOException { 14 | 15 | String passengerRecord = Text.decode(value.copyBytes()); 16 | 17 | String[] passengerData = passengerRecord.split(","); 18 | 19 | String status = ""; 20 | 21 | int survived = Integer.parseInt(passengerData[1]); 22 | 23 | if (passengerRecord.indexOf(",male,") > -1) 24 | status = "male," + (survived == 1 ? "survived" : "dead"); 25 | else if (passengerRecord.indexOf(",female,") > -1) 26 | status="female," + (survived == 1 ? "survived" : "dead"); 27 | 28 | output.collect(new IntWritable(Integer.parseInt(passengerData[2])), new Text(status)); 29 | } 30 | } 31 | 32 | -------------------------------------------------------------------------------- /Esercitazioni Hadoop/SurvivedPassengers/src/survivedpassengers/SurvivedPassengersReduce.java: -------------------------------------------------------------------------------- 1 | package survivedpassengers; 2 | 3 | import java.io.IOException; 4 | import java.util.*; 5 | 6 | import org.apache.hadoop.io.IntWritable; 7 | import org.apache.hadoop.io.Text; 8 | import org.apache.hadoop.mapred.*; 9 | 10 | public class SurvivedPassengersReduce extends MapReduceBase implements Reducer { 11 | 12 | public void reduce(IntWritable pclass, Iterator values, OutputCollector output, Reporter reporter) throws IOException { 13 | 14 | float embarkedMales = 0; 15 | float embarkedFemales = 0; 16 | float survivedFemales = 0; 17 | float survivedMales = 0; 18 | 19 | IntWritable passengersClass = pclass; 20 | 21 | 22 | while (values.hasNext()) { 23 | 24 | String[] passenger = Text.decode(values.next().copyBytes()).split(","); 25 | 26 | if (passenger[0].equals("male")){ 27 | embarkedMales += 1; 28 | survivedMales += passenger[1].equals("survived") ? 1 : 0; 29 | } 30 | else if (passenger[0].equals("female")){ 31 | embarkedFemales +=1; 32 | survivedFemales += passenger[1].equals("survived") ? 1 : 0; 33 | } 34 | 35 | } 36 | 37 | survivedMales = 100 * survivedMales / (embarkedMales == 0.0 ? 1 : embarkedMales); // avoid division by 0 38 | survivedFemales = 100 * survivedFemales / (embarkedFemales == 0.0 ? 1 : embarkedFemales); 39 | 40 | String result = Float.toString(survivedMales) + ", " + Float.toString(survivedFemales); 41 | 42 | output.collect(passengersClass, new Text(result)); 43 | } 44 | } 45 | -------------------------------------------------------------------------------- /Esercitazioni Hadoop/csv transform.hql: -------------------------------------------------------------------------------- 1 | create table passengers (id int, survived int, class int, name varchar(64), sex varchar(8), age float, sibsp int, parch int, ticket varchar(20), fare float, cabin varchar(20), embarked char(1)) row format serde 'org.apache.hadoop.hive.serde2.OpenCSVSerde' TBLPROPERTIES ("skip.header.line.count"="1"); 2 | 3 | load data local inpath '/home/cloudera/InputMapReduce/titanic.csv' into table passengers; 4 | 5 | create table passengers_qualified (id int, survived int, class int, name varchar(64), sex varchar(8), age float, sibsp int, parch int, ticket varchar(20), fare float, cabin varchar(20), embarked char(1)) row format delimited fields terminated by '\t'; 6 | 7 | insert overwrite table passengers_qualified select * from passengers; 8 | 9 | -------------------------------------------------------------------------------- /Esercitazioni Hadoop/percentage_pig.js: -------------------------------------------------------------------------------- 1 | percentage.OutputSchema = "perc:double"; 2 | 3 | function percentage(num, total){ 4 | return num * 100.0 / total; 5 | } 6 | -------------------------------------------------------------------------------- /Esercitazioni Hadoop/percentage_pig.py: -------------------------------------------------------------------------------- 1 | from pig_util import outputSchema; 2 | 3 | @outputSchema("perc: double") 4 | def percentage(num, total): 5 | return num*100/total; 6 | -------------------------------------------------------------------------------- /Esercitazioni Hadoop/survived_passengers.pig: -------------------------------------------------------------------------------- 1 | -- register 'percentage_pig.py' using streaming_python as myfuncs; 2 | -- register 'percentage_pig.js' using javascript as myfuncs; 3 | 4 | titanic = load 'hdfs://localhost/InputMapReduce/titanic_qualified.csv' using PigStorage() as (id:int, survived:int, class:int, name:chararray, sex:chararray,age:int, sibsp:int, parch:int, ticket:chararray, fare:double, cabin:chararray, embarked:chararray); 5 | 6 | embarked = group titanic by (sex,class); 7 | 8 | embarked_totals = FOREACH embarked GENERATE $0, COUNT(titanic); 9 | 10 | survived = filter titanic by survived == 1; 11 | 12 | survived_grouped = group survived by (sex,class); 13 | 14 | embarked_survived = JOIN survived_grouped BY $0, embarked_totals BY $0; 15 | 16 | survived_counts = FOREACH embarked_survived GENERATE $0, COUNT(survived), (float)COUNT(survived)*100.0/(float)$3, AVG(survived.age); 17 | 18 | -- survived_stats = FOREACH survived_counts GENERATE $0, $1, myfuncs.percentage($1,$2), $3; 19 | 20 | store survived_counts into 'hdfs://localhost/output_map_reduce/survived_stats' using PigStorage(); 21 | -------------------------------------------------------------------------------- /Integrazione Kafka Spark.ipynb: -------------------------------------------------------------------------------- 1 | { 2 | "cells": [ 3 | { 4 | "cell_type": "markdown", 5 | "metadata": {}, 6 | "source": [ 7 | "# Architettura di Kafka\n", 8 | "\n", 9 | "## Topic\n", 10 | "\n", 11 | "![Topic](https://miro.medium.com/max/4800/1*QssD-sG_L5rGzwP2TbpMuQ.webp \"Topic\")" 12 | ] 13 | }, 14 | { 15 | "cell_type": "markdown", 16 | "metadata": {}, 17 | "source": [ 18 | "## Broker\n", 19 | "\n", 20 | "![Broker](https://miro.medium.com/max/4800/1*Mp8m-nnX1L4LpMmgonhSZA.webp \"Broker\")" 21 | ] 22 | }, 23 | { 24 | "cell_type": "markdown", 25 | "metadata": {}, 26 | "source": [ 27 | "## Partizioni\n", 28 | "\n", 29 | "![Partizioni](https://miro.medium.com/max/4800/1*llGE-5Cgf2dXdUHVSuZL8w.webp \"Partizioni\")" 30 | ] 31 | }, 32 | { 33 | "cell_type": "markdown", 34 | "metadata": {}, 35 | "source": [ 36 | "## Producer\n", 37 | "\n", 38 | "![Producer](https://miro.medium.com/max/4800/1*F1bHGiLwS-MwlO9M0Ziktw.webp \"Producer\")" 39 | ] 40 | }, 41 | { 42 | "cell_type": "markdown", 43 | "metadata": {}, 44 | "source": [ 45 | "## Consumer\n", 46 | "\n", 47 | "![Consumer](https://miro.medium.com/max/1400/1*t1YCrA_3ucJs7zBOM3v5bg.webp \"Consumer\")" 48 | ] 49 | }, 50 | { 51 | "cell_type": "markdown", 52 | "metadata": {}, 53 | "source": [ 54 | "## Uso di Zookeeper\n", 55 | "\n", 56 | "![Zookeeper](https://miro.medium.com/max/4800/1*_vvrISaOtrVFV7lq4DO5bA.webp \"Zookeeper\")" 57 | ] 58 | }, 59 | { 60 | "cell_type": "markdown", 61 | "metadata": {}, 62 | "source": [ 63 | "## Architettura generale\n", 64 | "\n", 65 | "![Generale](https://miro.medium.com/max/1400/1*ZTA4pEuZZwc544vstwZ5Hw.webp \"Architettura\")" 66 | ] 67 | }, 68 | { 69 | "cell_type": "markdown", 70 | "metadata": {}, 71 | "source": [ 72 | "## Note di installazione\n", 73 | "\n", 74 | "Un buon tutorial per Unix/Mac si può trovare al seguente [link](https://www.digitalocean.com/community/tutorials/how-to-install-apache-kafka-on-ubuntu-18-04). Essenzialmente, l'installazione prevede la creazione di un utente `kafka` che abbia anche i privilegi di _sudoer_ e l'opportuna modifica del file di configurazione che si trova in `/config/server.properties`. Addizionalmente si può configurare `Kafka` come servizio che parte al bootstrap e fa partire automaticamente anche `Zookeeper`.\n", 75 | "\n", 76 | "Inoltre, può essere sempre utile aggiungere al proprio `PATH` il percorso di esecuzione di `Kafka`:\n", 77 | "\n", 78 | "```bash\n", 79 | "export KAFKA_HOME=/home/kafka/kafka\n", 80 | "export PATH=$PATH:$KAFKA_HOME/bin\n", 81 | "````\n", 82 | "\n", 83 | "\n", 84 | "Le ultime versioni di Kafka supportano delle opzioni da linea di comando differenti per fare riferimento a `Zookeeper` e anche la porta di default è cambiata, per cui l'opzione `--zookeeper localhost:2181` è stata sostituita da `--bootstrap-server localhost:9092`.\n", 85 | "\n" 86 | ] 87 | }, 88 | { 89 | "cell_type": "markdown", 90 | "metadata": {}, 91 | "source": [ 92 | "## Comandi principali\n", 93 | "\n", 94 | "- Avvio manuale dei server\n", 95 | " ```bash\n", 96 | " zookeeper-server-start $KAFKA_HOME/config/zookeeper.properties\n", 97 | " kafka-server-start $KAFKA_HOME/config/server.properties\n", 98 | " ````\n", 99 | "\n", 100 | "- Creazione/cancellazione di un topic\n", 101 | " ```bash\n", 102 | " kafka-topics --bootstrap-server localhost:9092 --create --replication-factor 1 --partitions 1 --topic \n", 103 | " kafka-topics --bootstrap-server localhost:9092 --delete --topic \n", 104 | " ````\n", 105 | "\n", 106 | "- Descrizione/lista dei topic\n", 107 | " ```bash\n", 108 | " kafka-topics --bootstrap-server localhost:9092 --describe --topic \n", 109 | " kafka-topics --bootstrap-server localhost:9092 --list\n", 110 | " ````\n", 111 | "\n", 112 | "- Creazione di un producer/consumer sul topic\n", 113 | " ```bash\n", 114 | " kafka-console-producer --bootstrap-server localhost:9092 --topic \n", 115 | " kafka-console-consumer --bootstrap-server localhost:9092 --topic \n", 116 | " ```" 117 | ] 118 | }, 119 | { 120 | "cell_type": "markdown", 121 | "metadata": {}, 122 | "source": [ 123 | "## Interfaccia Kafka in Python\n", 124 | "\n", 125 | "Va installato il pacchetto `kafka-python`, usando:\n", 126 | "\n", 127 | "```bash\n", 128 | "pip install kafka-python\n", 129 | "```\n", 130 | "\n", 131 | "Il pacchetto consente di definire un oggetto `KafkaProducer` ed un `KafkaConsumer`:\n", 132 | "\n", 133 | "```python\n", 134 | "from kafka import KafkaProducer, KafkaConsumer\n", 135 | "\n", 136 | "kafka_producer_obj = KafkaProducer(bootstrap_servers=_lista_server_)\n", 137 | "kafka_producer_obj.send(_nome_del_topic_, _stringa_messaggio_)\n", 138 | "\n", 139 | "consumer = KafkaConsumer(_nome_del_topic_,\\\n", 140 | " bootstrap_servers=_lista_server_,\\\n", 141 | " auto_offset_reset='latest',\\\n", 142 | " enable_auto_commit=True)\n", 143 | "\n", 144 | "```\n", 145 | "\n", 146 | "l'oggetto `consumer` è un iterabile da cui si scorrono i messaggi pubblicati nel topic." 147 | ] 148 | }, 149 | { 150 | "cell_type": "code", 151 | "execution_count": null, 152 | "metadata": {}, 153 | "outputs": [], 154 | "source": [] 155 | } 156 | ], 157 | "metadata": { 158 | "kernelspec": { 159 | "display_name": "Python 3.10.8 ('hadoop': venv)", 160 | "language": "python", 161 | "name": "python3" 162 | }, 163 | "language_info": { 164 | "name": "python", 165 | "version": "3.10.8" 166 | }, 167 | "orig_nbformat": 4, 168 | "vscode": { 169 | "interpreter": { 170 | "hash": "7553610f36a6045c2ac2337af6058c76912cf39c898d6f43a14b359d55f82e5b" 171 | } 172 | } 173 | }, 174 | "nbformat": 4, 175 | "nbformat_minor": 2 176 | } 177 | -------------------------------------------------------------------------------- /LICENSE: -------------------------------------------------------------------------------- 1 | MIT License 2 | 3 | Copyright (c) 2019 fredffsixty 4 | 5 | Permission is hereby granted, free of charge, to any person obtaining a copy 6 | of this software and associated documentation files (the "Software"), to deal 7 | in the Software without restriction, including without limitation the rights 8 | to use, copy, modify, merge, publish, distribute, sublicense, and/or sell 9 | copies of the Software, and to permit persons to whom the Software is 10 | furnished to do so, subject to the following conditions: 11 | 12 | The above copyright notice and this permission notice shall be included in all 13 | copies or substantial portions of the Software. 14 | 15 | THE SOFTWARE IS PROVIDED "AS IS", WITHOUT WARRANTY OF ANY KIND, EXPRESS OR 16 | IMPLIED, INCLUDING BUT NOT LIMITED TO THE WARRANTIES OF MERCHANTABILITY, 17 | FITNESS FOR A PARTICULAR PURPOSE AND NONINFRINGEMENT. IN NO EVENT SHALL THE 18 | AUTHORS OR COPYRIGHT HOLDERS BE LIABLE FOR ANY CLAIM, DAMAGES OR OTHER 19 | LIABILITY, WHETHER IN AN ACTION OF CONTRACT, TORT OR OTHERWISE, ARISING FROM, 20 | OUT OF OR IN CONNECTION WITH THE SOFTWARE OR THE USE OR OTHER DEALINGS IN THE 21 | SOFTWARE. 22 | -------------------------------------------------------------------------------- /Lezioni teoriche/.ipynb_checkpoints/2. Richiami di Teoria della Probabilita'-checkpoint.pdf: -------------------------------------------------------------------------------- https://raw.githubusercontent.com/fredffsixty/Big-Data/896430d4821c623d14fbf05beae34fe1afbd7a2d/Lezioni teoriche/.ipynb_checkpoints/2. Richiami di Teoria della Probabilita'-checkpoint.pdf -------------------------------------------------------------------------------- /Lezioni teoriche/0. Introduzione al corso.pdf: -------------------------------------------------------------------------------- https://raw.githubusercontent.com/fredffsixty/Big-Data/896430d4821c623d14fbf05beae34fe1afbd7a2d/Lezioni teoriche/0. Introduzione al corso.pdf -------------------------------------------------------------------------------- /Lezioni teoriche/1. Introduzione al Data Processing.pdf: -------------------------------------------------------------------------------- https://raw.githubusercontent.com/fredffsixty/Big-Data/896430d4821c623d14fbf05beae34fe1afbd7a2d/Lezioni teoriche/1. Introduzione al Data Processing.pdf -------------------------------------------------------------------------------- /Lezioni teoriche/10. MongoDB.pdf: -------------------------------------------------------------------------------- https://raw.githubusercontent.com/fredffsixty/Big-Data/896430d4821c623d14fbf05beae34fe1afbd7a2d/Lezioni teoriche/10. MongoDB.pdf -------------------------------------------------------------------------------- /Lezioni teoriche/11. Cassandra.pdf: -------------------------------------------------------------------------------- https://raw.githubusercontent.com/fredffsixty/Big-Data/896430d4821c623d14fbf05beae34fe1afbd7a2d/Lezioni teoriche/11. Cassandra.pdf -------------------------------------------------------------------------------- /Lezioni teoriche/12. Hadoop.pdf: -------------------------------------------------------------------------------- https://raw.githubusercontent.com/fredffsixty/Big-Data/896430d4821c623d14fbf05beae34fe1afbd7a2d/Lezioni teoriche/12. Hadoop.pdf -------------------------------------------------------------------------------- /Lezioni teoriche/13. Spark.pdf: -------------------------------------------------------------------------------- https://raw.githubusercontent.com/fredffsixty/Big-Data/896430d4821c623d14fbf05beae34fe1afbd7a2d/Lezioni teoriche/13. Spark.pdf -------------------------------------------------------------------------------- /Lezioni teoriche/14. Introduzione al ML.pdf: -------------------------------------------------------------------------------- https://raw.githubusercontent.com/fredffsixty/Big-Data/896430d4821c623d14fbf05beae34fe1afbd7a2d/Lezioni teoriche/14. Introduzione al ML.pdf -------------------------------------------------------------------------------- /Lezioni teoriche/15. Clustering.pdf: -------------------------------------------------------------------------------- https://raw.githubusercontent.com/fredffsixty/Big-Data/896430d4821c623d14fbf05beae34fe1afbd7a2d/Lezioni teoriche/15. Clustering.pdf -------------------------------------------------------------------------------- /Lezioni teoriche/16. Classificatori.pdf: -------------------------------------------------------------------------------- https://raw.githubusercontent.com/fredffsixty/Big-Data/896430d4821c623d14fbf05beae34fe1afbd7a2d/Lezioni teoriche/16. Classificatori.pdf -------------------------------------------------------------------------------- /Lezioni teoriche/16.bis. Mining Web Data.pdf: -------------------------------------------------------------------------------- https://raw.githubusercontent.com/fredffsixty/Big-Data/896430d4821c623d14fbf05beae34fe1afbd7a2d/Lezioni teoriche/16.bis. Mining Web Data.pdf -------------------------------------------------------------------------------- /Lezioni teoriche/17. Introduzione al Deep Learning.pdf: -------------------------------------------------------------------------------- https://raw.githubusercontent.com/fredffsixty/Big-Data/896430d4821c623d14fbf05beae34fe1afbd7a2d/Lezioni teoriche/17. Introduzione al Deep Learning.pdf -------------------------------------------------------------------------------- /Lezioni teoriche/2. Richiami di Teoria della Probabilità.pdf: -------------------------------------------------------------------------------- https://raw.githubusercontent.com/fredffsixty/Big-Data/896430d4821c623d14fbf05beae34fe1afbd7a2d/Lezioni teoriche/2. Richiami di Teoria della Probabilità.pdf -------------------------------------------------------------------------------- /Lezioni teoriche/3. Preparazione dei Dati.pdf: -------------------------------------------------------------------------------- https://raw.githubusercontent.com/fredffsixty/Big-Data/896430d4821c623d14fbf05beae34fe1afbd7a2d/Lezioni teoriche/3. Preparazione dei Dati.pdf -------------------------------------------------------------------------------- /Lezioni teoriche/4. Misure di Similarita'.pdf: -------------------------------------------------------------------------------- https://raw.githubusercontent.com/fredffsixty/Big-Data/896430d4821c623d14fbf05beae34fe1afbd7a2d/Lezioni teoriche/4. Misure di Similarita'.pdf -------------------------------------------------------------------------------- /Lezioni teoriche/5. Stimatori, Stima e Campionamento.pdf: -------------------------------------------------------------------------------- https://raw.githubusercontent.com/fredffsixty/Big-Data/896430d4821c623d14fbf05beae34fe1afbd7a2d/Lezioni teoriche/5. Stimatori, Stima e Campionamento.pdf -------------------------------------------------------------------------------- /Lezioni teoriche/6. Mining di Pattern frequenti.pdf: -------------------------------------------------------------------------------- https://raw.githubusercontent.com/fredffsixty/Big-Data/896430d4821c623d14fbf05beae34fe1afbd7a2d/Lezioni teoriche/6. Mining di Pattern frequenti.pdf -------------------------------------------------------------------------------- /Lezioni teoriche/7. Data Warehousing.pdf: -------------------------------------------------------------------------------- https://raw.githubusercontent.com/fredffsixty/Big-Data/896430d4821c623d14fbf05beae34fe1afbd7a2d/Lezioni teoriche/7. Data Warehousing.pdf -------------------------------------------------------------------------------- /Lezioni teoriche/8. Introduzione a HDFS.pdf: -------------------------------------------------------------------------------- https://raw.githubusercontent.com/fredffsixty/Big-Data/896430d4821c623d14fbf05beae34fe1afbd7a2d/Lezioni teoriche/8. Introduzione a HDFS.pdf -------------------------------------------------------------------------------- /Lezioni teoriche/9. Database NoSQL.pdf: -------------------------------------------------------------------------------- https://raw.githubusercontent.com/fredffsixty/Big-Data/896430d4821c623d14fbf05beae34fe1afbd7a2d/Lezioni teoriche/9. Database NoSQL.pdf -------------------------------------------------------------------------------- /Libri di testo/README.md: -------------------------------------------------------------------------------- 1 | # Riferimento ai libri di testo 2 | 3 | Per motivi di copyright non è possibile pubblicare i libri di testo che sono comunque accessibili dal portale di Ateneo. -------------------------------------------------------------------------------- /Map Reduce in MongoDB.ipynb: -------------------------------------------------------------------------------- 1 | { 2 | "cells": [ 3 | { 4 | "cell_type": "code", 5 | "execution_count": 2, 6 | "metadata": {}, 7 | "outputs": [ 8 | { 9 | "name": "stderr", 10 | "output_type": "stream", 11 | "text": [ 12 | "2022-11-23T16:19:25.755+0100\tconnected to: mongodb://localhost/\n", 13 | "2022-11-23T16:19:25.800+0100\t891 document(s) imported successfully. 0 document(s) failed to import.\n" 14 | ] 15 | } 16 | ], 17 | "source": [ 18 | "import numpy as np\n", 19 | "import pandas as pd\n", 20 | "import pymongo\n", 21 | "from bson.son import SON\n", 22 | "from bson.code import Code\n", 23 | "import os\n", 24 | "\n", 25 | "# importazione da script di sistema\n", 26 | "os.system('mongoimport -d titanic -c passengers --headerline --file ~/data/titanic.csv --type csv')\n", 27 | "\n", 28 | "myclient = pymongo.MongoClient(\"mongodb://localhost:27017/\") # 27017 è la porta di default\n", 29 | "\n", 30 | "db = myclient[\"titanic\"] # anche 'db = myclient.titanic'\n", 31 | "\n" 32 | ] 33 | }, 34 | { 35 | "cell_type": "markdown", 36 | "metadata": {}, 37 | "source": [ 38 | "## Definizione del mapper, del reducer e del finalizer\n", 39 | "\n", 40 | "E' importante che il reducer restituisca esattamente lo stesso oggetto che riceve come val cioè il value emesso dal mapper. Infatti il reducer può essere richiamato più volte su singole porzioni di dati mappati i quali devono essere quindi concatenati a quelli già processati in precedenza dal reducer stesso.\n", 41 | "\n", 42 | "Il mapper emette un oggetto siffatto:\n", 43 | "\n", 44 | "```javascript\n", 45 | "{id_classe, {countMale: 1/0, countFemale: 1/0}}\n", 46 | "```\n", 47 | "a seconda che il passeggero sia maschio o femmina. \n", 48 | "\n", 49 | "Il reducer riduce l'array di oggetti emessi per la stessa classe generando un solo oggetto siffatto:\n", 50 | "\n", 51 | "```javascript\n", 52 | "{id_classe, {countMale: , countFemale: \n", 210 | "\n", 223 | "\n", 224 | " \n", 225 | " \n", 226 | " \n", 227 | " \n", 228 | " \n", 229 | " \n", 230 | " \n", 231 | " \n", 232 | " \n", 233 | " \n", 234 | " \n", 235 | " \n", 236 | " \n", 237 | " \n", 238 | " \n", 239 | " \n", 240 | " \n", 241 | " \n", 242 | " \n", 243 | " \n", 244 | " \n", 245 | " \n", 246 | " \n", 247 | " \n", 248 | "
_idvalue
01.0{'countMale': 36.89, 'countFemale': 96.81}
12.0{'countMale': 15.74, 'countFemale': 92.11}
23.0{'countMale': 13.54, 'countFemale': 50.0}
\n", 249 | "" 250 | ], 251 | "text/plain": [ 252 | " _id value\n", 253 | "0 1.0 {'countMale': 36.89, 'countFemale': 96.81}\n", 254 | "1 2.0 {'countMale': 15.74, 'countFemale': 92.11}\n", 255 | "2 3.0 {'countMale': 13.54, 'countFemale': 50.0}" 256 | ] 257 | }, 258 | "execution_count": 7, 259 | "metadata": {}, 260 | "output_type": "execute_result" 261 | } 262 | ], 263 | "source": [ 264 | "# La semplice importazione del risultato della query a MongoDB\n", 265 | "# ci restituisce un dataframe che non ha le caratteristiche volute\n", 266 | "\n", 267 | "pd.DataFrame(db.survivedPassengers.find())" 268 | ] 269 | }, 270 | { 271 | "cell_type": "code", 272 | "execution_count": 8, 273 | "metadata": {}, 274 | "outputs": [ 275 | { 276 | "data": { 277 | "text/html": [ 278 | "
\n", 279 | "\n", 292 | "\n", 293 | " \n", 294 | " \n", 295 | " \n", 296 | " \n", 297 | " \n", 298 | " \n", 299 | " \n", 300 | " \n", 301 | " \n", 302 | " \n", 303 | " \n", 304 | " \n", 305 | " \n", 306 | " \n", 307 | " \n", 308 | " \n", 309 | " \n", 310 | " \n", 311 | " \n", 312 | " \n", 313 | " \n", 314 | " \n", 315 | " \n", 316 | " \n", 317 | " \n", 318 | " \n", 319 | " \n", 320 | " \n", 321 | " \n", 322 | "
Male %Female %
Class
1.036.8996.81
2.015.7492.11
3.013.5450.00
\n", 323 | "
" 324 | ], 325 | "text/plain": [ 326 | " Male % Female %\n", 327 | "Class \n", 328 | "1.0 36.89 96.81\n", 329 | "2.0 15.74 92.11\n", 330 | "3.0 13.54 50.00" 331 | ] 332 | }, 333 | "execution_count": 8, 334 | "metadata": {}, 335 | "output_type": "execute_result" 336 | } 337 | ], 338 | "source": [ 339 | "raw_data = list(db.survivedPassengers.find())\n", 340 | "\n", 341 | "transformed_data = []\n", 342 | "\n", 343 | "for data in raw_data:\n", 344 | " transformed_data.append({'Class': data['_id'],\n", 345 | " 'Male %': data['value']['countMale'],\n", 346 | " 'Female %': data['value']['countFemale']})\n", 347 | "\n", 348 | "survived_passengers = pd.DataFrame(transformed_data)\n", 349 | "survived_passengers.set_index('Class')" 350 | ] 351 | } 352 | ], 353 | "metadata": { 354 | "kernelspec": { 355 | "display_name": "Python 3.10.8 ('hadoop': venv)", 356 | "language": "python", 357 | "name": "python3" 358 | }, 359 | "language_info": { 360 | "codemirror_mode": { 361 | "name": "ipython", 362 | "version": 3 363 | }, 364 | "file_extension": ".py", 365 | "mimetype": "text/x-python", 366 | "name": "python", 367 | "nbconvert_exporter": "python", 368 | "pygments_lexer": "ipython3", 369 | "version": "3.10.8" 370 | }, 371 | "vscode": { 372 | "interpreter": { 373 | "hash": "7553610f36a6045c2ac2337af6058c76912cf39c898d6f43a14b359d55f82e5b" 374 | } 375 | } 376 | }, 377 | "nbformat": 4, 378 | "nbformat_minor": 4 379 | } 380 | -------------------------------------------------------------------------------- /Progetti di esame/Descrizione del progetto 2019-2020 invernale.docx: -------------------------------------------------------------------------------- https://raw.githubusercontent.com/fredffsixty/Big-Data/896430d4821c623d14fbf05beae34fe1afbd7a2d/Progetti di esame/Descrizione del progetto 2019-2020 invernale.docx -------------------------------------------------------------------------------- /Progetti di esame/Descrizione del progetto di esame 2020-2021.md: -------------------------------------------------------------------------------- 1 | # Progetto di esame a.a. 2020-2021 2 | 3 | Il progetto è una competizione Kaggle che si trova al [seguente indirizzo](https://www.kaggle.com/mlg-ulb/creditcardfraud). 4 | 5 | Si tratta di un data set di frodi su carte di credito in cui sono presenti solo 492 frodi su 284.807 transazioni. 6 | 7 | I dati contengono i seguenti campi: 8 | 9 | - Time: un identificativo numerico prograssivo della transazione 10 | - V1 ... V28: feature di dettaglio della transazione convertite con la PCA per questioni di privacy 11 | - Amount: ammntare della transazione 12 | - Class: 0/1 per indicare transazione normale/fraudolenta 13 | 14 | Si richiede di effettuare tutti i passi di data cleaning/inputation e una analisi delle feature rilevanti ai fini della classificazione. 15 | 16 | La metrica richiesta è la Area Under the Precision-Recall Curve (AUPRC). 17 | 18 | I gruppi candidati dovranno inoltre trovare una modalità di visualizzazione dei dati classificati in 2D o 3D che consenta di mettere in relazione i punti appartenenti a ciascuna classe con le feature utilizzate per la classificazione ai fini di apprezzare l'effettiva separazione tra le classi. 19 | 20 | Suggerimento: utilizzare il Multi-Dimensional Scaling (MDS). -------------------------------------------------------------------------------- /Python programming 1.ipynb: -------------------------------------------------------------------------------- 1 | { 2 | "cells": [ 3 | { 4 | "cell_type": "markdown", 5 | "metadata": { 6 | "pycharm": { 7 | "name": "#%% md\n" 8 | } 9 | }, 10 | "source": [ 11 | "# Introduzione a Python\n", 12 | "\n", 13 | "Python è un linguaggo interpretato, generalista, orientato agli oggetti che viene molto utilizzato al giorno d'oggi per l'analisi dei dati ed le applicazioni di Machine Learning.\n", 14 | "\n", 15 | "In questa breve introduzione si farà riferimento principalmente alle seguenti fonti:\n", 16 | "\n", 17 | "- Il testo di Kenneth A. Lambert [Programmazione in Python](http://www.apogeoeducation.com/programmazione-in-python.html) disponibile su tutti gli store di libri\n", 18 | "- Il sito [RealPython](https://realpython.com/) che contiene molti tutorial di livello base e avanzato\n", 19 | "- Il portale della [documentazione ufficiale di Python 3](https://docs.python.org/3/)\n", 20 | "\n", 21 | "Ecco un esempio di primo programma Python, `hello.py`:" 22 | ] 23 | }, 24 | { 25 | "cell_type": "markdown", 26 | "metadata": { 27 | "pycharm": { 28 | "is_executing": false, 29 | "name": "#%% md\n" 30 | } 31 | }, 32 | "source": [ 33 | "```python\n", 34 | "#!/usr/bin/env python\n", 35 | "\n", 36 | "# import modules used here -- sys is a very standard one\n", 37 | "import sys\n", 38 | "\n", 39 | "# Gather our code in a main() function\n", 40 | "def main():\n", 41 | " print ('Hello there', sys.argv[1])\n", 42 | " # Command line args are in sys.argv[1], sys.argv[2] ...\n", 43 | " # sys.argv[0] is the script name itself and can be ignored\n", 44 | "\n", 45 | "# Standard boilerplate to call the main() function to begin\n", 46 | "# the program.\n", 47 | "if __name__ == '__main__':\n", 48 | " main()\n", 49 | "```\n", 50 | "Eseguiamolo:" 51 | ] 52 | }, 53 | { 54 | "cell_type": "code", 55 | "execution_count": 1, 56 | "metadata": { 57 | "collapsed": false, 58 | "jupyter": { 59 | "outputs_hidden": false 60 | }, 61 | "pycharm": { 62 | "is_executing": false, 63 | "name": "#%%\n" 64 | }, 65 | "tags": [] 66 | }, 67 | "outputs": [ 68 | { 69 | "name": "stdout", 70 | "output_type": "stream", 71 | "text": [ 72 | "/Users/pirrone/src/github repositories/Big-Data/Python programming\n", 73 | "Hello Peppino\n" 74 | ] 75 | } 76 | ], 77 | "source": [ 78 | "%cd \"Python programming\"\n", 79 | "%run hello.py Peppino" 80 | ] 81 | }, 82 | { 83 | "cell_type": "markdown", 84 | "metadata": {}, 85 | "source": [ 86 | "Un programma Python standalone va eseguito con l'indicazione dell'interprete da usare e cioè `#!/usr/bin/env python` che invoca l'interprete predefinito nell'ambiente dell'utente.\n", 87 | "\n", 88 | "I commenti si inseriscono con:\n", 89 | "```python\n", 90 | "# questo è un commento\n", 91 | "'''\n", 92 | "Questo è un commento\n", 93 | "su più linee\n", 94 | "'''\n", 95 | "```\n", 96 | "\n", 97 | "`import` è la direttiva di importazione di moduli realizzati dall'utente ovvero di moduli di libreria. I moduli più comuni di libreria sono:\n", 98 | "- `sys`: utility di sistema, gestione dello standard input/output, `exit()`, lista degli argomenti di input `argv` etc.\n", 99 | "- `os`: accesso al sistema operativo, esecuzione di comandi di shell, variabili di ambiente etc.\n", 100 | "- `re`: espressioni regolari\n", 101 | "- `math`: libreria matematica\n", 102 | "\n", 103 | "\n", 104 | "```python\n", 105 | "import # importa l'intero modulo che farà da riferimento ai suoi metodi e classi interne \n", 106 | "import . [as ] # importa solamente . e, se usa il nome , ne fa il binding nell'ambiente \n", 107 | "from import [as ] # importa solamente , eventualmente con il nome , e ne fa sempre il binding nell'ambiente\n", 108 | "```\n", 109 | "\n", 110 | "Python utilizza `def` come istruzione per creare funzioni definite dall'utente:\n", 111 | "```python\n", 112 | "def ():\n", 113 | " istruzione\n", 114 | " istruzione\n", 115 | " ...\n", 116 | "```\n", 117 | "L'indentazione con il tasto `TAB` è ***fondamentale*** in Python perché non ci sono parentesi ad individuare gli _scope_ o ambiti di visibilità. Si entra in uno scope con il simbolo `:` e le istruzioni del blocco sono tutte ad un livello di indentazione più rientrato rispetto alla istruzione che controllas il blocco (dichiarazione di funzione o istruzione di controllo del flusso). Non si usa il \";\" a fine istruzione. Appena si toglie l'indentazione si esce dal blocco.\n", 118 | "\n", 119 | "La funzione `main()` costituisce il programma principale, ma la sua esecuzione è legata al codice:\n", 120 | "```python\n", 121 | "if __name__ == '__main__':\n", 122 | " main()\n", 123 | "```\n", 124 | "\n", 125 | "`__name__` è una delle _variabli speciali_ di Python che è legata alla costruzione dei moduli. In particolare essa contiene il nome del modulo. Tale nome viene impostato automaticamente a `__main__` quando il modulo viene eseguito interattivamente e quindi è connesso allo standard input e output. Di conseguenza usiamo questa istruzione come punto di accesso al nostro programma principale che eseguirà tutte le altre funzioni definite all'interno del nostro codice.\n", 126 | "\n", 127 | "Il nostro programma principale:\n", 128 | "\n", 129 | "```python\n", 130 | "def main():\n", 131 | " print ('Hello there', sys.argv[1])\n", 132 | "```\n", 133 | "richiama la funzione built-in `print()`per l'output eventualmente formattato di una sequenza di oggetti, nel nostro caso una stringa e il _secondo_ elemento della lista `sys.argv` che contiene gli argomenti passati dalla linea di comando, il primo essendo il nome del comando stesso. Le liste in Python si accedono con la notazione array ed indice che parte da 0, ma ***non sono*** array numerici bensì sequenze di oggetti i quali possono essere anche numeri.\n", 134 | "\n", 135 | "## Informazioni e documentazione on line\n", 136 | "Da console interattiva la funzione `help()` fornisce la descrizione del modulo/classe/oggetto/metodo richiesto come argomento, mentre `dir()` fornisce l'elenco dei _simboli_ o _attributi_ in questo definiti. Un modo semplice di ottenere la lista degli attributi di un oggetto è anche quello di usare il tasto `TAB` dopo aver digitato il punto." 137 | ] 138 | }, 139 | { 140 | "cell_type": "code", 141 | "execution_count": null, 142 | "metadata": { 143 | "collapsed": false, 144 | "jupyter": { 145 | "outputs_hidden": false 146 | }, 147 | "pycharm": { 148 | "is_executing": false, 149 | "name": "#%%\n" 150 | } 151 | }, 152 | "outputs": [], 153 | "source": [ 154 | "import sys\n", 155 | "\n", 156 | "help('pippo'.capitalize)\n", 157 | "\n", 158 | "help(sys)\n", 159 | "\n", 160 | "dir(sys)" 161 | ] 162 | }, 163 | { 164 | "cell_type": "markdown", 165 | "metadata": { 166 | "pycharm": { 167 | "name": "#%% md\n" 168 | } 169 | }, 170 | "source": [ 171 | "## Tipi di dati e variabili\n", 172 | "\n", 173 | "Qualunque dato è un oggetto in Python." 174 | ] 175 | }, 176 | { 177 | "cell_type": "code", 178 | "execution_count": 3, 179 | "metadata": { 180 | "collapsed": false, 181 | "jupyter": { 182 | "outputs_hidden": false 183 | }, 184 | "pycharm": { 185 | "is_executing": false, 186 | "name": "#%%\n" 187 | }, 188 | "tags": [] 189 | }, 190 | "outputs": [ 191 | { 192 | "name": "stdout", 193 | "output_type": "stream", 194 | "text": [ 195 | "\n", 196 | "\n" 197 | ] 198 | }, 199 | { 200 | "data": { 201 | "text/plain": [ 202 | "True" 203 | ] 204 | }, 205 | "execution_count": 3, 206 | "metadata": {}, 207 | "output_type": "execute_result" 208 | } 209 | ], 210 | "source": [ 211 | "print(type(5))\n", 212 | "\n", 213 | "a=3.56\n", 214 | "\n", 215 | "print(a.__class__)\n", 216 | "isinstance('pippo',str)" 217 | ] 218 | }, 219 | { 220 | "cell_type": "markdown", 221 | "metadata": { 222 | "pycharm": { 223 | "name": "#%% md\n" 224 | } 225 | }, 226 | "source": [ 227 | "I tipi di dati principali sono:\n", 228 | "- Interi\n", 229 | " - tipicamente implementati in 32 bit, ma con rappresentazione interna dipendente dall'architettura, si possono convertire da altre rappresentazioni con la funzione built-in `int()` ed accettano anche la forma esadecimale e ottale: ```21, 0x15, 0o25``` rispettivamente ottenibili tramite `hex()` e `oct()` rispettivamente.\n", 230 | "- Reali\n", 231 | " - si possono ottenere con la funzione built-in `float()` con range tipico $[-10^{308},\\ 10^{308}]$; letterali tipici sono, per esempio ```-3.456``` oppure in notazione scientifica ```-3.456e-7```\n", 232 | "- Numeri complessi\n", 233 | " - si possono ottenere con la funzione built-in `complex()` e il letterale ha la forma del tipo `1.2±3.4j`\n", 234 | "- Booleani\n", 235 | " - sono legati alle espressioni logiche ed agli operatori relazionali ed hanno i soli valori `True` e `False`\n", 236 | "- Caratteri\n", 237 | " - si ottengono con `chr()`applicato alla codifica ASCII o Unicode e di converso `ord()` restituisce il codice del carattere; il letterale è racchiuso da apici singoli `'f'`\n", 238 | "- Stringhe\n", 239 | " - si ottengono con `str()` e possono essere racchiuse da apici singoli o doppi; si possono accedere tramite notazione array ed usano la funzione built-in `len()` per ottenere la lunghezza.\n" 240 | ] 241 | }, 242 | { 243 | "cell_type": "code", 244 | "execution_count": 4, 245 | "metadata": { 246 | "collapsed": false, 247 | "jupyter": { 248 | "outputs_hidden": false 249 | }, 250 | "pycharm": { 251 | "is_executing": false, 252 | "name": "#%%\n" 253 | }, 254 | "tags": [] 255 | }, 256 | "outputs": [ 257 | { 258 | "name": "stdout", 259 | "output_type": "stream", 260 | "text": [ 261 | "5\n", 262 | "m\n", 263 | "o\n", 264 | "aper\n" 265 | ] 266 | } 267 | ], 268 | "source": [ 269 | "print(str(len('Pippo'))+'\\n'+\"mamma\"[2]+'\\n'+'pluto'[-1]+'\\n'+'paperino'[1:5])" 270 | ] 271 | }, 272 | { 273 | "cell_type": "markdown", 274 | "metadata": { 275 | "pycharm": { 276 | "name": "#%% md\n" 277 | } 278 | }, 279 | "source": [ 280 | "In Python sono in uso i caratteri di _escape_ `\\n, \\t, \\b, \\\\, \\', \\\"` e l'operatore `+` è sovraccaricato del significato di concatenazione tra _sole_ stringhe.\n", 281 | " \n", 282 | "Le stringhe, ma anche le liste e le tuple, che vedremo in seguito, possono essere accedute usando la notazione slice `[start:stop:step]` che è l'equivalente di creare un oggetto con `slice(start:stop:step)`. La posizione `stop` è esclusa dallo slicing per cui si arriva a `stop - 1`. Sussiste una seconda indicizzazione a partire da `-1` per valori negativi che riferisce la stringa (tupla o lista) dall'ultima posizione fino alla prima.\n", 283 | "\n", 284 | "![Indicizzazione in Python](https://developers.google.com/edu/python/images/hello.png)\n", 285 | "\n", 286 | "_Fonte: [Google Python Class](https://developers.google.com/edu/python/strings)_" 287 | ] 288 | }, 289 | { 290 | "cell_type": "code", 291 | "execution_count": 1, 292 | "metadata": { 293 | "collapsed": false, 294 | "jupyter": { 295 | "outputs_hidden": false 296 | }, 297 | "pycharm": { 298 | "is_executing": false, 299 | "name": "#%%\n" 300 | } 301 | }, 302 | "outputs": [ 303 | { 304 | "name": "stdout", 305 | "output_type": "stream", 306 | "text": [ 307 | "n\n", 308 | "pprn\n", 309 | "aeio\n", 310 | "otulp\n" 311 | ] 312 | } 313 | ], 314 | "source": [ 315 | "print(\"paperino\"[-2])\n", 316 | "print(\"paperino\"[::2])\n", 317 | "print(\"paperino\"[1::2])\n", 318 | "print(\"pluto\"[::-1])" 319 | ] 320 | }, 321 | { 322 | "cell_type": "markdown", 323 | "metadata": { 324 | "pycharm": { 325 | "name": "#%% md\n" 326 | } 327 | }, 328 | "source": [ 329 | "Per completezza si riporta la lista delle [funzioni built-in](https://docs.python.org/3/library/functions.html).\n", 330 | "\n", 331 | "\n", 332 | "### Convenzioni sui nomi\n", 333 | "\n", 334 | "- moduli e metodi: minuscole eventualmente con underscore `nome_mio_modulo`\n", 335 | "- classi e variabili che contengono tipi: iniziali maiuscole `MiaClasse`\n", 336 | "- funzioni e variabili: stile \"mixedCase\" `miaFunzione`\n", 337 | "- costanti: tutte maiuscole con eventuale underscore `MIA_COSTANTE`\n", 338 | "\n", 339 | "### Uso del carattere underscore\n", 340 | " - Underscore singolo iniziale (`_mio_modulo`) si utilizza per moduli/metodi/classi _private_ nel senso che non vengono importati utilizzando `import *`, ma non sono privati nel senso tipico della OOP\n", 341 | " - Underscore singolo finale (`mia_funzione_`) è solo una convenzione per evitare confusione con parole riservate del linguaggio.\n", 342 | " - Doppio underscore iniziale (`__mio_metodo`) è una sintassi per il cosiddetto _mangling_ dei metodi; all'interno di `Classe` il nome del metodo viene modificato dall'interprete in `_Classe__mio_metodo` per cui è di fatto privato, ma si tratta di un meccanismo di oscuramento di nomi di metodi per evitare confusione con metodi con lo stesso nome di possibili sottoclassi.\n", 343 | " - Doppio underscore iniziale e finale (`__magic__`) è riservato a una serie di nomi di metodi e variabili che hanno funzioni predefinite e rilevanti in Python e non dev'essere usato dagli utenti. Ad esempio:\n", 344 | " - `__init__` è il metodo di inizializzazione di una classe, di fatto il costruttore\n", 345 | " - `__eq__` è invocato internamente da Python su due oggetti quando si richiama l'operatore `==`\n", 346 | " - `__len__` analogamente quando si utilizza `len()`\n", 347 | " - `__file__` contiene il nome del file che stiamo utilizzando.\n", 348 | "\n", 349 | "\n", 350 | "## Operatori\n", 351 | " \n", 352 | "![Tabella di precedenza ed associatività degli operatori Python](https://www.miltonmarketing.com/wp-content/uploads/2018/04/Python-Operators-Precedence.jpg)\n", 353 | "\n", 354 | "_Fonte: [MiltonMarketing.com](https://www.miltonmarketing.com/coding/python/python-basic-operators/8/)_" 355 | ] 356 | } 357 | ], 358 | "metadata": { 359 | "kernelspec": { 360 | "display_name": "Python 3.10.7 ('primo_env')", 361 | "language": "python", 362 | "name": "python3" 363 | }, 364 | "language_info": { 365 | "codemirror_mode": { 366 | "name": "ipython", 367 | "version": 3 368 | }, 369 | "file_extension": ".py", 370 | "mimetype": "text/x-python", 371 | "name": "python", 372 | "nbconvert_exporter": "python", 373 | "pygments_lexer": "ipython3", 374 | "version": "3.10.7" 375 | }, 376 | "pycharm": { 377 | "stem_cell": { 378 | "cell_type": "raw", 379 | "metadata": { 380 | "collapsed": false 381 | }, 382 | "source": [] 383 | } 384 | }, 385 | "vscode": { 386 | "interpreter": { 387 | "hash": "92303316ce3aae2a184edf8faaa58a0e74be0a47f3c56fc6eb3017d3b455281c" 388 | } 389 | } 390 | }, 391 | "nbformat": 4, 392 | "nbformat_minor": 4 393 | } 394 | -------------------------------------------------------------------------------- /Python programming 2.ipynb: -------------------------------------------------------------------------------- 1 | { 2 | "cells": [ 3 | { 4 | "cell_type": "markdown", 5 | "metadata": { 6 | "pycharm": { 7 | "name": "#%% md\n" 8 | } 9 | }, 10 | "source": [ 11 | "# Stringhe, liste, tuple, strutture di controllo del flusso e ordinamento\n", 12 | "\n", 13 | "Le stringhe vengono generate con il costruttore built-in `str()` a partire da altri oggetti. Esse sono _immutable_ cioè immodificabili e quindi applicare operazioni alle stringhe produce sempre nuovi oggetti stringa.\n", 14 | "\n", 15 | "Alcuni tra i metodi principali delle stringhe sono riportati nel seguito:\n", 16 | "\n", 17 | "- `s.lower(), s.upper()` restituisce la stringa `s` tutta in minuscolo/maiuscolo\n", 18 | "- `s.strip()` restituisce la stringa senza spazi bianchi all'inizio e alla fine\n", 19 | "- `s.isalpha()/s.isdigit()/s.isspace()...` verifica se **tutti** i caratteri della stringa sono alfanumerici/numerici/di spaziatura etc.\n", 20 | "- `s.startswith('other'), s.endswith('other')` verifica se `s` inizia/finisce con la stringa `other`\n", 21 | "- `s.find('other')` cerca `other` in `s` e restituisce l'indice in cui inizia la prima occorrenza o `-1` se non la trova\n", 22 | "- `s.replace('old', 'new')` restituisce una stringa in cui tutte le occorrenze di `old` sono rimpiazzate da ` new`\n", 23 | "- `s.split('delim')` restituisce una lista di sottostringhe che risultano separate dalla stringa `delim` che ***non è*** una espressione regolare. ad es. `'aaa,bbb,ccc'.split(',') -> ['aaa', 'bbb', 'ccc']`. Senza argomenti `s.split()` usa gli spazi come delimitatori.\n", 24 | "- `s.join(list)` unisce gli elementi di `list` in un'unica stringa concatenata da `s` che fa da delimitatore. Ad esempio `'---'.join(['aaa', 'bbb', 'ccc']) -> aaa---bbb---ccc`\n", 25 | "\n", 26 | "Le stringhe Python 3 sono Unicode, in Python 2 invece no e bisognava esplicitamente crearle premettendo `u` al letterale ovvero con la funzione built-in `unicode` che non è più definita in Python 3.\n", 27 | "\n", 28 | "## Stampa formattata: `print()`\n", 29 | "\n", 30 | "Le stringhe Python 2, ma anche Python 3, possiedono una notazione `%` simile al C/C++ per inserire variabili di tipo diverso all'interno di una _stringa formato_ per l'output formattato:" 31 | ] 32 | }, 33 | { 34 | "cell_type": "code", 35 | "execution_count": 2, 36 | "metadata": { 37 | "collapsed": false, 38 | "jupyter": { 39 | "outputs_hidden": false 40 | }, 41 | "pycharm": { 42 | "is_executing": false, 43 | "name": "#%%\n" 44 | } 45 | }, 46 | "outputs": [ 47 | { 48 | "name": "stdout", 49 | "output_type": "stream", 50 | "text": [ 51 | "La mamma ha comprato 7 chili di pane a 0.35 € al chilo\n", 52 | "preci \n", 53 | "008.99\n" 54 | ] 55 | } 56 | ], 57 | "source": [ 58 | "print('La mamma ha comprato %d chili di %s a %g € al chilo' % (7,'pane',0.35))\n", 59 | "\n", 60 | "print('%-10.5s' % ('precivitevolissimevolmente')) # allineamento a destra in 10 caratteri troncato a 5\n", 61 | "\n", 62 | "print('%06.2f' % (8.9876543)) # allineamento in 6 cifre con due sole posizioni dopo la virgola" 63 | ] 64 | }, 65 | { 66 | "cell_type": "markdown", 67 | "metadata": { 68 | "pycharm": { 69 | "name": "#%% md\n" 70 | } 71 | }, 72 | "source": [ 73 | "per una review completa della formattazione si consulti la [guida Python 2](https://docs.python.org/2/library/stdtypes.html#string-formatting)\n", 74 | "\n", 75 | "In Python 3 le stringhe usano il metodo `str.format()` per gestire la stessa cosa." 76 | ] 77 | }, 78 | { 79 | "cell_type": "code", 80 | "execution_count": 27, 81 | "metadata": { 82 | "collapsed": false, 83 | "jupyter": { 84 | "outputs_hidden": false 85 | }, 86 | "pycharm": { 87 | "is_executing": false, 88 | "name": "#%%\n" 89 | } 90 | }, 91 | "outputs": [ 92 | { 93 | "name": "stdout", 94 | "output_type": "stream", 95 | "text": [ 96 | "Hello Jhonny! It looks like you're 23 years old!\n", 97 | " preci\n", 98 | "test______\n", 99 | "008.99\n", 100 | " 23\n" 101 | ] 102 | } 103 | ], 104 | "source": [ 105 | "name = 'Jhonny'\n", 106 | "age = 23\n", 107 | "print('Hello {}! It looks like you\\'re {} years old!'.format(name,age))\n", 108 | "\n", 109 | "print('{:>10.5}'.format('precivitevolissimevolmente')) # allineamento a destra in 10 caratteri troncato a 5\n", 110 | "\n", 111 | "print('{:_<10s}'.format('test')) #allineamento a sinistra in 10 caratteri e riempimento con '_'\n", 112 | "\n", 113 | "print('{:06.2f}'.format(8.9876543)) # allineamento in 6 cifre con due sole posizioni dopo la virgola\n", 114 | "\n", 115 | "print('{:=+5d}'.format(23)) # inserimento segno esplicito e allineamento in 5 caratteri senza zeri" 116 | ] 117 | }, 118 | { 119 | "cell_type": "markdown", 120 | "metadata": { 121 | "pycharm": { 122 | "name": "#%% md\n" 123 | } 124 | }, 125 | "source": [ 126 | "Da Python 3.6 in poi, sono state inserite le f-string che sono una ulteriore evoluzione della notazione '{...}' utilizzata da `format` e consentono l'inserimento diretto delle variabili nell'output formattato. Esse sono anche molto più efficienti computazionalmente." 127 | ] 128 | }, 129 | { 130 | "cell_type": "code", 131 | "execution_count": 32, 132 | "metadata": { 133 | "collapsed": false, 134 | "jupyter": { 135 | "outputs_hidden": false 136 | }, 137 | "pycharm": { 138 | "is_executing": false, 139 | "name": "#%%\n" 140 | } 141 | }, 142 | "outputs": [ 143 | { 144 | "name": "stdout", 145 | "output_type": "stream", 146 | "text": [ 147 | "hello, Root!! how are you?\n", 148 | "Hi **Jhonny**! You are +23.00 years old\n" 149 | ] 150 | } 151 | ], 152 | "source": [ 153 | "import os\n", 154 | "\n", 155 | "name = 'Jhonny'\n", 156 | "age = 23\n", 157 | "\n", 158 | "print(f'hello, {os.getlogin().capitalize()}!! how are you?') # si possono utilizzare direttamente metodi e variabili \n", 159 | "\n", 160 | "print(f'Hi {name:*^10s}! You are {age:+6.2f} years old')" 161 | ] 162 | }, 163 | { 164 | "cell_type": "markdown", 165 | "metadata": { 166 | "pycharm": { 167 | "name": "#%% md\n" 168 | } 169 | }, 170 | "source": [ 171 | "La funzione `print()` ha la seuguente sintassi\n", 172 | "```\n", 173 | "print(oggetto [, oggetto, ...] [,sep=''] [,end='])\n", 174 | "```\n", 175 | "Il separatore di default è lo spazio, mentre il terminatore di default è il newline `\\n`." 176 | ] 177 | }, 178 | { 179 | "cell_type": "code", 180 | "execution_count": 54, 181 | "metadata": { 182 | "collapsed": false, 183 | "jupyter": { 184 | "outputs_hidden": false 185 | }, 186 | "pycharm": { 187 | "is_executing": false, 188 | "name": "#%%\n" 189 | } 190 | }, 191 | "outputs": [ 192 | { 193 | "name": "stdout", 194 | "output_type": "stream", 195 | "text": [ 196 | "pippo # pluto # topolino.paperino paperoga gastone\n" 197 | ] 198 | } 199 | ], 200 | "source": [ 201 | "print('pippo','pluto','topolino',sep=' # ',end='.')\n", 202 | "print('paperino','paperoga','gastone')" 203 | ] 204 | }, 205 | { 206 | "cell_type": "markdown", 207 | "metadata": { 208 | "pycharm": { 209 | "name": "#%% md\n" 210 | } 211 | }, 212 | "source": [ 213 | "## Liste\n", 214 | "\n", 215 | "Le liste si definiscono il letterale `[elemento, elemento, ...]`. Una lista può contenere elementi di tipo diverso, utilizza la notazione array e lo slicing, ma non è un _immutable_. Le operazioni affliggono la stessa lista. Possiamo calcolarne la lunghezza con `len`." 216 | ] 217 | }, 218 | { 219 | "cell_type": "code", 220 | "execution_count": 42, 221 | "metadata": { 222 | "collapsed": false, 223 | "jupyter": { 224 | "outputs_hidden": false 225 | }, 226 | "pycharm": { 227 | "is_executing": false, 228 | "name": "#%%\n" 229 | } 230 | }, 231 | "outputs": [ 232 | { 233 | "name": "stdout", 234 | "output_type": "stream", 235 | "text": [ 236 | "['pippo', True] \n", 237 | "\n", 238 | " ['mamma', 'mia']\n" 239 | ] 240 | } 241 | ], 242 | "source": [ 243 | "a=[1,'pippo',True]\n", 244 | "b=a # b ed a puntano allo stesso oggetto\n", 245 | "# b = list(a) # b è una lista diversa da a\n", 246 | "a.pop(0) # a viene modificato da pop che rimuove il primo elemento della lista\n", 247 | "\n", 248 | "print(f'{a} \\n\\n {b}')" 249 | ] 250 | }, 251 | { 252 | "cell_type": "markdown", 253 | "metadata": { 254 | "pycharm": { 255 | "name": "#%% md\n" 256 | } 257 | }, 258 | "source": [ 259 | " di seguito vediamo applicati i principali metodi delle liste" 260 | ] 261 | }, 262 | { 263 | "cell_type": "code", 264 | "execution_count": 2, 265 | "metadata": { 266 | "collapsed": false, 267 | "jupyter": { 268 | "outputs_hidden": false 269 | }, 270 | "pycharm": { 271 | "is_executing": false, 272 | "name": "#%%\n" 273 | } 274 | }, 275 | "outputs": [ 276 | { 277 | "name": "stdout", 278 | "output_type": "stream", 279 | "text": [ 280 | "['pippo', 'pluto', 'paperino', 'topolino', 'clarabella']\n", 281 | "['qui quo qua', 'pippo', 'pluto', 'paperino', 'topolino', 'clarabella']\n", 282 | "['qui quo qua', 'pippo', 'pluto', 'paperino', 'topolino', 'clarabella', 'gastone', 'nonna papera']\n", 283 | "2\n" 284 | ] 285 | } 286 | ], 287 | "source": [ 288 | "lst = ['pippo', 'pluto', 'paperino', 'topolino']\n", 289 | "\n", 290 | "lst.append('clarabella') ## appende 'clarabella' alla fine\n", 291 | "print(lst) \n", 292 | "lst.insert(0, 'qui quo qua') ## inserisce la stringa in posizione 0\n", 293 | "print(lst) \n", 294 | "lst.extend(['gastone', 'nonna papera']) ## aggiunge una lista alla fine\n", 295 | "print(lst) \n", 296 | "print(lst.index('pluto')) ## 2\n", 297 | "\n" 298 | ] 299 | }, 300 | { 301 | "cell_type": "code", 302 | "execution_count": 3, 303 | "metadata": {}, 304 | "outputs": [ 305 | { 306 | "name": "stdout", 307 | "output_type": "stream", 308 | "text": [ 309 | "['qui quo qua', 'pippo', 'paperino', 'topolino', 'clarabella', 'gastone', 'nonna papera']\n", 310 | "pippo; ['qui quo qua', 'paperino', 'topolino', 'clarabella', 'gastone', 'nonna papera']\n", 311 | "['paperino', 'topolino', 'clarabella', 'gastone']\n", 312 | "['zio paperone', 'topolino', 'clarabella', 'gastone', 'nonna papera']\n" 313 | ] 314 | } 315 | ], 316 | "source": [ 317 | "lst.remove('pluto')\n", 318 | "print(lst) ## cerca e rimuove l'elemento\n", 319 | "disney = lst.pop(1) ## rimuove e erestituisce l'elemento in posizione 1\n", 320 | "print(disney,lst, sep='; ') \n", 321 | "\n", 322 | "'''\n", 323 | "Utilizzo dello slicing\n", 324 | "'''\n", 325 | "print(lst[1:-1]) # stampa la sottolista cha va dal secondo al penultimo elemento\n", 326 | "lst[0:2]=['zio paperone'] # sostituisce alla sottolista composta dai primi due elementi di list la lista ['zio paperone']\n", 327 | "\n", 328 | "print(lst)" 329 | ] 330 | }, 331 | { 332 | "cell_type": "markdown", 333 | "metadata": { 334 | "pycharm": { 335 | "name": "#%% md\n" 336 | } 337 | }, 338 | "source": [ 339 | "## Tuple\n", 340 | "\n", 341 | "le tuple sono simili al concetto di `struct` del C/C++, sono degli _immutable_ che racchiudono al loro interno degli elementi, normalmente eterogenei, per altro perfettamente simili alle liste. I singoli elementi di una tupla possono essere modificati. \n", 342 | "\n", 343 | "La sintassi utilizza le parentesi tonde, ad es. `(1,'pippo',False)`; è la classica struttura dati che viene usata quando è necessario che una funzione restituisca più di un valore." 344 | ] 345 | }, 346 | { 347 | "cell_type": "code", 348 | "execution_count": 58, 349 | "metadata": { 350 | "collapsed": false, 351 | "jupyter": { 352 | "outputs_hidden": false 353 | }, 354 | "pycharm": { 355 | "is_executing": false, 356 | "name": "#%%\n" 357 | } 358 | }, 359 | "outputs": [ 360 | { 361 | "name": "stdout", 362 | "output_type": "stream", 363 | "text": [ 364 | "('Giorgio', 'Giorgio') 5 2 1\n" 365 | ] 366 | }, 367 | { 368 | "data": { 369 | "text/plain": [ 370 | "('Giorgio', True, ['a', 'b', 'c'])" 371 | ] 372 | }, 373 | "execution_count": 58, 374 | "metadata": {}, 375 | "output_type": "execute_result" 376 | } 377 | ], 378 | "source": [ 379 | "t=(5, 'Giorgio', 'Giorgio', True, ['a','b','c'])\n", 380 | "\n", 381 | "#\n", 382 | "# count() conta le occorrenze dell'elemento passato\n", 383 | "# come argomento e index() ritorna la sua prima occorrenza\n", 384 | "#\n", 385 | "\n", 386 | "print(t[1:3],len(t),t.count('Giorgio'),t.index('Giorgio'))\n", 387 | "\n", 388 | "#\n", 389 | "# t è immutable e quindi per ottenere il riultato dello\n", 390 | "# slicing dobbiamo assegnarlo ad un altra tupla\n", 391 | "#\n", 392 | "\n", 393 | "a=t[2:5]\n", 394 | "a" 395 | ] 396 | }, 397 | { 398 | "cell_type": "markdown", 399 | "metadata": { 400 | "pycharm": { 401 | "name": "#%% md\n" 402 | } 403 | }, 404 | "source": [ 405 | "## Strutture di controllo del flusso\n", 406 | "\n", 407 | "- Selezione:\n", 408 | "```python\n", 409 | "if condizione: # si entra nel blocco quando condizione è valutata True\n", 410 | " istruzione\n", 411 | " ...\n", 412 | "elif condizione: # opzionale: anche più di uno per scelte multiple\n", 413 | " istruzione\n", 414 | " ...\n", 415 | "else:\n", 416 | " istruzione\n", 417 | " ...\n", 418 | "```" 419 | ] 420 | }, 421 | { 422 | "cell_type": "code", 423 | "execution_count": 59, 424 | "metadata": { 425 | "collapsed": false, 426 | "jupyter": { 427 | "outputs_hidden": false 428 | }, 429 | "pycharm": { 430 | "is_executing": false, 431 | "name": "#%%\n" 432 | } 433 | }, 434 | "outputs": [ 435 | { 436 | "name": "stdout", 437 | "output_type": "stream", 438 | "text": [ 439 | "x e' grande\n", 440 | "(5, 'Giorgio', 'Giorgio', True, ['a', 'b', 'c'])\n", 441 | "siamo arrivati alla fine!\n" 442 | ] 443 | } 444 | ], 445 | "source": [ 446 | "x = 35.67\n", 447 | "\n", 448 | "if x <= 15:\n", 449 | " print(f'x è piccolino e vale {x}')\n", 450 | " print(a)\n", 451 | "\n", 452 | "elif x<=23.7:\n", 453 | " print(f'il valore {x} assunto da x è intermedio')\n", 454 | " 'mamma'[1:3]\n", 455 | "\n", 456 | "elif x <= 45:\n", 457 | " print('x e\\' grande')\n", 458 | " print(t)\n", 459 | "\n", 460 | "else:\n", 461 | " print('x è decisamente grande!!')\n", 462 | "\n", 463 | "print('siamo arrivati alla fine!')" 464 | ] 465 | }, 466 | { 467 | "cell_type": "markdown", 468 | "metadata": { 469 | "pycharm": { 470 | "name": "#%% md\n" 471 | } 472 | }, 473 | "source": [ 474 | "- Iterazione `for`:\n", 475 | "```python\n", 476 | "for var in nome_oggetto_iterabile: # una stringa, lista, tupla o il risultato di range()\n", 477 | " istruzione\n", 478 | " istruzione\n", 479 | " ...\n", 480 | "```" 481 | ] 482 | }, 483 | { 484 | "cell_type": "code", 485 | "execution_count": 61, 486 | "metadata": { 487 | "collapsed": false, 488 | "jupyter": { 489 | "outputs_hidden": false 490 | }, 491 | "pycharm": { 492 | "is_executing": false, 493 | "name": "#%%\n" 494 | } 495 | }, 496 | "outputs": [ 497 | { 498 | "name": "stdout", 499 | "output_type": "stream", 500 | "text": [ 501 | "[-10, -8, -6, -4, -2, 0, 2, 4, 6, 8]\n", 502 | "[8, 6, 4, 2, 0, -2, -4, -6, -8, -10]\n" 503 | ] 504 | } 505 | ], 506 | "source": [ 507 | "l = []\n", 508 | "li = []\n", 509 | "\n", 510 | "for i in range(-10,10,2): # costruzione di una lista da lista vuota tramite for ... in\n", 511 | " # range(start,stop[,step]) genera un intervallo di valori interi da start a stop-1 con passo step (default: 1)\n", 512 | " # range(stop) genera un intervallo da 0 a stop-1 con passo 1\n", 513 | " l.append(i)\n", 514 | " li.insert(0,i)\n", 515 | "\n", 516 | "print(l,li,sep='\\n')\n", 517 | "\n" 518 | ] 519 | }, 520 | { 521 | "cell_type": "code", 522 | "execution_count": 64, 523 | "metadata": {}, 524 | "outputs": [ 525 | { 526 | "name": "stdout", 527 | "output_type": "stream", 528 | "text": [ 529 | "[4, 196]\n", 530 | "0 bim\n", 531 | "1 bum\n", 532 | "2 bam\n", 533 | "a, b, r, a, c, a, d, a, b, r, a, " 534 | ] 535 | } 536 | ], 537 | "source": [ 538 | "squares = [el**2 for el in [2,5,37,14] if el%2==0] # costruzione di una lista da un oggetto iterabile sotto condizioni con for ... in [if ...]\n", 539 | "print(squares)\n", 540 | "\n", 541 | "for k,v in enumerate(['bim','bum','bam']): # enumerate itera sulla lista e genera gli indici\n", 542 | " print(k,v)\n", 543 | "\n", 544 | "for c in 'abracadabra':\n", 545 | " print(c, end=', ')" 546 | ] 547 | }, 548 | { 549 | "cell_type": "markdown", 550 | "metadata": { 551 | "pycharm": { 552 | "name": "#%% md\n" 553 | } 554 | }, 555 | "source": [ 556 | "- Iterazione `while`:\n", 557 | "```python\n", 558 | "while condizione: # il blocco è eseguito quando condizione è valutata True\n", 559 | " istruzione\n", 560 | " istruzione\n", 561 | " ...\n", 562 | "```" 563 | ] 564 | }, 565 | { 566 | "cell_type": "code", 567 | "execution_count": 12, 568 | "metadata": { 569 | "collapsed": false, 570 | "jupyter": { 571 | "outputs_hidden": false 572 | }, 573 | "pycharm": { 574 | "is_executing": false, 575 | "name": "#%%\n" 576 | } 577 | }, 578 | "outputs": [ 579 | { 580 | "name": "stdout", 581 | "output_type": "stream", 582 | "text": [ 583 | "r o n e " 584 | ] 585 | } 586 | ], 587 | "source": [ 588 | "item = 'r'\n", 589 | "s = 'Zio Paperone'\n", 590 | "pos = s.index(item)\n", 591 | "while item in s and pos < len(s):\n", 592 | " print(item,end=' ')\n", 593 | " pos += 1\n", 594 | " if pos < len(s):\n", 595 | " item = s[pos]\n", 596 | " else:\n", 597 | " break # esiste anche continue con il significato solito" 598 | ] 599 | }, 600 | { 601 | "cell_type": "markdown", 602 | "metadata": { 603 | "pycharm": { 604 | "name": "#%% md\n" 605 | } 606 | }, 607 | "source": [ 608 | "## Ordinamento\n", 609 | "\n", 610 | "L'ordinamento degli elementi di un oggetto iterabile si può ottenere attraverso la funzione `sorted(iterable, key=None, reverse=False)` che in automatico restituisce una lista di elementi ordinati in ordine crescente. `key` contiene il riferimento ad una funzione che fa da criterio di selezione per l'ordinamento, mentre `reverse=True` abilita l'ordinamento inverso.\n", 611 | "\n", 612 | "Le liste hanno il loro metodo `sort()` per l'ordinamento _in place_ crescente automatico degli elementi, il quale restituisce `None` che è il letterale che esprime l'oggetto nullo (equivalente di `null` del C/C++)" 613 | ] 614 | }, 615 | { 616 | "cell_type": "code", 617 | "execution_count": 5, 618 | "metadata": { 619 | "collapsed": false, 620 | "jupyter": { 621 | "outputs_hidden": false 622 | }, 623 | "pycharm": { 624 | "is_executing": false, 625 | "name": "#%%\n" 626 | } 627 | }, 628 | "outputs": [ 629 | { 630 | "name": "stdout", 631 | "output_type": "stream", 632 | "text": [ 633 | "[['clarabella', 'paperino'], ('True', 'False'), ['1', '2', '3']]\n", 634 | "['pippo', 'clarabella', 'paperino']\n" 635 | ] 636 | } 637 | ], 638 | "source": [ 639 | "a = ['pippo','clarabella','paperino']\n", 640 | "\n", 641 | "#sa = sorted(a,key=lambda x : x[1],reverse=False)\n", 642 | "sa = sorted((['1','2','3'],['clarabella','paperino'],('True', 'False')),key=lambda x : x[1],reverse=True)\n", 643 | "print(sa)\n", 644 | "print(a)\n" 645 | ] 646 | }, 647 | { 648 | "cell_type": "code", 649 | "execution_count": 2, 650 | "metadata": {}, 651 | "outputs": [ 652 | { 653 | "name": "stdout", 654 | "output_type": "stream", 655 | "text": [ 656 | "['pippo', 'paperino', 'clarabella']\n" 657 | ] 658 | } 659 | ], 660 | "source": [ 661 | "a = ['pippo','clarabella','paperino']\n", 662 | "a.sort(reverse=True)\n", 663 | "print(a)" 664 | ] 665 | }, 666 | { 667 | "cell_type": "markdown", 668 | "metadata": { 669 | "pycharm": { 670 | "name": "#%% md\n" 671 | } 672 | }, 673 | "source": [ 674 | "La funzione `reversed()` genera un ***iteratore*** che elenca la sequenza in ordine inverso. Gli iteratori sono oggetti sui quali si può scorrere utilizzando la funzione `next()` che genera l'eccezione `StopIteration`. La funzione `iter()` genera un iteratore dal suo argomento.\n", 675 | "\n", 676 | "## Esercizi\n", 677 | "\n", 678 | "1. Scrivere un programma Python `tail.py` che accetta due argomenti da linea di comando: `tail.py |` e stampa l'ultima parte della stringa a partire dall'ultima occorrenza del carattere ovvero a partire dall'indice specificato, anche negativo. Il programma dovrà effettuare il controllo di consistenza degli argomenti come tipo e numero e fornire un messaggio di utilizzo corretto in caso di errore nel passaggio degli argomenti ovvero di carattere non presente o indice fuori dal range della stringa. Si definisca una funzione `lastIndexOf` che ritorna ***l'ultima*** occorrenza di un carattere in una stringa e si richiami questa funzione dal programma principale.\n", 679 | "\n", 680 | "2. Scrivere un programma Pyhton `linear_merge.py` che accetta due liste con lo stesso tipo di elementi da linea di comando: `linear_merge.py [-r]` e stampa un'unica lista in cui gli elementi ripetuti di ogni lista sono stati rimossi e le due liste risultanti sono state fuse in un'unica lista ordinata e senza elementi ripetuti. Se l'argomento `-r` è presente l'output dovrà essere ordinato in senso inverso. Il programma dovrà effettuare il controllo di consistenza degli argomenti in tipo e numero e fornire un messaggio di utilizzo corretto in caso di errore. Si realizzino due funzioni `removeDuplicates` e `merge` per realizzare rispettivamente la rimozione di duplicati e la fuzione.\n", 681 | " - _Opzionale_: gestire anche il caso in cui gli elementi delle due liste siano di tipo diverso e ordinarli rispetto alla loro rappresentazione interna di tipo stringa che si ottiene con la funzione `repr()` \n", 682 | "\n", 683 | "\n" 684 | ] 685 | } 686 | ], 687 | "metadata": { 688 | "interpreter": { 689 | "hash": "aee8b7b246df8f9039afb4144a1f6fd8d2ca17a180786b69acc140d282b71a49" 690 | }, 691 | "kernelspec": { 692 | "display_name": "Python 3.9.6 64-bit", 693 | "name": "python3" 694 | }, 695 | "language_info": { 696 | "codemirror_mode": { 697 | "name": "ipython", 698 | "version": 3 699 | }, 700 | "file_extension": ".py", 701 | "mimetype": "text/x-python", 702 | "name": "python", 703 | "nbconvert_exporter": "python", 704 | "pygments_lexer": "ipython3", 705 | "version": "3.10.7" 706 | }, 707 | "pycharm": { 708 | "stem_cell": { 709 | "cell_type": "raw", 710 | "metadata": { 711 | "collapsed": false 712 | }, 713 | "source": [] 714 | } 715 | } 716 | }, 717 | "nbformat": 4, 718 | "nbformat_minor": 4 719 | } 720 | -------------------------------------------------------------------------------- /Python programming/hello.py: -------------------------------------------------------------------------------- 1 | #!/usr/bin/python -tt 2 | # Copyright 2010 Google Inc. 3 | # Licensed under the Apache License, Version 2.0 4 | # http://www.apache.org/licenses/LICENSE-2.0 5 | 6 | # Google's Python Class 7 | # http://code.google.com/edu/languages/google-python-class/ 8 | 9 | """A tiny Python program to check that Python is working. 10 | Try running this program from the command line like this: 11 | python hello.py 12 | python hello.py Alice 13 | That should print: 14 | Hello World -or- Hello Alice 15 | Try changing the 'Hello' to 'Howdy' and run again. 16 | Once you have that working, you're ready for class -- you can edit 17 | and run Python code; now you just need to learn Python! 18 | """ 19 | 20 | import sys 21 | 22 | # Define a main() function that prints a little greeting. 23 | def main(): 24 | # Get the name from the command line, using 'World' as a fallback. 25 | if len(sys.argv) >= 2: 26 | name = sys.argv[1] 27 | else: 28 | name = 'World' 29 | print ('Hello', name) 30 | 31 | # This is the standard boilerplate that calls the main() function. 32 | if __name__ == '__main__': 33 | main() 34 | -------------------------------------------------------------------------------- /Python programming/linear_merge.py: -------------------------------------------------------------------------------- 1 | #!/usr/bin/env python 2 | import sys 3 | 4 | ''' 5 | Script che fonde due liste di elementi passate da linea di comando e separate da virgole e restituisce 6 | la lista ordinata senza duplicati ed opzionalmente in ordine inverso: 7 | 8 | linear_merge.py [-r] 9 | ''' 10 | 11 | ## 12 | # 13 | # scandisce la lista e, per ogni elemento, analizza i successivi; 14 | # se trova un elemento uguale all'elemento considerato, lo rimuove 15 | # 16 | def removeDuplicates(l): 17 | for i in l: 18 | for j in l[l.index(i)+1:]: 19 | if i==j: 20 | l.pop(l.index(j)) 21 | 22 | ## 23 | # 24 | # scandisce list1 e list2 a partire dalla fine e confronta sempre gli ultimi elementi 25 | # tra di loro, trasferendoli nella lista risultato e rimuovendoli dalle 26 | # liste di input; il risultato viene privato dei duplicati chiamando removeDuplicates(); 27 | # si ottiene una lista ordinata all'inverso per cui alla fine 28 | # si inverte l'ordine degli elementi nella lista risultato se si vuole una lista ordinata 29 | # convenzionalmente 30 | # 31 | def merge(list1, list2, rev=False): 32 | out_list = list1 + list2 33 | 34 | removeDuplicates(out_list) # rimozione duplicati 35 | out_list.sort() # ordinamento 36 | 37 | if rev: 38 | out_list.reverse() # inversione, se richiesta 39 | 40 | return out_list 41 | 42 | ## 43 | # 44 | # Stampa il messaggio di errore passato come argomento insieme alle modalità di utilizzo dello script 45 | # 46 | def errorMessage(error_string): 47 | print(f'{error_string}\n\nUtilizzo: linear_merge.py [-r] ') 48 | exit() 49 | 50 | def main(): 51 | 52 | to_reverse = False # Flag che indice se il risultato finale dev'essere invertito 53 | 54 | if len(sys.argv) < 2 or len(sys.argv) > 4\ 55 | or (len(sys.argv) == 4 and sys.argv[1] != '-r'): # verifica la lunghezza e correttezza degli argomenti 56 | errorMessage('Argomenti non validi!') 57 | elif len(sys.argv) == 3: # caso in cui la lista non dev'essere invertita 58 | l1 = sys.argv[1].split(',') # converte la lista ottenuta dall'argomento di ingresso 59 | l2 = sys.argv[2].split(',') # separando i token rispetto allo spazio 60 | else: 61 | to_reverse = True 62 | l1 = sys.argv[2].split(',') # analogo discorso, ma con secondo argomento impostato a '-r' 63 | l2 = sys.argv[3].split(',') 64 | 65 | result = merge(l1,l2,rev=to_reverse) # fusione con rimozione dei duplicati e eventuale inversione 66 | 67 | print(result) 68 | 69 | # This is the standard boilerplate that calls the main() function. 70 | if __name__ == '__main__': 71 | main() -------------------------------------------------------------------------------- /Python programming/mymodule.py: -------------------------------------------------------------------------------- 1 | """ 2 | Definizione del modulo mymodule.py 3 | """ 4 | 5 | def foo(n): 6 | for i in range(n): 7 | print('foo') 8 | 9 | def bar(s): 10 | print(s.capitalize()) 11 | -------------------------------------------------------------------------------- /Python programming/mypackage/.ipynb_checkpoints/__init__-checkpoint.py: -------------------------------------------------------------------------------- 1 | """ 2 | Mypackage contiene il modulo module1 e il package subpackage che a sua volta contiene il modulo 3 | module2. 4 | 5 | Importare i moduli con la seguente sintassi: 6 | 7 | - import mypackage.module1 8 | - import mypackage.subpackage.module2 9 | """ -------------------------------------------------------------------------------- /Python programming/mypackage/.ipynb_checkpoints/module1-checkpoint.py: -------------------------------------------------------------------------------- 1 | """ 2 | Il modulo module1 è caricato direttamente da package 3 | """ 4 | 5 | def myFun(): 6 | """ 7 | myFun() -- stampa un messaggio 8 | """ 9 | print('Sono il modulo 1!!') -------------------------------------------------------------------------------- /Python programming/mypackage/__init__.py: -------------------------------------------------------------------------------- 1 | """ 2 | Mypackage contiene il modulo module1 e il package subpackage che a sua volta contiene il modulo 3 | module2. 4 | 5 | Importare i moduli con la seguente sintassi: 6 | 7 | - import mypackage.module1 8 | - import mypackage.subpackage.module2 9 | """ -------------------------------------------------------------------------------- /Python programming/mypackage/__pycache__/__init__.cpython-37.pyc: -------------------------------------------------------------------------------- https://raw.githubusercontent.com/fredffsixty/Big-Data/896430d4821c623d14fbf05beae34fe1afbd7a2d/Python programming/mypackage/__pycache__/__init__.cpython-37.pyc -------------------------------------------------------------------------------- /Python programming/mypackage/__pycache__/module1.cpython-37.pyc: -------------------------------------------------------------------------------- https://raw.githubusercontent.com/fredffsixty/Big-Data/896430d4821c623d14fbf05beae34fe1afbd7a2d/Python programming/mypackage/__pycache__/module1.cpython-37.pyc -------------------------------------------------------------------------------- /Python programming/mypackage/module1.py: -------------------------------------------------------------------------------- 1 | """ 2 | Il modulo module1 è caricato direttamente da package 3 | """ 4 | 5 | def myFun(): 6 | """ 7 | myFun() -- stampa un messaggio 8 | """ 9 | print('Sono il modulo 1!!') -------------------------------------------------------------------------------- /Python programming/mypackage/mysubpackage/.ipynb_checkpoints/__init__-checkpoint.py: -------------------------------------------------------------------------------- 1 | """ 2 | subpackage è caricato da package e contiene il modulo module2 3 | """ -------------------------------------------------------------------------------- /Python programming/mypackage/mysubpackage/.ipynb_checkpoints/module2-checkpoint.py: -------------------------------------------------------------------------------- 1 | """ 2 | Il modulo module2 è caricato da subpackage 3 | """ 4 | 5 | def myMethod(*args,**kwargs): 6 | """ 7 | myMethod(*args,lang=en,newline=False) -- stampa un messaggio di saluto ad args in 8 | inglese e senza andare a capo dopo ogni saluto. 9 | 10 | lang=it saluta in italiano 11 | newline=True va a acapo dopo ogni saluto 12 | """ 13 | # valori di defalut degli argomenti 14 | saluto = 'Hello' 15 | separatore = ', ' 16 | 17 | result = '' 18 | 19 | try: 20 | if len(kwargs) >2: 21 | raise SyntaxError('Invalid arguments') 22 | else: 23 | for k in kwargs.keys(): 24 | if k not in {'lang','newline'}: 25 | raise SyntaxError('Invalid arguments') 26 | elif k == 'lang': 27 | if kwargs[k] == 'it': 28 | saluto = 'Ciao' 29 | elif k == 'newline': 30 | if kwargs[k] == True: 31 | separatore = '\n' 32 | elif (k == 'lang' and kwargs[k] != 'en') or (k == 'newline' and kwargs[k] != False): 33 | raise SyntaxError('Invalid arguments') 34 | except SyntaxError: 35 | return None 36 | raise 37 | else: 38 | for people in args: 39 | if args.index(people) == len(args) -1: 40 | result += f'{saluto} {people}! \n' 41 | else: 42 | result += f'{saluto} {people}! {separatore}' 43 | return result 44 | -------------------------------------------------------------------------------- /Python programming/mypackage/mysubpackage/__init__.py: -------------------------------------------------------------------------------- 1 | """ 2 | subpackage è caricato da package e contiene il modulo module2 3 | """ -------------------------------------------------------------------------------- /Python programming/mypackage/mysubpackage/__pycache__/__init__.cpython-37.pyc: -------------------------------------------------------------------------------- https://raw.githubusercontent.com/fredffsixty/Big-Data/896430d4821c623d14fbf05beae34fe1afbd7a2d/Python programming/mypackage/mysubpackage/__pycache__/__init__.cpython-37.pyc -------------------------------------------------------------------------------- /Python programming/mypackage/mysubpackage/__pycache__/module2.cpython-37.pyc: -------------------------------------------------------------------------------- https://raw.githubusercontent.com/fredffsixty/Big-Data/896430d4821c623d14fbf05beae34fe1afbd7a2d/Python programming/mypackage/mysubpackage/__pycache__/module2.cpython-37.pyc -------------------------------------------------------------------------------- /Python programming/mypackage/mysubpackage/module2.py: -------------------------------------------------------------------------------- 1 | """ 2 | Il modulo module2 è caricato da subpackage 3 | """ 4 | 5 | def myMethod(*args,**kwargs): 6 | """ 7 | myMethod(*args,lang=en,newline=False) -- stampa un messaggio di saluto ad args in 8 | inglese e senza andare a capo dopo ogni saluto. 9 | 10 | lang=it saluta in italiano 11 | newline=True va a acapo dopo ogni saluto 12 | """ 13 | # valori di defalut degli argomenti 14 | saluto = 'Hello' 15 | separatore = ', ' 16 | 17 | result = '' 18 | 19 | try: 20 | if len(kwargs) >2: 21 | raise SyntaxError('Invalid arguments') 22 | else: 23 | for k in kwargs.keys(): 24 | if k not in {'lang','newline'}: 25 | raise SyntaxError('Invalid arguments') 26 | elif k == 'lang' and kwargs[k] == 'it': 27 | saluto = 'Ciao' 28 | elif k == 'newline' and kwargs[k] == True: 29 | separatore = '\n' 30 | elif (k == 'lang' and kwargs[k] != 'en') or (k == 'newline' and kwargs[k] != False): 31 | raise SyntaxError('Invalid arguments') 32 | except SyntaxError: 33 | raise 34 | else: 35 | for people in args: 36 | if args.index(people) == len(args) -1: 37 | result += f'{saluto} {people}! \n' 38 | else: 39 | result += f'{saluto} {people}! {separatore}' 40 | return result 41 | -------------------------------------------------------------------------------- /Python programming/tail.py: -------------------------------------------------------------------------------- 1 | #!/usr/bin/env python 2 | 3 | ''' 4 | Script che restituisce la sottostringa ottenuta del primo argomento 5 | da linea di comando a partire dal carattere o numero di posizione passato 6 | come secondo argomento: 7 | 8 | tail.py | 9 | ''' 10 | import sys 11 | 12 | def lastIndexOf(s,c): 13 | ''' 14 | lastIndexOf(str,chr) --> int 15 | 16 | Restituisce l'indice dell'ultima occorrenza del carattere c 17 | nella stringa s ovvero -1 nel caso in cui c non sia presente in s 18 | ''' 19 | return len(s) - 1 - s[::-1].index(c) if c in s else -1 20 | 21 | 22 | def main(): 23 | 24 | if len(sys.argv) != 3: 25 | print('Numero errato di argomenti: tail.py |') 26 | elif not sys.argv[1].isalpha() or\ 27 | not(sys.argv[2].isdigit() or\ 28 | (sys.argv[2].isalpha() and len(sys.argv[2]) == 1)): 29 | 30 | print('Tipo errato degli argomenti: tail.py |') 31 | else: 32 | idx = int(sys.argv[2]) if sys.argv[2].isdigit() else lastIndexOf(sys.argv[1],sys.argv[2]) 33 | 34 | print(sys.argv[1][idx::] if idx in range(0,len(sys.argv[1])) else\ 35 | 'Indice non compreso nella stringa') 36 | 37 | 38 | if __name__ == '__main__': 39 | main() -------------------------------------------------------------------------------- /Python programming/test.py: -------------------------------------------------------------------------------- 1 | #!/usr/bin/env python 2 | 3 | import mypackage.mysubpackage.module2 as m2 4 | 5 | def main(): 6 | m2.myMethod('Harry','Sally',lang='ru') 7 | 8 | if __name__ == '__main__': 9 | main() -------------------------------------------------------------------------------- /README.md: -------------------------------------------------------------------------------- 1 | # Big-Data 2 | ### Repository of the UNIPA Big Data class 2020-2021 3 | 4 | Questo repository conterrà lezioni ed esercitazioni in diversi formati, quali PDF o PowerPoint nonché Jupyter Notebook interattivi per gli esercizi del corso di Big Data per la laurea Magistrale in Ingegneria Informatica 5 | 6 | -------------------------------------------------------------------------------- /Uso di HDFS.ipynb: -------------------------------------------------------------------------------- 1 | { 2 | "cells": [ 3 | { 4 | "cell_type": "markdown", 5 | "metadata": {}, 6 | "source": [ 7 | "# Uso di HDFS\n", 8 | "\n", 9 | "Hadoop Distributed File System (HDFS) è il File System distribuito di riferimento per le applicazioni di elaborazione Big Data del cosiddetto _Ecosistema Hadoop_.\n", 10 | "\n", 11 | "HDFS si accompagna a YARN (Yet Another Resource Negotiator) che fa da Resource Manager per la computazione distribuita sul cluster Hadoop. Un'applicazione Hadoop può essere sviluppata direttamente con le API Java ovvero attraverso uno dei molteplici framework che fanno a front-end per lo sviluppo e che mappano il proprio codice nativo in processi Java gestiti da YARN direttamente sul cluster.\n", 12 | "\n", 13 | "\n", 14 | "## Installazione\n", 15 | "\n", 16 | "Il prerequisito è l'installazine del Java JDK la cui cartella di installazione dovrà essere esposta esplicitamente come variabile di ambiente ```JAVA_HOME```.\n", 17 | "\n", 18 | "I processi Hadoop hanno la necessità di connettersi in ``ssh`` senza password al server del filesystem ovvero al nodemanager. Per configurare questa opzione su ``localhost``, al fine di realizzare una configurazione a singolo nodo, eseguire i seguenti comandi nella shell:\n", 19 | "\n", 20 | "```bash\n", 21 | "$ ssh-keygen -t rsa -P '' -f ~/.ssh/id_rsa\n", 22 | "$ cat ~/.ssh/id_rsa.pub >> ~/.ssh/authorized_keys\n", 23 | "$ chmod 0600 ~/.ssh/authorized_keys\n", 24 | "````\n", 25 | "\n", 26 | "A questo punto, si può scaricare il sorgente ```.tar.gz``` di Hadoop dalla sua [home page](https://hadoop.apache.org/releases.html) e procedere all'installazione vera e propria.\n", 27 | "\n", 28 | "_Nota per MacOS X:_ è possibile installare Hadoop con ```brew install hadoop```\n", 29 | "\n", 30 | "\n", 31 | "## Configurazione\n", 32 | "\n", 33 | "La configurazione del cluster consiste nella personalizzazione di alcuni file `xml` che stabiliscono il comportamento di HDFS e YARN e che si trovano nella cartella ```/percorso/di/installazione/etc/hadoop```. In questi file andranno riportate delle proprietà di configurazione organizzate come coppie nome-valore. Di seguito si riporta la configurazione distribuita con un solo nodo all'indirizzo ``localhost``.\n", 34 | "\n", 35 | "### ```core_site.xml```\n", 36 | "\n", 37 | "Definisce essenzialmente l'URL del server HDFS per la connessione dei processi interessati. La web interface per l'utente si trova all'indirizzo [http://localhost:9870](http://localhost:9870) in Hadoop 3.X ovvero [http://localhost:50070](http://localhost:50070) in Hadoop 2.X.\n", 38 | "La URL [hdfs://localhost:9099]() serve invece per la connessione al file system da parte di client e applicazioni (le porte hdfs di default sono 8020 ovvero 9000).\n", 39 | "Le altre proprietà servono a fare in modo che l'utente di shell che si connette tramite ``beeline`` al server ``hiveserver2`` di ``hive`` possa usere le credenziali di connessione configurate per il server da tutti i nodi del cluster, da cui la wildcard ``*``.\n", 40 | "\n", 41 | "```xml\n", 42 | "\n", 43 | " \n", 44 | " fs.defaultFS\n", 45 | " hdfs://localhost:9099\n", 46 | " \n", 47 | " \n", 48 | " hadoop.proxyuser..hosts\n", 49 | " *\n", 50 | " \n", 51 | " \n", 52 | " hadoop.proxyuser..groups\n", 53 | " *\n", 54 | " \n", 55 | "\n", 56 | "```\n", 57 | "\n", 58 | "### ```hdfs_site.xml```\n", 59 | "\n", 60 | "Definisce il numero dei nodi e la lista di path nel filesystem locale in cui verranno memorizzate le informazioni del NameNode e dei DataNode. Con proprietà analoghe si definiscono le cartelle per i nodi di backup, checkpoint etc.\n", 61 | "\n", 62 | "```xml\n", 63 | "\n", 64 | " \n", 65 | " dfs.replication\n", 66 | " 1\n", 67 | " \n", 68 | " \n", 69 | " dfs.namenode.name.dir\n", 70 | " /Users/pirrone/src/hdfs/name\n", 71 | " \n", 72 | " \n", 73 | " dfs.datanode.data.dir\n", 74 | " /Users/pirrone/src/hdfs/data\n", 75 | " \n", 76 | "\n", 77 | "```\n", 78 | "\n", 79 | "### ```yarn_site.xml```\n", 80 | "\n", 81 | "Definisce il tipo di servizio del nodemanager di YARN e le variabili di ambiente di cui questo ha bisogno (sono tutte gestite direttamente dall'installazione tranne ``JAVA_HOME``). La web interface per l'utente per monitorare i processi sul cluster si trova all'indirizzo [http://localhost:8088](http://localhost:8088).\n", 82 | "\n", 83 | "```xml\n", 84 | "\n", 85 | " \n", 86 | " yarn.nodemanager.aux-services\n", 87 | " mapreduce_shuffle\n", 88 | " \n", 89 | " \n", 90 | " yarn.nodemanager.env-whitelist\n", 91 | " JAVA_HOME,HADOOP_COMMON_HOME,HADOOP_HDFS_HOME,HADOOP_CONF_DIR,CLASSPATH_PREPEND_DISTCACHE,HADOOP_YARN_HOME,HADOOP_MAPRED_HOME\n", 92 | " \n", 93 | "\n", 94 | "```\n", 95 | "\n", 96 | "### ```mapred_site.xml```\n", 97 | "\n", 98 | "Definisce YARN quale framework di esecuzione di Map Reduce e istanzia il ``classpath`` per le applicazioni.\n", 99 | "\n", 100 | "```xml\n", 101 | "\n", 102 | " \n", 103 | " mapreduce.framework.name\n", 104 | " yarn\n", 105 | " \n", 106 | " \n", 107 | " mapreduce.application.classpath\n", 108 | " $HADOOP_MAPRED_HOME/share/hadoop/mapreduce/*:$HADOOP_MAPRED_HOME/share/hadoop/mapreduce/lib/*\n", 109 | " \n", 110 | "\n", 111 | "```\n", 112 | "\n", 113 | "### Avvio del cluster\n", 114 | "\n", 115 | "Prima dell'avvio può essere opportuno configurare la variabile di ambiente ``HADOOP_HOME`` a puntare a ``/percorso/di/installazione/hadoop``. Su questa base, la prima volta che sia avvia il cluster, si deve formattare il datanode con il comando ``$HADOOP_HOME/bin/hdfs namenode -format``. Ad ogni avvio/stop del cluster e del resource manager si possono usare gli script appositi ``$HADOOP_HOME/sbin/start-all.sh`` e ``$HADOOP_HOME/sbin/stop-all.sh``.\n", 116 | "\n", 117 | "## Uso della shell\n", 118 | "\n", 119 | "I comandi interattivi per la shell di HDFS si possono invocare come argomenti di ``hadoop fs`` ovvero di ``hdfs dfs``. La forma è la stessa:\n", 120 | "\n", 121 | "```bash\n", 122 | "$ hdfs dfs - [-] \n", 123 | "\n", 124 | "$ hadoop fs - [-] \n", 125 | "```\n", 126 | "\n", 127 | "In generale ```` è uno dei tipici comandi di shell UNIX insieme con le sue opzioni. La documentazione completa si trova sul sito di [Apache Hadoop](https://hadoop.apache.org/docs/r3.3.0/hadoop-project-dist/hadoop-common/FileSystemShell.html).\n", 128 | "\n", 129 | "## Esecuzione di applicazioni MapReduce\n", 130 | "\n", 131 | "E' prassi creare nel filesystem HDFS delle cartelle con dei nomi ben precisi. Usualmente, si crea la cartella ``/user/`` con il comando:\n", 132 | "\n", 133 | "```bash\n", 134 | "$ hdfs dfs -mkdir /user/\n", 135 | "```\n", 136 | "\n", 137 | "In questa cartella ogni applicazione MapReduce gestirà una coppia di cartelle, una per l'input dei dati e una per l'output, ad esempio ``/user///input`` e ``/user///output`` che viene però **creata dinamicamente** dall'applicazione stessa quando viene eseguita. I dati di input saranno caricati preventivamente nella cartella di input, per esempio, con il comando:\n", 138 | "\n", 139 | "```bash\n", 140 | "$ hdfs dfs -put /percorso/dati/nel/fs/locale /user///input/\n", 141 | "```\n", 142 | "\n", 143 | "Le applicazioni che usano la API Java verranno costruite sotto forma di file ``.jar`` e saranno invocate nella forma:\n", 144 | "\n", 145 | "```bash\n", 146 | "$ hadoop jar .jar [] /user///input /user///output\n", 147 | "```\n", 148 | "\n", 149 | "La cartella di output viene creata dall'applicazione e popolata con i risultati.\n", 150 | "\n" 151 | ] 152 | } 153 | ], 154 | "metadata": { 155 | "interpreter": { 156 | "hash": "8293d9868bd684e14650ff4220f8cffaf1d9c6f3393a385a785f2b79459e56ab" 157 | }, 158 | "kernelspec": { 159 | "display_name": "Python 3.9.9 64-bit ('bigdata': venv)", 160 | "language": "python", 161 | "name": "python3" 162 | }, 163 | "language_info": { 164 | "name": "python", 165 | "version": "3.9.14" 166 | } 167 | }, 168 | "nbformat": 4, 169 | "nbformat_minor": 4 170 | } 171 | -------------------------------------------------------------------------------- /kafka_python/consumer.py: -------------------------------------------------------------------------------- 1 | from kafka import KafkaConsumer 2 | import time 3 | import sys 4 | import argparse 5 | 6 | def main(): 7 | 8 | parser = argparse.ArgumentParser(description='A simple Kafka Consumer') 9 | 10 | parser.add_argument('-b', '--bootstrap-server', dest='bootstrap_servers', default='localhost:9092') 11 | parser.add_argument('-t', '--topic', dest='topic', default='titanic') 12 | 13 | args = parser.parse_args() 14 | print("Kafka consumer application started ...") 15 | 16 | consumer = KafkaConsumer(args.topic,\ 17 | bootstrap_servers=args.bootstrap_servers,\ 18 | auto_offset_reset='latest',\ 19 | enable_auto_commit=True) 20 | 21 | print('Reading messages from kafka topic about to start ...') 22 | 23 | message_list = [] 24 | 25 | for message in consumer: 26 | print('Key: ', message.key) 27 | output_message = message.value 28 | print(type(message.value)) 29 | print('Message received: ',output_message) 30 | message_list.append(output_message) 31 | time.sleep(1) 32 | 33 | if __name__ == "__main__": 34 | main() 35 | -------------------------------------------------------------------------------- /kafka_python/producer.py: -------------------------------------------------------------------------------- 1 | from kafka import KafkaProducer 2 | import time 3 | import csv 4 | import sys 5 | import argparse 6 | 7 | def main(): 8 | 9 | parser = argparse.ArgumentParser(description='A simple Kafka Producer') 10 | 11 | parser.add_argument('-s', '--source', dest='source_file', default='/home/rpirrone/data/passengers.csv') 12 | parser.add_argument('-b', '--bootstrap-server', dest='bootstrap_servers', default='localhost:9092') 13 | parser.add_argument('-t', '--topic', dest='topic', default='titanic') 14 | parser.add_argument('-i', '--interval', dest='interval', default=1) 15 | 16 | args = parser.parse_args() 17 | 18 | print("Kafka producer application started ...") 19 | 20 | kafka_producer_obj = KafkaProducer(bootstrap_servers=args.bootstrap_servers) 21 | 22 | message = None 23 | 24 | with open(args.source_file, 'r') as file: 25 | reader = csv.reader(file, delimiter=',') 26 | for messages in reader: 27 | key = messages[0] 28 | message = ','.join(messages[1:]) 29 | print(key, message) 30 | kafka_producer_obj.send(args.topic, \ 31 | key = bytes(key, 'utf-8'), \ 32 | value = bytes(message,'utf-8')) 33 | time.sleep(float(args.interval)) 34 | 35 | if __name__ == "__main__": 36 | main() -------------------------------------------------------------------------------- /kafka_python/spark_batch_processing.py: -------------------------------------------------------------------------------- 1 | from pyspark.sql import SparkSession 2 | from pyspark.sql.types import * 3 | from pyspark.sql.functions import * 4 | from pyspark.accumulators import AccumulatorParam 5 | 6 | import findspark 7 | 8 | KAFKA_TOPIC_NAME_PROD = "titanic" 9 | KAFKA_BOOTSTRAP_SERVERS = "localhost:9092" 10 | KAFKA_TOPIC_NAME_CONS = "survived" 11 | 12 | 13 | if __name__ == '__main__': 14 | 15 | # Creiamo la SparkSession 16 | location = findspark.find() 17 | findspark.init(location) 18 | spark = SparkSession.builder.appName('SparkBatchApp').getOrCreate() 19 | sc = spark.sparkContext 20 | sc.setLogLevel('ERROR') 21 | 22 | # Leggiamo tutto lo stream prodotto nel topic per effettuare una query batch 23 | kafka_df = spark.readStream \ 24 | .format("kafka") \ 25 | .option("kafka.bootstrap.servers", KAFKA_BOOTSTRAP_SERVERS) \ 26 | .option("kafka.security.protocol", "PLAINTEXT") \ 27 | .option("failOnDataLoss", "false") \ 28 | .option("startingOffsets", "earliest") \ 29 | .option("subscribe", KAFKA_TOPIC_NAME_PROD) \ 30 | .load() 31 | 32 | # creiamo il dataframe in ingresso effettuando il casting del 33 | # flusso di byte di ogni messaggio nella coppia di stringhe chiave-valore 34 | # che questo contiene 35 | kafka_df = kafka_df.selectExpr("CAST(key AS STRING)", "CAST(value AS STRING)") 36 | kafka_df.dropDuplicates(['key']) 37 | 38 | # leggiamo i campi della stringa value e inseriamo apposite colonne 39 | split_col = split(kafka_df['value'],',') 40 | 41 | kafka_df = kafka_df.withColumn('Survived',split_col.getItem(0).cast('integer')) 42 | kafka_df = kafka_df.withColumn('Class',split_col.getItem(1).cast('integer')) 43 | # nel nostro data set la stringa del nome contiene il carattere ',' 44 | kafka_df = kafka_df.withColumn('Name',concat_ws(',',split_col.getItem(2),split_col.getItem(3))) 45 | kafka_df = kafka_df.withColumn('Gender',split_col.getItem(4)) 46 | kafka_df = kafka_df.withColumn('Age',split_col.getItem(5).cast('float')) 47 | kafka_df = kafka_df.select('Survived','Class','Gender','Age').where('Survived==1') 48 | kafka_df = kafka_df.dropna() 49 | 50 | # Creiamo una query streaming in uscita che salva i risultati su un file in 51 | # formato Apache Parquet che è un formato comodo perché conserva lo schema 52 | query= kafka_df.writeStream\ 53 | .option("checkpointLocation",'/home/rpirrone/src/kafka_python/batch_checkpoint')\ 54 | .option('path','/home/rpirrone/src/kafka_python/save_stream')\ 55 | .trigger(processingTime="5 seconds")\ 56 | .format("parquet")\ 57 | .start() 58 | 59 | query.awaitTermination(100) 60 | 61 | titanic = spark.read.format('parquet')\ 62 | .load('/home/rpirrone/src/kafka_python/save_stream') 63 | 64 | titanic.groupBy('Gender','Class')\ 65 | .agg(expr('avg(Age) as avg_age'),expr('count(*) as surv_num'))\ 66 | .show() 67 | 68 | # Analogo risultato si poteva ottenere fintrando il df in ingresso e 69 | # salvandolo su una tabella sulla quale si esegue spark.sql() 70 | 71 | #survived = kafka_df.filter('Survived == 1').\ 72 | # groupBy('Gender','Class').\ 73 | # agg(expr('avg(Age) as avg_age'),expr('count(*) as surv_num')) 74 | # 75 | # 76 | #survived.writeStream \ 77 | # .queryName("aggregates") \ 78 | # .outputMode("complete") \ 79 | # .format("memory") \ 80 | # .start().awaitTermination(100) 81 | 82 | #spark.sql("select * from aggregates").show() 83 | 84 | # Versione per debug su console 85 | 86 | #survived \ 87 | # .writeStream \ 88 | # .outputMode("complete") \ 89 | # .format("console")\ 90 | # .trigger(processingTime="5 seconds")\ 91 | # .start().awaitTermination(180) 92 | 93 | 94 | print("SparkBatchApp terminated") -------------------------------------------------------------------------------- /kafka_python/spark_stream_processing.py: -------------------------------------------------------------------------------- 1 | from pyspark.sql import SparkSession 2 | from pyspark.sql.types import * 3 | from pyspark.sql.functions import * 4 | import findspark 5 | 6 | KAFKA_TOPIC_NAME_PROD = "titanic" 7 | KAFKA_BOOTSTRAP_SERVERS = "localhost:9092" 8 | KAFKA_TOPIC_NAME_CONS = "survived" 9 | 10 | 11 | if __name__ == '__main__': 12 | 13 | # Creiamo la SparkSession 14 | location = findspark.find() 15 | findspark.init(location) 16 | spark = SparkSession.builder.appName('SparkStreamingApp').getOrCreate() 17 | spark.sparkContext.setLogLevel('ERROR') 18 | 19 | # Leggiamo lo stream a partire dall'ultimo offset nel topic per effettuare una query streaming 20 | kafka_df = spark.readStream \ 21 | .format("kafka") \ 22 | .option("kafka.bootstrap.servers", KAFKA_BOOTSTRAP_SERVERS) \ 23 | .option("kafka.security.protocol", "PLAINTEXT") \ 24 | .option("failOnDataLoss", "false") \ 25 | .option("subscribe", KAFKA_TOPIC_NAME_PROD) \ 26 | .option("includeHeaders", "false") \ 27 | .option("startingOffsets", "latest") \ 28 | .option("spark.streaming.kafka.maxRatePerPartition", "50") \ 29 | .load() 30 | 31 | # creiamo il dataframe in ingresso effettuando il casting del 32 | # flusso di byte di ogni messaggio nella coppia di stringhe chiave-valore 33 | # che questo contiene 34 | kafka_df = kafka_df.selectExpr("CAST(key AS STRING)", "CAST(value AS STRING)") 35 | 36 | # leggiamo i campi della stringa value e inseriamo apposite colonne 37 | split_col = split(kafka_df['value'],',') 38 | 39 | kafka_df = kafka_df.withColumn('Survived',split_col.getItem(0).cast('integer')) 40 | kafka_df = kafka_df.withColumn('Class',split_col.getItem(1).cast('integer')) 41 | # nel nostro data set la stringa del nome contiene carattere ',' 42 | kafka_df = kafka_df.withColumn('Name',concat_ws(',',split_col.getItem(2),split_col.getItem(3))) 43 | kafka_df = kafka_df.withColumn('Gender',split_col.getItem(4)) 44 | kafka_df = kafka_df.withColumn('Age',split_col.getItem(5).cast('float')) 45 | 46 | # Selezioniamo i sopravvissuti per classe e genere 47 | kafka_df = kafka_df.filter("Survived == 1 AND Gender == 'female' AND Class == 1") 48 | 49 | # Selezioniamo le sole colonne che emetteremo in uscita 50 | female_survived_first_class = kafka_df['key','Name','Age'] 51 | 52 | # Generiamo uno stream in uscita su un topic dedicato 53 | # in modo che un altro consumer possa leggerli 54 | out_df_stream_2 = female_survived_first_class \ 55 | .selectExpr("CAST(key AS STRING)", "to_json(struct(Name,Age)) AS value") \ 56 | .writeStream \ 57 | .format("kafka") \ 58 | .option("kafka.bootstrap.servers", KAFKA_BOOTSTRAP_SERVERS) \ 59 | .option("topic", KAFKA_TOPIC_NAME_CONS) \ 60 | .trigger(processingTime='1 seconds') \ 61 | .outputMode("update") \ 62 | .option('checkpointLocation','/home/rpirrone/src/kafka_python/streaming_checkpoint') \ 63 | .start() \ 64 | .awaitTermination() 65 | 66 | print("SparkStreamingApp terminated") -------------------------------------------------------------------------------- /tensorflow.ipynb: -------------------------------------------------------------------------------- 1 | { 2 | "cells": [ 3 | { 4 | "cell_type": "markdown", 5 | "metadata": {}, 6 | "source": [ 7 | "# Introduzione a Tensorflow\n", 8 | "\n", 9 | "TensorFlow (TF) è la API di Google per lo sviluppo di modelli di Deep Learning. Interagiremo con TF in Python, ma è possibile usare altri linguaggi, almeno a basso livello. La tipica applicazione TF lavora secondo lo schema riportato di seguito:\n", 10 | "\n", 11 | "\"Architettura\n", 12 | "\n", 13 | "- Keras è una nota libreria per specificare ad alto livello i layer del modello che lavora anche con altri back-end\n", 14 | "- La Data API è il modulo `tf.data` di TF che serve a specificare le azioni da compiere sul data set ai fini di addestramento e test\n", 15 | "- L'Execution Engine di TF (che può essere locale o anche distribuito su più nodi di un cluster di calcolo) rappresenta il nucleo vero e proprio di TF. A questo livello, vengono esposte API in diversi linguaggi.\n", 16 | "\n", 17 | "Nell'execution engine, viene definita la _sessione_ di lavoro `tf.Session(...)` in cui si svolgono le operazioni atomiche (`tf.Operation`) sui dati in forma tensoriale (`tf.Tensor`). \n", 18 | "\n", 19 | "La sessione gestisce l'esecuzione di un _*grafo di computaizone*_ ovvero di una specifica _astratta_ della sequenza di operazioni secondo una struttura a grafo dove i nodi sono operazioni che restituiscono tensori che vanno in ingresso ad altri nodi secondo la struttura definita dagli archi.\n", 20 | "\n", 21 | "\"Esempio\n", 22 | "\n", 23 | "L'esecuzione si ottiene attraverso il metodo `tf.Operation.run()` che è ereditato anche dalla sessione ovvero si può valutare un singolo tensore con `tf.Tensor.eval()`. La sessione va chiusa esplicitamente con il metodo `close()`.\n", 24 | "\n" 25 | ] 26 | }, 27 | { 28 | "cell_type": "code", 29 | "execution_count": 1, 30 | "metadata": {}, 31 | "outputs": [ 32 | { 33 | "name": "stdout", 34 | "output_type": "stream", 35 | "text": [ 36 | "/job:localhost/replica:0/task:0/device:CPU:0\n", 37 | "/job:localhost/replica:0/task:0/device:XLA_CPU:0\n", 38 | "/job:localhost/replica:0/task:0/device:XLA_GPU:0\n", 39 | "/job:localhost/replica:0/task:0/device:GPU:0\n", 40 | "b'Hello World'\n", 41 | "The session is closed? False\n" 42 | ] 43 | } 44 | ], 45 | "source": [ 46 | "import tensorflow as tf\n", 47 | "import os\n", 48 | "\n", 49 | "os.environ[\"TF_CPP_MIN_LOG_LEVEL\"] = \"2\"\n", 50 | "\n", 51 | "\n", 52 | "# Sostituisce la vecchia chiamata tf.Session() \n", 53 | "# che è deprecata da quando è stato rilasciato TF v.2\n", 54 | "sess = tf.compat.v1.Session()\n", 55 | "\n", 56 | "# chiediamo la lista dei device di calcolo presenti\n", 57 | "# quelli di tipo XLA_GPU o XLA_CPU sono abilitati all'algebra lineare accelerata\n", 58 | "for d in sess.list_devices():\n", 59 | " print(d.name)\n", 60 | "\n", 61 | "# Definiamo una semplice computazione che definisce un elemento (o meglio un **nodo**)\n", 62 | "# costante di tipo stringa e lo esegue ottenendone la stampa\n", 63 | "bye_bye = tf.constant('Hello World')\n", 64 | "result = sess.run(bye_bye)\n", 65 | "\n", 66 | "print(result)\n", 67 | "\n", 68 | "print(f'The session is closed? {sess._closed}')\n", 69 | "# chiudiamo la sessione\n", 70 | "sess.close()" 71 | ] 72 | }, 73 | { 74 | "cell_type": "markdown", 75 | "metadata": {}, 76 | "source": [ 77 | "La sessione può essere invocata con diverse opzioni e, soprattutto, con la possibilità di definire un _context manager_ all'interno del quale specificare le operazioni che non richiede più la chiusura esplicita." 78 | ] 79 | }, 80 | { 81 | "cell_type": "code", 82 | "execution_count": 2, 83 | "metadata": {}, 84 | "outputs": [ 85 | { 86 | "name": "stdout", 87 | "output_type": "stream", 88 | "text": [ 89 | "2\n", 90 | "Tensor(\"Const_1:0\", shape=(), dtype=int32)\n", 91 | "Tensor(\"Const_2:0\", shape=(), dtype=int32)\n", 92 | "Tensor(\"Mul:0\", shape=(), dtype=int32)\n", 93 | "6 ()\n", 94 | "Session closed: True\n" 95 | ] 96 | } 97 | ], 98 | "source": [ 99 | "\n", 100 | "with tf.compat.v1.Session() as sess:\n", 101 | " # definizione di due valori costanti interi\n", 102 | " n1=tf.constant(2)\n", 103 | " n2=tf.constant(3)\n", 104 | " \n", 105 | " print(n1.eval())\n", 106 | " \n", 107 | " #n3 = n1 * n2 # questa **non è** la moltiplicaione tra interi, \n", 108 | " # ma la tf.Operation di moltiplicazione tra tensori\n", 109 | " \n", 110 | " n3 = tf.multiply(n1,n2)\n", 111 | " \n", 112 | " print(n1,n2,n3,sep='\\n')\n", 113 | " \n", 114 | " #print(sess.run(n3))\n", 115 | " print(n3.eval(), n3.dtype, n3.shape)\n", 116 | "\n", 117 | "print(f'Session closed: {sess._closed}')" 118 | ] 119 | }, 120 | { 121 | "cell_type": "markdown", 122 | "metadata": {}, 123 | "source": [ 124 | "La sintassi completa del costruttore dell'oggetto `tf.compat.v1.Session` è:\n", 125 | "\n", 126 | "```python\n", 127 | "tf.compat.v1.Session(target='',\\ # engine di computazione da utilizzare, locale o distribuito\n", 128 | " graph=None,\\ # grafo di computazione da utilizzare\n", 129 | " config=None) # oggetto con le specifiche particolari di configurazione\n", 130 | "```\n", 131 | "\n", 132 | "Apriamo la sessione con una configurazione di default per l'allocazopne dinamica della computazione sui diversi device disponibili ed eseguiamo il grafo di computazione della figura precedente" 133 | ] 134 | }, 135 | { 136 | "cell_type": "code", 137 | "execution_count": 1, 138 | "metadata": {}, 139 | "outputs": [ 140 | { 141 | "name": "stdout", 142 | "output_type": "stream", 143 | "text": [ 144 | "Device mapping:\n", 145 | "/job:localhost/replica:0/task:0/device:XLA_CPU:0 -> device: XLA_CPU device\n", 146 | "/job:localhost/replica:0/task:0/device:XLA_GPU:0 -> device: XLA_GPU device\n", 147 | "/job:localhost/replica:0/task:0/device:GPU:0 -> device: 0, name: TITAN Xp, pci bus id: 0000:03:00.0, compute capability: 6.1\n", 148 | "\n", 149 | "Device mapping:\n", 150 | "/job:localhost/replica:0/task:0/device:XLA_CPU:0 -> device: XLA_CPU device\n", 151 | "/job:localhost/replica:0/task:0/device:XLA_GPU:0 -> device: XLA_GPU device\n", 152 | "/job:localhost/replica:0/task:0/device:GPU:0 -> device: 0, name: TITAN Xp, pci bus id: 0000:03:00.0, compute capability: 6.1\n", 153 | "Mul: (Mul): /job:localhost/replica:0/task:0/device:GPU:0\n", 154 | "Add: (Add): /job:localhost/replica:0/task:0/device:GPU:0\n", 155 | "truediv/Cast: (Cast): /job:localhost/replica:0/task:0/device:GPU:0\n", 156 | "truediv/Cast_1: (Cast): /job:localhost/replica:0/task:0/device:GPU:0\n", 157 | "truediv: (RealDiv): /job:localhost/replica:0/task:0/device:GPU:0\n", 158 | "Const: (Const): /job:localhost/replica:0/task:0/device:GPU:0\n", 159 | "Const_1: (Const): /job:localhost/replica:0/task:0/device:GPU:0\n", 160 | "1.875\n" 161 | ] 162 | } 163 | ], 164 | "source": [ 165 | "import tensorflow as tf\n", 166 | "import os\n", 167 | "\n", 168 | "os.environ[\"TF_CPP_MIN_LOG_LEVEL\"] = \"2\"\n", 169 | "\n", 170 | "# Usiamo esplicitamente l'oggetto di configurazione\n", 171 | "\n", 172 | "sess = tf.compat.v1.Session(config=tf.compat.v1.ConfigProto(\n", 173 | " allow_soft_placement=True, # gestione dinamica dell'allocazione dei device\n", 174 | " log_device_placement=True)) # registrazione del log sull'allocazione dei device\n", 175 | "\n", 176 | "with sess.as_default():\n", 177 | " assert tf.compat.v1.get_default_session() is sess # impostiamo la nostra sessione configurata come quella di default\n", 178 | " \n", 179 | " # La nostra computazione è: res = (a*b) / (a+b)\n", 180 | " \n", 181 | " # ingressi\n", 182 | " a = tf.constant(5)\n", 183 | " b = tf.constant(3)\n", 184 | " \n", 185 | " # operazioni intermedie\n", 186 | " prod = tf.multiply(a,b)\n", 187 | " sum = tf.add(a,b)\n", 188 | " \n", 189 | " # uscita\n", 190 | " #res = tf.div(prod,sum)\n", 191 | " res = tf.math.divide(prod,sum)\n", 192 | "\n", 193 | " \n", 194 | " #print(res.eval())\n", 195 | " print(sess.run(res))\n" 196 | ] 197 | }, 198 | { 199 | "cell_type": "code", 200 | "execution_count": 2, 201 | "metadata": {}, 202 | "outputs": [ 203 | { 204 | "name": "stdout", 205 | "output_type": "stream", 206 | "text": [ 207 | "(2, 3) \n" 208 | ] 209 | } 210 | ], 211 | "source": [ 212 | "# Creiamo tensori con diverse funzioni\n", 213 | "mat = tf.constant([[1., 2., 3.], [4., 5., 6.]])\n", 214 | "\n", 215 | "print(mat.shape, mat.dtype)" 216 | ] 217 | }, 218 | { 219 | "cell_type": "code", 220 | "execution_count": 3, 221 | "metadata": {}, 222 | "outputs": [ 223 | { 224 | "name": "stdout", 225 | "output_type": "stream", 226 | "text": [ 227 | "Tensor(\"random_normal:0\", shape=(3, 3), dtype=float32)\n", 228 | "Mul: (Mul): /job:localhost/replica:0/task:0/device:GPU:0\n", 229 | "Add: (Add): /job:localhost/replica:0/task:0/device:GPU:0\n", 230 | "truediv/Cast: (Cast): /job:localhost/replica:0/task:0/device:GPU:0\n", 231 | "truediv/Cast_1: (Cast): /job:localhost/replica:0/task:0/device:GPU:0\n", 232 | "truediv: (RealDiv): /job:localhost/replica:0/task:0/device:GPU:0\n", 233 | "random_normal/RandomStandardNormal: (RandomStandardNormal): /job:localhost/replica:0/task:0/device:GPU:0\n", 234 | "random_normal/mul: (Mul): /job:localhost/replica:0/task:0/device:GPU:0\n", 235 | "random_normal: (Add): /job:localhost/replica:0/task:0/device:GPU:0\n", 236 | "random_uniform/RandomUniform: (RandomUniform): /job:localhost/replica:0/task:0/device:GPU:0\n", 237 | "random_uniform/sub: (Sub): /job:localhost/replica:0/task:0/device:GPU:0\n", 238 | "random_uniform/mul: (Mul): /job:localhost/replica:0/task:0/device:GPU:0\n", 239 | "random_uniform: (Add): /job:localhost/replica:0/task:0/device:GPU:0\n", 240 | "Const: (Const): /job:localhost/replica:0/task:0/device:GPU:0\n", 241 | "Const_1: (Const): /job:localhost/replica:0/task:0/device:GPU:0\n", 242 | "Const_2: (Const): /job:localhost/replica:0/task:0/device:GPU:0\n", 243 | "random_normal/shape: (Const): /job:localhost/replica:0/task:0/device:GPU:0\n", 244 | "random_normal/mean: (Const): /job:localhost/replica:0/task:0/device:GPU:0\n", 245 | "random_normal/stddev: (Const): /job:localhost/replica:0/task:0/device:GPU:0\n", 246 | "random_uniform/shape: (Const): /job:localhost/replica:0/task:0/device:GPU:0\n", 247 | "random_uniform/min: (Const): /job:localhost/replica:0/task:0/device:GPU:0\n", 248 | "random_uniform/max: (Const): /job:localhost/replica:0/task:0/device:GPU:0\n", 249 | "[[-2.0744095 -0.24003883 1.5144365 ]\n", 250 | " [-0.17038149 -2.5960207 -1.188079 ]\n", 251 | " [-1.5299348 0.34452125 -0.49177837]]\n", 252 | "[[0.14536846 0.6468046 0.6251013 0.9200802 ]\n", 253 | " [0.41084158 0.18548429 0.43867946 0.8946738 ]\n", 254 | " [0.87436116 0.7000619 0.46352565 0.166525 ]\n", 255 | " [0.06613743 0.57079065 0.7628063 0.34697175]]\n" 256 | ] 257 | } 258 | ], 259 | "source": [ 260 | "mat_randn = tf.random.normal((3,3), mean=0, stddev=1.0)\t # A 3ｘ3 random normal matrix.\n", 261 | "mat_randu = tf.random.uniform((4,4), minval=0, maxval=1.0)\n", 262 | "\n", 263 | "print(mat_randn)\n", 264 | "\n", 265 | "with sess.as_default():\n", 266 | " assert tf.compat.v1.get_default_session() is sess\n", 267 | " \n", 268 | " \n", 269 | " print(mat_randn.eval())\n", 270 | " print(mat_randu.eval())\n", 271 | " " 272 | ] 273 | }, 274 | { 275 | "cell_type": "code", 276 | "execution_count": 6, 277 | "metadata": {}, 278 | "outputs": [ 279 | { 280 | "name": "stdout", 281 | "output_type": "stream", 282 | "text": [ 283 | "None\n", 284 | "[[0.5368296 0.5577097 0.95285404 0.72499657]\n", 285 | " [0.92383134 0.3147235 0.07189012 0.5213605 ]\n", 286 | " [0.9221605 0.7092 0.36317253 0.6396687 ]\n", 287 | " [0.23651493 0.44773293 0.67429364 0.56049836]]\n" 288 | ] 289 | } 290 | ], 291 | "source": [ 292 | "# Esempio di uso delle variabili\n", 293 | "with tf.compat.v1.Session(config=tf.compat.v1.ConfigProto(allow_soft_placement=True)) as sess:\n", 294 | "\n", 295 | " init_values = tf.random.uniform((4,4), minval=0, maxval=1.0)\n", 296 | "\n", 297 | " t = tf.Variable(initial_value=init_values,name='myvar')\n", 298 | "\n", 299 | " init = tf.compat.v1.global_variables_initializer()\n", 300 | " \n", 301 | " print(sess.run(init))\n", 302 | " print(sess.run(t))\n" 303 | ] 304 | }, 305 | { 306 | "cell_type": "code", 307 | "execution_count": 7, 308 | "metadata": {}, 309 | "outputs": [ 310 | { 311 | "name": "stdout", 312 | "output_type": "stream", 313 | "text": [ 314 | "[[ 8. 24. 48.]\n", 315 | " [ 88. 130. 180.]]\n" 316 | ] 317 | } 318 | ], 319 | "source": [ 320 | "# Definiamo i placeholder per z = 2x^2 + 2xy\n", 321 | "with tf.compat.v1.Session(config=tf.compat.v1.ConfigProto(allow_soft_placement=True)) as sess:\n", 322 | "\n", 323 | " two = tf.constant(2.0)\n", 324 | " \n", 325 | " x = tf.compat.v1.placeholder(tf.float32,shape=(None, 3))\n", 326 | " \n", 327 | " y = tf.compat.v1.placeholder(tf.float32,shape=(None, 3))\n", 328 | " \n", 329 | " z = tf.add(tf.multiply(two, tf.multiply(x, x)),\\\n", 330 | " tf.multiply(two, tf.multiply(x, y)))\n", 331 | " \n", 332 | " print(sess.run(z, feed_dict={x: [[1., 2., 3.],[4., 5., 6.]], y: [[3., 4., 5.],[7., 8., 9.]]}))\n" 333 | ] 334 | } 335 | ], 336 | "metadata": { 337 | "interpreter": { 338 | "hash": "b8fa43838452e9e93f8e7562de70ac54321a3b66f4651442f84440771fb9be48" 339 | }, 340 | "kernelspec": { 341 | "display_name": "Python 3 (ipykernel)", 342 | "language": "python", 343 | "name": "python3" 344 | }, 345 | "language_info": { 346 | "codemirror_mode": { 347 | "name": "ipython", 348 | "version": 3 349 | }, 350 | "file_extension": ".py", 351 | "mimetype": "text/x-python", 352 | "name": "python", 353 | "nbconvert_exporter": "python", 354 | "pygments_lexer": "ipython3", 355 | "version": "3.7.5" 356 | }, 357 | "orig_nbformat": 4 358 | }, 359 | "nbformat": 4, 360 | "nbformat_minor": 2 361 | } 362 | --------------------------------------------------------------------------------