Narzędzia i protokół do powtarzalnej analizy danych za pomocą Pythona

Pracuję nad projektem nauki danych za pomocą Pythona. Projekt składa się z kilku etapów. Każdy etap obejmuje pobranie zestawu danych, użycie skryptów Python, danych pomocniczych, konfiguracji i parametrów oraz utworzenie innego zestawu danych. Przechowuję kod w git, więc ta część jest objęta. Chciałbym usłyszeć o:

1. Narzędzia do kontroli wersji danych.
2. Narzędzia umożliwiające odtwarzanie etapów i eksperymentów.
3. Protokół i sugerowana struktura katalogów dla takiego projektu.
4. Zautomatyzowane narzędzia do budowania / uruchamiania.

Temat badań powtarzalnych (RR) jest dziś bardzo popularny i dlatego jest ogromny , ale mam nadzieję, że moja odpowiedź będzie wystarczająco wyczerpująca jako odpowiedź i dostarczy wystarczających informacji do dalszych badań , jeśli zdecydujesz się to zrobić.

Chociaż na pewno istnieją narzędzia specyficzne dla Pythona dla RR, myślę, że bardziej sensowne jest skupienie się na bardziej uniwersalnych narzędziach (nigdy nie wiadomo na pewno, z którymi językami programowania i środowiskami komputerowymi będziesz pracować w przyszłości). Powiedziawszy to, spójrzmy, jakie narzędzia są dostępne na twojej liście.

1) Narzędzia do kontroli wersji danych . Chyba, że ​​jeśli nie planujesz pracy z (bardzo) dużymi danymi , sensowne byłoby użycie tego samego git, którego używasz do kontroli wersji kodu źródłowego. Infrastruktura już tam jest. Nawet jeśli twoje pliki są binarne i duże, ta rada może być pomocna: https://stackoverflow.com/questions/540535/managing-large-binary-files-with-git .

2) Narzędzia do zarządzania przepływami pracy RR i eksperymentami . Oto lista najpopularniejszych narzędzi w tej kategorii, zgodnie z moją najlepszą wiedzą (w kolejności malejącej popularności):

• Taverna Workflow Management System ( http://www.taverna.org.uk ) - bardzo solidny, choć nieco zbyt skomplikowany zestaw narzędzi. Głównym narzędziem jest oprogramowanie komputerowe oparte na Javie. Jest jednak kompatybilny z internetowym portalem repozytorium przepływów pracy myExperiment ( http://www.myexperiment.org ), w którym użytkownik może przechowywać i udostępniać swoje przepływy pracy RR. Internetowy portal RR, w pełni kompatybilny z Taverna, nazywa się Taverna Online , ale jest rozwijany i obsługiwany przez zupełnie inną organizację w Rosji (zwaną tam OnlineHPC : http://onlinehpc.com ).

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

• VisTrails ( http://vistrails.org )

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

Przykład . Oto ciekawy artykuł na temat naukowych przepływów pracy z przykładem rzeczywistego projektu przepływu pracy i analizy danych, opartego na wykorzystaniu projektów Kepler i myExperiment : http://f1000research.com/articles/3-110/v1 .

Istnieje wiele narzędzi RR, które implementują umiejętny paradygmat programowania , czego przykładem jest LaTeXrodzina oprogramowania. Narzędzia, które pomagają w generowaniu i prezentacji raportów, to także duża kategoria, gdzie Sweavei knitrprawdopodobnie są one najbardziej znane. Sweavejest narzędziem skoncentrowanym na języku R, ale można je zintegrować z projektami opartymi na języku Python, choć przy pewnym dodatkowym wysiłku ( https://stackoverflow.com/questions/2161152/sweave-for-python ). Myślę, że knitrmoże to być lepsza opcja, ponieważ jest nowoczesna, ma szerokie wsparcie popularnych narzędzi (takich jak RStudio) i jest neutralna językowo ( http://yihui.name/knitr/demo/engines ).

3) Protokół i sugerowana struktura katalogów . Jeśli dobrze zrozumiałem, co sugerujesz, używając terminu protokół ( przepływ pracy ), ogólnie uważam, że standardowy przepływ pracy analizy danych RR składa się z następujących następujących po sobie faz: zbieranie danych => przygotowanie danych (czyszczenie, transformacja, scalanie, próbkowanie) => analiza danych => prezentacja wyników (generowanie raportów i / lub prezentacji). Niemniej jednak każdy przepływ pracy jest specyficzny dla projektu, dlatego niektóre określone zadania mogą wymagać dodania dodatkowych kroków.

Przykładową strukturę katalogów można znaleźć w dokumentacji pakietu R ProjectTemplate( http://projecttemplate.net ), próbując zautomatyzować przepływy pracy i projekty analizy danych:

4) Zautomatyzowane narzędzia do budowania / uruchamiania . Ponieważ moja odpowiedź skupia się na uniwersalnych (neutralnych językowo) narzędziach RR, najbardziej popularnymi narzędziami są make. Przeczytaj poniższy artykuł z kilku powodów, aby używać go makejako preferowanego narzędzia do automatyzacji przepływu pracy RR: http://bost.ocks.org/mike/make . Z pewnością istnieją inne podobne narzędzia, które albo poprawiają niektóre aspekty make, albo dodają dodatkowe funkcje. Na przykład: ant(oficjalnie Apache Ant: http://ant.apache.org ), Maven(„następna generacja ant”: http://maven.apache.org ), rake( https://github.com/ruby/rake ) , Makepp( http://makepp.sourceforge.net). Pełna lista takich narzędzi znajduje się w Wikipedii: http://en.wikipedia.org/wiki/List_of_build_automation_software .

Odkąd zacząłem prowadzić badania w środowisku akademickim, ciągle szukałem satysfakcjonującego przepływu pracy. Myślę, że w końcu znalazłem coś, z czego jestem zadowolony:

1) Umieść wszystko pod kontrolą wersji, np. Git:

W projektach badawczych związanych z hobby korzystam z GitHub, do badań w pracy używam prywatnego serwera GitLab, który zapewnia nasza uczelnia. Trzymam tam również moje zbiory danych.

2) Większość moich analiz wykonuję wraz z dokumentacją dotyczącą notebooków IPython. Dla mnie bardzo dobrze jest zorganizować kod, wykresy i dyskusję / wnioski w jednym dokumencie. Jeśli uruchamiam większe skrypty, zwykle umieszczam je w osobnych plikach skryptowych .py, ale nadal je wykonuję z notesu IPython poprzez magię% run, aby dodać informacje o celu, wyniku i innych parametrach.

Napisałem małe rozszerzenie o komórkowej magii dla notebooków IPython i IPython, zwane „znakiem wodnym”, którego używam do wygodnego tworzenia znaczników czasu i śledzenia różnych używanych przeze mnie wersji pakietów, a także skrótów Git

Na przykład

%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

Aby uzyskać więcej informacji, zobacz dokumentację tutaj .

Najlepszym narzędziem odtwarzalności jest rejestrowanie twoich działań, mniej więcej tak:

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

Można to zapisać na papierze, ale jeśli twoje eksperymenty mieszczą się w środowisku obliczeniowym, możesz użyć narzędzi obliczeniowych do częściowej lub całkowitej automatyzacji tego procesu rejestrowania (w szczególności pomagając w śledzeniu wejściowych zestawów danych, które mogą być ogromne, i wyników liczby).

Świetnym narzędziem odtwarzalności dla Pythona z niską krzywą uczenia się jest oczywiście Notatnik IPython / Jupyter (nie zapomnij o % logon i% logstart magics ). Wskazówka: aby upewnić się, że Twój notebook jest odtwarzalny, zrestartuj jądro i spróbuj uruchomić wszystkie komórki od góry do dołu (przycisk Uruchom wszystkie komórki): jeśli to działa, zapisz wszystko w pliku archiwum („zamrażanie”), w innym przypadku, szczególnie jeśli chcesz uruchamiać komórki w sposób nieliniowy, niesekwencyjny i nieoczywisty, aby uniknąć błędów, musisz trochę przerobić.

Kolejnym świetnym narzędziem, które jest bardzo aktualne (2015), jest przepis , który jest bardzo podobny do sumatry (patrz poniżej), ale stworzony specjalnie dla Pythona. Nie wiem, czy to działa z notatnikami Jupyter, ale wiem, że autor często z nich korzysta, więc sądzę, że jeśli nie jest obecnie obsługiwany, będzie w przyszłości.

Git jest także niesamowity i nie jest powiązany z Pythonem. Pomoże ci to nie tylko zachować historię wszystkich twoich eksperymentów, kodu, zestawów danych, liczb itp., Ale także zapewni ci narzędzia do utrzymywania ( git kilof ), współpracy ( obwinianie ) i debugowania ( git - bisect ) przy użyciu naukowych metoda debugowania (zwana debugowaniem delta ). Oto historia fikcyjnego badacza, który próbuje stworzyć własny system rejestrowania eksperymentów, dopóki nie stanie się on faksem Gita.

Innym ogólnym narzędziem współpracującym z dowolnym językiem (z API Pythona na pypi ) jest Sumatra , która została specjalnie zaprojektowana, aby pomóc ci w przeprowadzaniu powtarzalnych badań ( powtarzalne cele mają na celu uzyskanie tych samych wyników przy tym samym kodzie i oprogramowaniu, podczas gdy odtwarzalność ma na celu wytworzenie takie same wyniki dla dowolnego medium, które jest o wiele trudniejsze i czasochłonne, a nie automatyczne).

Oto jak działa Sumatra: dla każdego eksperymentu przeprowadzanego przez Sumatrę oprogramowanie to będzie działać jak „zapisywanie stanu gry” często występujące w grach wideo. Dokładniej, pozwoli to zaoszczędzić:

• wszystkie podane parametry;
• dokładny stan kodu źródłowego całej eksperymentalnej aplikacji i plików konfiguracyjnych;
• dane wyjściowe / wykresy / wyniki, a także każdy plik utworzony przez twoją eksperymentalną aplikację.

Następnie zbuduje bazę danych ze znacznikiem czasu i innymi metadatami dla każdego eksperymentu, które można później przeszukiwać za pomocą webGUI. Ponieważ Sumatra zapisała pełny stan aplikacji dla określonego eksperymentu w określonym momencie, możesz przywrócić kod, który dał określony wynik w dowolnym momencie, dzięki czemu masz powtarzalne badania przy niskim koszcie (z wyjątkiem przechowywania, jeśli pracujesz na ogromnych zestawach danych, ale możesz skonfigurować wyjątki, jeśli nie chcesz zapisywać wszystkiego za każdym razem).

Innym niesamowitym narzędziem jest Zeitgeist GNOME (wcześniej zakodowany w Pythonie, ale teraz przeniesiony do Vala), wszechstronny system dziennika działań, który rejestruje wszystko, co robisz, i może korzystać z uczenia maszynowego, aby podsumować przez pewien okres czasu zależność między elementami na podstawie w sprawie wzorców podobieństwa i użytkowania, np. odpowiadania na pytania typu „Co było dla mnie najbardziej istotne, kiedy pracowałem nad projektem X przez miesiąc w zeszłym roku?” . Co ciekawe, Zim Desktop Wiki , aplikacja do robienia notatek podobna do Evernote, ma wtyczkę do współpracy ze Zeitgeist.

W końcu możesz użyć Git lub Sumatry lub dowolnego innego oprogramowania, które zapewnią ci taką samą moc replikacji, ale Sumatra jest specjalnie dostosowana do badań naukowych, więc zapewnia kilka fantazyjnych narzędzi, takich jak internetowy interfejs GUI do indeksowania Twoje wyniki, podczas gdy Git jest bardziej dostosowany do obsługi kodu (ale ma narzędzia do debugowania, takie jak git-bisect, więc jeśli twoje eksperymenty obejmują kody, może być lepsze). Lub oczywiście możesz użyć obu!

/ EDIT: dsign dotknął tutaj bardzo ważnej kwestii: replikacja twojej instalacji jest równie ważna jak replikacja twojej aplikacji. Innymi słowy, powinieneś przynajmniej dostarczyć pełną listę używanych bibliotek i kompilatorów wraz z ich dokładnymi wersjami i szczegółami twojej platformy .

Osobiście w informatyce naukowej w Pythonie odkryłem, że pakowanie aplikacji wraz z bibliotekami jest po prostu zbyt bolesne, dlatego teraz po prostu używam uniwersalnego naukowego pakietu python, takiego jak Anaconda (z doskonałym menedżerem pakietów conda ), i po prostu doradzam użytkownikom korzystanie z tego samego pakietu. Innym rozwiązaniem może być dostarczenie skryptu do automatycznego generowania virtualenv lub spakowanie wszystkiego za pomocą komercyjnej aplikacji Docker, cytowanej przez dsign lub Vagrant z open source (na przykład pylearn2-in-a-box, które używają Vagrant do stworzenia łatwo redystrybucyjnej dystrybucji pakiet środowiska wirtualnego).

Wreszcie, aby naprawdę upewnić się, że masz w pełni działające środowisko za każdym razem, gdy potrzebujesz, możesz stworzyć maszynę wirtualną (patrz VirtualBox), a nawet zapisać stan maszyny (migawka) z eksperymentem gotowym do uruchomienia w środku. Następnie możesz po prostu udostępnić tę maszynę wirtualną wszystkim, co jest w niej zawarte, aby każdy mógł powtórzyć eksperyment z Twoją dokładną konfiguracją. Jest to prawdopodobnie najlepszy sposób na powtórzenie eksperymentu opartego na oprogramowaniu. Kontenery mogą być lżejszą alternatywą, ale nie obejmują całego środowiska, dlatego wierność replikacji będzie mniej niezawodna.

/ EDIT2: Oto świetne podsumowanie wideo (do debugowania, ale można to również zastosować do badań), co jest fundamentem do przeprowadzenia powtarzalnych badań: rejestrowanie eksperymentów i poszczególnych etapów metody naukowej, rodzaj „jawnego eksperymentowania” .

Koniecznie sprawdź dokera ! Ogólnie rzecz biorąc, wszystkie inne dobre rzeczy, które inżynieria oprogramowania tworzyła przez dziesięciolecia w celu zapewnienia izolacji i odtwarzalności.

Chciałbym podkreślić, że nie wystarczy mieć tylko powtarzalne przepływy pracy, ale także łatwy do odtworzenia przepływów pracy. Pokażę, co mam na myśli. Załóżmy, że twój projekt używa Pythona, bazy danych X i Scipy. Z pewnością będziesz używać konkretnej biblioteki do łączenia się z bazą danych z Pythona, a Scipy z kolei będzie używać rzadkich procedur algebraicznych. Jest to z pewnością bardzo prosta konfiguracja, ale nie do końca łatwa w konfiguracji, przewidziana gra słów. Jeśli ktoś chce wykonać twoje skrypty, będzie musiał zainstalować wszystkie zależności. Lub, co gorsza, mogła mieć już zainstalowane niekompatybilne wersje. Naprawienie tych rzeczy wymaga czasu. Zajmie ci to również trochę czasu, jeśli będziesz musiał przenieść swoje obliczenia do klastra, innego klastra lub niektórych serwerów w chmurze.

Tutaj uznaję dokera za użyteczny. Docker to sposób na sformalizowanie i skompilowanie przepisów dla środowisk binarnych. Możesz zapisać następujące pliki w pliku dokowanym (używam tutaj zwykłego angielskiego zamiast składni Dockerfile):

• Zacznij od podstawowego środowiska binarnego, takiego jak Ubuntu
• Zainstaluj libsparse-dev
• (Pip) Zainstaluj numpy i scipy
• Zainstaluj X
• Zainstaluj libX-dev
• (Pip) Zainstaluj Python-X
• Zainstaluj IPython-Notebook
• Skopiuj moje skrypty / notesy w języku Python do mojego środowiska binarnego, tych plików danych i tych konfiguracji, aby wykonywać inne czynności. Aby zapewnić odtwarzalność, skopiuj je z nazwanego adresu URL zamiast pliku lokalnego.
• Może uruchom IPython-Notebook.

Niektóre linie będą instalowały różne rzeczy w Pythonie przy użyciu pip, ponieważ pip może wykonać bardzo czystą pracę przy wyborze konkretnych wersji pakietów. Sprawdź to też!

I to wszystko. Jeśli po utworzeniu pliku Dockerfile można go zbudować, może go zbudować w dowolnym miejscu, przez kogokolwiek (pod warunkiem, że mają one również dostęp do plików specyficznych dla projektu, np. Ponieważ umieścisz je w publicznym adresie URL, do którego odwołuje się plik Dockerfile). Co najlepsze, możesz przesłać powstałe środowisko (zwane „obrazem”) na publiczny lub prywatny serwer (zwany „rejestrem”), z którego mogą korzystać inne osoby. Kiedy więc publikujesz swój przepływ pracy, masz zarówno w pełni powtarzalny przepis w postaci pliku Docker, jak i łatwy sposób dla ciebie lub innych osób na odtworzenie tego, co robisz:

docker run dockerregistery.thewheezylab.org/nowyouwillbelieveme

Lub jeśli chcą się bawić w twoje skrypty i tak dalej:

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

Niestety nie mam wystarczającej liczby punktów reputacji, aby odpowiedzieć na post przez Plank, więc muszę odpowiedzieć na cały wątek - przepraszam za to.

W rzeczywistości jestem programistą wspomnianego powyżej open-source Collective Knowledge Framework. Stara się uprościć udostępnianie artefaktów i eksperymentalne przepływy pracy jako wielokrotnego użytku i odtwarzalne komponenty Pythona z ujednoliconym interfejsem API JSON i meta JSON współdzielonymi przez GitHub. Można je również łączyć z analizą predykcyjną za pomocą tego samego zunifikowanego interfejsu API JSON.

Właśnie wypuściliśmy nową wersję V1.8.1 i udostępniliśmy obszerną dokumentację, więc mam nadzieję, że łatwiej będzie teraz zrozumieć pojęcia: http://github.com/ctuning/ck/wiki

Mamy teraz wiele projektów akademickich i przemysłowych opartych na tych ramach, więc możesz sprawdzić jeden z nich - optymalizację programu crowdsourcingu na urządzeniach mobilnych zapewnianą przez wolontariuszy w odtwarzalny sposób: http://cknowledge.org/repo

Śledzimy również różne zasoby związane z odtwarzalną nauką tutaj: https://github.com/ctuning/ck/wiki/Enabling-open-science

Chociaż koncentruję się przede wszystkim na odtwarzaniu badań systemów komputerowych, odbyłem ciekawe rozmowy z kolegami z innych dziedzin i wygląda na to, że mają bardzo podobne problemy. Będę więc bardzo szczęśliwy, jeśli nasze ramy mogą być pomocne dla innych społeczności! Jeśli masz jakieś pytania lub sugestie, skontaktuj się z nami!

Cały kurs poświęcony jest powtarzalnym badaniom. https://www.coursera.org/learn/reproducible-research Kurs ten oparty jest na języku R, ale można nauczyć się podstawowej idei.

Jednym prostym sposobem jest posiadanie notesu Ipython i zapisywanie każdej brudnej pracy, którą wykonujesz, czy to czyszczenia danych, analizy eksploracyjnej czy budowy modelu.

Ostatnio natknąłem się na następujące narzędzie - http://github.com/ctuning/ck . Jest już napisany w Pythonie i wydaje się, że zawiera to, czego potrzebujesz (mój kolega używa go w projekcie pilotażowym do automatyzacji rozpoznawania obrazów).

Plusy:

1. bardzo mały, przenośny i konfigurowalny
2. obejmuje serwer WWW do dystrybucji eksperymentów i przetwarzania ich za pomocą analizy predykcyjnej
3. ma fajny przykład użycia do gromadzenia zasobów i odtwarzania optymalizacji kompilatora - http://cknowledge.org/repo

Cons:

1. nieco niski poziom - musisz zaimplementować własny przepływ pracy ze składników Pythona współdzielonych przez GitHub przy użyciu JSON API lub wiersza poleceń
2. dokumentacja jest dość skomplikowana - mam nadzieję, że znajdą czas na jej aktualizację wkrótce.

Stworzyłem i niedawno wydałem narzędzie open source http://dvc.org lub DVC, które robi dokładnie to, co próbujesz osiągnąć:

1. [Narzędzia do kontroli wersji danych.] DVC działa na Git, dodaje kontrolę wersji pliku danych (pliki są przechowywane poza Git) i śledzi zależności między kodem a plikami danych. DVC automatycznie wyprowadza wykres zależności (DAG) dla kodu i danych.
2. [Narzędzia umożliwiające odtwarzanie etapów i eksperymentów.] dvc repro data/scores.csvOdtwarza wszystkie wymagane kroki dotyczące DAG.
3. [Protokół i sugerowana struktura katalogów dla takiego projektu.] DVC wymagało katalogu danych ( datadomyślnie), w którym należy przechowywać wszystkie pliki danych. Jednak DVC transparentnie przenosi rzeczywistą zawartość do .cachekatalogu i tworzy dowiązania symboliczne (tak, dostosowałem ją również do systemu Windows). .cacheKatalog nie jest zsynchronizowana z Git, ale może to być synchronizowane przez chmury (S3 lub GCP) poleceniem dvc sync data/scores.csv(synchronizuje odzwierciedlał plik danych z pamięci podręcznej podobnego .cache/scores.csv_29de545)
4. [Zautomatyzowane narzędzia do budowania / uruchamiania.] Patrz powyżej.

Samouczek DVC jest dobrym punktem wyjścia - „Kontrola wersji danych: iteracyjne uczenie maszynowe” .

ZASTRZEŻENIE: Pracuję w firmie Datmo , która tworzy do tego celu narzędzie typu open source.

Najlepsza praktyka w zakresie odtwarzalności jest następująca:

1) Najpierw spakuj środowisko do środowiska Docker, tworząc plik Docker i upewniając się, że wszystkie zależności są uwzględnione w tym pliku. Uważam, że ten zasób jest najlepszy ( https://arxiv.org/pdf/1410.0846.pdf )

2) Gdy już to zrobisz, będziesz musiał zdecydować, gdzie możesz śledzić wszystkie wskaźniki wydajności i konfiguracje (aby móc ponownie odwiedzić ją w celu przyszłego eksperymentowania)

3) Na koniec napisz dokumentację, aby nowy eksperymentator / programista mógł ponownie sprawdzić kod, zreplikować go ze środowiskiem i zobaczyć, gdzie zachowałeś swoje konfiguracje i wskaźniki wydajności.