spark graphx 图操作函数示例（全）

最新推荐文章于 2024-08-28 08:50:05 发布
最新推荐文章于 2024-08-28 08:50:05 发布
阅读量2.4k 收藏 6
点赞数 1
分类专栏： spark
版权声明：本文为博主原创文章，遵循 CC 4.0 BY-SA 版权协议，转载请附上原文出处链接和本声明。
本文链接：https://blog.csdn.net/zht245648124/article/details/86667616
版权
  1. 求最大度数
  2. 取出前5个节点
  3. pageRank算法找出最重要的节点
  4. mapTriplets的用法，对图的边属性进行增加，与mapEdges区别为同时对三元组进行转换
  5. mapEdges操作，只能对边的属性进行操作（不能拿到对象的相关信息）
  6. mapVertices操作，只能对节点进行操作
  7. 使用aggregateMessages操作，计算每个节点的出度（join）
  8. 使用aggregateMessages操作，计算每个节点的入度（rightOuterJoin）
  9. 使用aggregateMessages计算每个节点与根节点的距离
  10. 使用Pregel计算每个节点与根节点的距离
  11. 官网的aggregateMessages例子
  12. Spark Graphx图计算案例实战之aggregateMessages求社交网络中的最大年纪追求者和平均年纪！
  13. 生成Gexf的xml文件
package com.spark.scala

import org.apache.spark.graphx._
import org.apache.spark.graphx.util.GraphGenerators
import org.apache.spark.rdd.RDD
import org.apache.spark.{SparkConf, SparkContext}

import scala.collection.mutable

/**
  * 求最大度数
  */
object Test2 {
  def main(args: Array[String]): Unit = {
    val conf = new SparkConf().setAppName("test").setMaster("local[*]")
    val sc = new SparkContext(conf)
    val graph = GraphLoader.edgeListFile(sc, "E:\\测试文本\\cit-HepTh\\Cit-HepTh.txt")
    val degreeRdd = graph.inDegrees
    val tuple: (VertexId, Int) = degreeRdd.reduce((a, b) => if (a._2 > b._2) a else b)

    println(tuple)
    // res: (9711200,2414)

  }
}

/**
  * 取出前5个节点
  */
object Test3 {
  def main(args: Array[String]): Unit = {
    val conf = new SparkConf().setAppName("test").setMaster("local[*]")
    val sc = new SparkContext(conf)
    val graph = GraphLoader.edgeListFile(sc, "E:\\测试文本\\cit-HepTh\\Cit-HepTh.txt")
    println(graph.vertices.take(5).toBuffer)
  }
}

/**
  * pageRank算法找出最重要的节点
  */
object Test4 {
  def main(args: Array[String]): Unit = {
    val conf = new SparkConf().setAppName("test").setMaster("local[*]")
    val sc = new SparkContext(conf)
    val graph = GraphLoader.edgeListFile(sc, "E:\\测试文本\\cit-HepTh\\Cit-HepTh.txt")
    val res: Graph[Double, Double] = graph.pageRank(0.001)
    //    val vertices: Array[(VertexId, Double)] = res.vertices.take(5)
    println(res.vertices.reduce((a, b) => if (a._2 > b._2) a else b))

  }
}

/**
  * mapTriplets的用法，对图的边属性进行增加，与mapEdges区别为同时对三元组进行转换
  */
object MapTriplets {
  def main(args: Array[String]): Unit = {
    val conf = new SparkConf().setAppName("test").setMaster("local[*]")
    val sc = new SparkContext(conf)

    val myVertices = sc.makeRDD(Array((1L, "Ann"), (2L, "Bill"), (3L, "Charles"), (4L, "Diane"),
      (5L, "Went to gym this morning")))

    val myEdges = sc.makeRDD(Array(Edge(1L, 2L, "is-friends-with"), Edge(2L, 3L, "is-friends-with"),
      Edge(3L, 4L, "is-friends-with"), Edge(4L, 5L, "Likes-status"), Edge(3L, 5L, "Wrote- status")))

    val myGraph = Graph(myVertices, myEdges)

    val trip = myGraph.mapTriplets(t => {
      (t.attr, t.attr == "is-friends-with" && t.srcAttr.toLowerCase.contains("a"))
    })

    val triplets: RDD[EdgeTriplet[String, (String, Boolean)]] = trip.triplets
    println(triplets.collect().toBuffer)
//    ArrayBuffer(((1,Ann),(2,Bill),(is-friends-with,true)), ((2,Bill),(3,Charles),(is-friends-with,false)), ((3,Charles),(4,Diane),(is-friends-with,true)), ((4,Diane),(5,Went to gym this morning),(Likes-status,false)), ((3,Charles),(5,Went to gym this morning),(Wrote- status,false)))

  }
}

/**
  * mapEdges操作，只能对边的属性进行操作（不能拿到对象的相关信息）
  */
object MapEdges {
  def main(args: Array[String]): Unit = {
    val conf = new SparkConf().setAppName("test").setMaster("local[*]")
    val sc = new SparkContext(conf)

    val myVertices = sc.makeRDD(Array((1L, "Ann"), (2L, "Bill"), (3L, "Charles"), (4L, "Diane"),
      (5L, "Went to gym this morning")))

    val myEdges = sc.makeRDD(Array(Edge(1L, 2L, "is-friends-with"), Edge(2L, 3L, "is-friends-with"),
      Edge(3L, 4L, "is-friends-with"), Edge(4L, 5L, "Likes-status"), Edge(3L, 5L, "Wrote- status")))

    val myGraph = Graph(myVertices, myEdges)

    val graph1 = myGraph.mapEdges(e => {
      (e.attr, e.attr == "is-friends-with" && e.srcId == 1)
    })

    val triplets: RDD[EdgeTriplet[String, (String, Boolean)]] = graph1.triplets
    println(triplets.collect().toBuffer)
//    ArrayBuffer(((1,Ann),(2,Bill),(is-friends-with,true)), ((2,Bill),(3,Charles),(is-friends-with,false)), ((3,Charles),(4,Diane),(is-friends-with,false)), ((4,Diane),(5,Went to gym this morning),(Likes-status,false)), ((3,Charles),(5,Went to gym this morning),(Wrote- status,false)))

  }
}

/**
  * mapVertices操作，只能对节点进行操作
  */
object MapVertices {
  def main(args: Array[String]): Unit = {
    val conf = new SparkConf().setAppName("test").setMaster("local[*]")
    val sc = new SparkContext(conf)

    val myVertices = sc.makeRDD(Array((1L, "Ann"), (2L, "Bill"), (3L, "Charles"), (4L, "Diane"),
      (5L, "Went to gym this morning")))

    val myEdges = sc.makeRDD(Array(Edge(1L, 2L, "is-friends-with"), Edge(2L, 3L, "is-friends-with"),
      Edge(3L, 4L, "is-friends-with"), Edge(4L, 5L, "Likes-status"), Edge(3L, 5L, "Wrote- status")))

    val myGraph = Graph(myVertices, myEdges)

    val graph1 = myGraph.mapVertices((vId: VertexId, attr: String) => {
      (attr, vId == 1)
    })

    val triplets: RDD[EdgeTriplet[(String, Boolean), String]] = graph1.triplets
    println(triplets.collect().toBuffer)
  }
}

/**
  * 使用aggregateMessages操作，计算每个节点的出度（join）
  */
object AggregateMessages {
  def main(args: Array[String]): Unit = {
    val conf = new SparkConf().setAppName("test").setMaster("local[*]")
    val sc = new SparkContext(conf)

    val myVertices = sc.makeRDD(Array((1L, "Ann"), (2L, "Bill"), (3L, "Charles"), (4L, "Diane"),
      (5L, "Went to gym this morning")))

    val myEdges = sc.makeRDD(Array(Edge(1L, 2L, "is-friends-with"), Edge(2L, 3L, "is-friends-with"),
      Edge(3L, 4L, "is-friends-with"), Edge(4L, 5L, "Likes-status"), Edge(3L, 5L, "Wrote- status")))

    val myGraph = Graph(myVertices, myEdges)

    val vertices1: VertexRDD[Int] = myGraph.aggregateMessages[Int](_.sendToSrc(1), _ + _)

    val vertice2: RDD[(VertexId, (Int, String))] = vertices1.join(myGraph.vertices)

    val vertice3: RDD[(String, Int)] = vertice2.map(_._2.swap)

    println(vertice3.collect().toBuffer)
//    ArrayBuffer((Ann,1), (Bill,1), (Charles,2), (Diane,1))

  }
}

/**
  * 使用aggregateMessages操作，计算每个节点的入度（rightOuterJoin）
  */
object AggregateMessages2 {
  def main(args: Array[String]): Unit = {
    val conf = new SparkConf().setAppName("test").setMaster("local[*]")
    val sc = new SparkContext(conf)

    val myVertices = sc.makeRDD(Array((1L, "Ann"), (2L, "Bill"), (3L, "Charles"), (4L, "Diane"),
      (5L, "Went to gym this morning")))

    val myEdges = sc.makeRDD(Array(Edge(1L, 2L, "is-friends-with"), Edge(2L, 3L, "is-friends-with"),
      Edge(3L, 4L, "is-friends-with"), Edge(4L, 5L, "Likes-status"), Edge(3L, 5L, "Wrote- status")))

    val myGraph = Graph(myVertices, myEdges)

    val vertices1: VertexRDD[Int] = myGraph.aggregateMessages[Int](_.sendToSrc(1), _ + _)

    val vertice2: RDD[(VertexId, (Option[Int], String))] = vertices1.rightOuterJoin(myGraph.vertices).cache()

    val vertice3: RDD[(String, Option[Int])] = vertice2.map(_._2.swap)

    val vertice4: RDD[(String, PartitionID)] = vertice2.map(x => (x._2._2, x._2._1.getOrElse(0)))

    println(vertice3.collect().toBuffer)
//    ArrayBuffer((Ann,Some(1)), (Bill,Some(1)), (Charles,Some(2)), (Diane,Some(1)), (Went to gym this morning,None))


    println(vertice4.collect().toBuffer)
//    ArrayBuffer((Ann,1), (Bill,1), (Charles,2), (Diane,1), (Went to gym this morning,0))

  }
}

/**
  * 使用aggregateMessages计算每个节点与根节点的距离
  */
object AggregateMessages3 {
  def main(args: Array[String]): Unit = {
    val conf = new SparkConf().setAppName("test").setMaster("local[*]")
    val sc = new SparkContext(conf)

    val myVertices = sc.makeRDD(Array((1L, "Ann"), (2L, "Bill"), (3L, "Charles"), (4L, "Diane"),
      (5L, "Went to gym this morning")))

    val myEdges = sc.makeRDD(Array(Edge(1L, 2L, "is-friends-with"), Edge(2L, 3L, "is-friends-with"),
      Edge(3L, 4L, "is-friends-with"), Edge(4L, 5L, "Likes-status"), Edge(3L, 5L, "Wrote- status")))

    val myGraph = Graph(myVertices, myEdges)
    val initGraph: Graph[Int, String] = myGraph.mapVertices((vId, attr) => {
      0
    })
    val graphRes: Graph[PartitionID, String] = proopagateEdgeCount(initGraph)
    val buffer: mutable.Buffer[(VertexId, PartitionID)] = graphRes.vertices.collect.toBuffer

    println(buffer)
//    ArrayBuffer((1,0), (2,1), (3,2), (4,3), (5,4))
  }

  def sendMsg(ec: EdgeContext[Int, String, Int]) = {
    ec.sendToDst(ec.srcAttr + 1)
  }

  def mergeMsg(a: Int, b: Int): Int = {
    math.max(a, b)
  }

  def proopagateEdgeCount(g: Graph[Int, String]): Graph[Int, String] = {
    println("vertice--" + g.vertices.collect.toBuffer)

    val vertice1: VertexRDD[Int] = g.aggregateMessages[Int](sendMsg, mergeMsg)

    println("vertice1--" + vertice1.collect.toBuffer)

    val g2: Graph[Int, String] = Graph(vertice1, g.edges).cache()

    val vertice3: RDD[(VertexId, (Int, Int))] = g2.vertices.join(g.vertices)

    println("vertice3--" + vertice3.collect.toBuffer)

    val vertice4: RDD[Int] = vertice3.map(x => x._2._1 - x._2._2)

    val i: PartitionID = vertice4.reduce(_ + _)

    if (i > 0) {
      proopagateEdgeCount(g2)
    } else {
      g
    }

  }
}

/**
  * 使用Pregel计算每个节点与根节点的距离
  */
object PregelTest {
  def main(args: Array[String]): Unit = {
    val conf = new SparkConf().setAppName("test").setMaster("local[*]")
    val sc = new SparkContext(conf)

    val myVertices = sc.makeRDD(Array((1L, "Ann"), (2L, "Bill"), (3L, "Charles"), (4L, "Diane"),
      (5L, "Went to gym this morning")))

    val myEdges = sc.makeRDD(Array(Edge(1L, 2L, "is-friends-with"), Edge(2L, 3L, "is-friends-with"),
      Edge(3L, 4L, "is-friends-with"), Edge(4L, 5L, "Likes-status"), Edge(3L, 5L, "Wrote- status")))

    val myGraph = Graph(myVertices, myEdges)

    val value: Graph[PartitionID, String] = myGraph.mapVertices((vId, attr) => 0)

    val g1 : Graph[Int,String] = (Pregel(value, 0, activeDirection = EdgeDirection.Out) // --注意最外层必须要有（）
    (
      (id: VertexId, vd: Int, a: Int) => math.max(vd, a),
      (et: EdgeTriplet[Int, String]) => Iterator((et.dstId, et.srcAttr + 1)),
      (a: Int, b: Int) => math.max(a, b)
    ))

    println(g1.vertices.collect.toBuffer)
    //    ArrayBuffer((1,0), (2,1), (3,2), (4,3), (5,4))

  }
}

/**
  * 官网的aggregateMessages例子
  */
object AggregateMessages4 {
  def main(args: Array[String]): Unit = {
    val conf = new SparkConf().setAppName("test").setMaster("local[*]")
    val sc = new SparkContext(conf)


    // Create a graph with "age" as the vertex property.
    // Here we use a random graph for simplicity.
    val graph: Graph[Double, Int] =
    GraphGenerators.logNormalGraph(sc, numVertices = 100).mapVertices((id, _) => id.toDouble)

    // Compute the number of older followers and their total age
    val olderFollowers: VertexRDD[(Int, Double)] = graph.aggregateMessages[(Int, Double)](
      triplet => { // Map Function
        if (triplet.srcAttr > triplet.dstAttr) {
          // Send message to destination vertex containing counter and age
          triplet.sendToDst((1, triplet.srcAttr))
        }
      },
      // Add counter and age
      (a, b) => (a._1 + b._1, a._2 + b._2) // Reduce Function
    )
    // Divide total age by number of older followers to get average age of older followers
    val avgAgeOfOlderFollowers: VertexRDD[Double] =
      olderFollowers.mapValues((id, value) =>
        value match {
          case (count, totalAge) => totalAge / count
        })
    // Display the results
    avgAgeOfOlderFollowers.collect.foreach(println(_))
  }
}

/**
  * Spark Graphx图计算案例实战之aggregateMessages求社交网络中的最大年纪追求者和平均年纪！
  */
object AggregateMessages5 {
  def main(args: Array[String]): Unit = {
    val conf = new SparkConf().setAppName("test").setMaster("local[*]")
    val sc = new SparkContext(conf)

    val tempVertice = sc.textFile("E:\\测试文本\\users.txt").map(line => {
      val arr: Array[String] = line.split(",")
      (arr(0).toLong, arr(1).toDouble)
    })

    val graph1: Graph[Int, Int] = GraphLoader.edgeListFile(sc,"E:\\测试文本\\followers.txt").cache()

    //重要方法，对已有的图进行顶点属性替换操作
    val graph2 = graph1.outerJoinVertices(tempVertice)(
      (vId,attr,option) => {
      option.getOrElse(0.0)
    } )

    val graph3 = graph1.joinVertices(tempVertice)((vId,attr,u) => {
      attr
    })

    // 进行聚合求出每个节点追随者的个数和总追随者总的年龄
    val vertice2 : VertexRDD[(Int, Double)]= graph2.aggregateMessages[(Int, Double)](
      ec => ec.sendToDst((1,ec.srcAttr)),
      (a,b) => (a._1 + b._1, a._2 + b._2)
    )

    // 对年龄求平均值
    val aveAgeRDD : VertexRDD[Double]= vertice2.mapValues((vId,tuple) => tuple._2/tuple._1)
    
    println(aveAgeRDD.collect.toBuffer)
//    ArrayBuffer((4,37.0), (6,29.0), (2,23.0), (1,32.5), (3,33.0), (7,29.5))

    // 进行聚合求出年龄最大的追随者
   val maxAgeRDD = graph2.aggregateMessages[(VertexId,Double)](
      ec => ec.sendToDst((ec.srcId,ec.srcAttr)),
     (a,b) => if (a._2 > b._2) a else b
    )

    println("max age--" + maxAgeRDD.collect.toBuffer)
//    max age--ArrayBuffer((4,(5,37.0)), (6,(7,29.0)), (2,(1,23.0)), (1,(2,34.0)), (3,(5,37.0)), (7,(6,33.0)))

    //    val pw=new java.io.PrintWriter("E:\\测试文本\\myGraph.gexf")
//    pw.write(ToGexf.toGexf(graph2))
//    pw.close


    /*println("tempVertice--" + tempVertice.collect().toBuffer)
//    tempVertice--ArrayBuffer((1,23.0), (2,34.0), (3,26.0), (4,31.0), (6,33.0), (7,29.0), (5,37.0))

    println("graph1--" + graph1.vertices.collect().toBuffer)
//    graph1--ArrayBuffer((4,1), (6,1), (2,1), (1,1), (3,1), (7,1), (5,1))

    println("graph2--" + graph2.vertices.collect().toBuffer)
//    graph2--ArrayBuffer((4,31.0), (6,33.0), (2,34.0), (1,23.0), (3,26.0), (7,29.0), (5,37.0))

    println("graph3--" + graph3.vertices.collect().toBuffer)
//    graph3--ArrayBuffer((4,1), (6,1), (2,1), (1,1), (3,1), (7,1), (5,1))*/
  }
}

/**
  * 生成Gexf的xml文件
  */
object ToGexf {
  def toGexf[VD,ED](g:Graph[VD,ED]) : String = {
    val string = "<?xml version=\"1.0\" encoding=\"UTF-8\"?>\n" +
      "<gexf xmlns=\"http://www.gexf.net/1.2draft\" version=\"1.2\">\n" +
      " <graph mode=\"static\" defaultedgetype=\"directed\">\n" +
      " <nodes>\n" +
      g.vertices.map(v => " <node id=\"" + v._1 + "\" label=\"" +
        v._2 + "\" />\n").collect.mkString +
      " </nodes>\n" +
      " <edges>\n" +
      g.edges.map(e => " <edge source=\"" + e.srcId +
        "\" target=\"" + e.dstId + "\" label=\"" + e.attr +
        "\" />\n").collect.mkString +
      " </edges>\n" +
      " </graph>\n" +
      "</gexf>"
    return string
  }
}
IT社团
关注
专栏目录
graphx解决图中心
BookLing的博客
09-15 3456
图的中心点所谓图的中心点，就是到其他点的距离之和最小的点，可以将它近似看做图。如果将该点看作根节点，那么各层顶点到根节点的距离之和也是最小的。示例下图中的中心点是哪个呢？图中各点到其他点距离之和分别是{1-> 14, 2->14, 3->9, 4->8 , 5->13, 6->12, 7->12}。很明显到其他距离最小的点是4(距离之和为8)，所以4是该图的中心点。 以4为根节点形成的最小生成树图
头歌：Spark GraphX—寻找社交媒体中的“影响力用户”
weixin_62399938的博客
05-01 2127
Spark GraphX中提供了方便开发者的基于谷歌Pregel API的迭代算法，因此可以用Pregel的计算框架来处理Spark上的图数据。GraphX的Pregel API提供了一个简明的函数式算法设计，用它可以在图中方便的迭代计算，如最短路径、关键路径、n度关系等，也可以通过对一些内部数据集的缓存和释放缓存操作来提升性能。近年来互联网技术的发展带来了在线社交网络的繁荣,微博、微信、Twitter等社交平台已经走进人们生活的方方面面。
graphx-algorithm:在 GraphX 和 Spark 风格中实现的图算法
06-10
graphx-算法 在 GraphX 和 Spark 风格中实现的图算法 集成开发环境 IntelliJ IDEA >= 14 Scala SDK == 2.10.5 火花 1.3.0 GraphX 2.1.0 Apache Maven >= 3.3.1 开发目录 算法的实现放置在包org.apache.spark.graphx.iiot 。 其他修改/添加的文件如下： org.apache.spark.graphx.GraphLoaderPlus Spark 项目示例 Spark 文档 Scala 文档 算法
Spark入门实战系列--9.Spark图计算GraphX介绍及实例
yyy
09-16 1789
1、GraphX介绍 1.1 GraphX应用背景 Spark GraphX是一个分布式图处理框架，它是基于Spark平台提供对图计算和图挖掘简洁易用的而丰富的接口，极大的方便了对分布式图处理的需求。 众所周知·，社交网络中人与人之间有很多关系链，例如Twitter、Facebook、微博和微信等，这些都是大数据产生的地方都需要图计算，现在的图处理基本都是分布式的图处理，而并非单机处理。Sp
大数据-105 Spark GraphX 基本概述 与 架构基础 概念详解 核心数据结构
最新发布
永远好奇，无限进步！
08-28 4233
上节研究Spark Streaming Kafka的Offsets管理，通过Redis进行管理操作。本节研究Spark GraphX 是 Spark 一个组件，专门用来表示图以及进行图的并行计算。GraphX通过重新定义了图的抽象概念来拓展了RDD：定向多图，其属性附加到每个顶点和边。为了支持图计算，GraphX公开了一系列基本运算（比如：mapVertices、mapEdges、subgraph）以及优化后的 Pregel API 变种。此外，还包含越来越多的图算法和构建器，以简化图形分析任务。
Spark GraphX图计算实例
赵昕彧
12-19 482
航空数据简单计算 数据格式 dom – 月中第几天 (day of month) dow – 周中第几天 (day of week) carrier – 航空公司 tail_num – 飞机注册号 fl_num – 航班号 origin_id – 起飞机场编号 origin – 起飞机场 dest_id – 到达机场编号 dest – 到达机场 crs_dep_time – 预计起飞时间 d...
Spark_GraphX大规模图计算和图挖掘
12-05
Spark_GraphX大规模图计算和图挖掘
深入Spark GraphX：图计算的利器
07-28
### 深入Spark GraphX：图计算的利器 #### 引言 随着大数据时代的到来，数据科学家们面临着越来越复杂的任务。其中，图计算作为一项关键的技术，在处理诸如社交网络、交通网络、分子结构等复杂关系时发挥着不可替代...
基于Spark GraphX 的图形数据分析
weixin_49165958的博客
11-25 385
目录为什么需要图计算一.图（Graph）的基本概念二.Spark GraphX 简介三.GraphX API1.属性图应用示例-12.属性图应用示例-23.查看图信息4.图的算子5.GraphX API 应用6.练习一:谁是网络红人？7.PageRank in GraphX8.练习2：PageRank应用9.Pregel概述10.练习3：使用Pregel计算单源最短路径 为什么需要图计算 许多大数据以大规模图或网络的形式呈现- 许多非图结构的大数据，常会被转换为图模型进行分析- 图数据结构很好地表达了数据
Spark GraphX 图计算
lyd882的博客
09-12 1197
源码：https://github.com/NickyWooden/graphx-demo.git 给部门内部做的培训 1.图论基础 点 边 有向图、无向图 度（入度、出度） 环 DAG 联通图 子图 2.属性图 定义 属性图是一个有向多图，每个顶点和边都有用户定义的对象（属性） Vertex （VertexId,顶点属性） Edge (srcVertexId,de...
Spark GraphX：图计算入门与关键操作
Spark是一个强大的大数据处理框架，而GraphX扩展了其功能，使得在大规模集群上进行复杂图结构的分析和操作变得更加容易。 GraphX的核心概念包括： 1. **图（Graph）**：在GraphX中，图由顶点（Vertices）和边...
sparkGraphX 图操作：GranphX的map操作（mapVertices、mapEdges、mapTriplets）
weixin_43087913的博客
06-07 314
def mapVertices[VD2](map:(VertexId, VD)=> VD2): Graph[VD2, ED] def mapEdges[ED2](map: Edge[ED] => ED2): Graph[VD, ED2] def mapTriplets[ED2](map: EdgeTriplet[VD, ED] => ED2): Graph[VD, ED2]
Spark Graphx常用函数
菜鸟也学大数据的博客
11-26 417
Spark Graph定义 object SparkGraph { def main(args: Array[String]): Unit = { val spark: SparkSession = SparkSession.builder().master("local").appName("Graph").getOrCreate() val sc: SparkContext = spark.sparkContext //创建Vertices //注意元组的顶点的数据类
第八章：在Spark集群上掌握比较重要的图操作之Property Operators（1）
sdujava2011
07-16 563
本部分的内容专注于集群上Property Operator的内容，其中比较重要的就是mapVertices、mapEdges和mapTriplets，即对顶点进行map、对边进行map、对Triplets进行map，在Graph中其方法分别如下所示：       首先来看一下graph实例中的10个元素的具体的值：   可以看到这个10个顶点元素中每个顶
Spark GraphX图计算入门基础
BigData_Hubert的博客
10-13 2115
spark 系列 Spark 核心原理及运行架构 Spark RDD详解 Spark 常用算子大全 Spark SQL 详解 Spark GraphX 图计算入门基础 Spark GraphX图计算入门基础spark 系列前言Spark GraphX 简介GraphX应用背景GraphX 核心APIGraphX 特点Spark GraphX 实现原理两种视图存储模式计算模式GraphX实例 前言 前面几篇博客已经为大家介绍了 Spark 的基础框架、RDD、核心 SparkCore 和 Spark
Spark中文手册8：spark GraphX编程指南（1）
木东的博客
12-15 1405
1.什么是GraphX？ 2.如何将Spark和GraphX引入到项目中？ 3.从一个图中取出顶点特征加入到另外一个图中如何实现？ Spark中文手册-编程指南 Spark之一个快速的例子Spark之基本概念 Spark之基本概念 Spark之基本概念（2） Spark之基本概念（3） Spark-sql由入门到精通 Spark-sql由入门到精通续
sparkGraphx图计算DEMO
qq_16234927的博客
07-18 658
spark图计算简单来说就是构建边集合，点集合，然后把边集合，点集合放到graphx中进行计算。 下面我用scala写一下spark图计算的demo。 package sparksql import org.apache.spark.graphx.{Edge, Graph} import org.apache.spark.{SparkConf, SparkContext} object spa...
Spark GraphX学习笔记
热门推荐
qq_34531825的博客
08-26 1万+
Spark 2.0Graphx学习笔记 概述、图计算应用场景、Spark中图的建立及图的基本操作 利用顶点和边RDD建立一个简单的属性图、读取文件建立图 三种视图及操作、Spark GraphX中的图的函数大全、结构操作 子图subgraph、图的基本信息统计-度计算、Join 连接、相邻聚合消息聚合 图算法工具包、数三角形、连通图、PageRank让链接来投票 pregel、应用实例一Louvai
Apache GraphX 图文详解
05-18 1572
GraphX 图文详解
评论
添加红包

请填写红包祝福语或标题

个

红包个数最小为10个

元

红包金额最低5元

当前余额3.43元 前往充值 >
需支付：10.00元
成就一亿技术人!
领取后你会自动成为博主和红包主的粉丝 规则
hope_wisdom
发出的红包
实付元
使用余额支付
点击重新获取
扫码支付
钱包余额 0

抵扣说明：

1.余额是钱包充值的虚拟货币，按照1:1的比例进行支付金额的抵扣。
2.余额无法直接购买下载，可以购买VIP、付费专栏及课程。

余额充值