如何从UDF创建自定义Transformer?

时间:2016-02-03 15:03:49

标签: scala apache-spark apache-spark-sql user-defined-functions apache-spark-ml

我尝试使用自定义阶段创建并保存Pipeline。我需要使用columnDataFrame添加UDF。因此,我想知道是否可以将UDF或类似操作转换为Transformer

我的自定义UDF看起来像这样,我想学习如何使用UDF作为自定义Transformer

def getFeatures(n: String) = {
    val NUMBER_FEATURES = 4  
    val name = n.split(" +")(0).toLowerCase
    ((1 to NUMBER_FEATURES)
         .filter(size => size <= name.length)
         .map(size => name.substring(name.length - size)))
} 

val tokenizeUDF = sqlContext.udf.register("tokenize", (name: String) => getFeatures(name))

3 个答案:

答案 0 :(得分:15)

它不是一个功能齐全的解决方案,但你可以从这样的事情开始:

import org.apache.spark.ml.{UnaryTransformer}
import org.apache.spark.ml.util.Identifiable
import org.apache.spark.sql.types.{ArrayType, DataType, StringType}

class NGramTokenizer(override val uid: String)
  extends UnaryTransformer[String, Seq[String], NGramTokenizer]  {

  def this() = this(Identifiable.randomUID("ngramtokenizer"))

  override protected def createTransformFunc: String => Seq[String] = {
    getFeatures _
  }

  override protected def validateInputType(inputType: DataType): Unit = {
    require(inputType == StringType)
  }

  override protected def outputDataType: DataType = {
    new ArrayType(StringType, true)
  }
}

快速检查:

val df = Seq((1L, "abcdef"), (2L, "foobar")).toDF("k", "v")
val transformer = new NGramTokenizer().setInputCol("v").setOutputCol("vs")

transformer.transform(df).show
// +---+------+------------------+
// |  k|     v|                vs|
// +---+------+------------------+
// |  1|abcdef|[f, ef, def, cdef]|
// |  2|foobar|[r, ar, bar, obar]|
// +---+------+------------------+

您甚至可以尝试将其概括为:

import org.apache.spark.sql.catalyst.ScalaReflection.schemaFor
import scala.reflect.runtime.universe._

class UnaryUDFTransformer[T : TypeTag, U : TypeTag](
  override val uid: String,
  f: T => U
) extends UnaryTransformer[T, U, UnaryUDFTransformer[T, U]]  {

  override protected def createTransformFunc: T => U = f

  override protected def validateInputType(inputType: DataType): Unit = 
    require(inputType == schemaFor[T].dataType)

  override protected def outputDataType: DataType = schemaFor[U].dataType
}

val transformer = new UnaryUDFTransformer("featurize", getFeatures)
  .setInputCol("v")
  .setOutputCol("vs")

如果你想使用UDF而不是包装函数,你必须直接扩展Transformer并覆盖transform方法。不幸的是,大多数有用的类都是私有的,所以它可能相当棘手。

或者您可以注册UDF:

spark.udf.register("getFeatures", getFeatures _)

并使用SQLTransformer

import org.apache.spark.ml.feature.SQLTransformer

val transformer = new SQLTransformer()
  .setStatement("SELECT *, getFeatures(v) AS vs FROM __THIS__")

transformer.transform(df).show
// +---+------+------------------+
// |  k|     v|                vs|
// +---+------+------------------+
// |  1|abcdef|[f, ef, def, cdef]|
// |  2|foobar|[r, ar, bar, obar]|
// +---+------+------------------+

答案 1 :(得分:1)

我最初尝试扩展TransformerUnaryTransformer摘要但遇到了我的应用程序无法访问DefaultParamsWriteable的问题。作为一个可能与您的问题相关的示例,我创建了一个简单的术语规范化器作为跟随this example的UDF。我的目标是将术语与模式和集合相匹配,以用通用术语替换它们。例如:

"\b[A-Z0-9._%+-]+@[A-Z0-9.-]+\.[A-Z]{2,}\b".r -> "emailaddr"

这是班级

import scala.util.matching.Regex

class TermNormalizer(normMap: Map[Any, String]) {
  val normalizationMap = normMap

  def normalizeTerms(terms: Seq[String]): Seq[String] = {
    var termsUpdated = terms
    for ((term, idx) <- termsUpdated.view.zipWithIndex) {
      for (normalizer <- normalizationMap.keys: Iterable[Any]) {
        normalizer match {
          case (regex: Regex) =>
            if (!regex.findFirstIn(term).isEmpty) termsUpdated = 
              termsUpdated.updated(idx, normalizationMap(regex))
          case (set: Set[String]) =>
            if (set.contains(term)) termsUpdated = 
              termsUpdated.updated(idx, normalizationMap(set))
        }
      }
    }
    termsUpdated
  }
}

我这样用:

val testMap: Map[Any, String] = Map("hadoop".r -> "elephant",
  "spark".r -> "sparky", "cool".r -> "neat", 
  Set("123", "456") -> "set1",
  Set("789", "10") -> "set2")

val testTermNormalizer = new TermNormalizer(testMap)
val termNormalizerUdf = udf(testTermNormalizer.normalizeTerms(_: Seq[String]))

val trainingTest = sqlContext.createDataFrame(Seq(
  (0L, "spark is cool 123", 1.0),
  (1L, "adsjkfadfk akjdsfhad 456", 0.0),
  (2L, "spark rocks my socks 789 10", 1.0),
  (3L, "hadoop is cool 10", 0.0)
)).toDF("id", "text", "label")

val testTokenizer = new Tokenizer()
  .setInputCol("text")
  .setOutputCol("words")

val tokenizedTrainingTest = testTokenizer.transform(trainingTest)
println(tokenizedTrainingTest
  .select($"id", $"text", $"words", termNormalizerUdf($"words"), $"label").show(false))

现在我把这个问题读得更近一点了,听起来你好像在问这样怎么避免这样做。无论如何,我还会发布它,以防将来某人正在寻找一种简单的方法来应用变压器 - 就像功能一样

答案 2 :(得分:0)

如果您希望变换器也可写,那么您可以在您选择的公共包中的sharedParams库中重新实现HasInputCol等特征,然后将它们与DefaultParamsWritable特性一起使用,以使变换器可持久化。 / p>

通过这种方式,您还可以避免将部分代码放在spark core ml软件包中,但是您可以在自己的软件包中维护一组并行的params。鉴于他们几乎没有改变,这不是一个真正的问题。

但是要跟踪他们的JIRA板here中的错误,该错误要求将一些常见的共享参数公开,而不是私有到ml,以便人们可以直接使用来自外部类的那些。