Frage:
Wie werden der Code und die Daten während der Analyse versioniert?
Iakov Davydov
2017-05-18 14:27:51 UTC
view on stackexchange narkive permalink

Ich suche derzeit nach einem System, mit dem ich sowohl den Code als auch die Daten in meiner Forschung versionieren kann.

Ich denke, meine Art der Datenanalyse ist nicht ungewöhnlich, und dies ist nützlich für Viele Leute machen Bioinformatik und streben nach Reproduzierbarkeit.

Hier sind die Anforderungen:

  • Die Analyse wird auf mehreren Computern (lokal, Cluster, Server) durchgeführt.
  • Der gesamte Code wird transparent zwischen den Computern synchronisiert.
  • Quellcode-Versionierung.
  • Generierte Datenversionierung.
  • Unterstützung für eine große Anzahl kleiner generierter Dateien (> 10k). Diese können auch gelöscht werden.
  • Unterstützung für große Dateien (> 1 GB). Irgendwann können alte generierte Dateien dauerhaft gelöscht werden. Es wäre verrückt, diese transparent zu synchronisieren, aber es wäre schön, sie bei Bedarf synchronisieren zu können.

Bisher verwende ich git + rsync / scp. Es gibt jedoch mehrere Nachteile.

  • Die Synchronisierung zwischen mehreren Computern ist etwas mühsam, d. H. Sie müssen vor jedem Arbeitsbeginn einen Git-Pull ausführen und nach jedem Update einen Git-Push durchführen. Damit kann ich leben.
  • Sie sollten keine großen generierten Datendateien oder eine große Anzahl von Dateien in Ihrem Repository speichern.
  • Daher muss ich Datendateien manuell mit rsync synchronisieren. Dies ist fehleranfällig.

Es gibt einen so genannten Git-Anhang. Es scheint wirklich nah an dem zu sein, was ich brauche. Aber:

  • Ein bisschen mehr Arbeit als Git, aber das ist in Ordnung.
  • Leider scheint es mit der großen Anzahl von Dateien nicht gut zu funktionieren. Oft habe ich mehr als 10.000 kleine Dateien in meiner Analyse. Es gibt einige Tricks, um die Indizierung zu verbessern, aber das Problem wird dadurch nicht gelöst. Was ich brauche, ist ein Symlink, der den gesamten Inhalt des Verzeichnisses darstellt.

Eine mögliche Lösung besteht darin, Dropbox oder ähnliches (wie Syncthing) in Kombination mit Git zu verwenden. Der Nachteil ist jedoch, dass keine Verbindung zwischen der Quellcodeversion und der Datenversion besteht.

Gibt es ein Versionsverwaltungssystem für den Code und die Daten, die den von Ihnen empfohlenen Anforderungen entsprechen?

Es ist nicht genau das, wonach Sie suchen, und es ist auch nicht in der Lage, es in Vollzeit zu verwenden, aber ich habe eine Software namens "chitin" geschrieben: https://github.com/SamStudio8/chitin /. Es wurde entwickelt, um zu verfolgen, wie Dateien erstellt wurden und was mit ihnen passiert ist. Es ist nicht dafür gedacht, die Änderungen zu speichern (wie git) - aber tatsächlich finde ich die Metadaten weitaus nützlicher als die tatsächlichen Änderungen (abgesehen von Code, der natürlich in git lebt).
@SamStudio8 sieht interessant aus. Ich bin noch nicht ganz überzeugt, aber meiner Meinung nach lohnt es sich, als Antwort zu posten.
Der normale Ansatz hierfür besteht darin, ein einziges Verzeichnis zu haben, das auf die verschiedenen Computer (lokal, Cluster, Server) exportiert wird. Warum sollten Sie die Daten auf diese Weise duplizieren, anstatt nur ein zentrales Repository zu verwenden?
@terdon Oft haben Sie keinen Root-Zugriff auf einen Cluster, daher können Sie dort nicht einfach ein Netzwerk-Dateisystem bereitstellen (und wenn es viele kleine oder große Dateien gibt, möchten Sie dies aufgrund der Leistung nicht). In einem anderen Sinne ähnelt dies einer Syncthing / Dropbox-Lösung, bei der es an der richtigen Versionierung und Übereinstimmung zwischen dem Quellcode und den Daten mangelt.
Wenn Sie GB Daten synchronisieren müssen, machen Sie es falsch. Wenn Sie Root-Zugriff benötigen, würde ich Ihren Systemadministrator bitten, das System so einzurichten, dass Sie gemeinsam genutzte Laufwerke verwenden können. Ich habe noch nie jemanden so arbeiten sehen, wie Sie es beschrieben haben. Alle drei Orte, an denen ich gearbeitet habe, hatten immer gemeinsam genutzte Netzwerklaufwerke. Alternativ können Sie "sshfs" verwenden, um sie selbst zu mounten, ohne Root-Zugriff zu benötigen. Die Netzwerk-E / A-Last ist in der Tat ein Faktor. Manchmal kopieren wir Daten auf ein lokales Laufwerk und löschen sie nach der Analyse.
@terdon mehrere kleine Dateien ist auch ein Problem für die meisten Netzwerk-Dateisysteme. Ich bin damit einverstanden, dass das Synchronisieren von Gigabyte an Daten nicht immer eine gute Idee ist, aber manchmal unvermeidlich böse (beachten Sie, dass der Git-Anhang dies nicht automatisch tut; und das ist in Ordnung). Ich sehe ziemlich viele bioinformatische Gruppen an meiner Universität, die sehr ähnliche Probleme haben, also ist das zumindest nicht ungewöhnlich. `sshfs` ist eine Option, aber es ist wieder ein Netzwerk-Dateisystem. Und bei vielen Clustern ist die Sicherung im Kernel nicht verfügbar (einschließlich unseres Clusters, eines der größten Cluster, die nur für Bioinformatik bekannt sind).
Ich muss @terdon, zustimmen. Es gibt keinen Grund, warum Sie zahlreiche große Dateien über mehrere Knoten hinweg synchronisieren sollten. Wenn Sie keinen Root-Zugriff haben, um ein vernetztes Speicherlaufwerk bereitzustellen, müssen Sie es abrufen. All diese Dateisynchronisierung wird das Netzwerk verstopfen, und Ihre Administratoren sollten dies vermeiden wollen. Das Aufbewahren mehrerer Kopien von Dateien ist ein Rezept für eine Katastrophe. Sie sollten dies unbedingt vermeiden.
@woemler es scheint, dass ich nicht klar genug war. Ich möchte keine transparente Synchronisation von Datenauftritten. Ich möchte nur, dass dies versioniert und abrufbar ist. Ich habe die Frage aktualisiert, um sie klarer zu machen. Außerdem ist es ein Rezept für eine Katastrophe, 100.000 winzige Dateien im Netzwerk zu speichern. Wie auch immer, das Problem mit großen Dateien ist mit dem Git-Anhang leicht zu lösen. kleine Dateien sind komplizierter.
Sieben antworten:
#1
+14
Michael Schubert
2017-05-18 21:57:58 UTC
view on stackexchange narkive permalink

Hier sind einige Punkte zu beachten, die ich unten skizziere. Das Ziel hier sollte sein, einen Workflow zu finden, der minimal aufdringlich ist, zusätzlich zur Verwendung von git .

Bisher gibt es keinen idealen Workflow, der alle Anwendungsfälle abdeckt, aber Was ich unten skizziere, ist das, was ich am nächsten kommen könnte.

Reproduzierbarkeit bedeutet nicht nur, alle Ihre Daten zu behalten.

Sie haben Ihre Rohdaten, mit denen Sie Ihr Projekt starten.

Alle anderen Daten in Ihrem Projektverzeichnis sollten niemals nur "da sein", sondern Aufzeichnungen darüber haben, woher sie stammen. Datenverarbeitungsskripte eignen sich hervorragend dafür, da sie bereits dokumentieren, wie Sie von Ihren Rohdaten zu Ihren Analysedaten und dann zu den für Ihre Analysen erforderlichen Dateien übergegangen sind.

Und diese Skripte können Versioniert werden, mit einem geeigneten einzelnen Einstiegspunkt für die Verarbeitung (z. B. einem Makefile , der beschreibt, wie Ihre Skripte ausgeführt werden).

Auf diese Weise wird der Status aller Ihrer Projektdateien definiert anhand der Rohdaten und der Version Ihrer Verarbeitungsskripte (und der Versionen externer Software, aber das ist ein ganz anderes Problem).

Welche Daten / Codes sollten versioniert werden und welche nicht

Genau wie Sie generierte Codedateien nicht versionieren würden, sollten Sie keine 10k-Zwischendatendateien versionieren möchten, die Sie bei der Durchführung Ihrer Analysen erstellt haben. Die Daten, die versioniert werden sollten, sind Ihre Rohdaten (am Anfang Ihrer Pipeline) und keine automatisch generierten Dateien.

Möglicherweise möchten Sie sie übernehmen Schnappschüsse Ihres Projektverzeichnisses, aber nicht jede Version jeder jemals erstellten Datei. Dies reduziert Ihr Problem bereits um einiges.

Ansatz 1: Tatsächliche Versionierung von Daten

Für Ihre Roh- oder Analysedaten wurde Git LFS (und alternativ Git Annex, die Sie bereits erwähnt haben) entwickelt, um genau dies zu lösen Problem: Fügen Sie Tracking-Informationen zu Dateien in Ihrem Git-Baum hinzu, speichern Sie jedoch nicht den Inhalt dieser Dateien im Repository (da sonst bei jeder Änderung die Größe einer nicht diffabilen Datei hinzugefügt würde).

Für Ihre Zwischendateien gehen Sie genauso vor wie für Zwischencodedateien: Fügen Sie sie Ihrem .gitignore hinzu und versionieren Sie sie nicht.

Dies wirft einige Überlegungen auf:

  • Git LFS ist ein kostenpflichtiger Dienst von Github (die kostenlose Stufe ist auf 1 GB Speicher / Bandbreite pro Monat begrenzt, was sehr wenig ist). und es ist teurer als andere vergleichbare Cloud-Speicherlösungen. Sie könnten in Betracht ziehen, für den Speicher bei Github zu bezahlen oder Ihren eigenen LFS-Server zu betreiben (es gibt eine Referenzimplementierung, aber ich gehe davon aus, dass dies immer noch ein erheblicher Aufwand wäre).
  • Git Annex ist kostenlos, ersetzt jedoch Dateien durch verknüpft und ändert damit Zeitstempel, was z GNU Make-basierte Workflows (Hauptnachteil für mich). Das Abrufen von Dateien muss auch manuell oder über einen Commit-Hook erfolgen.

Ansatz 2: Nur Versionscode, Daten synchronisieren

Wenn Ihre Analysedaten für gleich bleiben Bei den meisten Ihrer Analysen kann die tatsächliche Notwendigkeit einer Versionierung (im Gegensatz zur Sicherung und Dokumentation der Datenherkunft, die von wesentlicher Bedeutung ist) begrenzt sein.

Der Schlüssel, damit dies funktioniert, besteht darin, alle Datendateien in Ihrem .gitignore und ignorieren Sie alle Ihre Codedateien in rsync mit einem Skript in Ihrem Projektstamm ( Erweiterungen und Verzeichnisse sind nur ein Beispiel):

  #! / bin / bashcd $ (dirname $ 0) rsync -auvr \ --exclude "* .r" \ --include "* .RData "\ --exclude" -Dir mit riesigen Dateien, die Sie lokal nicht benötigen "\ yourhost: / your / project / path / *.  

Der Vorteil hierbei ist, dass Sie sich nicht an den Befehl rsync erinnern müssen, den Sie ausführen. Das Skript selbst wird in die Versionskontrolle übernommen.

Dies ist besonders nützlich, wenn Sie Ihre umfangreiche Verarbeitung in einem Computercluster ausführen, aber Diagramme aus Ihren Ergebnisdateien auf Ihrem lokalen Computer erstellen möchten. Ich behaupte, dass Sie im Allgemeinen keine bidirektionale Synchronisierung benötigen.

Übrigens können Sie zumindest in biomake Datei-Hash anstelle von Zeitstempel verwenden (doi: 10.1093 / bioinformatics / btx306).
@IakovDavydov Ich bin mir dessen bewusst, aber ich habe nicht wirklich versucht, ob es funktioniert
+1 für alle Änderungen an den Rohdaten sollte +1 für den Datei-Hash dokumentiert werden. Ich bin selbst ein großer Fan von Lese- und Schreibkenntnissen und habe diesen Ansatz auch genutzt, um die Version meiner Tools / Pakete zu dokumentieren, die ich für die Analyse und den Hash der Rohdaten verwendet habe. Wenn ich also ein Ergebnis oder eine Handlung sehe, habe ich auch den Produktionskontext.
#2
+9
Sam Nicholls
2017-05-18 14:51:52 UTC
view on stackexchange narkive permalink

Ihre Frage ist etwas offen, aber ich denke, sie könnte sich als interessante Diskussion erweisen. Ich glaube in vielen Fällen nicht, dass es sich lohnt, die Daten zu speichern, die Sie in git erstellt haben. Wie Sie bereits bemerkt haben, ist es nicht für große Dateien konzipiert (obwohl wir git-lfs haben) und es ist definitiv nicht für binäre Formate wie BAM konzipiert.

Ich bin der Meinung, dass wie eine Datei erstellt wurde und was seitdem damit gemacht wurde, der Schlüssel ist. Große Dateien, deren Erstellung viel Aufwand gekostet hat, sollten irgendwo gespiegelt werden (aber nicht unbedingt in einem Versionskontrollsystem). Andere weniger wichtige (oder weniger schwierig zu erstellende) Dateien, die verloren gegangen, überlastet oder auf andere Weise beschädigt wurden, können neu generiert werden, solange Sie wissen, wie sie entstanden sind.

Für das, was es wert ist, habe ich Ich habe an einer Software namens chitin gearbeitet (selbst beschrieben als Shell für unorganisierte Bioinformatiker). Ich schrieb auch einen langen Blog-Beitrag darüber, warum ich dies für ein notwendiges Projekt hielt, aber der Hauptgrund war, dass ich trotz meiner Versuche, mein Dateisystem zu organisieren und gute Archive meiner Experimente zu erstellen, im Laufe der Zeit Vergessen Sie, was meine Kurzverzeichnisnamen bedeuteten oder welches Programm genau welche Daten generiert hat.

chitin Ziel ist es, Änderungen am Dateisystem während der Ausführung eines Befehls automatisch zu erfassen . Es weiß, welche Befehle ausgeführt werden müssen, um eine bestimmte Datei neu zu erstellen, welche Befehle diese Datei verwendet haben und kann Ihnen sagen, wann und warum diese Datei geändert wurde (und von wem;) auch.

Sie ist noch nicht fertig (nichts ist es jemals), aber ich habe das Gefühl, dass Sie möglicherweise den falschen Weg einschlagen, wenn Sie alle Ihre Daten und deren Versionen speichern möchten, obwohl ich denke, dass die meisten Leute nur die Befehle kennen wollen, die Änderungen ausgelöst haben. Wenn der Datenverlauf wichtig ist (und Ihr Code gut versioniert ist), können Sie einfach jedes Commit überprüfen und Ihre Analyse ausführen, um Daten neu zu generieren.

Es tut mir leid, aber ich stimme dem zu. Interessanter Diskussionspunkt, aber keine Beantwortung der Frage des OP.
#3
+6
Daniel Standage
2017-05-21 12:27:58 UTC
view on stackexchange narkive permalink

Zunächst einmal ein großes Lob an Sie, dass Sie die Versionierung ernst genommen haben. Die Tatsache, dass Sie sich dieses Problems bewusst sind, ist ein gutes Zeichen dafür, dass Sie verantwortungsbewusst recherchieren möchten!

Bei vielen Bioinformatikprojekten sind Datendateien so groß, dass eine direkte Versionierung der Daten mit einem Tool wie git möglich ist unpraktisch. Ihre Frage befasst sich jedoch mit einigen unterschiedlichen Fragen.

  • Wie mache ich meine Recherchen reproduzierbar und zeige die volle Herkunft für jeden Datenpunkt und jedes Ergebnis, das ich produziere?
  • Wie verwalte und synchronisiere ich meine Forschungsarbeit auf mehreren Computern?

Die kurze Antwort :

  • Archivieren Sie die Primärdaten.
  • Stellen Sie Ihren Workflow unter Versionskontrolle.
  • Versionsprüfsummen großer Datendateien.
  • Verwenden Sie GitHub, um Ihren Workflow zwischen Computern zu synchronisieren.

Die lange Antwort :

Archivieren Sie die Primärdaten

Für die Reproduzierbarkeit sind vor allem die Primärdaten von Bedeutung: die rohen, unverarbeiteten Daten, die Sie vom Instrument erfassen. Wenn Sie Daten analysieren, die von anderen veröffentlicht wurden, schreiben Sie ein Skript, das das Herunterladen der Daten von der offiziellen Hauptquelle automatisiert, und stellen Sie dieses Skript unter Versionskontrolle.

Wenn Sie oder a Ein Laborkollege oder ein Kollege hat die Daten erstellt und sie sind noch nicht veröffentlicht. Dann sollten Sie bereits Pläne haben, sie an ein Archiv zu senden. In der Tat verlangen die meisten Zeitschriften und Förderagenturen dies jetzt vor der Veröffentlichung. Ich würde sogar so weit gehen zu sagen, dass die Daten übermittelt werden sollten, sobald sie gesammelt wurden. Wissenschaftler machen sich große Sorgen darüber, dass ihre Daten gestohlen und ihre Ideen aufgegriffen werden. Statistisch gesehen ist es jedoch viel weniger wahrscheinlich, dass jemand Ihre Daten berührt oder Ihre Zeitung liest. Wenn Sie oder ein Berater darauf bestehen, können Sie in den meisten Datenarchiven Daten für einen längeren Zeitraum privat halten, bis ein unterstützendes Manuskript veröffentlicht wird.

Das Einfügen von (zum Beispiel) Fastq-Dateien in ein Git-Repository ist aus vielen Gründen eine schlechte Idee. Kein Hosting-Service unterstützt so große Dateien, Git ist bei so großen Dateien sehr langsam, aber am wichtigsten ist, dass Git / GitHub nicht archiviert wird! Verwenden Sie ein geeignetes Datenarchiv!

Stellen Sie Ihren Workflow unter Versionskontrolle.

Behandeln Sie Ihre Rohdaten als schreibgeschützt. Verarbeiten Sie die Rohdaten nur mit Skripten und halten Sie diese Skripte unter Versionskontrolle. Vince Buffalo beschreibt dies gut in seinem Buch Bioinformatics Data Skills. Probieren Sie es aus!

Versionsprüfsummen großer Datendateien

Wenn Sie Datendateien verfolgen möchten, die jedoch zu groß sind, um unter Versionskontrolle gestellt zu werden, berechnen Sie Prüfsummen und platzieren Sie diese unter Versionskontrolle. Prüfsummen sind sehr kleine alphanumerische Zeichenfolgen, die praktisch für jede Datendatei eindeutig sind. Anstatt diese 5 GB gekürzte Fastq-Datei oder die 7 GB BAM-Datei der Versionskontrolle zu unterziehen, berechnen Sie ihre Prüfsummen und stellen Sie die Prüfsummen der Versionskontrolle. Die Prüfsummen geben keinen Aufschluss über den Inhalt Ihrer Dateien, können jedoch darüber informieren, wann sich der Inhalt der Datei ändert.

Dies sollte für jeden Datenpunkt in Ihrer Analyse eine vollständige Offenlegung und vollständige Herkunft bieten. Der Workflow verfügt über Skripte / Befehle zum Herunterladen der Primärdaten, Skripte / Befehle zum Verarbeiten der Daten und Prüfsummen, die als Signatur zum Überprüfen der Zwischen- und Endausgabedateien dienen. Damit sollte jeder in der Lage sein, Ihre Analyse zu reproduzieren!

Verwenden Sie GitHub, um Ihren Workflow zwischen Computern zu synchronisieren.

Wenn Ihr Workflow bereits mit git unter Versionskontrolle steht, ist es trivial, dies zu pushen zu einem Hosting-Service wie GitHub, GitLab oder BitBucket. Dann müssen Sie nur noch git push und git pull verwenden, um Ihren Code auf Ihren verschiedenen Computern auf dem neuesten Stand zu halten.

#4
+5
H. Gourlé
2017-05-18 17:46:13 UTC
view on stackexchange narkive permalink

Das Open Science Framework verwendet die Versionierung für alle Dateien und kann kostenlos verwendet werden: https://osf.io

Sie können Daten oder Code aus verschiedenen Quellen integrieren, z Github, Dropbox, Google Drive, Figshare oder Amazon Cloud

Sie können Dateien auch mithilfe des OSF-Datenspeichers auf ihrem Server speichern, aber ich weiß nicht genau, wie hoch die Dateigröße ist.

#5
+4
Ian Sudbery
2017-05-19 14:33:59 UTC
view on stackexchange narkive permalink

Wir gehen folgendermaßen damit um:

  • Alle Arbeiten werden in einem einzelnen Dateisystem ausgeführt, das auf dem Cluster bereitgestellt wird.
  • Dieses Dateisystem wird über sshfs auf lokalen Computern bereitgestellt / samba (abhängig vom Standort des aktuellen "lokalen" Computers im Netzwerk).
  • Der Code wird mit dem Git-Hub versioniert.
  • Alle Berechnungen werden über leichte automatisierte Pipelines ausgeführt . Wir verwenden Ruffus in Kombination mit einer internen Versorgungsschicht. Das System spielt keine Rolle, solange es nicht mehr Arbeit ist, der Pipeline einen weiteren Schritt hinzuzufügen, als ihn manuell auszuführen.
  • Alle fragwürdigen Entwurfsentscheidungen werden in Konfigurationsdateien codiert. Diese Konfigurationsdateien, zusammen mit einer sehr detaillierten Protokollausgabe durch die Pipeline (was wurde ausgeführt, was war das Git-Commit des ausgeführten Codes, was war der Zeitstempel der Dateien, auf denen es ausgeführt wurde usw.) und die anfänglichen Eingabedateien sind Versionskontrolliert.
  • Der Vorteil davon ist, dass Code + Konfiguration + Zeit = Ausgabe. Es wird nicht erwartet, dass die gesamte Pipeline bei jeder Änderung erneut ausgeführt wird. Die Pipeline zeigt jedoch an, ob etwas veraltet ist (es können Zeitstempel oder Datei-Hashes verwendet werden), und alles kann vor der Veröffentlichung auf einmal ausgeführt werden.
  • Jede andere Analyse wird in Juptyer-Notizbüchern durchgeführt. Diese sind versioniert.

Zusammenfassend lässt sich sagen, dass wir nicht synchronisieren, da wir immer nur von einem Festplattenspeicherort aus arbeiten, selbst wenn wir mehrere CPU-Speicherorte verwenden. Wir haben Versionskontrolle:

  • Code
  • Eingaben, Konfiguration, Protokolle
  • Juptyer-Notizbücher

Protokoll zeichnet das auf Git-Commits werden verwendet, um die aktuellen Ausgaben zu erzeugen.

Interessanter Ian, das ist die Art von Design, die ich anstrebe, aber nicht wirklich in die Praxis umsetze. Ich bin fasziniert von dieser internen Schicht auf Ruffus. Was ist das?
Der Trick besteht darin, das Schreiben einer Pipeline-Aufgabe einfacher zu gestalten als ein Skript zur Übermittlung von Cluster-Jobs. Die Nutzschicht wird von CGATPipelines bereitgestellt (www.github.com/CGATOxford/CGATPipelines).
#6
+3
woemler
2017-05-18 18:44:31 UTC
view on stackexchange narkive permalink

Die Verwendung von Git zur Versionskontrolle von Code ist eine gute Vorgehensweise, eignet sich jedoch nicht für die Versionierung großer Datendateien. Das manuelle Synchronisieren von Daten über mehrere Knoten hinweg ist problematisch. Sie möchten, dass diese Synchronisierung entweder automatisch in einer verwalteten Umgebung durchgeführt wird oder dass die Dateien nur auf einem einzelnen an das Netzwerk angeschlossenen Speichergerät gespeichert werden.

Ein Tool, das Sie möglicherweise verwenden Schauen Sie sich Arvados an, das für die Synchronisierung von Bioinformatikdaten und Workflows auf mehreren Computern entwickelt wurde. Von der Projektwebsite:

Arvados ist eine Plattform zum Speichern, Organisieren, Verarbeiten und Teilen von genomischen und anderen Big Data. Die Plattform soll Datenwissenschaftlern die Entwicklung von Analysen, Entwicklern die Erstellung genomischer Webanwendungen und IT-Administratoren die Verwaltung umfangreicher genomischer Rechen- und Speicherressourcen erleichtern. Die Plattform kann in der Cloud oder auf Ihrer eigenen Hardware ausgeführt werden.

Ich würde Arvados nur verwenden, wenn es wirklich viel besser wird als vorher.
@nuin: Was genau hat Ihrer Meinung nach gefehlt und / oder würde es als Lösung für das OP-Problem nicht geeignet machen?
@woemier Ich habe es in letzter Zeit nicht ausprobiert, und wenn ich mich richtig erinnere, war es eine PITA, einfache Dinge einzurichten und auszuführen. Aber wie gesagt, ich weiß nicht, ob es besser geworden ist.
#7
+3
weiji14
2018-03-27 08:17:13 UTC
view on stackexchange narkive permalink

Diese Antwort deckt nur die Big-Data-Teile ab, d. h. Dinge> 100 MB, und nur dann, wenn Ihre Analyse-Pipeline mit dem Python-Ökosystem verknüpft ist. Es wird ein wenig Lernen erfordern.

Versuchen Sie, Quilt zu verwenden, was einer Art Docker für Daten ähnelt ( Github-Seite).

  $ pip install quilt $ quilt install uciml / iris -x da2b6f5 #notiz der kurze Hash $ python>>> aus quilt.data.uciml importiere Iris # du hast Daten  

Vorteile:

  • Es scheint keine Dateigrößenbeschränkung für öffentliche Pakete zu geben (dies wurde jedoch nicht auf Stresstests getestet).
  • Hashes Ihre Daten, um die Reproduzierbarkeit sicherzustellen
  • Unterstützung für Versionierung und Tags

Nachteile:

  • Das Speichern privater Daten beginnt bei 7 USD pro Benutzer / Monat bis zu 1 TB Daten
  • Ziemlich viel Python nur zu diesem Zeitpunkt, mit etwas Community Unterstützung für R

Weitere Informationen hier.



Diese Fragen und Antworten wurden automatisch aus der englischen Sprache übersetzt.Der ursprüngliche Inhalt ist auf stackexchange verfügbar. Wir danken ihm für die cc by-sa 3.0-Lizenz, unter der er vertrieben wird.
Loading...