Strumenti e protocollo per la scienza dei dati riproducibili utilizzando Python


50

Sto lavorando a un progetto di data science usando Python. Il progetto prevede diverse fasi. Ogni fase comprende l'acquisizione di un set di dati, l'utilizzo di script Python, dati ausiliari, configurazione e parametri e la creazione di un altro set di dati. Conservo il codice in git, quindi quella parte è coperta. Mi piacerebbe sapere di:

  1. Strumenti per il controllo della versione dei dati.
  2. Strumenti che consentono di riprodurre fasi ed esperimenti.
  3. Protocollo e struttura di directory suggerita per tale progetto.
  4. Strumenti di compilazione / esecuzione automatizzati.

2
Dov'è la domanda in questa domanda? Dedica un momento alla revisione delle linee guida del Centro assistenza , in particolare: "Se la tua motivazione per porre la domanda è" Vorrei partecipare a una discussione su ______ ", non dovresti chiedere qui".
Air

"Dovresti solo porre domande pratiche e di risposta basate sui problemi reali che affronti."
Yuval F,

Ciò è pratico, rispondibile e basato su un problema reale più o meno allo stesso modo in cui "Dimmi come eseguire la scienza dei dati" è pratico, rispondibile e basato su un problema reale.
Air

Risposte:


46

Il tema della ricerca riproducibile (RR) è molto popolare oggi e, di conseguenza, è enorme , ma spero che la mia risposta sarà sufficientemente completa come risposta e fornirà informazioni sufficienti per ulteriori ricerche , nel caso decidessi di farlo.

Mentre gli strumenti specifici per Python per RR esistono sicuramente là fuori, penso che abbia più senso concentrarsi su strumenti più universali (non si sa mai con certezza quali linguaggi di programmazione e ambienti di elaborazione lavorerete in futuro). Detto questo, diamo un'occhiata a quali strumenti sono disponibili per il tuo elenco.

1) Strumenti per il controllo della versione dei dati . A meno che tu non abbia intenzione di lavorare con (molto) big data , immagino, avrebbe senso usare lo stesso git, che usi per il controllo della versione del codice sorgente. L'infrastruttura è già lì. Anche se i tuoi file sono binari e di grandi dimensioni, questo consiglio potrebbe essere utile: https://stackoverflow.com/questions/540535/managing-large-binary-files-with-git .

2) Strumenti per la gestione dei flussi di lavoro RR e degli esperimenti . Ecco un elenco degli strumenti più popolari in questa categoria, per quanto ne so (in ordine decrescente di popolarità):

  • Taverna Workflow Management System ( http://www.taverna.org.uk ) - set di strumenti molto solido, anche se un po 'troppo complesso. Lo strumento principale è un software desktop basato su Java. Tuttavia, è compatibile con il portale di repository del flusso di lavoro online myExperiment ( http://www.myexperiment.org ), dove l'utente può archiviare e condividere i propri flussi di lavoro RR. Il portale RR basato sul Web, pienamente compatibile con Taverna, si chiama Taverna Online , ma è stato sviluppato e gestito da un'organizzazione totalmente diversa in Russia (denominata OnlineHPC : http://onlinehpc.com ).

  • Il progetto Kepler ( https://kepler-project.org )

  • VisTrails ( http://vistrails.org )

  • Madagascar ( http://www.reproducibility.org )

ESEMPIO . Ecco un interessante articolo sui flussi di lavoro scientifici con un esempio di progettazione del flusso di lavoro reale e analisi dei dati, basato sull'utilizzo dei progetti Kepler e myExperiment : http://f1000research.com/articles/3-110/v1 .

Esistono molti strumenti RR che implementano un paradigma di programmazione letteraria , esemplificato dalla LaTeXfamiglia di software. Gli strumenti che aiutano nella generazione e nella presentazione dei report sono anche una grande categoria, dove Sweavee knitrsono probabilmente i più noti. Sweaveè uno strumento incentrato su R, ma può essere integrato con progetti basati su Python, sebbene con qualche sforzo aggiuntivo ( https://stackoverflow.com/questions/2161152/sweave-for-python ). Penso che knitrpotrebbe essere un'opzione migliore, poiché è moderna, ha un ampio supporto da parte di strumenti popolari (come RStudio) ed è indipendente dalla lingua ( http://yihui.name/knitr/demo/engines ).

3) Protocollo e struttura di directory suggerita . Se ho capito correttamente cosa hai implicato usando il termine protocollo ( flusso di lavoro ), in generale penso che il flusso di lavoro standard di analisi dei dati RR consista nelle seguenti fasi sequenziali: raccolta dei dati => preparazione dei dati (pulizia, trasformazione, fusione, campionamento) => analisi dei dati => presentazione dei risultati (generazione di report e / o presentazioni). Tuttavia, ogni flusso di lavoro è specifico del progetto e, pertanto, alcune attività specifiche potrebbero richiedere l'aggiunta di ulteriori passaggi.

Per una struttura di directory di esempio, puoi dare un'occhiata alla documentazione per il pacchetto R ProjectTemplate( http://projecttemplate.net ), come un tentativo di automatizzare i flussi di lavoro e i progetti di analisi dei dati:

inserisci qui la descrizione dell'immagine

4) Strumenti automatici di compilazione / esecuzione . Poiché la mia risposta è incentrata su strumenti RR universali (neutri dal punto di vista linguistico), gli strumenti più popolari sono make. Leggi l'articolo seguente per alcuni motivi da utilizzare makecome strumento di automazione del flusso di lavoro RR preferito: http://bost.ocks.org/mike/make . Certamente, ci sono altri strumenti simili , che migliorano alcuni aspetti makeo aggiungono alcune funzionalità aggiuntive. Ad esempio: ant(ufficialmente, Apache Ant: http://ant.apache.org ), Maven("prossima generazione ant": http://maven.apache.org ), rake( https://github.com/ruby/rake ) , Makepp( http://makepp.sourceforge.net). Per un elenco completo di tali strumenti, vedere Wikipedia: http://it.wikipedia.org/wiki/List_of_build_automation_software .


Un link sulla programmazione alfabetica qui : in sostanza, si tratta di commentare abbastanza il codice in modo che il codice diventi una documentazione autonoma.
Gaborous,

@gaborous: sono consapevole del significato della programmazione alfabetica e non ho incluso alcun link al paradigma, poiché ci sono molte fonti per questo e sono molto facili da trovare. Tuttavia, grazie per il tuo commento.
Aleksandr Blekh,

1
L'ho indovinato, è per questo che ho aggiunto queste informazioni come commento per il lettore interessato :)
gaborous,

4
Questa è una risposta molto esauriente, ma sono sorpreso che un aspetto sembri mancare. La convalida incrociata è un componente vitale della maggior parte dei progetti di DS e in genere richiede un campione casuale, che può rendere difficile la riproducibilità. Suggerisco di toccare brevemente l'uso dello stesso seme per generatori casuali al fine di poter riprodurre i risultati indipendentemente dalla variazione statistica. Grazie!
AN6U5,

@ AN6U5: grazie per le belle parole! Sono d'accordo - ho perso quell'aspetto (+1). Sentiti libero di aggiornare la mia risposta, aggiungendo brevi informazioni rilevanti sulla validazione incrociata.
Aleksandr Blekh,

24

Da quando ho iniziato a fare ricerche in ambito accademico ero costantemente alla ricerca di un flusso di lavoro soddisfacente. Penso di aver finalmente trovato qualcosa di cui sono contento:

1) Metti tutto sotto controllo della versione, ad es. Git:

Per i progetti di ricerca per hobby utilizzo GitHub, per la ricerca sul lavoro utilizzo il server GitLab privato fornito dalla nostra università. Conservo anche i miei set di dati lì.

2) Faccio la maggior parte delle mie analisi insieme alla documentazione sui notebook IPython. È molto organizzato (per me) avere il codice, i grafici e la discussione / conclusione in un unico documento Se sto eseguendo script più grandi, di solito li metterei in file .py di script separati, ma li eseguirò comunque dal notebook IPython tramite% run magic per aggiungere informazioni su scopo, risultato e altri parametri.

Ho scritto una piccola estensione cell-magic per notebook IPython e IPython, chiamata "filigrana" che utilizzo per creare facilmente timestamp e tenere traccia delle diverse versioni del pacchetto che ho usato e anche degli hash Git

Per esempio


%watermark

29/06/2014 01:19:10

CPython 3.4.1
IPython 2.1.0

compiler   : GCC 4.2.1 (Apple Inc. build 5577)
system     : Darwin
release    : 13.2.0
machine    : x86_64
processor  : i386
CPU cores  : 2
interpreter: 64bit


%watermark -d -t

29/06/2014 01:19:11 


%watermark -v -m -p numpy,scipy

CPython 3.4.1
IPython 2.1.0

numpy 1.8.1
scipy 0.14.0

compiler   : GCC 4.2.1 (Apple Inc. build 5577)
system     : Darwin
release    : 13.2.0
machine    : x86_64
processor  : i386
CPU cores  : 2
interpreter: 64bit

Per ulteriori informazioni, consultare la documentazione qui .


2
Mi piace la magia della filigrana. Per coloro che non sono a conoscenza, GitHub ora offre fino a 5 repository privati ​​gratuiti per gli utenti associati alle istituzioni accademiche.
Bogogon,

19

Il miglior strumento di riproducibilità è creare un registro delle tue azioni, qualcosa del genere:

experiment/input ; expected ; observation/output ; current hypothesis and if supported or rejected
exp1 ; expected1 ; obs1 ; some fancy hypothesis, supported

Questo può essere scritto su un documento, ma, se i tuoi esperimenti si inseriscono in un framework computazionale, puoi utilizzare strumenti computazionali per automatizzare parzialmente o completamente quel processo di registrazione (in particolare aiutandoti a tracciare i set di dati di input che possono essere enormi e l'output figure).

Un ottimo strumento di riproducibilità per Python con una curva di apprendimento bassa è ovviamente Notebook IPython / Jupyter (non dimenticare le magie % di accesso e% di avvio ). Suggerimento: per assicurarsi che il notebook sia riproducibile, riavvia il kernel e prova a eseguire tutte le celle dall'alto verso il basso (pulsante Esegui tutte le celle): se funziona, salva tutto in un file di archivio ("blocco"), altrimenti, in particolare se è necessario eseguire celle in modo non lineare, non sequenziale e non ovvio per evitare errori, è necessario rielaborare un po '.

Un altro ottimo strumento molto recente (2015) è recipy , che è molto simile a Sumatra (vedi sotto), ma realizzato appositamente per Python. Non so se funziona con i Notebook Jupyter, ma so che l'autore li usa frequentemente, quindi suppongo che se non è attualmente supportato, lo sarà in futuro.

Anche Git è fantastico e non è legato a Python. Ti aiuterà non solo a conservare una cronologia di tutti i tuoi esperimenti, codice, set di dati, figure, ecc., Ma ti fornirà anche strumenti per mantenere ( git piccone ), collaborare ( incolpare ) e debug ( git - bisect ) usando un metodo scientifico metodo di debug (chiamato delta debugging ). Ecco la storia di un ricercatore immaginario che cerca di creare i propri esperimenti con il sistema di registrazione, fino a quando non diventa un facsimile di Git.

Un altro strumento generale lavorare con qualsiasi linguaggio (con un API Python su PyPI ) è di Sumatra , che è specificamente progettato per aiutarti a fare replicabile ricerca ( replicabili mira a produrre gli stessi risultati dato lo stesso codice e software esatto, mentre riproducibilità mira a produrre il stessi risultati dato qualsiasi mezzo, che è molto più difficile e richiede tempo e non automatizzabile).

Ecco come funziona Sumatra: per ogni esperimento che conduci attraverso Sumatra, questo software agirà come uno "stato di gioco salvato" che si trova spesso nei videogiochi. Più precisamente, salverà:

  • tutti i parametri che hai fornito;
  • l'esatto stato del codice sorgente dell'intera applicazione sperimentale e dei file di configurazione;
  • l'output / grafici / risultati e anche qualsiasi file prodotto dalla tua applicazione sperimentale.

Costruirà quindi un database con il timestamp e altre metadate per ciascuno dei tuoi esperimenti, che potrai successivamente scansionare usando la webGUI. Poiché Sumatra ha salvato l'intero stato della tua applicazione per un esperimento specifico in un determinato momento, puoi ripristinare il codice che ha prodotto un risultato specifico in qualsiasi momento desiderato, quindi hai una ricerca replicabile a basso costo (tranne per l'archiviazione se lavori su enormi set di dati, ma puoi configurare eccezioni se non vuoi salvare tutto ogni volta).

Un altro fantastico strumento è Zeitgeist di GNOME (precedentemente codificato in Python ma ora portato su Vala), un sistema di journaling di azioni onnicomprensivo, che registra tutto ciò che fai e può usare l'apprendimento automatico per riassumere per un periodo di tempo che desideri la relazione tra elementi basati su modelli di somiglianza e utilizzo, ad esempio rispondendo a domande come "Qual è stato più rilevante per me, mentre stavo lavorando al progetto X, per un mese l'anno scorso?" . È interessante notare che Zim Desktop Wiki , un'app per prendere appunti simile a Evernote, ha un plugin per lavorare con Zeitgeist.

Alla fine, puoi utilizzare Git o Sumatra o qualsiasi altro software che desideri, ti forniranno circa lo stesso potere di replicabilità, ma Sumatra è specificamente progettato per la ricerca scientifica, quindi fornisce alcuni strumenti fantasiosi come una GUI Web per la scansione i tuoi risultati, mentre Git è più mirato alla manutenzione del codice (ma ha strumenti di debug come git-bisect, quindi se i tuoi esperimenti riguardano codici, potrebbe effettivamente essere migliore). O ovviamente puoi usare entrambi!

/ EDIT: dsign ha toccato un punto molto importante qui: la replicabilità della tua configurazione è importante quanto la replicabilità della tua applicazione. In altre parole, dovresti almeno fornire un elenco completo delle librerie e dei compilatori che hai usato insieme alle loro esatte versioni e ai dettagli della tua piattaforma .

Personalmente, nell'informatica scientifica con Python, ho scoperto che impacchettare un'applicazione insieme alle librerie è troppo doloroso, quindi ora uso solo un pacchetto di pitone scientifico all-in-one come Anaconda (con l'eccezionale conda gestore pacchetti ), e consiglia agli utenti di usare lo stesso pacchetto. Un'altra soluzione potrebbe essere quella di fornire uno script per generare automaticamente un virtualenv o impacchettare tutto usando l' applicazione Docker commerciale come citata da dsign o il Vagrant di opensource (con ad esempio pylearn2-in-a-box che usa Vagrant per produrre un ridistribuibile facilmente pacchetto ambiente virtuale).

Infine, per assicurarti davvero di avere un ambiente completamente funzionante ogni volta che ne hai bisogno, puoi creare una macchina virtuale (vedi VirtualBox) e puoi persino salvare lo stato della macchina (istantanea) con l'esperimento pronto per essere eseguito all'interno. Quindi puoi semplicemente condividere questa macchina virtuale con tutto ciò che è incluso in modo che chiunque possa replicare il tuo esperimento con la tua configurazione esatta. Questo è probabilmente il modo migliore per replicare un esperimento basato su software. I contenitori potrebbero essere un'alternativa più leggera, ma non includono l'intero ambiente, quindi la fedeltà della replica sarà meno solida.

/ EDIT2: Ecco un ottimo video riassuntivo (per il debug ma questo può essere applicato anche alla ricerca) che cosa è fondamentale per fare una ricerca riproducibile: registrare i tuoi esperimenti e ogni altro passaggio del metodo scientifico, una sorta di "sperimentazione esplicita" .


14

Assicurati di dare un'occhiata alla finestra mobile ! E in generale, tutte le altre cose positive che l'ingegneria del software ha creato nel corso di decenni per garantire l'isolamento e la riproducibilità.

Vorrei sottolineare che non è sufficiente avere solo flussi di lavoro riproducibili, ma anche riprodurre facilmente i flussi di lavoro. Lasciami mostrare cosa intendo. Supponiamo che il tuo progetto usi Python, un database X e Scipy. Sicuramente userete una libreria specifica per connettervi al vostro database da Python e Scipy a sua volta utilizzerà alcune routine algebriche sparse. Questo è sicuramente un setup molto semplice, ma non del tutto semplice da configurare, gioco di parole inteso. Se qualcuno vuole eseguire i tuoi script, dovrà installare tutte le dipendenze. O peggio, potrebbe avere versioni incompatibili già installate. Riparare queste cose richiede tempo. Ci vorrà anche del tempo se in qualche momento hai bisogno di spostare i tuoi calcoli in un cluster, in un cluster diverso o in alcuni server cloud.

Qui è dove trovo utile la finestra mobile. Docker è un modo per formalizzare e compilare ricette per ambienti binari. Puoi scrivere quanto segue in un file docker (sto usando qui un inglese semplice invece della sintassi Dockerfile):

  • Inizia con un ambiente binario di base, come quello di Ubuntu
  • Installa libsparse-dev
  • (Pip) Installa numpy e scipy
  • Installa X
  • Installa libX-dev
  • (Pip) Installa python-X
  • Installa IPython-Notebook
  • Copia i miei script / notebook python nel mio ambiente binario, questi file di dati e queste configurazioni per fare altre cose varie. Per garantire la riproducibilità, copiarli da un URL denominato anziché da un file locale.
  • Forse eseguire IPython-Notebook.

Alcune linee installeranno cose in Python usando pip, dal momento che pip può fare un lavoro molto pulito nella selezione di versioni di pacchetti specifici. Dai un'occhiata anche a te!

E questo è tutto. Se dopo aver creato il tuo Dockerfile può essere creato, può essere costruito ovunque, da chiunque (purché abbiano anche accesso ai tuoi file specifici del progetto, ad esempio perché li metti in un URL pubblico a cui fa riferimento il Dockerfile). La cosa migliore è che puoi caricare l'ambiente risultante (chiamato "immagine") su un server pubblico o privato (chiamato "registro") per essere utilizzato da altre persone. Quindi, quando pubblichi il tuo flusso di lavoro, hai sia una ricetta completamente riproducibile sotto forma di Dockerfile, sia un modo semplice per te o altre persone di riprodurre ciò che fai:

docker run dockerregistery.thewheezylab.org/nowyouwillbelieveme

O se vogliono rovistare nei tuoi script e così via:

docker run -i -t dockerregistery.thewheezylab.org/nowyouwillbelieveme /bin/bash

8

Sfortunatamente, non ho abbastanza punti reputazione per rispondere al post di Plank, quindi devo rispondere a tutto il thread - mi dispiace per quello.

In realtà sono lo sviluppatore del framework open source di conoscenza collettiva di cui sopra. Tenta di semplificare la condivisione di artefatti e flussi di lavoro sperimentali come componenti Python riutilizzabili e riproducibili con API JSON unificate e meta JSON condivisi tramite GitHub. Possono anche essere collegati all'analisi predittiva con la stessa API JSON unificata.

Abbiamo appena rilasciato la nuova versione V1.8.1 e fornito un'ampia documentazione, quindi spero che ora sarà più facile capire i concetti: http://github.com/ctuning/ck/wiki

Ora abbiamo molti progetti accademici e industriali basati su questo framework, quindi puoi verificarne uno - l'ottimizzazione del programma di crowdsourcing su dispositivi mobili forniti da volontari in modo riproducibile: http://cknowledge.org/repo

Teniamo anche traccia delle varie risorse relative alla scienza riproducibile qui: https://github.com/ctuning/ck/wiki/Enabling-open-science

Anche se mi sto concentrando principalmente sul rendere riproducibile la ricerca dei sistemi informatici, ho avuto interessanti chat con colleghi di altri settori e sembra che abbiano problemi molto simili. Quindi, sarò molto felice se il nostro quadro può essere di qualche aiuto per altre comunità! Se hai domande o suggerimenti, sentiti libero di metterti in contatto!


1
Questa sintesi estiva sulla ricerca riproducibile (compresi collegamenti a strumenti, set di dati, articoli ed eventi correlati) potrebbe anche essere interessante: github.com/ctuning/ck/wiki/Enabling-open-science-blog-20160919
gfursin

7

C'è un intero corso dedicato alla ricerca riproducibile. https://www.coursera.org/learn/reproducible-research Questo corso si basa su R, ma l'idea di base può essere appresa.

Un modo semplice è avere un notebook Ipython e continuare a salvare tutti i lavori sporchi che fai, che si tratti di pulizia dei dati, analisi esplorativa o costruzione del modello.


6

Di recente mi sono imbattuto nel seguente strumento: http://github.com/ctuning/ck . È già scritto in Python e sembra includere ciò di cui hai bisogno (il mio collega lo sta usando nel progetto pilota per automatizzare il riconoscimento delle immagini).

Professionisti:

  1. molto piccolo, portatile e personalizzabile
  2. include un server web per distribuire esperimenti ed elaborarli mediante analisi predittive
  3. ha un ottimo esempio di utilizzo per crowdsource e riprodurre l'ottimizzazione del compilatore - http://cknowledge.org/repo

Contro:

  1. un po 'di basso livello - devi implementare il tuo flusso di lavoro dai componenti Python condivisi tramite GitHub usando l'API JSON o la riga di comando
  2. la documentazione è alquanto complessa - spero davvero che trovino presto il tempo per aggiornarla.

6

Ho creato e recentemente rilasciato uno strumento open source http://dvc.org o DVC che fa esattamente quello che stai cercando di raggiungere:

  1. [Strumenti per il controllo della versione dei dati.] DVC funziona su Git, aggiunge il controllo della versione dei file di dati (i file sono memorizzati al di fuori di Git) e tiene traccia delle dipendenze tra il codice e i file di dati. DVC deriva automaticamente il grafico delle dipendenze (DAG) per codice e dati.
  2. [Strumenti che consentono di riprodurre fasi ed esperimenti.] dvc repro data/scores.csvRiproduce tutti i passaggi necessari relativi al DAG.
  3. [Protocollo e struttura di directory suggerita per tale progetto.] DVC richiedeva una directory di dati ( dataper impostazione predefinita) in cui si supponeva che memorizzasse tutti i file di dati. Tuttavia, DVC sposta in modo trasparente il contenuto effettivo nella .cachedirectory e crea i collegamenti simbolici (sì, l'ho fatto funzionare anche su Windows). La .cachedirectory non è sincronizzata con Git ma potrebbe essere sincronizzata attraverso il cloud (S3 o GCP) per comando dvc sync data/scores.csv(sincronizza il file di dati corrispondente dalla cache come .cache/scores.csv_29de545)
  4. [Strumenti automatici di compilazione / esecuzione.] Vedi da sopra.

Il tutorial DVC è un buon punto di partenza: "Controllo della versione dei dati: apprendimento automatico iterativo" .


5

DISCLAIMER: lavoro in un'azienda, Datmo , che crea uno strumento open source per farlo.

La migliore pratica per la riproducibilità è la seguente:

1) In primo luogo containerizzare l'ambiente in un ambiente Docker creando un file Docker e assicurando che tutte le dipendenze siano coperte in quel file. Ho trovato questa risorsa la migliore ( https://arxiv.org/pdf/1410.0846.pdf )

2) Una volta ottenuto ciò, dovrai decidere dove tenere traccia di tutte le metriche e configurazioni delle prestazioni (in modo da poterle rivisitare per future sperimentazioni)

3) Infine, scrivi un po 'di documentazione in modo che un nuovo sperimentatore / sviluppatore sia in grado di rivisitare il tuo codice, replicarlo con l'ambiente e vedere dove hai conservato le tue configurazioni e le metriche delle prestazioni.

Utilizzando il nostro sito, riconosci di aver letto e compreso le nostre Informativa sui cookie e Informativa sulla privacy.
Licensed under cc by-sa 3.0 with attribution required.