Spark GraphX ​​Tutorial - Graph Analytics Sa Apache Spark

GraphX ay Apache Spark's API para sa mga grap at graph-parallel computation. Pinagsasama ng GraphX ​​ang proseso ng ETL (Extract, Transform & Load), exploratory analysis at umuulit na pagkalkula ng grap sa loob ng isang solong system. Ang paggamit ng mga graph ay makikita sa mga kaibigan ng Facebook, mga koneksyon ng LinkedIn, mga router ng internet, mga ugnayan sa pagitan ng mga kalawakan at mga bituin sa astrophysics at Google's Maps. Kahit na ang konsepto ng pagkalkula ng grap ay tila napakasimple, ang mga aplikasyon ng mga grap ay literal na walang hanggan sa mga kaso ng paggamit sa pagtuklas ng sakuna, pagbabangko, stock market, banking at mga sistemang pangheograpiya upang mangalanan lamang ang ilan.Ang pag-aaral ng paggamit ng API na ito ay isang mahalagang bahagi ng .Sa pamamagitan ng blog na ito, malalaman natin ang mga konsepto ng Spark GraphX, mga tampok at bahagi nito sa pamamagitan ng mga halimbawa at dadaan sa isang kumpletong kaso ng paggamit ng Flight Data Analytics gamit ang GraphX.

Saklaw namin ang mga sumusunod na paksa sa Spark GraphX ​​blog na ito:

1. Ano ang mga Grapto?
2. Gumamit ng Mga Kaso ng Pagkalkula ng Grap
3. Ano ang Spark GraphX?
4. Mga Tampok ng Spark GraphX
5. Pag-unawa sa GraphX ​​sa Mga Halimbawa
6. Gumamit ng Kaso - Pagtatasa ng Data ng Paglipad gamit ang GraphX

Ano ang mga Grapto?

Ang isang Grap ay isang istrakturang matematika na nagkakahalaga ng isang hanay ng mga bagay kung saan ang ilang mga pares ng mga bagay ay naiugnay sa ilang kahulugan. Ang mga ugnayan na ito ay maaaring kinatawan gamit ang mga gilid at vertex na bumubuo ng isang grap. Ang mga vertex ay kumakatawan sa mga bagay at ang mga gilid ay nagpapakita ng iba't ibang mga ugnayan sa pagitan ng mga bagay na iyon.

Larawan: Spark GraphX ​​Tutorial - Mga Vertice, gilid at triplet sa mga graphic

Sa computer science, ang grap ay isang abstract na uri ng data na nilalayong ipatupad ang hindi na-derekta na grap at nagdidirektang mga konsepto ng grap mula sa matematika, partikular na ang larangan ng teorya ng grap. Ang isang istraktura ng data ng grap ay maaari ring maiugnay sa bawat gilid ng ilan halaga ng gilid , tulad ng isang simbolikong label o isang numerong katangian (gastos, kapasidad, haba,at iba pa).

Gumamit ng Mga Kaso ng Pagkalkula ng Grap

Ang mga sumusunod na kaso ng paggamit ay nagbibigay ng isang pananaw sa pagkalkula ng grap at karagdagang saklaw upang maipatupad ang iba pang mga solusyon gamit ang mga graph.

1. Disaster Detection System

   Maaaring gamitin ang mga grap upang makita ang mga sakuna tulad ng mga bagyo, lindol, tsunami, sunog sa kagubatan at bulkan upang makapagbigay ng mga babala upang maalerto ang mga tao.

   
   
   
2. Pagraranggo ng Pahina Maaaring magamit ang Pagraranggo ng Pahina sa paghahanap ng mga nakaka-impluwensya sa anumang network tulad ng papel na binabanggit sa papel o network ng social media.
3. Pagtuklas sa Panloko sa Pinansyal

   Maaaring magamit ang pagsusuri sa grap upang masubaybayan ang transaksyong pampinansyal at makita ang mga taong kasangkot sa pandaraya sa pananalapi at paglalabada ng salapi.

4. Pagsusuri sa Negosyo

   Ang mga graphic, kapag ginamit kasama ang Pag-aaral ng Machine, ay tumutulong sa pag-unawa sa mga uso sa pagbili ng customer. Hal. Uber, McDonald's, atbp.

5. Mga Sistema ng Impormasyon sa Heograpiya
   

   Ang mga grap ay masinsinang ginagamit upang makabuo ng mga pag-andar sa mga heograpikong sistema ng impormasyon tulad ng paglarawan ng tubig sa tubig at hula ng panahon.

6. Google Pregel

   Ang Pregel ay ang nasusukat at mapagparaya na platform ng Google na may isang API na sapat na kakayahang umangkop upang maipahayag ang di-makatwirang grapikomga algorithm

Ano ang Spark GraphX?

GraphX ay ang Spark API para sa mga graph at graph-parallel computation. May kasamang lumalaking koleksyon ng mga algorithm ng grap at tagabuo upang gawing simple ang mga gawain sa graph analytics.

Pinahahaba ng GraphX ​​ang Spark RDD na may isang nababanat na Ipinamahagi na Graph ng Ari-arian.Ang graph ng pag-aari ay isang nakadirektang multigraph na maaaring magkaroon ng maraming mga gilid nang kahanay. Ang bawat gilid at vertex ay may tinukoy ng gumagamit na mga katangiang nauugnay dito. Pinapayagan ng mga parallel na gilid ang maramihangmga ugnayan sa pagitan ng parehong mga vertex.

Mga Tampok ng Spark GraphX

Ang mga sumusunod ay ang mga tampok ng Spark GraphX:

1. Kakayahang umangkop :
   Gumagana ang Spark GraphX ​​kasama ang parehong mga grap at pagkalkula. Pinagsasama ng GraphX ​​ang ETL (Extract, Transform & Load), exploratory analysis at umuulit na pagkalkula ng grap sa loob ng isang solong system. Maaari naming tingnan ang parehong data tulad ng parehong mga graph at koleksyon, ibahin ang anyo at sumali sa mga graphic na may mga RDD nang mahusay at isulat ang mga pasadyang umuulit na mga algorithm ng grap gamit ang Pregel API.
2. Bilis :
   Nagbibigay ang Spark GraphX ​​ng maihahambing na pagganap sa pinakamabilis na dalubhasang mga sistema ng pagpoproseso ng grap. Maihahalintulad ito sa pinakamabilis na mga system ng grap habang pinapanatili ang kakayahang umangkop ng Spark, pagpapaubaya sa kasalanan at madaling paggamit.
3. Lumalagong Library ng Algorithm :
   Maaari kaming pumili mula sa isang lumalagong library ng mga graph algorithm na inaalok ng Spark GraphX. Ang ilan sa mga tanyag na algorithm ay ang ranggo ng pahina, mga konektadong bahagi, pagpapalaganap ng label, SVD ++, mahigpit na konektadong mga bahagi atbilang ng tatsulok.

Pag-unawa sa GraphX ​​sa Mga Halimbawa

Mauunawaan namin ang mga konsepto ng Spark GraphX ​​gamit ang isang halimbawa. Isaalang-alang natin ang isang simpleng grap tulad ng ipinakita sa imahe sa ibaba.

Larawan: Spark GraphX ​​Tutorial - Halimbawa ng Graph

Sa pagtingin sa grap, maaari naming makuha ang impormasyon tungkol sa mga tao (mga vertex) at mga ugnayan sa pagitan nila (mga gilid). Ang grap dito ay kumakatawan sa mga gumagamit ng Twitter at sinusundan nila sa Twitter. Para sa hal. Sinusundan ni Bob sina Davide at Alice sa Twitter.

Ipatupad natin ang pareho gamit ang Apache Spark. Una, mai-import namin ang mga kinakailangang klase para sa GraphX.

// Pag-import ng mga kinakailangang klase sa pag-import ng org.apache.spark._ import org.apache.spark.rdd.RDD import org.apache.spark.util.IntParam import org.apache.spark.graphx._ import org.apache.spark .graphx.util.GraphGenerators

Nagpapakita ng mga Vertice :Dagdag dito, ipapakita namin ngayon ang lahat ng mga pangalan at edad ng mga gumagamit (mga vertex).

val vertexRDD: RDD [(Long, (String, Int))] = sc.parallelize (vertexArray) val edgeRDD: RDD [Edge [Int]] = sc.parallelize (edgeArray) val graph: Graph [(String, Int), Int] = Grap (vertexRDD, edgeRDD) graph.vertices.filter {case (id, (pangalan, edad)) => edad> 30} .collect.foreach {case (id, (pangalan, edad)) => println ( s '$ name is $ age')}

Ang output para sa code sa itaas ay tulad ng sa ibaba:

Daviday42 Franaylimampu Eday55 Charlieay65

Ipinapakita ang mga gilid : Tingnan natin kung aling tao ang may gusto sa Twitter.

para sa (triplet<- graph.triplets.collect) { println(s'${triplet.srcAttr._1} likes ${triplet.dstAttr._1}') } 

Ang output para sa code sa itaas ay tulad ng sa ibaba:

Si BobgustoAlice Si BobgustoDavid CharliegustoSi Bob CharliegustoFran DavidgustoAlice EdgustoSi Bob EdgustoCharlie EdgustoFran

Ngayon na naintindihan na natin ang mga pangunahing kaalaman sa GraphX, magsisid tayo nang medyo mas malalim at magsagawa ng ilang mga advanced na pagkalkula sa pareho.

Bilang ng mga tagasunod : Ang bawat gumagamit sa aming grap ay may iba't ibang bilang ng mga tagasunod. Tingnan natin ang lahat ng mga tagasunod para sa bawat gumagamit.

// Pagtukoy sa isang klase upang mas malinaw na modelo ang modelo ng kaso ng pag-aari ng gumagamit User (pangalan: String, edad: Int, inDeg: Int, outDeg: Int) // Lumilikha ng isang gumagamit ng Graph val initialUserGraph: Grap [Gumagamit, Int] = grap. mapVertices {case (id, (pangalan, edad)) => Gumagamit (pangalan, edad, 0, 0)} // Pagpuno ng impormasyon ng degree val userGraph = initialUserGraph.outerJoinVertices (initialUserGraph.inDegrees) {case (id, u, inDegOpt) => Gumagamit (u.name, u.age, inDegOpt.getOrElse (0), u.outDeg)} .outerJoinVertices (initialUserGraph.outDegrees) {case (id, u, outDegOpt) => Gumagamit (u.name, u.age, u.inDeg, outDegOpt.getOrElse (0))} para sa ((id, pag-aari)<- userGraph.vertices.collect) { println(s'User $id is called ${property.name} and is liked by ${property.inDeg} people.') } 

Ang output para sa code sa itaas ay tulad ng sa ibaba:

Gumagamit isaay tinatawag naAliceat nagustuhan ng2mga tao. Gumagamit 2ay tinatawag naSi Bobat nagustuhan ng2mga tao. Gumagamit 3ay tinatawag naCharlieat nagustuhan ngisamga tao. Gumagamit 4ay tinatawag naDavidat nagustuhan ngisamga tao. Gumagamit 5ay tinatawag naEdat nagustuhan ng0mga tao. Gumagamit 6ay tinatawag naFranat nagustuhan ng2mga tao.

Pinakamatandang Tagasunod : Maaari din naming pag-uri-uriin ang mga tagasunod ayon sa kanilang mga katangian. Hahanapin namin ang pinakamatandang tagasunod ng bawat gumagamit ayon sa edad.

// Paghahanap ng pinakalumang tagasunod para sa bawat gumagamit na pinakalumangFollower: VertexRDD [(String, Int)] = userGraph.mapReduceTriplets [(String, Int)] (// Para sa bawat gilid magpadala ng mensahe sa tuktok ng patutunguhan na may katangian ng mapagkukunan vertex edge => Iterator ((edge.dstId, (edge.srcAttr.name, edge.srcAttr.age))), // Upang pagsamahin ang mga mensahe kunin ang mensahe para sa mas matandang tagasunod (a, b) => kung (a. _2> b._2) iba pa b)

Ang output para sa code sa itaas ay tulad ng sa ibaba:

Daviday ang pinakalumang tagasunod ngAlice. Charlieay ang pinakalumang tagasunod ngSi Bob. Eday ang pinakalumang tagasunod ngCharlie. Si Bobay ang pinakalumang tagasunod ngDavid. Eday walang anumang mga tagasunod. Charlieay ang pinakalumang tagasunod ngFran. 

Gumamit ng Kaso: Pagtatasa ng Data ng Paglipad gamit ang Spark GraphX

Ngayon na naintindihan na namin ang mga pangunahing konsepto ng Spark GraphX, malutas natin ang isang problema sa totoong buhay gamit ang GraphX. Makakatulong ito sa amin na magbigay ng kumpiyansa na magtrabaho sa anumang mga proyekto ng Spark sa hinaharap.

Pahayag ng Suliranin : Upang pag-aralan ang data ng Real-Time Flight gamit ang Spark GraphX, magbigay ng malapit sa mga resulta sa pagkalkula ng real-time at mailarawan ang mga resulta gamit ang Google Data Studio.

Gumamit ng Kaso - Magagawa ang mga pagkalkula :

saltstack vs papet vs chef

1. Kalkulahin ang kabuuang bilang ng mga ruta ng flight
2. Kalkulahin at pag-uri-uriin ang pinakamahabang mga ruta sa paglipad
3. Ipakita ang paliparan na may pinakamataas na degree na vertex
4. Ilista ang pinakamahalagang paliparan ayon sa PageRank
5. Ilista ang mga ruta na may pinakamababang gastos sa paglipad

Gagamitin namin ang Spark GraphX ​​para sa mga pagkalkula sa itaas at mailarawan ang mga resulta gamit ang Google Data Studio.

Gumamit ng Kaso - Dataset :

Larawan: Gumamit ng Kaso - USA Flight Dataset

Gumamit ng Kaso - Diagram ng Daloy :

Malinaw na ipinapaliwanag ng sumusunod na ilustrasyon ang lahat ng mga hakbang na kasangkot sa aming Pagtatasa ng Data ng Flight.

Larawan: Gumamit ng Kaso - Daloy ng diagram ng Pagsusuri ng Data ng Paglipad gamit ang Spark GraphX

Gumamit ng Kaso - Pagpapatupad ng Spark :

Patuloy, ngayon ipatupad natin ang aming proyekto gamit ang Eclipse IDE para sa Spark.

Hanapin ang Pseudo Code sa ibaba:

// Pag-import ng mga kinakailangang klase sa pag-import ng org.apache.spark._ ... import java.io.File object airport {def main (args: Array [String]) {// Lumilikha ng isang Class Class ng kaso ng Flight flight na flight (dofM: String, dofW: String, ..., dist: Int) // Pagtukoy sa isang function ng Parse String upang i-parse ang input sa Flight class def parseFlight (str: String): Flight = {val line = str.split (',') Flight (line (0), line (1), ..., line (16) .toInt)} val conf = new SparkConf (). setAppName ('airport'). setMaster ('local [2]') val sc = bagong SparkContext (conf) // I-load ang data sa isang RDD val textRDD = sc.textFile ('/ home / edureka / usecases / airport / airportdataset.csv') // I-parse ang RDD ng mga linya ng CSV sa isang RDD ng mga flight class val flightRDD = Map ParseFlight to Text RDD // Lumikha ng mga paliparan RDD na may ID at Pangalan na mga paliparan = Map Flight OriginID at Pinagmulang mga paliparan. Dalhin (1) // Ang pagtukoy ng isang default na vertex na tinawag kahit saan at pagmamapa ng Airport ID para sa mga printlns val nowhere = 'nowhere' val airportMap = Gumamit ng Map Function .collect.toList.toMap // Lumikha ng mga ruta RDD na may mga sourceID, patutunguhanID at distansya ng mga ruta ng val = flightRDD. Gumamit ng Map Function .distinct na mga ruta.take (2) // Lumikha ng mga gilid ng RDD na may sourceID, destinationID at distansya ng mga gilid ng val = mga ruta.map {(Map OriginID at DestinationID) => Edge (org_id.toLong, dest_id.toLong, distansya)} edge.take (1) // Tukuyin ang grap at ipakita ang ilang mga vertex at edge val graph = Grap (Mga Paliparan, Mga gilid at Wala Kahit saan) graph.vertices. Kunin ang (2) graph.edges.take (2) // Query 1 - Hanapin ang kabuuang bilang ng mga paliparan val numairports = Vertices Number // Query 2 - Kalkulahin ang kabuuang bilang ng mga ruta? val numroutes = Number Of Edges // Query 3 - Kalkulahin ang mga rutang iyon na may distansya na higit sa 1000 milya graph.edges.filter {Kunin ang distansya sa gilid) => distansya> 1000}. kumuha (3) // Gayundin isulat ang Scala code para sa sa ibaba ng mga query // Query 4 - Pagbukud-bukurin at i-print ang pinakamahabang ruta // Query 5 - Ipakita ang mga pinakamataas na degree na vertice para sa mga papasok at papalabas na flight ng mga paliparan // Query 6 - Kunin ang pangalan ng paliparan na may mga ID 10397 at 12478 // Query 7 - Hanapin ang paliparan na may pinakamataas na papasok na flight // Query 8 - Hanapin ang paliparan na may pinakamataas na papalabas na flight // Query 9 - Hanapin ang pinakamahalagang paliparan ayon sa PageRank // Query 10 - Pagbukud-bukurin ang mga paliparan sa pamamagitan ng pagraranggo // Query 11 - Ipakita ang pinaka mahahalagang paliparan // Query 12 - Hanapin ang Mga Ruta na may pinakamababang gastos sa paglipad // Query 13 - Maghanap ng mga paliparan at ang kanilang pinakamababang gastos sa paglipad // Query 14 - Ipakita ang mga code ng paliparan kasama ang pinagsunod-sunod na pinakamababang mga gastos sa paglipad

Gumamit ng Kaso - Pagpapakita ng Mga Resulta :

Gagamitin namin ang Google Data Studio upang mailarawan ang aming pagsusuri. Ang Google Data Studio ay isang produkto sa ilalim ng Google Analytics 360 Suite. Gagamitin namin ang serbisyo ng Geo Map upang mapa ang Mga Paliparan sa kani-kanilang mga lokasyon sa mapa ng USA at ipakita ang dami ng sukatan.

1. Ipakita ang kabuuang bilang ng mga flight bawat Paliparan
2. Ipakita ang sukatan ng mga ruta ng Destination mula sa bawat Paliparan
3. Ipakita ang kabuuang pagkaantala ng lahat ng mga flight bawat Paliparan
   

Ngayon, nagtatapos ito sa Spark GraphX ​​blog. Inaasahan kong nasiyahan ka sa pagbabasa nito at nalaman mong ito ay may kaalaman. Suriin ang susunod na blog sa aming serye ng Apache Spark sa upang maging handa sa merkado sa Apache Spark.

Inirerekumenda namin ang sumusunod Apache Spark Training | Video ng Pagsusuri ng Data ng Flight mula sa Edureka upang magsimula sa:

Apache Spark Training | Pagsusuri sa Data ng Paglipad ng Spark GraphX ​​| Edureka

May tanong ba sa amin? Mangyaring banggitin ito sa seksyon ng mga komento at babalik kami sa iyo sa pinakamaagang.

Kung nais mong malaman ang Spark at bumuo ng isang karera sa domain ng Spark at bumuo ng kadalubhasaan upang maisagawa ang malakihang Pagproseso ng Data gamit ang RDD, Spark Streaming, SparkSQL, MLlib, GraphX ​​at Scala na may mga Real-Life Life na kaso, tingnan ang aming interactive, live -online dito, na may kasamang 24 * 7 na suporta upang gabayan ka sa buong panahon ng iyong pag-aaral.