Question

我有一个包含1300万行和800列的PySpark数据帧。我需要对这些数据进行规范化，因此一直使用此代码，该代码适用于较小的开发数据集。

def z_score_w(col, w):
    avg_ = avg(col).over(w)
    stddev_ = stddev_pop(col).over(w)
    return (col - avg_) / stddev_

w = Window().partitionBy().rowsBetween(-sys.maxsize, sys.maxsize)    
norm_exprs = [z_score_w(signalsDF[x], w).alias(x) for x in signalsDF.columns]

normDF = signalsDF.select(norm_exprs)

但是，在使用完整数据集时，我遇到了codegen：

的异常

        at org.apache.spark.sql.catalyst.expressions.codegen.CodeGenerator$.org$apache$spark$sql$catalyst$expressions$codegen$CodeGenerator$$doCompile(CodeGenerator.scala:893
)
        at org.apache.spark.sql.catalyst.expressions.codegen.CodeGenerator$$anon$1.load(CodeGenerator.scala:950)
        at org.apache.spark.sql.catalyst.expressions.codegen.CodeGenerator$$anon$1.load(CodeGenerator.scala:947)
        at org.spark_project.guava.cache.LocalCache$LoadingValueReference.loadFuture(LocalCache.java:3599)
        at org.spark_project.guava.cache.LocalCache$Segment.loadSync(LocalCache.java:2379)
        ... 44 more
Caused by: org.codehaus.janino.JaninoRuntimeException: Code of method "(Lorg/apache/spark/sql/catalyst/expressions/GeneratedClass;[Ljava/lang/Object;)V" of class "org.apache.
spark.sql.catalyst.expressions.GeneratedClass$SpecificMutableProjection" grows beyond 64 KB
        at org.codehaus.janino.CodeContext.makeSpace(CodeContext.java:941)
        at org.codehaus.janino.CodeContext.write(CodeContext.java:836)
        at org.codehaus.janino.UnitCompiler.writeOpcode(UnitCompiler.java:10251)
        at org.codehaus.janino.UnitCompiler.pushConstant(UnitCompiler.java:8933)
        at org.codehaus.janino.UnitCompiler.compileGet2(UnitCompiler.java:4346)
        at org.codehaus.janino.UnitCompiler.access$7100(UnitCompiler.java:185)
        at org.codehaus.janino.UnitCompiler$10.visitBooleanLiteral(UnitCompiler.java:3267)

周围有一些Spark JIRA issues看似相似，但这些都标记为已解决。还有this SO question是相关的，但答案是另一种技术。

我有自己的解决方法，我规范化数据帧的批量列。这样可行，但我最终得到了多个数据帧，然后我必须加入，这很慢。

所以，我的问题是 - 是否有一种替代技术可以规范化我丢失的大型数据帧？

我使用的是spark-2.0.1。

Answer 1

一个明显的问题是您使用窗口函数的方式。以下框架：

Window().partitionBy().rowsBetween(-sys.maxsize, sys.maxsize)

在实践中有点无用。如果没有分区列，它会首先将所有数据重新分配到单个分区。这种缩放方法仅适用于在组中执行缩放。

Spark提供了两个可用于扩展功能的类：

pyspark.ml.feature.StandardScaler
pyspark.mllib.feature.StandardScaler

不幸的是，两者都需要Vector个数据作为输入。用ML

from pyspark.ml.feature import StandardScaler as MLScaler, VectorAssembler
from pyspark.ml import Pipeline

scaled = Pipeline(stages=[
    VectorAssembler(inputCols=df.columns, outputCol="features"), 
    MLScaler(withMean=True, inputCol="features", outputCol="scaled")
]).fit(df).transform(df).select("scaled")

如果您需要原始形状，则需要进一步扩展scaled列。

使用MLlib：

from pyspark.mllib.feature import StandardScaler as MLLibScaler
from pyspark.mllib.linalg import DenseVector

rdd = df.rdd.map(DenseVector)
scaler = MLLibScaler(withMean=True, withStd=True)

scaler.fit(rdd).transform(rdd).map(lambda v: v.array.tolist()).toDF(df.columns)

如果存在与列数相关的codegen问题，则后一种方法会更有用。

您可以通过另一种方法来解决此问题以计算全局统计数据

from pyspark.sql.functions import avg, col, stddev_pop, struct

stats = df.agg(*[struct(avg(c), stddev_pop(c)) for c in df.columns]).first()

并选择：

df.select(*[
    ((col(c) - mean) / std).alias(c)
    for (c, (mean, std)) in zip(df.columns, stats)
])

根据您的评论，您可以想到的最简单的解决方案可以使用NumPy和一些基本转换来表达：

rdd = df.rdd.map(np.array)  # Convert to RDD of NumPy vectors
stats = rdd.stats()  # Compute mean and std
scaled = rdd.map(lambda v: (v - stats.mean()) / stats.stdev())  # Normalize

并转换回DataFrame：

scaled.map(lambda x: x.tolist()).toDF(df.columns)

Answer 2

请查看此链接，我们通过在代码中添加检查点来解决此错误。

Checkpoint只是将数据或数据帧写回到磁盘并读回。

https://stackoverflow.com/a/55208567/7241837

检查点详细信息

https://github.com/JerryLead/SparkInternals/blob/master/markdown/english/6-CacheAndCheckpoint.md

问：哪种RDD需要检查点？

the computation takes a long time
the computing chain is too long
depends too many RDDs

实际上，将ShuffleMapTask的输出保存在本地磁盘上也是检查点，但这仅用于分区的数据输出。

问：何时要检查点？

如上所述，每次需要缓存计算分区时，都会将其缓存到内存中。但是，检查点不遵循相同的原理。相反，它将等待到作业结束，然后启动另一个作业以完成检查点。需要检查点的RDD将被计算两次；因此建议在rdd.checkpoint（）之前执行rdd.cache（）。在这种情况下，第二个作业将不会重新计算RDD。相反，它将仅读取缓存。实际上，Spark提供了rdd.persist（StorageLevel.DISK_ONLY）方法，例如在磁盘上进行缓存。因此，它在第一次计算时会将RDD缓存在磁盘上，但是这种持久性和检查点是不同的，我们将在后面讨论差异。

问：如何实施检查点？

这是步骤：

RDD将为：[初始化->标记为检查点->   检查点进行中->检查点]。最后，它将是   检查点。

用于数据框的Similalry：将数据框写入磁盘或s3，然后将数据读回到新的数据框中。

已初始化

在驱动程序端，调用rdd.checkpoint（）之后，RDD将由RDDCheckpointData管理。用户应设置检查点的存储路径（在hdfs上）。

标记为检查点

初始化后，RDDCheckpointData将标记RDD MarkedForCheckpoint。

检查点正在进行中

作业完成后，将调用finalRdd.doCheckpoint（）。 finalRDD向后扫描计算链。当遇到需要检查的RDD时，该RDD将标记为CheckpointingInProgress，然后将配置文件（用于写入hdfs）（如core-site.xml）广播到其他工作节点的blockManager。之后，将启动一个作业以完成检查点：

  rdd.context.runJob(rdd, CheckpointRDD.writeToFile(path.toString,  broadcastedConf))

检查点

作业完成检查点后，它将清除RDD的所有依赖项并将RDD设置为检查点。然后，添加一个补充依赖项并将父RDD设置为CheckpointRDD。将来将使用checkpointRDD从文件系统读取检查点文件，然后生成RDD分区

有趣的是：

两个RDD在驱动程序中被检查点，但是只有结果（请参见下面的代码）被成功检查点。不确定是错误还是仅对下游RDD进行有意检查。

val data1 = Array[(Int, Char)]((1, 'a'), (2, 'b'), (3, 'c'),
    (4, 'd'), (5, 'e'), (3, 'f'), (2, 'g'), (1, 'h'))
   val pairs1 = sc.parallelize(data1, 3)

   val data2 = Array[(Int, Char)]((1, 'A'), (2, 'B'), (3, 'C'), (4, 'D'))
   val pairs2 = sc.parallelize(data2, 2)

   pairs2.checkpoint

   val result = pairs1.join(pairs2)
   result.checkpoint

在规范化大型PySpark数据帧时，CodeGen增长超过64 KB

2 个答案: