Download presentation
Presentation is loading. Please wait.
Published byBuddy Matthews Modified over 9 years ago
1
From Graphs to Tables: The Design of Scalable Systems for Graph Analytics Joseph E. Gonzalez Post-doc, UC Berkeley AMPLab jegonzal@eecs.berkeley.edu Co-founder, GraphLab Inc. joseph@graphlab.com WWW’14 Workshop on Big Graph Mining *These slides are best viewed in PowerPoint with animation.
2
Graphs are Central to Analytics Raw Wikipedia XML HyperlinksPageRankTop 20 Pages TitlePR Text Table TitleBody Topic Model (LDA) Word Topics WordTopic Editor Graph Community Detection User Community UserCom. Term-Doc Graph Discussion Table UserDisc. Community Topic Com.
3
Update ranks in parallel Iterate until convergence Rank of user i Sum of neighbors 3 PageRank: Identifying Leaders
4
Ratings Item s Recommending Products Users
5
Low-Rank Matrix Factorization: 5 r 13 r 14 r 24 r 25 f(1) f(2) f(3) f(4) f(5) User Factors (U) Movie Factors (M) User s Movie s Netflix User s ≈ x Movie s f(i) f(j) Iterate: Recommending Products
6
Liberal Conservative Post Predicting User Behavior Post ? ? ? ? ? ? ? ? ? ? ? ? ? ? ? ? ? ? ? ? ? ? ? ? ? ? ? ? ? ? 6 Conditional Random Field Belief Propagation
7
Post Mean Field Algorithm Y2Y2 Y1Y1 Y3Y3 X2X2 X3X3 X1X1 Sum over Neighbors
8
Count triangles passing through each vertex: Measures “cohesiveness” of local community 1 2 3 4 Finding Communities
9
The Graph-Parallel Pattern 9 Model / Alg. State Model / Alg. State Computation depends only on the neighbors
10
Many Graph-Parallel Algorithms Collaborative Filtering –Alternating Least Squares –Stochastic Gradient Descent –Tensor Factorization Structured Prediction –Loopy Belief Propagation –Max-Product Linear Programs –Gibbs Sampling Semi-supervised M L –Graph SSL –CoEM Community Detection –Triangle-Counting –K-core Decomposition –K-Truss Graph Analytics –PageRank –Personalized PageRank –Shortest Path –Graph Coloring Classification –Neural Networks 10
11
Graph-Parallel Systems 11 Expose specialized APIs to simplify graph programming.
12
The Pregel (Push) Abstraction Vertex-Programs interact by sending messages. i i Pregel_PageRank(i, messages) : // Receive all the messages total = 0 foreach( msg in messages) : total = total + msg // Update the rank of this vertex R[i] = 0.15 + total // Send new messages to neighbors foreach(j in out_neighbors[i]) : Send msg(R[i]) to vertex j 12 Malewicz et al. [PODC’09, SIGMOD’10]
13
The GraphLab (Pull) Abstraction Vertex Programs directly access adjacent vertices and edges GraphLab_PageRank(i) // Compute sum over neighbors total = 0 foreach( j in neighbors(i)): total = total + R[j] * w ji // Update the PageRank R[i] = 0.15 + total 13 R[4] * w 41 R[3] * w 31 R[2] * w 21 + + 4 4 1 1 3 3 2 2 Data movement is managed by the system and not the user.
14
Barrier Iterative Bulk Synchronous Execution ComputeCommunicate
15
Graph-Parallel Systems 15 Exploit graph structure to achieve orders-of-magnitude performance gains over more general data-parallel systems.
16
Real-World Graphs 16 Top 1% of vertices are adjacent to 50% of the edges! More than 10 8 vertices have one neighbor. Number of Vertices AltaVista WebGraph1.4B Vertices, 6.6B Edges Degree -Slope = α ≈ 2 Power-Law Degree Distribution Edges >> Vertices
17
Challenges of High-Degree Vertices Touches a large fraction of graph Sequentially process edges 17 CPU 1 CPU 2 Provably Difficult to Partition
18
Machine 1 Machine 2 Split High-Degree vertices New Abstraction Equivalence on Split Vertices 18 Program This Run on This
19
Machine 2 Machine 1 Machine 4 Machine 3 GAS Decomposition Σ1Σ1 Σ1Σ1 Σ2Σ2 Σ2Σ2 Σ3Σ3 Σ3Σ3 Σ4Σ4 Σ4Σ4 + + + Y Y YY Y’ Σ Σ Gather Apply Scatter 19 Master Mirror
20
Minimizing Communication in PowerGraph Y YY 20 Vertex Cut Communication is linear in the number of machines each vertex spans. Total communication upper bound:
21
Shrinking Working Sets 51% of vertices run only once! PageRank on Web Graph
22
The GraphLab (Pull) Abstraction Vertex Programs directly access adjacent vertices and edges GraphLab_PageRank(i) // Compute sum over neighbors total = 0 foreach( j in neighbors(i)): total = total + R[j] * w ji // Update the PageRank R[i] = 0.15 + total 22 R[4] * w 41 R[3] * w 31 R[2] * w 21 + + 4 4 1 1 3 3 2 2 GraphLab_PageRank(i) // Compute sum over neighbors total = 0 foreach( j in neighbors(i)): total = total + R[j] * w ji // Update the PageRank R[i] = 0.15 + total // Trigger neighbors to run again if R[i] not converged then signal nbrsOf(i) to be recomputed Trigger computation only when necessary.
23
PageRank on the Live-Journal Graph GraphLab is 60x faster than Hadoop GraphLab is 16x faster than Spark
24
Counted: 34.8 Billion Triangles 24 Triangle Counting on Twitter 64 Machines 15 Seconds 1536 Machines 423 Minutes Hadoop [WWW’11] S. Suri and S. Vassilvitskii, “Counting triangles and the curse of the last reducer,” WWW’11 1000 x Faster 40M Users, 1.4 Billion Links
25
Graph Analytics Pipeline Raw Wikipedia XML HyperlinksPageRankTop 20 Pages TitlePR Text Table TitleBody Topic Model (LDA) Word Topics WordTopic Editor Graph Community Detection User Community UserCom. Term-Doc Graph Discussion Table UserDisc. Community Topic Com.
26
Tables Raw Wikipedia XML HyperlinksPageRankTop 20 Pages TitlePR Text Table TitleBody Topic Model (LDA) Word Topics WordTopic Editor Graph Community Detection User Community UserCom. Term-Doc Graph Discussion Table UserDisc. Community Topic Com.
27
Graphs Raw Wikipedia XML HyperlinksPageRankTop 20 Pages TitlePR Text Table TitleBody Topic Model (LDA) Word Topics WordTopic Editor Graph Community Detection User Community UserCom. Term-Doc Graph Discussion Table UserDisc. Community Topic Com.
28
Separate Systems to Support Each View Table ViewGraph View Dependency Graph Table Resul t Row
29
Separate systems for each view can be difficult to use and inefficient 29
30
Difficult to Program and Use Users must Learn, Deploy, and Manage multiple systems Leads to brittle and often complex interfaces 30
31
Inefficient 31 Extensive data movement and duplication across the network and file system XML HDFS Limited reuse internal data-structures across stages
32
Solution: The GraphX Unified Approach Enabling users to easily and efficiently express the entire graph analytics pipeline New API Blurs the distinction between Tables and Graphs New System Combines Data-Parallel Graph-Parallel Systems
33
Tables and Graphs are composable views of the same physical data GraphX Unified Representation GraphX Unified Representation Graph ViewTable View Each view has its own operators that exploit the semantics of the view to achieve efficient execution
34
View a Graph as a Table Id Rxin Jegonzal Franklin Istoica SrcIdDstId rxinjegonzal franklinrxin istoicafranklin jegonzal Property (E) Friend Advisor Coworker PI Property (V) (Stu., Berk.) (PstDoc, Berk.) (Prof., Berk) R J F I Property Graph Vertex Property Table Edge Property Table
35
Table Operators Table (RDD) operators are inherited from Spark: 35 map filter groupBy sort union join leftOuterJoin rightOuterJoin reduce count fold reduceByKey groupByKey cogroup cross zip sample take first partitionBy mapWith pipe save...
36
class Graph [ V, E ] { def Graph(vertices: Table[ (Id, V) ], edges: Table[ (Id, Id, E) ]) // Table Views ----------------- def vertices: Table[ (Id, V) ] def edges: Table[ (Id, Id, E) ] def triplets: Table [ ((Id, V), (Id, V), E) ] // Transformations ------------------------------ def reverse: Graph[V, E] def subgraph(pV: (Id, V) => Boolean, pE: Edge[V,E] => Boolean): Graph[V,E] def mapV(m: (Id, V) => T ): Graph[T,E] def mapE(m: Edge[V,E] => T ): Graph[V,T] // Joins ---------------------------------------- def joinV(tbl: Table [(Id, T)]): Graph[(V, T), E ] def joinE(tbl: Table [(Id, Id, T)]): Graph[V, (E, T)] // Computation ---------------------------------- def mrTriplets(mapF: (Edge[V,E]) => List[(Id, T)], reduceF: (T, T) => T): Graph[T, E] } Graph Operators 36
37
Triplets Join Vertices and Edges The triplets operator joins vertices and edges: The mrTriplets operator sums adjacent triplets. SELECT t.dstId, reduce( map(t) ) AS sum FROM triplets AS t GROUPBY t.dstId TripletsVertices B A C D Edges AB AC BC CD AB AB AC BC CD SELECT s.Id, d.Id, s.P, e.P, d.P FROM edges AS e JOIN vertices AS s, vertices AS d ON e.srcId = s.Id AND e.dstId = d.Id
38
We express enhanced Pregel and GraphLab abstractions using the GraphX operators in less than 50 lines of code! 38
39
Enhanced to Pregel in GraphX 39 Malewicz et al. [PODC’09, SIGMOD’10] pregelPR(i, messageList ): // Receive all the messages total = 0 foreach( msg in messageList) : total = total + msg // Update the rank of this vertex R[i] = 0.15 + total // Send new messages to neighbors foreach(j in out_neighbors[i]) : Send msg(R[i]/E[i,j]) to vertex Require Message Combiners messageSum Remove Message Computation from the Vertex Program Remove Message Computation from the Vertex Program sendMsg(i j, R[i], R[j], E[i,j]): // Compute single message return msg(R[i]/E[i,j]) combineMsg(a, b): // Compute sum of two messages return a + b
40
Implementing PageRank in GraphX 40 // Load and initialize the graph val graph = GraphBuilder.text(“hdfs://web.txt”) val prGraph = graph.joinVertices(graph.outDegrees) // Implement and Run PageRank val pageRank = prGraph.pregel(initialMessage = 0.0, iter = 10)( (oldV, msgSum) => 0.15 + 0.85 * msgSum, triplet => triplet.src.pr / triplet.src.deg, (msgA, msgB) => msgA + msgB)
41
We express the Pregel and GraphLab like abstractions using the GraphX operators in less than 50 lines of code! 41 By composing these operators we can construct entire graph-analytics pipelines.
42
Example Analytics Pipeline // Load raw data tables val verts = sc.textFile(“hdfs://users.txt”).map(parserV) val edges = sc.textFile(“hdfs://follow.txt”).map(parserE) // Build the graph from tables and restrict to recent links val graph = new Graph(verts, edges) val recent = graph.subgraph(edge => edge.date > LAST_MONTH) // Run PageRank Algorithm val pr = graph.PageRank(tol = 1.0e-5) // Extract and print the top 25 users val topUsers = verts.join(pr).top(25).collect topUsers.foreach(u => println(u.name + ‘\t’ + u.pr))
43
GraphX System Design
44
Part. 2 Part. 1 Vertex Table (RDD) B B C C A A D D F F E E A A D D Distributed Graphs as Tables (RDDs) D D Property Graph B B C C D D E E A A A A F F Edge Table (RDD) A A B B A A C C C C D D B B C C A A E E A A F F E E F F E E D D B B C C D D E E A A F F Routing Table (RDD) B B C C D D E E A A F F 1 2 12 12 1 2 2D Vertex Cut Heuristic
45
Vertex Table (RDD) Caching for Iterative mrTriplets Edge Table (RDD) A A B B A A C C C C D D B B C C A A E E A A F F E E F F E E D D Mirror Cache B B C C D D A A Mirror Cache D D E E F F A A B B C C D D E E A A F F B B C C D D E E A A F F A A D D
46
Vertex Table (RDD) Edge Table (RDD) A A B B A A C C C C D D B B C C A A E E A A F F E E F F E E D D Mirror Cache B B C C D D A A Mirror Cache D D E E F F A A Incremental Updates for Iterative mrTriplets B B C C D D E E A A F F Change A A A A E E Scan
47
Vertex Table (RDD) Edge Table (RDD) A A B B A A C C C C D D B B C C A A E E A A F F E E F F E E D D Mirror Cache B B C C D D A A Mirror Cache D D E E F F A A Aggregation for Iterative mrTriplets B B C C D D E E A A F F Change Scan Change Local Aggregate Local Aggregate B B C C D D F F
48
Reduction in Communication Due to Cached Updates Most vertices are within 8 hops of all vertices in their comp.
49
Benefit of Indexing Active Edges Scan All Edges Index of “Active” Edges
50
Join Elimination Identify and bypass joins for unused triplet fields 50 Factor of 2 reduction in communication sendMsg(i j, R[i], R[j], E[i,j]): // Compute single message return msg(R[i]/E[i,j])
51
Additional Query Optimizations Indexing and Bitmaps: To accelerate joins across graphs To efficiently construct sub-graphs Substantial Index and Data Reuse: Reuse routing tables across graphs and sub- graphs Reuse edge adjacency information and indices 51
52
Performance Comparisons GraphX is roughly 3x slower than GraphLab Live-Journal: 69 Million Edges
53
GraphX scales to larger graphs GraphX is roughly 2x slower than GraphLab Scala + Java overhead: Lambdas, GC time, … No shared memory parallelism: 2x increase in comm. Twitter Graph: 1.5 Billion Edges
54
PageRank is just one stage…. What about a pipeline?
55
HDFS Compute Spark Preprocess Spark Post. A Small Pipeline in GraphX Timed end-to-end GraphX is faster than GraphLab Raw Wikipedia XML HyperlinksPageRankTop 20 Pages 605 375
56
Conclusion and Observations Domain specific views: Tables and Graphs tables and graphs are first-class composable objects specialized operators which exploit view semantics Single system that efficiently spans the pipeline minimize data movement and duplication eliminates need to learn and manage multiple systems Graphs through the lens of database systems Graph-Parallel Pattern Triplet joins in relational alg. Graph Systems Distributed join optimizations 56
57
Open Source Project Alpha release as part of Spark 0.9
58
Active Research Static Data Dynamic Data Apply GraphX unified approach to time evolving data Materialized view maintenance for graphs Serving Graph Structured Data Allow external systems to interact with GraphX Unify distributed graph databases with relational database technology 58
59
Collaborators Yucheng Low Aapo Kyrola Danny Bickson Alex Smola Haijie Gu GraphLab : Carlos Guestrin Guy Blelloch GraphX: Reynold Xin Ankur Dave Daniel Crankshaw Michael Franklin Ion Stoica
60
Thanks! jegonzal@eecs.berkeley.edu http://tinyurl.com/ampgraphx
Similar presentations
© 2024 SlidePlayer.com. Inc.
All rights reserved.