Question

假设我有一个顶点数组，我想以每个顶点连接到下一个x顶点的方式创建它们的边。 x可以有任何整数值。有没有办法用Spark做到这一点？

到目前为止，这就是我对Scala的看法：

CPTPlotRange *newXRange = [CPTPlotRange plotRangeWithLocation:CPTDecimalFromDouble(avgValue-delta)
                                                       length:CPTDecimalFromDouble(delta * 2.0)];

其中vertices变量是（Long，String）的数组。但整个过程当然是顺序的。

修改：

例如，如果我有这样的顶点：//array that holds the edges var edges = Array.empty[Edge[Double]] for(j <- 0 to vertices.size - 2) { for(i <- 1 to x) { if((j+i) < vertices.size) { //add edge edges = edges ++ Array(Edge(vertices(j)._1, vertices(j+i)._1, 1.0)) //add inverse edge, we want both directions edges = edges ++ Array(Edge(vertices(j+i)._1, vertices(j)._1, 1.0)) } } }，Hello，World，and Planet。我需要以下边缘：cosmos，Hello -> World，World -> Hello，Hello -> and，and -> Hello - ＆gt; Hello，Planet，Planet -> Hello，World -> and，and -> World，World -> Planet，Planet -> World，World -> cosmos等等上。

Answer 1

你的意思是这样吗？

// Add dummy vertices at the end (assumes that you don't use negative ids)
(vertices ++ Array.fill(n)((-1L, null))) 
  .sliding(n + 1) // Slide over n + 1 vertices at the time
  .flatMap(arr => { 
     val (srcId, _) = arr.head // Take first
     // Generate 2n edges
     arr.tail.flatMap{case (dstId, _) => 
       Array(Edge(srcId, dstId, 1.0), Edge(dstId, srcId, 1.0))
     }}.filter(e => e.srcId != -1L & e.dstId != -1L)) // Drop dummies
  .toArray

如果你想在RDD上运行它，你只需调整这样的初始步骤：

import org.apache.spark.mllib.rdd.RDDFunctions._

val nPartitions = vertices.partitions.size - 1

vertices.mapPartitionsWithIndex((i, iter) =>
  if (i == nPartitions) (iter ++ Array.fill(n)((-1L, null))).toIterator
  else iter)

当然会丢弃toArray。如果您想要圆形连接（尾部连接到头部），您可以将Array.fill(n)((-1L, null))替换为vertices.take(n)并删除filter。

Answer 2

所以，我认为这会得到你想要的东西：

首先，我定义了一个小辅助函数（注意我在这里设置了边缘数据到顶点名称，因此它更容易在视觉上检查）：

def pairwiseEdges(list: List[(Long, String)]): List[Edge[String]] = {
  list match {
    case x :: xs => xs.flatMap(i => List(Edge(x._1, i._1, x._2 + "--" + i._2), Edge(i._1, x._1, i._2 + "--" + x._2))) ++ pairwiseEdges(xs)
    case Nil => List.empty
  }
}

我在你的数组上做zipWithIndex来获取密钥，然后将数组转换为RDD：

val vertices = List((1L,"hello"), (2L,"world"), (3L,"and"), (4L, "planet"), (5L,"cosmos")).toArray
val indexedVertices = vertices.zipWithIndex
val rdd = sc.parallelize(indexedVertices)

然后使用x=3生成边缘：

val edges = rdd
  .flatMap{case((vertexId, name), index) => for {i <- 0 to 3; if (index - i) >= 0} yield ((index - i, (vertexId, name)))}
  .groupByKey()
  .flatMap{case(index, iterable) => pairwiseEdges(iterable.toList)}
  .distinct()

编辑：重写flatmap并删除评论中@ zero323建议的filter。

这将生成以下输出：

Edge(1,2,hello--world))
Edge(1,3,hello--and))
Edge(1,4,hello--planet)

Edge(2,1,world--hello)
Edge(2,3,world--and)
Edge(2,4,world--planet)
Edge(2,5,world--cosmos)

Edge(3,1,and--hello)
Edge(3,2,and--world)
Edge(3,4,and--planet)
Edge(3,5,and--cosmos)

Edge(4,1,planet--hello)
Edge(4,2,planet--world)
Edge(4,3,planet--and)
Edge(4,5,planet--cosmos)

Edge(5,2,cosmos--world)
Edge(5,3,cosmos--and)
Edge(5,4,cosmos--planet)

使用Spark从顶点创建边

2 个答案: