- 85 -
(100; 171) (250; 408) (500; 815) (750; 1,231) (1,000; 1,622) (Số Cạnh; Số Đỉnh)
- CHƯƠNG 5:
- KẾT LUẬN
- & HƯỚNG PHÁT TRIỀN
5.1. Những thách thức khi thực hiện đề tài
-Khi thực hiện đề tài tôi phải đối mặt với nhiều thách thức trong việc thu thập dữ liệu, tổ chức dữ liệu, làm việc với tập dữ liệu khá lớn, xử lý đồ thị... Nhưng cũng nhờ những thách thức đó đã giúp cho tơi tích lũy thêm nhiều kinh nghiệm.
-Do dữ liệu mạng trích dẫn các bài báo khoa học lấy từ web site https://aminer.org/citation ở dạng text file nên cần phải thực hiện việc xử lý text file để tổ chức và lưu trữ trong OrientDb Server. Hơn nữa, dữ liệu này có nhiều lỗi như: hai bài báo tham khảo lẫn nhau, bài báo tham khảo đến chính nó, bài báo xuất bản trước lại tham khảo đến bài báo xuất bản sau... Do đó phải thực hiện việc chuẩn hóa dữ liệu để loại bỏ các sai sót đó.
-Việc chuyển dữ liệu đồ thị từ OrientDb thành GraphX cũng là một vấn đề không đơn giản. Cần phải hiểu rõ OrientDb API để truy vấn dữ liệu, Apache Spark - GraphX API để tổ chức và xử lý đồ thị GraphX. Một thách thức không nhỏ là chuyển cơ sở dữ liệu đồ thị lớn từ OrientDb thành GraphX phải hiệu quả về thời gian và ít tốn bộ nhớ. Để giải quyết những thách thức đó tơi đã dành khá nhiều thời gian để nghiên cứu và thử nghiệm về Big Data, các kỹ thuật xử lý Big Data, ngơn ngữ lập trình Scala, OrientDb, Apache Spark - GraphX...
-Nội dung chính trong đề tài là xử lý và phân tích đồ thị GraphX như tính PageRank, tìm thành phần liên thơng, tìm sự lan tỏa của một bài báo theo thời gian... Việc làm chủ kỹ thuật xử lý đồ thị GraphX, thuật toán Pregel để giải quyết những vấn đề trên cũng là một thách thức không nhỏ.
-Việc xây dựng ứng dụng Web bằng Scala kết hợp với Play FrameWork cũng là một thách thức nhưng thú vị và đáng giá do đây là lần đầu tiên tiếp xúc với ngôn ngữ Scala và Play FrameWork.
-Một vấn đề rất thú vị nhưng không hề đơn giản là biểu diễn trực quan đồ thị bằng thư viện JavaScript VisJs. Tôi phải dành khá nhiều thời gian để nghiên cứu lý thuyết và thực nghiệm để có thể biểu diễn đồ thị trực quan, đẹp mắt và linh hoạt.
-Mặt khác, do khả năng phần cứng hạn chế nên tơi cũng gặp khó khăn khi xử lý khối lượng dữ liệu lớn như: thiếu bộ nhớ, tốc độ xử lý chậm... Việc giải quyết những thách thức đó cũng mang đến cho tơi nhiều kinh nghiệm trong thiết kế các thuật toán xử lý khối lượng dữ liệu lớn tiết kiệm bộ nhớ và tốc độ xử lý chấp nhận được.
-Mặc dù hầu hết các kỹ thuật trên mang đến nhiều thách thức nhưng thật sự rất đáng giá để trải nghiệm, rất bổ ích và thú vị. Có thể nói, mỗi thách thức đã giúp tơi tích lũy rất nhiều kinh nghiệm trong xử lý vấn đề. Cảm giác mỗi lần giải quyết được một thách thức thật sự không tệ.
5.2. Kinh nghiệm thu thập được khi thực hiện đề tài
-Sau khi thực hiện xong đề tơi đã tích lũy thêm rất nhiều tri thức và kinh nghiệm thực tế. Có thể nói tơi đã hiểu rõ và làm chủ được các kỹ thuật sau:
- Mạng trích dẫn và các vấn đề liên quan cần giải quyết.
- Cơ sở dữ liệu đồ thị và hệ quản trị cơ sở dữ liệu NoSQL đa mơ hình OrientDb.
- Big Data và những kỹ thuật xử lý liên quan như: Hadoop, Apache Spark, GraphX...
- Các kỹ thuật phân tích và xử lý đồ thị lớn bằng GraphX API và đặc biệt là thuật toán Pregel, thuật toán xử lý song song và giải quyết hầu hết những vấn đề trên đồ thị lớn.
- Ngơn ngữ lập trình Scala - ngơn ngữ lập trình hàm mạnh mẽ và hỗ trợ lập trình thơng minh.
- Xây dựng ứng dụng Web theo mơ hình MVC (Model - View - Controller) với Play FrameWork kết hợp với Scala.
- Biểu diễn trực quan đồ thị bằng thư viện JavaScript VisJs.
5.3. Ưu nhược điểm của hệ thống Citation Network Explorer
5.3.1. Nhược điểm của hệ thống
- Có nhiều phương pháp xác định tầm ảnh hưởng của một bài báo. Nhưng vì thời gian có hạn nên dự án chỉ tập trung vào các phương pháp:
- Tầm ảnh hưởng theo chiều rộng (hay tầm ảnh hưởng trực tiếp).
- Tầm ảnh hưởng của một bài báo theo chiều sâu (hay tầm ảnh hưởng gián tiếp).
- Độ lan tỏa của một bài báo.
- Dùng thuật toán PageRank.
-Để xây dựng hệ thống xử lý cơ sở dữ liệu đồ thị cực lớn (Big Data) hàng tỉ node cần phải có hệ thống Server Cluster gồm nhiều máy server mạnh. Do điều kiện kinh phí khơng cho phép nên chỉ triển khai dự án trên máy tính thơng thường. Vì thế độ lớn của cơ sở dữ liệu đồ thị cũng được giới hạn lại cho phù hợp với khả năng phần cứng của hệ thống.
5.3.2. Ưu điểm của hệ thống
-Hệ thống đã đạt được những ưu điểm quan trọng sau:
- Chuyển một đồ thị lớn từ OrientDb thành đồ thị trong GraphX với thời gian chấp nhận được và tiêu tốn bộ nhớ ở mức tối thiểu. Hệ thống cũng rất linh hoạt khi cho phép tải toàn bộ đồ thị hoặc một phần đồ thị từ OrientDb sang GraphX.
- Biểu diễn trực quan toàn bộ hoặc một phần đồ thị bằng thư viện JavaScript VisJs khá đẹp mắt và linh hoạt.
- tìm thành phần liên thơng chứa một bài báo, tìm sự lan tỏa của một
bài báo
theo thời gian...
- Có thể mở rộng và triển khai hệ thống trong môi trường thực tế trên OrientDb Server Cluster và Apache Spark Cluster để xử lý đồ thị cực lớn.
5.4. Hướng phát triển trong tương lai
- Để hệ thống Citation Network Explorer hoàn thiện và linh hoạt hơn nữa ta có thể thực hiện những việc sau:
- Bổ sung chức năng còn thiếu vào hệ thống.
- Cải tiến thuật tốn PageRank. Cụ thể, có thể xem xét thêm các yếu tố sự nổi tiếng, uy tín, học vị... của tác giả bài báo khi tính PageRank thay vì chỉ dựa vào số lượng tham khảo như hiện tại.
- Nghiên cứu và triển khai các phương pháp khác để xác định tầm ảnh hưởng của một bài báo như: Betweenness centrality, Closeness centrality, Eigenvector centrality, Degree centrality, Harmonic Centrality, Katz centrality...
- Nghiên cứu và triển khai các giải thuật phát hiện cộng đồng trên mạng trích dẫn như: Minimum-cut method, Hierarchical clustering, Girvan-Newman algorithm, Modularity maximization, Statistical inference, Clique-based methods...
- Mở rộng hệ thống để có thể xử lý cơ sở dữ liệu đồ thị cực lớn (very large graph) bằng cách triển khai OrientDb Server Cluster và Apache Spark Cluster trên các máy server thật sự.
- Kết hợp hệ thống với những hệ quản trị cơ sở dữ liệu đồ thị khác, như Neo4J, chứ không chỉ là OrientDb.
- TÀI LIỆU THAM KHẢO
1. Andlinger, P., 2015. Graph DBMS increased theirpopularity by 500% within
the last 2 years. [Online]
-Available at: http://db-engines.com/en/blog post//43
-[Accessed 2 4 2017].
2. Anon., n.d. Hadoop Tutorial. [Online]
-Available at: https://www.tutorialspoint.com/hadoop/hadoop introduction.htm [Accessed 10 9 2016].
3. Apache Spark API, 2017. Apache SparkAPI- Scala. [Online]
-Available at: http://spark.apache.org/docs/latest/api/scala/#package [Accessed 20 4 2017].
4. Apache Spark Docs, 2017. GraphX Programming Guide. [Online]
-Available at: http://spark.apache.org/docs/latest/graphx-programming- guide.html#pregel-api
-[Accessed 20 04 2017].
5. Batagelj, V., 2003. Efficient Algorithms for Citation Network Analysis.
6. Chambers, B., 2015. AnalyzingFlightData: A Gentle Introduction to GraphXin
Spark. [Online]
-Available at: http://sparktutorials.net/analỵzing-flight-data:-a-gentle-
-introduction-to-graphx-in-spark
-[Accessed 3 4 2017].
7. citnetexplorer.nl, 2016. CitNetExplorer. [Online]
-Available at: http://www.citnetexplorer.nl/ [Accessed 1 10 2016].
8. doc.akka.io, 2017. Basics and working with Flows. [Online]
-basics.html
- [Accessed 4 4 2017].
9. en.wikipedia.org, 2016. Citation network. [Online]
-Available at: https://en.wikipedia.org/wiki/Citation network [Accessed 2 4 2017].
10. en.wikipedia.org, 2017. PageRank. [Online]
-Available at: https://en.wikipedia.org/wiki/PageRank [Accessed 4 4 2017].
11.Eric Redmond, Jim R. Wilson, 2012. Seven Databases in Seven Days. Dallas, Texas - Raleigh, North Carolina: Pragmatic Bookshelf.
12.H. Karau, A. Konwinski, P. Wendell, M. Zaharia, 2015. Learning Spark. Sebastopol: O’Reilly Media, Inc..
13. Harzing, P. A.-W., 2016. Harzing.com. [Online]
-Available at: http://www.harzing.com/resources/publish-or-perish [Accessed 12 10 2016].
14. libraryguides.helsinki.fi, 2016. ResearchGuides. [Online]
-Available at: http://libraryguides.helsinki.fi/c.php?g=212738&p=1403623 [Accessed 12 10 2016].
15.M. Odersky, L. Spoon, B. Venners, 2007. Programming in Scala. Mountain View: Artima.
16.marketsandmarkets.com, 2016. Big DataMarket by Component (Software and
Services), Type (Structured, Semi-Structured and Unstructured), Deployment Model, Vertical, and Region (North America, Europe, Asia-Pacific, Latin America & Middle East andAfrica) - Global Forecast to 2021. [Online]
Available at: http://www.marketsandmarkets.com/Market-Reports/big-data- market-1068.html?gclid=CNDt78G gNMCFcEsvQod4IINFA
17. Michael S. Malak, Robin East, 2016. Spark GraphXin Action. New York: Manning Publications Co..
18. Min Chen, Shiwen Mao, Yunhao Liu, 2014. Big Data: A Survey. Springer
Science.
19. N.P. Hummon, P. Doreian, L.C. Freeman, 1990. Analyzing the Structure of the Centrality Productivity Literature Created Between 1948 and 1979.
20. N.P. Hummon, P. Doreian, 1989. Connectivity in a Citation Network: The Development of DNA Theory.
21. N.P. Hummon, P. Doreian, 1990. Computational Methods for Social Network Analysis.
22. Pena, J. A. d. l., 2011. Impact íunctions on the citation network of scientiíic articles. Journal of Informetrics.
23. Pengsheng Jiy, Jiashun Jinz, 2015. Coauthorship and citation networks for statisticians.
24. playframework.com, 2017. Play 2.5.X documentation. [Online]
-Available at: https://www.playframework.com/documentation/2.5.x/Home [Accessed 4 4 2017].
25. Ramamonjison, R., 2015. Apache Spark Graph Processing. 1st ed. BIRMINGHAM - MUMBAI: Packt Publishing.
26. S. Bergsma, R. L. Mandryk, G. McCalla, 2014. Learning to Measure Influence in a Scientic Social Network. In: Advances in Artificial Intelligence. Montréal: Springer, pp. 35-46.
27. Sabia, Love Arora, 2014. Technologies to Handle Big Data: A Survey. 28. Smith, C., 2017. 160 Amazing YouTube Statistics (February 2017). [Online]
Available at: http://expandedramblings.com/index.php/youtube-statistics/ [Accessed 2 4 2017].
29. Tesoriero, C., 2013. Getting Started with OrientDB. Mumbai: Pack Publishing. 30. Tín, H. N., 2014. Luận Án Tiến Sĩ Tin Học.
31. vosviewer.com, 2016. VOSviewer. [Online]
-Available at: http://www.vosviewer.com/ [Accessed 1 10 2016].
32. zephoria.com, 2017. The Top 20 Valuable Facebook Statistics - UpdatedMarch
2017. [Online]
-Available at: https://zephoria.com/top-15-valuable-facebook-statistics/ [Accessed 2 4 2017].
- PHỤ LỤC 1: DANH MỤC CODE SCALA
-........................................................................Code 1 - Hiện thực hàm prepareGraph() 2 -.........................................................................Code 2 - Hiện thực hàm importNodes() 2 -..........................................................................Code 3 - Hiện thực hàm createEdges() 3 -.....................................................................................Code 4 - Hiện thực hàm main() 4 - Code 5- Hiện thực thuật toán..........Pregel trong Apache Spark
4
- Code 6- Hiện thực....................................................................thuật toán Find Connected Component 5
- Code 7- Hiện thực....................................................................thuật toán Find Propagation 6
- Code 8- Hiện thực....................................................................thuật toán Load
Graph 7
- Code 9- Hiện thực....................................................................thuật toán Traverse Graph 8
- Code 10 - Hiện thực thuật toán
Visualize Graph trong lớp TasksController...............9
- Code 11 - Hiện thực thuật toán
Visualize Graph trong lớp Index.............................10
Trong phần phụ lục này tơi sẽ trình bày code Scala hiện thực các thuật toán quan trọng được dùng trong hệ thống Citation Network Explorer (CNE).
1. Hiện thực hàm prepareGraph().
Code 1 — Hiện thực hàmprepareGraphộ.
Hàm prepareGraph() chuẩn bị cơ sở dữ liệu đồ thị trước khi đọc text file.
1. def prepareGraph(graph: OrientGraph): Unit = {
2. //extend the Vertex class for Paper
3. val paper: OrientVertexType = graph.createVertexType("Paper")
4. paper.createProperty("id", Otype.LONG) 5. paper.createProperty("title", Otype.STRING) 6. paper.createProperty("authors", Otype.STRING) 7. paper.createProperty("year", Otype.SHORT) 8. paper.createProperty("pUblicationVenue", Otype.STRING) 9. paper.createProperty("index", Otype.STRING) 10. paper.createProperty("abstract",Otype.STRING) 11. paper.createProperty("references", Otype.STRING) 12. //creating index for index property
13. graph.createKeyIndex("index",classOf[Vertex],
14. new Parameter("class", "Paper"))
15. //extend the Edge class for Reference
16. val reference: OrientEdgeType = graph.createEdgeType("Reference")
17. reference.createProperty("src",Otype.LONG) 18. reference.createProperty("dst",Otype.LONG)
19. }
2. Hiện thực hàm importNodes()
Code 2 — Hiện thực hàm importNodesộ.
Hàm importNodes() đọc text file và tạo các đỉnh trong cơ sở dữ liệu đồ thị.
1. def importNodes(graph: OrientGraph, fileName: String): Unit = {
2. val source=Source. fromFile(fileName)
3. var paper: Vertex = null
4. for (line <- source.getLines) {
5. if (line.contains("#*")) {
7. println(count)
8. paper = graph.addVertex("class:Paper",Nil: _*)
9. paper.setProperty("id", count)
10. paper.setProperty("title", line.substring(2).trim)
11. if( count % 100 == 0) graph.commit()//to release resources
12. } else if (line.contains("#@")) { 13. paper.setProperty("authors", line.substring(2).trim) 14. }else if (line.contains("#t")) { 15. paper.setProperty("year", line.substring(2).trim) 16. }else if (line.contains("#c")) { 17. paper.setProperty("publicationVenue", line.substring(2).trim) 6. count += 1
18. } else if (line.contains("#index")) {
19. paper.setProperty("index", line.substring(6).trim) 20. } else if (line.contains("#!")) {
21. paper.setProperty("abstract", line.substring(2).trim) 22. } else if (line.contains("#%")) {
23. var references: String = paper.getProperty[String]("references")
24. if (references == null) references = ""
25. references += line.substring(2).trim + ";" 26. paper.setProperty("references", references)
27. }
28. }
29. source.close()//to release resources
30. }
Lưu ý khi hiện thực hàm importNodes() bằng Scala, khi thêm một số đỉnh thì nên thực hiện lệnh commit() để giải phóng bộ nhớ, để tránh hiện tượng tràn bộ nhớ; như dòng 11 trong Code 2, sau khi thêm 100 đỉnh vào đồ thị thì thực hiện lệnh commit().
3. Hiện thực hàm createEdges()
Code 3 - Hiện thực hàm createEdgesộ.
Hàm createEdges() đọc thuộc tính references của mỗi đỉnh để tạo các cạnh trong cơ sở dữ liệu đồ thị.
1. def createEdges(graph: OrientGraph): Unit ={
2. var paper:Vertex=null
3. val iterator = graph.getVertices().iterator() 4. var count=0
5. while(iterator.hasNext){
6. paper=iterator.next()
7. if(paper.getProperty("references")!=null){
8. val indices = paper.getProperty("references").toString.split(";")
9. indices.foreach(refIndex => { 10. //Paper.index: using index
11. val innerIterator = graph.getVertices("Paper.index", refIndex).iterator()
12. if (innerIterator.hasNext) {
13. val originalPaper: Vertex = innerIterator.next() 14. val reference: Edge = graph.addEdge(null, paper, 15. originalPaper, "Reference")
16. reference.setProperty("src",paper.getProperty[Long]("id"))
17. reference.setProperty("dst",originalPaper.getProperty[Long]("id"))
18. count+=1
19. if(count % 100 ==0) graph.commit()//to release resources
20. }
21. })
22. }
23. }
24. }
importNodes(), khi thêm một số cạnh thì nên thực hiện lệnh commit() để giải phóng bộ
nhớ, để tránh hiện tượng tràn bộ nhớ; như dòng 19 trong Code 3, sau khi thêm 100 cạnh
vào đồ thị thì thực hiện lệnh commit().
4. Hiện thực hàm main()
Code 4 — Hiện thực hàm main().
Hàm main() gọi các hàm ở trên để tạo nội dung cho cơ sở dữ liệu đồ thị.
1. def main(args: Array[String]) {
2. println("Begin creating the graph...”)
3. val uri: String = "remote:localhost/cn"
4. val factory: OrientGraphFactory = new OrientGraphFactory(uri)
5. val graph: OrientGraph = factory.getTx()
6. try {
7. prepareGraph(graph)
8. importNodes(graph,s"D:\\dblpX\dblp.txt")26
9. createEdges(graph)
10. } finally {
11. // To release all the instances and free all the resources
12. // (in case of pool usage), call the close()
13. factory.close()
14. }
15. println("End creating the graph.")
16. }
5. Hiện thực thuật toán Pregel trong Apache Spark
Trong GraphX, thuật toán Pregel được hiện thực bằng phương thức apply trong đối tượng Pregel như trong Code 5. (Apache Spark Docs, 2017), (Apache Spark API, 2017)
Code 5 — Hiện thực thuật toán Pregel trong Apache Spark.
Thuật toán xử lý song song và có thể giải quyết hầu hết các vấn đề trên đồ thị.
1. def apply[VD: ClassTag, ED: ClassTag, A: ClassTag]
2. (graph: Graph[VD, ED], 3. initialMsg: A,
4. maxIterations: Int = Int. MaxValue,
5. activeDirection: EdgeDirection = EdgeDirection.Either) 6. (vprog: (VertexId, VD, A) => VD,
7. sendMsg: EdgeTriplet[VD, ED] => Iterator[(VertexId, A)], 8. mergeMsg: (A, A) => A)
9. : Graph[VD, ED] = { 10.
10.require (maxIterations >= 0, s"Maximum number of iterations must be greater than
or equal to 0, but got ${maxIterations}")
11. var g = graph.mapVertices((vid, vdata) => vprog(vid, vdata, initialMsg))
12. .cache()
13. // compute the messages
14. var messages = GraphXUtils.mapReduceTriplets(g, sendMsg, mergeMsg)
15. var activeMessages = messages.count()
16. // Loop
17. var prevG: Graph[VD, ED] = null
18. var i = 0
19. while (activeMessages > 0 && i < maxIterations) {
20. // Receive the messages andupdatethe vertices.
21. prevG = g
22. g = g.joinVertices(messages)(vprog).cache()
23. val oldMessages = messages
24. // Send new messages, skipping edges where neither side received a message.
25. // We must cache messages so it can be materialized on the next line,
26. // allowing us to uncache the previous iteration.
27. messages = GraphXUtils.mapReduceTriplets(
28. g, sendMsg, mergeMsg, Some((oldMessages, activeDirection))).cache() 29. // The call to count() materializes 'messages' and the vertices of 'g'.
30. // This hides oldMessages (depended on by the vertices of g) and
31. // the vertices of prevG (depended on by oldMessages and the vertices of g).
32. activeMessages = messages.count()
33. // Unpersist the RDDs hidden by newly-materialized RDDs
34. oldMessages.unpersist(blocking= false)
35. prevG.unpersistVertices(blocking = false) 36. prevG.edges.unpersist(blocking= false)
37. // count the iteration
38. i += 1
39. logInfo(''Pregel finished iteration “ + i)
40. }
41. messages.unpersist(blocking = false)
42. g
43. } // end of apply
6. Hiện thực thuật toán Find Connected Component
Code 6 — Hiện thực thuật toán Find Connected Component.
Thuật tốn tìm thành phần liên thơng chứa một bài báo.
1. def findConnectedComponent(id: Int): Graph[Int, Int] = {//Graph[depth,nothing]