Python Multiprocessing, Verteilte Cluster

Ich bin auf der Suche nach einem python-Paket, das tun können, multiprocessing, nicht nur zwischen verschiedenen Kernen in einem einzigen computer, sondern auch mit einem cluster, verteilt auf mehrere Maschinen. Es gibt eine Menge von verschiedenen Pakete für python, für distributed computing, aber die meisten scheinen zu erfordern eine änderung im code ausführen (zum Beispiel ein Präfix, der angibt, dass das Objekt auf einer remote-Maschine). Insbesondere möchte ich etwas so nah wie möglich an die multiprocessing pool.map Funktion. So, zum Beispiel, wenn auf einer einzigen Maschine ist das Skript:

from multiprocessing import Pool
pool = Pool(processes = 8)
resultlist = pool.map(function, arglist)

Dann der pseudocode für eine verteilte cluster wäre:

from distprocess import Connect, Pool, Cluster

pool1 = Pool(processes = 8)
c = Connect(ipaddress)
pool2 = c.Pool(processes = 4)
cluster = Cluster([pool1, pool2])
resultlist = cluster.map(function, arglist)
  • Wahrscheinlich erfordert mehr setup als du suchst, aber man kann einen Blick auf Sellerie für eine verteilte Warteschlange Aufgabe. docs.celeryproject.org/en/latest/getting-started/...
  • Ich würde check out Krug
  • Ich kann am Ende mit Sellerie, aber es erfordert eine ganze Menge, und die Hilfe-Dateien sind schwer zu Folgen (disjunkt, anstatt klare Anweisungen Schritt für Schritt mit einer Kopie des gesamten Skript am Ende). Kanne docs reden parallelisieren, aber nicht die Parallelisierung auf verschiedenen Computern.
  • Es gibt auch eine Recht umfassende Liste von Lösungen: wiki.python.org/moin/ParallelProcessing
  • Erwähnenswert ist auch, dass es eine neuere Lösung, die ähnlich ist pathos -- ein Paket namens dask.
InformationsquelleAutor Michael | 2014-11-12
  1. 11

    Ich würde vorschlagen, dass Sie einen Blick auf Ray, die darauf abzielt, genau das zu tun.

    Ray verwendet die gleiche syntax zu parallelisieren code in der einzigen Maschine, die multicore-Einstellung, wie es in der dezentralen Einstellung. Wenn Sie bereit sind, verwenden Sie eine for-Schleife statt einer Karte nennen, dann ist dein Beispiel würde wie folgt Aussehen.

    import ray
import time

ray.init()

@ray.remote
def function(x):
    time.sleep(0.1)
    return x

arglist = [1, 2, 3, 4]

result_ids = [function.remote(x) for x in arglist]
resultlist = ray.get(result_ids)

    Ausgeführt werden vier Aufgaben parallel über wie viele Kerne Sie haben lokal. Zum ausführen der gleichen Beispiel auf einem cluster, die einzige Linie, die ändern würde, wäre der Aufruf ray.init(). Die entsprechende Dokumentation finden hier.

    Beachten Sie, dass ich einen Beitrag zur Entwicklung Ray.

    InformationsquelleAutor Robert Nishihara
  2. 10

    Wenn Sie möchten, eine einfache Lösung gibt es nicht.

    Allerdings gibt es eine Lösung, die die multiprocessing Schnittstelle -- pathos -- hat die Fähigkeit, um verbindungen zu remote-Servern über eine parallel-Karte, und multiprocessing.

    Wenn Sie möchten, um eine ssh-Getunnelte Verbindung, die Sie tun können, dass... " oder, wenn Sie sind ok mit einer weniger sicheren Methode können Sie das auch tun.

    >>> # establish a ssh tunnel
>>> from pathos.core import connect
>>> tunnel = connect('remote.computer.com', port=1234)
>>> tunnel       
Tunnel('-q -N -L55774:remote.computer.com:1234 remote.computer.com')
>>> tunnel._lport
55774
>>> tunnel._rport
1234
>>> 
>>> # define some function to run in parallel
>>> def sleepy_squared(x):
...   from time import sleep
...   sleep(1.0)
...   return x**2
... 
>>> # build a pool of servers and execute the parallel map
>>> from pathos.pp import ParallelPythonPool as Pool
>>> p = Pool(8, servers=('localhost:55774',))
>>> p.servers
('localhost:55774',)
>>> y = p.map(sleepy_squared, x)
>>> y
[0, 1, 4, 9, 16, 25, 36, 49, 64, 81]

    Oder, statt Sie konfigurieren können für eine direkte Verbindung (kein ssh)

    >>> p = Pool(8, servers=('remote.computer.com:5678',))
# use an asynchronous parallel map
>>> res = p.amap(sleepy_squared, x)
>>> res.get()
[0, 1, 4, 9, 16, 25, 36, 49, 64, 81]

    Es ist alles ein bisschen pingelig, für die remote-server zu arbeiten, müssen Sie starten Sie einen server läuft auf remote.computer.com am angegebenen port, Voraus-und Sie haben zu stellen Sie sicher, dass die Einstellungen auf deinem localhost und dem remote-host zu, dass entweder die direkte Verbindung oder die ssh-Getunnelte Verbindung. Plus, Sie müssen die gleiche version von pathos und der pathos Gabel pp auf jedem host laufen. Auch für ssh, müssen Sie einen ssh-agent laufen zu allow password-less login mit ssh.

    Aber dann, hoffentlich funktioniert es... wenn Ihr die Funktion code transportiert werden können, kann über die remote-host mit dill.source.importable.

    FYI, pathos ist überfällig, eine Veröffentlichung, und im Grunde, es gibt ein paar bugs und interface-änderungen, die gelöst werden müssen, bevor eine neue stabile Version ist geschnitten.

    • Ich sollte erwähnen, ich bin der pathos Autor.
    • Ich würde Sie ermutigen, zu erstellen eine detaillierte setup-guide von Anfang bis Ende, so dass nach dem ausführen einer server.py Datei auf dem server und ein client.py Datei auf dem client, der client tatsächlich Zugriff auf die server, und führen Sie einen job, gebündelt über die client-und die server. Nach dem Lesen dieser Antwort und Ihrer Antwort auf meine andere Frage ich bin noch nicht sicher, wie (a) einrichten der server oder (b) aufbauen einer sicheren Verbindung zum server.
    • Ich habe keine Ahnung, wie zu tun ist (ein). Macht den server einrichten, nur meine server, die ausgeführt wird, python, wenn der SSH-Authentifizierung korrekt ist? Ich glaube, dass Sie davon ausgehen, (b) behandelt wird, die außerhalb des python durch openSSH? In dem Beispiel, das Sie Ihnen scheinen, um die Verbindung herzustellen, aber dann die tunnel Objekt wird nie wieder benutzt und remote.computer.com ist nicht enthalten in der next pool, die Sie erstellen. Es wird in der "statt, die Sie konfigurieren können für eine direkte Verbindung (kein ssh)" aber ich verstehe wirklich nicht, wie das funktioniert, denn ohne SSH wie kann ich die Authentifizierung gegenüber dem server?
    • Wenn Sie erstellen einen tunnel, der tunnel links einen lokalen port einen remote-port. So, Ihr computer muss nur senden Sie alle Anfragen an einen lokalen port, und der tunnel zu leiten, um den remote-server für Sie-mit SSH. Sie müssen nur SSH zum einrichten des Tunnels, so musst es nur einmal. Ab dann können Sie die Leitung unsichere Kommunikation über einen sicheren tunnel durch die Kommunikation mit Ihren eigenen lokalen port. Wenn Sie nicht mit einem tunnel, Sie müssen Sie sagen, der pool für die Verbindung zum remote-server. Blick auf einige Unterlagen, wie man einen ssh-tunnel funktioniert. Pathos stellt nur für Sie.
    • Wenn Sie mit pp zu sprechen, um die remote-server müssen Sie eine ppserver läuft auf dem remote-host. Wenn Sie etwas anderes (zmq, ...), dann benötigen Sie einen server dieser Art zu laufen. Pathos hat einige code, können Sie einen server für Sie auf einem remote-host, aber es ist nicht völlig robust, dass Sie brauchen, um zu speichern Sie die jobid Referenz, es herunterzufahren, oder sonst müssen Sie sich dort einloggen und herausfinden, welche Laufenden job ist Ihr server. Sie können dies aus der Ferne mit pathos, aber es ist nicht wirklich etwas ein, Sie würden wollen, um in zu erhalten, wenn Sie sich nicht wohlfühlen töten unix-Prozesse.
    • Ich Schreibe etwas, im tutorial-Stil, es gibt definitiv Raum für Verbesserungen in der Dokumentation von use cases. Ich werde wahrscheinlich link, um etwas über SSH-tunneling (und auch der Einrichtung eines remote-hosts). Wenn Sie wissen wollen, was die ssh-tunnel zu tun, können Sie leicht überprüfen, die __repr__ des Tunnels... es zeigt den Befehl, der pathos ist mit unter der Decke. Mit, dass, können Sie die SSH-docs, um zu sehen, was der Befehl tut.
    • haben Sie jemals schreiben, dass tutorial? Ich bin daran interessiert, verteilte Karte, aber die Dokumentation lässt sehr zu wünschen übrig
    • Angefangen hier: github.com/mmckerns/tuthpc, aber es ist in keiner Weise noch zu vervollständigen.

    InformationsquelleAutor Mike McKerns
  3. 9

    Ein wenig spät zur party hier, aber da war ich auch auf der Suche für eine ähnliche Lösung, und diese Frage noch nicht als beantwortet markiert, ich dachte, ich würde tragen meine Erkenntnisse.

    Landete ich mit SCOOP. Es bietet eine parallele map-Implementierung, die können die Arbeit auf mehrere Kerne, über mehrere hosts hinweg. Es können auch wieder zurückgehen, um Python-serial map - Funktion, wenn gewünscht, während der Anrufung.

    Vom SCOOP-Einführung Seite, es führt die folgenden Funktionen:

    SCOOP-features und Vorteile gegenüber futures, multiprocessing und
    ähnliche Module sind wie folgt:

    • Nutzen Sie die Leistung von mehreren Computern über das Netzwerk;
    • Fähigkeit zum laichen mehrere Aufgaben innerhalb einer Aufgabe;
    • API-kompatibel mit PEP-3148;
    • Parallelisierung serieller code mit nur geringen änderungen;
    • Effiziente load-balancing.

    Es hat einige Macken (Funktionen/Klassen müssen pickleable), und das setup, um die Dinge reibungslos laufen über mehrere hosts hinweg mühsam sein kann, wenn Sie nicht alle teilen die gleichen filesystem-schema, aber insgesamt bin ich Recht zufrieden mit den Ergebnissen. Für unsere Zwecke tut ziemlich viel von Numpy & Cython, es bietet eine hervorragende performance.

    Hoffe, das hilft.

    • SCOOP ist weniger fähig, aber besser unterstützt als Paket pathos... aber dennoch ist es keine schlechte Wahl. Soweit ich weiß, pathos und SCOOP sind nur zwei solcher Pakete, hierarchische parallele/verteilte Karten.
    • Vielen Dank für diese Anregung. Können Sie sagen, ein wenig mehr / haben Sie Beispiel-code für das abrufen von mehreren Knoten ausgeführt? Dieser link ist die nächste Sache, die ich finden konnte, um wirklich zu kommen, ist es eingerichtet und läuft über mehrere Maschinen, aber es ist völlig unzureichend. scoop.readthedocs.org/en/0.7/install.html#remote-usage
    • Ich habe auch gesehen, Apache Spark. Können Sie erklären, wie, das unterscheidet sich von pathos (oder SCHAUFEL)?
    • Immer mehrere Knoten-setup ist nicht so schwierig. Die Dokumentation [hier] (scoop.readthedocs.org/en/0.7/...) umfasst, die unter Hostfile format. Allerdings sicherstellen, dass der master(broker) und alle remote-hosts haben genau die gleiche Verzeichnis-layout, code, Abhängigkeiten, sowie Zugang zu externen Daten wird helfen, machen die Dinge leichter und sparen Sie viel debugging-Zeit. Es unserem Fall war es sinnvoll, rsync Daten und code, um alle worker-hosts vor dem Start. Die SCOOP-community ist klein, aber auch hilfreich als gut.
    • Wir sahen uns auch Funken -, Sellerie -, Krug, - und ein paar andere. Angesichts der kleinen Forscher-team und bare-metal-wir haben, mit zu arbeiten, suchten wir nach Lösungen, die nicht verlangen, ein anderes Programmier-Paradigma, erhebliche Umgestaltung, noch einige andere server-Prozess, den wir benötigen, um admin auf alle worker-hosts. Wir waren einfach mit dem Ziel für die meisten Kosten-effektiv (in Bezug auf Zeit) Weg zu parallelisieren komplexen code, der bereits dort war.
    • Apache spark wurde ursprünglich in Berkeley, und ist nun Apache. Es ist Teil eines größeren ökosystems, und ist sehr stabil, und mehr breit abgestützt, als pathos oder SCOOP. Es bietet Parallelität auf viele verschiedene backends, jedoch glaube ich nicht, es bietet hierarchisch parallel, wie pathos und SCOOP tun.
    • wurde speziell gebaut, um die gleiche API für parallele und verteilte backends, so dass Sie nicht haben, um zu Bearbeiten dein code zum Umschalten von parallel-verteilten, oder threads zu Prozessoren auf sockel. Die Idee ist, den code mit einem map, pipe etc Art der Konstrukte, die in standard-python.... und Sie müssen nicht ändern Sie Ihren code wirklich auf allen zu gehen, um verteilte/parallele. pathos ist wohl der einfachste in diesem Zusammenhang, wie das ist, wie es entworfen war, um zu arbeiten.
    • Ich glaube SCOOP hat eine ähnliche Philosophie, aber erfordert etwas mehr Aufwand für die parallele Programmiermodelle. Im wesentlichen, sowohl Sie als auch pathos betreiben, auf die Idee der Einrichtung und Durchführung eines AST. Die pathos' API ist nahezu identisch mit der multiprocessing --- aber funktioniert für beliebige backends.
    • Wir parallelisiert unseren code auf SCOOP mit buchstäblich zwei Zeilen code. Eine Zeile für den import-Anweisung (from scoop import futures) und das andere ersetzen von Python ' s built-in serielle Karte mit SCOOP-Karte (futures.map(func,arraydata)). Könnte nicht einfacher sein.
    • Ich weiß, wie einfach es ist, mit SCOOP, und es ist nicht immer so einfach, wie die beiden obigen Zeilen. Das ist das, was ein "Programmiermodell" macht, es macht Parallelität transparent. Was ich damit sagen will ist, dass pathos hat die gleichen zwei line-Philosophie, aber pathos hat mehr Fälle, die es behandeln kann, wo es wirklich funktioniert in zwei Zeilen... wo Sie nicht haben, ändern Sie Ihren code auf alle von serial-nur import-und überlastung der map ich bin froh, dass Sie hatte eine gute Erfahrung mit SCOOP. Es ist ein gutes Paket. Wenn ich hätte, etwas zu verwenden, abgesehen von pathos, das ist, was würde ich wählen.

    InformationsquelleAutor bazel
  4. 0

    Haben Sie sah disco?

    Features:

    • Map /reduce-Paradigma
    • Python-Programmierung
    • Distributed shared disk
    • ssh darunterliegenden transport -
    • web-und Konsolen-Schnittstellen
    • leicht zu hinzufügen/sperren/löschen eines Knotens
    • master starten Sklaven Knoten ohne eingreifen des Benutzers
    • Sklaven Knoten werden automatisch neu gestartet, im Falle des Scheiterns
    • schöne Dokumentation. Nach der Install Guide ich war in der Lage zu starten, ein 2-Rechner-cluster in ein paar Minuten (das einzige, was ich tun müssen, war die Schaffung von $DISCO_HOME/root-Ordner, um die Verbindung zu der Firmware, ich denke, aufgrund der log-Datei-Fehler Schöpfung).

    Einem einfachen Beispiel aus der disco in der Dokumentation:

    from disco.core import Job, result_iterator

def map(line, params):
    for word in line.split():
        yield word, 1

def reduce(iter, params):
    from disco.util import kvgroup
    for word, counts in kvgroup(sorted(iter)):
        yield word, sum(counts)

if __name__ == '__main__':
    job = Job().run(input=["http://discoproject.org/media/text/chekhov.txt"],
                    map=map,
                    reduce=reduce)
    for word, count in result_iterator(job.wait(show=True)):
        print(word, count)
    InformationsquelleAutor asterio gonzalez
Schreibe einen Kommentar