Erstellen Sie Ihre eigene Grafikverarbeitungsanwendung in Giraph


    Seien Sie mein Freund von oosDesign

    Große Internetunternehmen stehen häufig vor so komplexen Aufgaben wie der Verarbeitung von Big Data und der Analyse von Diagrammen sozialer Netzwerke. Die Frameworks helfen bei der Lösung, aber zuerst müssen Sie die möglichen Optionen analysieren und die richtige auswählen. Im Labor der Technosphere Mail.Ru untersuchen wir diese Probleme anhand von Beispielen aus Projekten der Mail.Ru-Gruppe (myTarget, Mail.Ru Search, Antispam). Aufgaben können sowohl rein praktisch als auch mit einer Forschungskomponente sein. Basierend auf einer dieser Aufgaben wurde dieser Artikel veröffentlicht.

    Während der Montage und des Starts ihres ersten Giraph-Projekts hatten die Mitarbeiter des Mail.Ru-Labors für die Datenanalyse in der Technosphäre mit einer Reihe von Problemen zu kämpfen. Dies führte zu der Idee, ein kurzes Tutorial zum Erstellen und Starten ihres ersten Giraph-Projekts zu schreiben.

    In diesem Artikel erfahren Sie, wie Sie Ihre eigenen Anwendungen für das Giraph-Framework erstellen, das ein Add-On für das beliebte Hadoop-Datenverarbeitungssystem ist.

    0. Was ist ein Giraph


    Giraph ist ein umfangreiches, grafisch iteratives Framework, das auf dem sehr beliebten verteilten Hadoop-Datenverarbeitungssystem aufbaut. So wie der Anstoß für Hadoop und HDFS von einem Google-Artikel zum Konzept von MapReduce und GFS (Google File System) kam, erschien Giraph als Open-Source-Version von Googles Pregel, über den 2010 ein Artikel veröffentlicht wurde. Giraph wird von großen Unternehmen wie Facebook verwendet , um Grafiken zu verarbeiten.

    Was zeichnet Giraph aus? Sein Haupttrick ist das sogenannte Vertex-Centric-Modell. Wie in Practical Graph Analytics mit Apache Giraph geschrieben :
    Bei diesem Modell muss sich der Entwickler in den Peaks befinden, damit zwischen den Iterationen Nachrichten mit anderen Peaks ausgetauscht werden können. Während der Entwicklung müssen Sie sich nicht mit den Problemen der Parallelisierung und Skalierung befassen - genau das macht Giraph.

    Die Verarbeitung von Giraph-Graphen sieht wie folgt aus: Der Prozess ist in Iterationen unterteilt, die als Supersteps bezeichnet werden. Bei jedem Superstep führt der Vertex das erforderliche Programm aus und kann bei Bedarf Nachrichten an andere Vertices senden. Bei der nächsten Iteration empfängt der Vertex Nachrichten, führt das Programm aus, sendet Nachrichten usw. Nach Abschluss aller Superschritte erhalten Sie den resultierenden Graphen.

    Giraph unterstützt eine Vielzahl von Optionen für die Interaktion mit dem Diagramm, darunter das Erstellen / Löschen von Scheitelpunkten, das Erstellen / Löschen von Kanten, die Möglichkeit, das Format zu überschreiben, in dem das Diagramm angegeben oder aus vorhandenen ausgewählt wird, das Laden von der Festplatte zu steuern und Teile des Diagramms während der Arbeit auf die Festplatte zu entladen und vieles mehr. Weitere Informationen finden Sie unter Praktische Diagrammanalyse mit Apache Giraph.

    1. Benötigte Software


    Zuerst brauchst du Hadoop selbst. Wenn Sie mit Hadoop keinen Zugriff auf einen Cluster haben, können Sie dessen Einzelknotenversion bereitstellen. Es ist nicht sehr ressourcenintensiv, es funktioniert leise auf einem Laptop. Hierzu können Sie beispielsweise die Hadoop-Distribution namens Cloudera verwenden. Die Cloudera Installationsanleitung finden Sie hier . Während der Entwicklung und des Testens wurde in diesem Artikel Cloudera 5.5 (Hadoop 2.6.0) verwendet.

    Giraph ist in Java implementiert. Beim Erstellen von Projekten wird der Maven- Build-Manager verwendet . Der Quellcode von Giraph kann von der offiziellen Website heruntergeladen werden . Eine Anleitung zum Kompilieren von Giraph selbst und die dazugehörigen Beispiele finden Sie hier und in der Kurzanleitung .

    Jede IDE wie Eclipse oder IntelliJ IDEA kann mit Maven in Projekten arbeiten, was während der Entwicklung sehr praktisch ist. Wir haben in unseren Experimenten IntelliJ IDEA verwendet.

    2. Giraph kompilieren


    Beginnen wir mit dem Kompilieren des Inhalts der Giraph-Quellen und versuchen, etwas auszuführen. Führen Sie, wie in den Anweisungen erwähnt , im Ordner mit dem Giraph-Projekt den folgenden Befehl aus:

    mvn -Phadoop_2 -fae -DskipTests clean install
    

    Und wir warten eine Weile, bis alles fertig ist ... Die gesammelten JAR-Dateien erscheinen im Ordner giraph-examples / target, wir benötigen giraph-examples-1.2.0-SNAPSHOT-for-hadoop-2.5.1-jar-with-dependencies. Glas.

    Lassen Sie uns beispielsweise SimpleShortestPathsComputation ausführen . Zuerst brauchen wir eine Datei mit Eingabedaten. Nehmen Sie ein Beispiel aus der Kurzanleitung :

    [0,0,[[1,1],[3,3]]]
    [1,0,[[0,1],[2,2],[3,1]]]
    [2,0,[[1,2],[4,4]]]
    [3,0,[[0,3],[1,1],[4,4]]]
    [4,0,[[3,4],[2,4]]]
    

    Speichern Sie dies in tiny_graph.txt und speichern Sie es in HDFS in unserem lokalen Ordner:

    hdfs dfs -put ./tiny_graph.txt ./
    

    Mit diesem Befehl wird die Datei in Ihr lokales Verzeichnis verschoben. Sie können dies überprüfen, indem Sie den Inhalt der Datei anzeigen:

    hdfs dfs -text tiny_graph.txt
    

    Ok, alles ist cool und jetzt fangen wir an:

    hadoop jar \
    giraph-examples-1.2.0-SNAPSHOT-for-hadoop-2.5.1-jar-with-dependencies.jar \
    org.apache.giraph.GiraphRunner \
    org.apache.giraph.examples.SimpleShortestPathsComputation \
    -vif org.apache.giraph.io.formats.JsonLongDoubleFloatDoubleVertexInputFormat \
    -vip tiny_graph.txt \
    -vof org.apache.giraph.io.formats.IdWithValueTextOutputFormat \
    -op shortestpaths \
    -w 1 
    

    Mal sehen, was hier geschrieben steht:

    • hadoop jar giraph-examples-1.2.0-SNAPSHOT-for-hadoop-2.5.1-jar-with-dependencies.jar - Dieser Teil des Befehls weist Khadup an, die JAR-Datei auszuführen.
    • org.apache.giraph.GiraphRunnerIst der Name des Rangers. Hier wird die Standardeinstellung verwendet. Rahner kann neu definiert werden. Damit er zum Beispiel beim Start alte Daten löscht oder andere vorbereitende Aktionen durchführt. Weitere Informationen hierzu finden Sie in dem Buch Practical Graph Analytics with Apache Giraph;
    • org.apache.giraph.examples.SimpleShortestPathsComputation - eine Klasse, die die auszuführende Rechenmethode enthält;
    • -vifDefiniert die Klasse, die die Eingabedatei mit Scheitelpunkten liest. Diese Klasse wird abhängig vom Format der Eingabedatei ausgewählt und kann unterschiedlich sein. Sie kann bei Bedarf sogar überschrieben werden (siehe Praktische Diagrammanalyse mit Apache Giraph). Eine Beschreibung der Standardklassen finden Sie hier ;
    • -vip - Pfad zur Eingabedatei, die Beschreibungen der Eckpunkte enthält;
    • -vof- In welchem ​​Format wird das Arbeitsergebnis gespeichert? Falls gewünscht, neu definiert, Beschreibungen der Standardklassen siehe hier ;
    • -op - wo zu speichern;
    • -w - die Anzahl der Arbeiter (Prozesse, die das Diagramm vertikal verarbeiten).

    Weitere Informationen zu Startoptionen erhalten Sie, indem Sie Folgendes in die Konsole eingeben:

    hadoop jar \
    giraph-examples-1.2.0-SNAPSHOT-for-hadoop-2.5.1-jar-with-dependencies.jar \
    org.apache.giraph.GiraphRunner \
    org.apache.giraph.examples.SimpleShortestPathsComputation  -h
    

    Nach dem Start können wir das Ergebnis auf kürzesten Wegen lesen

    hdfs dfs -text shortestpaths/*
    

    3. Erstellen Sie Ihr eigenes Projekt


    Schreiben wir nun eine Anwendung, die den Grad der Eckpunkte in einem ungerichteten Diagramm berechnet. Ich erstelle ein neues Maven-Projekt. Wie das geht, steht zum Beispiel hier . Füllen Sie die Datei pom.xml im Stammverzeichnis des Projekts wie folgt aus:

    4.0.0ru.simple.giraph.project.orgsimple-giraph-project1.0-SNAPSHOTcloudera
                    https://repository.cloudera.com/artifactory/cloudera-repos/
                2.6.0-cdh5.5.1maven-assembly-plugin2.4simple-giraph-project
                            ${project.basedir}/src/main/assembly/single-jar.xml
                        singlepackageorg.apache.hadoophadoop-client${org.apache.hadoop.version}org.apache.hadoophadoop-common${org.apache.hadoop.version}org.apache.giraphgiraph-core1.1.0-hadoop2com.google.guavaguava19.0

    Um zu erfahren , wie eine Pom-Dateien und die Arbeit mit dem Maven erstellen, können Sie in der offiziellen Haidee lesen hier . Danach erstelle ich in src eine neue ComputationDegree.java-Datei. Dies wird unsere Klasse sein, die Vertexgrade berücksichtigt:

    /**
     * This is a simple implementation of vertex degree computation.
     */
    package ru.simple.giraph.project.org;
    import com.google.common.collect.Iterables;
    import org.apache.giraph.graph.BasicComputation;
    import org.apache.giraph.graph.Vertex;
    import org.apache.hadoop.io.IntWritable;
    import org.apache.hadoop.io.NullWritable;
    import org.apache.hadoop.io.Text;
    import java.io.IOException;
    public class ComputeDegree extends
            BasicComputation {
        public void compute(Vertex vertex, Iterable iterable) throws IOException {
            if (getSuperstep() == 0){
                sendMessageToAllEdges(vertex, new Text());
            } else if (getSuperstep() == 1){
                Integer degree = Iterables.size(vertex.getEdges());
                vertex.setValue(new IntWritable(degree));
            }else{
                vertex.voteToHalt();
            }
        }
    }
    

    Das funktioniert so:

    1. Im ersten Schritt sendet jeder Vertex Nachrichten an seine Nachbarn.
    2. Jeder Vertex zählt die Anzahl der eingehenden Nachrichten und speichert sie im Vertex-Wert.
    3. Alle Eckpunkte stimmen ab, um die Berechnung zu beenden.

    Am Ausgang haben wir ein Diagramm, das den Grad des Scheitelpunkts im Wert des Scheitelpunkts speichert. Wir kompilieren mit dem Befehl:

    mvn package -fae -DskipTests clean install
    

    In der Regel wird nach der Kompilierung der Zielordner erstellt, in dem sich die Datei giraph-test-fatjar.jar befindet. Diese Datei werden wir ausführen. Nehmen wir ein sehr einfaches Diagramm, zum Beispiel dieses:



    Wir verwenden org.apache.giraph.io.formats.IntIntNullTextVertexInputFormat als Eingabedatenformat , sodass die Datei, die unser Diagramm beschreibt, folgendermaßen aussieht:

    0	0	1	2	3
    1	0	0	2
    2	0	0	1
    3	0	0
    

    Wir speichern es in der Datei example_graph.txt, setzen es auf HDFS und führen unser Programm aus:

    hadoop jar ./target/giraph-test-fatjar.jar org.apache.giraph.GiraphRunner \
    ru.giraph.test.org.ComputeDegree \
    -vif org.apache.giraph.io.formats.IntIntNullTextVertexInputFormat \
    -vip example_graph.txt \
    -vof org.apache.giraph.io.formats.IdWithValueTextOutputFormat \
    -op degrees \
    -w 1
    

    Wir schauen uns das Ergebnis an:

    hdfs dfs -text degrees/*
    

    Und wir sehen so etwas:

    0	3
    2	2
    1	2
    3	1
    

    In diesem Artikel haben wir also gelernt, wie man Giraph kompiliert, und unsere eigene kleine Anwendung geschrieben. Und das ganze Projekt kann hier heruntergeladen werden .

    Im nächsten Artikel werden wir uns mit der Arbeit mit Giraph am Beispiel des eingeschränkten Boltzmann-Algorithmus für maschinelles Lernen befassen. Wir werden versuchen, den Algorithmus so weit wie möglich zu beschleunigen, um die Feinheiten des Giraph-Setups zu verstehen und zu bewerten, wie bequem und effizient dieses System ist.

    Jetzt auch beliebt: