FEATURED POST

Come creare un grafico previsionale sulla diffusione del Covid-19 con Linux, Bash e Python

All’inizio dell’emergenza sanitaria da Coronavirus (nCoV-19), durante i primi giorni di lockdown, mi sono dato subito da fare mettendo in piedi una semplice webapp www.coronavirus-italy.it, per il monitoraggio, tramite API nazionali e internazionali, della pandemia.

Poi arricchendola di alcune funzionalità più specifiche, una di queste: le previsioni sulla diffusione in Italia del virus, in base ai dati forniti giorno per giorno dalla Protezione Civile.

In questo articolo voglio condividere la mia esperienza per mettere in piedi un sistema previsionale automatico sul nostro server Linux.

Iniziamo con la preparazione dell’ambiente.

Nel nostro server Linux dobbiamo accertarci di avere installato Python3 e questi moduli necessari: scipy, venv, pandas, sklearn, numpy, matplotlib.

Ora possiamo iniziare con la creazione del file Python che genererà i grafici previsionali con i dati della Protezione Civile.

Teniamo presente che i nuovi dati vengono diffusi ogni giorno intorno alle 18.00 circa, e comunque entro le 18.30.

Per fare i calcoli previsionali tramite modello matematico logistico, mi sono affidato a questo progetto: https://github.com/marcello-dev/coronavirus-forecast, facendone le opportune modifiche che condivido qui.

Possiamo inserire questo codice all’interno di un nuovo file di testo che chiameremo covid-forecast.py

import pandas as pd
import numpy as np
from datetime import datetime, timedelta
from sklearn.metrics import mean_squared_error
from scipy.optimize import curve_fit
from scipy.optimize import fsolve
import matplotlib.pyplot as plt

url = "https://raw.githubusercontent.com/pcm-dpc/COVID-19/master/dati-andamento-nazionale/dpc-covid19-ita-andamento-nazionale.csv"
df = pd.read_csv(url)

df = df.loc[:, ['data', 'totale_casi']]

FMT = '%Y-%m-%dT%H:%M:%S'
date = df['data']
df['data'] = date.map(lambda x2: (datetime.strptime(x2, FMT) - datetime.strptime("2020-01-01T00:00:00", FMT)).days)

def logistic_model(x3, a3, b3, c3):
    return c3/(1+np.exp(-(x3-b3)/a3))

x = list(df.iloc[:, 0])
y = list(df.iloc[:, 1])

fit = curve_fit(logistic_model, x, y, p0=[2, 100, 20000])

a = fit[0][0]
b = fit[0][1]
c = fit[0][2]

first_january = datetime.strptime('2020/01/01', "%Y/%m/%d")
a = fit[0][0]
b = fit[0][1]
c = fit[0][2]

first_january = datetime.strptime('2020/01/01', "%Y/%m/%d")
infection_peak_date = first_january + timedelta(days=int(b))
print('{"status": "ok","previsioni": [{ "piccoContagio": "',datetime.strftime(infection_peak_date,"%d/%m/%Y"),'",')
errors = [np.sqrt(fit[1][i][i]) for i in [0, 1, 2]]
print('"totaleInfetti": "{}", "minInfetti": "{}", "maxInfetti": "{}",'.format(int(c), int(c-errors[2]),int(c+errors[2])))

sol = int(fsolve(lambda x : logistic_model(x, a, b, c) - int(c),b))

infection_end_date = first_january + timedelta(days=int(sol))
print('"fineContagio": "',datetime.strftime(infection_end_date,"%d/%m/%Y"),'",')

def add_real_data(df, label, color=None):
    x = df['data'].tolist()
    y = df['totale_casi'].tolist()
    plt.scatter(x, y, label="Dati reali (" + label + ")", c=color)

pred_x = list(range(max(x), sol))
plt.rcParams['figure.figsize'] = [7, 7]
plt.rc('font', size=14)
# Real data
add_real_data(df[-1:], "oggi")
add_real_data(df[-2:-1], "ieri")
add_real_data(df[:-2], "2 giorni fa")
# Predicted curve of today
plt.plot(x+pred_x, [logistic_model(i,fit[0][0],fit[0][1],fit[0][2]) for i in x+pred_x], label="Previsione dati oggi")

# Predicted curve of yesterday
x = list(df[:-1].iloc[:, 0])
y = list(df[:-1].iloc[:, 1])
pred_x = list(range(max(x), sol))
fit = curve_fit(logistic_model, x, y, p0=[2, 100, 20000])
plt.plot(x+pred_x, [logistic_model(i,fit[0][0],fit[0][1],fit[0][2]) for i in x+pred_x],
         label="Previsione dati ieri", dashes=[4, 4])

# Predicted curve of 2 days ago curve
x = list(df[:-2].iloc[:, 0])
y = list(df[:-2].iloc[:, 1])
pred_x = list(range(max(x), sol))
fit = curve_fit(logistic_model, x, y, p0=[2, 100, 20000])
plt.plot(x+pred_x, [logistic_model(i,fit[0][0],fit[0][1],fit[0][2]) for i in x+pred_x],
         label="Previsione dati 2 giorni fa",dashes=[8, 8])

today_date = datetime.today().strftime('%Y-%m-%d')
plt.title("Previsioni per casi accertati in Italia del " + today_date)

plt.legend()
plt.xlabel("Giorni da 1 gennaio 2020")
plt.ylabel("Numero totale persone infette")
plt.ylim((min(y)*0.9,c*1.1))

filename = 'plot-' + today_date + '.png'
plt.savefig('plots/'+filename, bbox_inches="tight")
y_pred_logistic = [logistic_model(i,fit[0][0],fit[0][1],fit[0][2]) for i in x]
print('"erroreModello": "', mean_squared_error(y,y_pred_logistic),'"}]}')

Creiamo allo stesso livello del nostro file Python una cartella che chiameremo plots/.

A questo punto, prima di procedere facciamo il test, per verificare che tutti gli import e le istruzioni Python vadano a buon fine, digitiamo questi 3 comandi uno dopo l’altro, il tutto si dovrebbe eseguire senza errori.

python3 -m venv venv

source venv/bin/activate

python3 main.py > plots/previsione.json

Tutta la parte di codice di generazione del file Json assieme al grafico previsionale è una modifica che ho implementato io e non troverete nel progetto originale, ad ogni modo la condivido in quanto ritenuta utile a future implementazioni di ogni genere, rimane pur sempre un JSON aggiornato quotidianamente contenente dei dati.

Possiamo ora procedere all’automatizzazione del tutto semplicemente creando uno script Bash che chiameremo covidscript:

#!/bin/bash
cd /home/Covid/coronavirus-forecast
python3 -m venv venv
source venv/bin/activate
python3 main.py > plots/previsione.json

Ovviamente ricordate di personalizzare l'indirizzo della cartella dove risiede il vostro applicativo Python per questo progetto, dichiarato nella seconda riga di questo script appena creato.

Se vogliamo inserire lo script in un Cron automatico ricordiamoci di non inserire alcuna estensione al file Bash e di renderlo eseguibile:

chmod +x covidscript

Poi effettuiamo un link simbolico dello script alla cartella di Cron:

ln -s /home/covid/covidscript /etc/cron.daily

A questo punto ogni giorno avremo sempre aggiornati il grafico previsionale e il file Json pronto per qualsiasi utilizzo.

Se vogliamo modificare l’orario dei Cron giornalieri possiamo inserire una riga all’interno del file /etc/crontab ricordandoci di inserire un orario non inferiore alle 18.30, perché altrimenti rischiamo ogni giorno di essere troppo in anticipo rispetto alla diffusione pubblica dei dati di quel giorno:

35 18   * * *   root    test -x /usr/sbin/anacron || ( cd / && run-parts --report /etc/cron.daily )
END FEATURED POST
FEATURED POST
Cover Image

Top 3 dei migliori IDE per Python free

Quando si tratta di programmazione Python, hai molte opzioni per grandi ambienti di sviluppo integrati.

Python è ovunque. Ai giorni nostri, sembra che alimenti tutto, dai grandi siti web alle utilità desktop al software aziendale. Python è stato utilizzato per scrivere i progetti software come dnf / yum, OpenStack, OpenShot, Blender, Calibre e anche il client BitTorrent originale.

Inoltre è anche uno dei miei linguaggi di programmazione preferiti. Personalmente, Python è stato il mio linguaggio sempre usato nel corso degli anni per tutto, dai progetti di classe all’università a minuscoli script per aiutarmi a automatizzare compiti ricorrenti. È uno dei pochi linguaggi che è facile iniziare essendo principianti fino a diventarne utilizzatori più esperti per progetti nel mondo reale.

Per modificare i programmi Python, hai un certo numero di opzioni. Alcuni ancora preferiscono un editor di testo di base, come Emacs, VIM o Gedit, che possono essere estesi con funzioni come l’evidenziazione della sintassi e l’autocompletamento. Ma molti utenti che lavorano su grandi progetti con basi di codice complesse preferiscono un ambiente di sviluppo integrato (IDE) come l’editor di testo e una combinazione di terminali. La linea tra un editor di testo avanzato e un IDE è sottile e non è sempre chiara, qui infatti lascerò a voi il compito di decidere con esattezza quali funzioni desiderate per le vostre esigenze di sviluppo.

Diamo un’occhiata a alcune delle opzioni più popolari disponibili per gli sviluppatori di Python e vediamo come sono associate. Tutti e tre sono cross-platform e possono essere utilizzati sul vostro sistema operativo qualsiasi esso sia.

Eclipse con PyDev

È difficile scrivere un elenco di ambienti di sviluppo integrati open source senza nominare Eclipse, che dispone di un’enorme comunità di sviluppatori e di innumerevoli plugin disponibili per consentirti di personalizzarlo per soddisfare qualsiasi esigenza che potete immaginarvi durante lo sviluppo. Ma questo approccio così completo è anche uno dei disagi di Eclipse. Molti lo criticano per le dimensioni e risorse che impegna e le prestazioni sui sistemi a basso livello possono certamente essere un problema.

Detto questo, se stai entrando in Python da un background in altro linguaggio, in particolare Java, Eclipse può già essere il tuo IDE preferito. E se usi le sue molteplici funzionalità, potrai trovare la vita senza di loro, davvero difficile.

PyDev aggiunge un numero enorme di funzionalità a Eclipse, ben al di là di un semplice codice di evidenziazione. Gestisce il completamento del codice, integra il debug di Python, aggiunge un browser a token, strumenti di refactoring e molto altro ancora. Per coloro che lavorano con il popolare framework web Django Python, PyDev ti permetterà di creare nuovi progetti Django, eseguire azioni Django tramite hotkeys e utilizzare una configurazione di esecuzione separata solo per Django.

Eric

Eric utilizza Scintilla, un componente di modifica del codice sorgente utilizzato in diversi IDE

e editor, disponibile anche come editor SciTE autonomo.
Le funzionalità di Eric sono simili agli altri IDE: la corrispondenza tra parentesi, il completamento dei codici, un browser di classe, i test di unità integrate, ecc. Essa dispone anche di una funzione di anteprima dei form Qt, utile se si sta sviluppando una Qt GUI per l’applicazione e personalmente mi piacciono le funzione di elenco delle attività integrate.
Ho sentito alcune critiche sulla documentazione di Eric che, essendo essenzialmente consegnata attraverso un massiccio PDF, lascia qualcosa a desiderare, ma se ti prendi il tempo giusto per impararlo, troverai Eric come un ambiente di programmazione molto leggero ma completo.

PyCharm

PyCharm è un altro editor di Python. Pycharm è un prodotto commerciale, ma i creatori offrono anche un’edizione della comunità gratuita e aperta sotto la licenza Apache 2.0.

PyCharm offre praticamente tutto ciò che ci si potreb

be aspettare da un IDE: test di unità integrate, ispezione dei codici, controllo integrato di versione, strumenti per il refactoring di codice, vari strumenti per la navigazione dei progetti, nonché le funzioni di evidenziazione e di completamento automatico che ci si aspetterebbe con qualsiasi IDE.
Per me, l’inconveniente principale di PyCharm è il suo modello open core. Molte delle funzionalità avanzate di PyCharm non sono disponibili sotto una licenza open source e per me è un problema. Tuttavia, se non si desidera utilizzare le funzionalità più avanzate incluse nella versione con codice sorgente chiusa, le caratteristiche non consentite possono anche essere tralasciate e quindi come scelta, si può andare avanti in modo più leggero per l’editing di Python, con questa versione free.

 

Abbiamo dimenticato il tuo preferito? Facci sapere quale è nei commenti qui di seguito, e ci spieghi perché, di modo da aumentare questa Top List.

 

END FEATURED POST
FEATURED POST
Cover Image

Una lettura estiva: Machine Learning

Voglio fare anche qui una piccola recensione per un libro che ho appena avuto modo di terminare di leggere proprio in questi giorni. Machine learning for the Web è una lettura davvero interessante per tutti coloro che vogliono addentrarsi nel mondo dell’apprendimento automatico, ma non solo nella parte teorica di questo mondo, bensì anche nella parte pratica e reale. Che conduce poi all’utilizzo quotidiano di questa tecnica, nelle pratiche commerciali più in uso già da oggi.

In questo libro vengono spiegati i più importanti algoritmi di machine learning maggiormente utilizzati nella realtà commerciale dello sviluppo web. Aumentando significativamente la propria conoscenza in questo campo il lettore sarà perfettamente in grado di comprenderne prima il funzionamento matematico e poi la pratica di funzionamento di una applicazione web basata su questi algoritmi.

Machine Learning for the Web

Il libro dà inoltre molti spunti di riflessione utili per fare pratica con il machine learning nelle applicazioni quotidiane più comuni.Questo tipo di tecnologia infatti è sempre più utilizzata da chiunque faccia business con i grandi numeri, con i big data. La manipolazione dei dati sempre meno viene effettuata ormai manualmente o con algoritmi che scansionano tutti i singoli dati uno a uno (certe moli sono importantissime), dunque, tramite una matematica applicata, statistica e informatica, si ricorre sempre di più a tecniche di machine learning, con le quali si generano algoritmi in grado di capire da soli, che dato serve e che conclusioni trarre con certi dati.

Come dicevo il libro non è solo un manuale teorico, ma contiene e sviluppa anche una serie di esempi e casi di utilizzo, pratici e realmente funzionanti, adattando il machine learning al Python come linguaggio di programmazione, con il framework Django per l’adattamento al Web. Si realizzano dunque passo passo anche semplici applicazioni web che sottolineano proprio questi concetti base di apprendimento automatico.

Una lettura davvero consigliata!

END FEATURED POST
intopic.it