基於spark2.0文字分詞+多分類模型

文字分類

spark2.0開始引入dataframe作為RDD的上層封裝，以遮蔽RDD層次的複雜操作，本文使用spark milib中ml機器學習庫進行新聞文字多分類預測，包含資料預預處理，分詞，標籤和特徵向量化轉換、多分類模型訓練（包含樸素貝葉斯、邏輯迴歸、決策樹和隨機森林），多分類模型預測和模型評估等完整的機器學習demo。本文分詞方法選用HanLP分詞工具（文件豐富、演算法公開、程式碼開源，並且經測試分詞效果比較好）。

1.資料預處理

1.1文字資料

本文使用的資料為4類新聞，每條資料包含標籤，標題，時間和新聞內容，以"\u00EF"符號作為分割符，資料格式如下：

1.2預處理流程

文字清洗->標籤索引化->內容文字分詞->去除停用詞->分詞取前5000個詞作為特徵->特徵向量化->儲存預處理模型->呼叫預處理模型->輸出預處理資料（indexedLabel，features）

1.3標籤索引化

首先將文字讀取成Dataframe格式，將標籤列資料索引化，{文化，經濟，軍事和體育}向量化後為{0,1,2,3}

/**
    * 資料清洗 可根據具體資料結構和業務場景的不同進行重寫. 注意: 輸出必須要有標籤欄位"label"
    * @param filePath 資料路徑
    * @param spark SparkSession
    * @return 清洗後的資料, 包含欄位: "label", "title", "time", "content"
    */
  def clean(filePath: String, spark: SparkSession): DataFrame = {
    import spark.implicits._
    val textDF = spark.sparkContext.textFile(filePath).flatMap { line =>
      val fields = line.split("\u00EF")   //分隔符：ï，分成標籤，標題，時間，內容
      //首頁|文化新聞ï第十一屆全國優秀舞蹈節目展演將在武漢舉辦ï2016-07-05 19:25:00ï新華社北京7月5日電(記者周瑋)由文化部...
      //首頁|財經中心|財經頻道ï上半年浙江口岸原油進口量創同期歷史新高ï2016-07-04 21:54:00ï杭州7月4日...
      if (fields.length > 3) {
        val categoryLine = fields(0)
        val categories = categoryLine.split("\\|")
        val category = categories.last
        //分成4個標籤名和其他，最後去除標籤為其他的資料
        var label = "其他"
        if (category.contains("文化")) label = "文化"
        else if (category.contains("財經")) label = "財經"
        else if (category.contains("軍事")) label = "軍事"
        else if (category.contains("體育")) label = "體育"
        else {}
        //輸出標籤，標題，時間，內容
        val title = fields(1)
        val time = fields(2)
        val content = fields(3)
        if (!label.equals("其他")) Some(label, title, time, content) else None
      } else None
    }.toDF("label", "title", "time", "content")
    //輸出標籤，標題，時間，內容DF
    textDF
  }
  /**
    * 處理label轉換為索引形式
    * @param data 輸入label欄位的資料
    * @return 標籤索引模型, 模型增加欄位: "indexedLabel"
    */
  def indexrize(data: DataFrame): StringIndexerModel = {
    val labelIndexer = new StringIndexer()
      .setInputCol("label")
      .setOutputCol("indexedLabel")
      .fit(data)

    labelIndexer
  }
複製程式碼

predictDF.select("label","indexedLabel").show(10, truncate = false)
複製程式碼

1.4內容欄位分詞

處理內容欄位，首先要進行分詞，然後去除停用詞以及轉換為特徵向量，方便分類模型進行訓練和預測。本文模仿spark的ml包下的StopWordsRemover類建立了Segmenter類，用於對資料進行分詞，其內部呼叫了HanLP分詞工具。

由於spark自帶的StopWordsRemover等使用的閉包僅限於ml包，自定義的類無法呼叫，故只是採用了與StopWordsRemover類似的使用形式，內部結構並不相同，並且由於以上原因，Segmenter類沒有繼承Transformer類，故無法進行pipeline管道操作,故在分類模型超引數調優過程中，沒有加入分詞模型的引數調優。

/**
    * 分詞過程，包括"分詞", "去除停用詞"
    * @param data   輸入需要分詞的欄位的資料"content"
    * @param params 分詞引數
    * @return 分詞處理後的DataFrame,增加欄位: "tokens", "removed"
    */
  def segment(data: DataFrame, params: PreprocessParam): DataFrame = {
    val spark = data.sparkSession
    //設定分詞模型
    val segmenter = new Segmenter()
      .setSegmentType(params.segmentType) //分詞方式
      .isDelEn(params.delEn)              //是否去除英語單詞
      .isDelNum(params.delNum)            //是否去除數字
      .addNature(params.addNature)        //是否新增詞性
      .setMinTermLen(params.minTermLen)   //最小詞長度
      .setMinTermNum(params.minTermNum)   //行最小詞數
      .setInputCol("content")             //輸入內容欄位
      .setOutputCol("tokens")             //輸出分詞後的欄位
    //進行分詞
    val segDF = segmenter.transform(data)
複製程式碼

1.5去除停用詞

分詞之後，需要對一些常用的無意義詞如：“的”、“我們”、“是”等（統稱為“停用詞”）進行去除。這些詞沒有多大的意義，但這些詞不去掉會強烈的干擾我們對特徵的抽取效果。（比如：在體育分類中，“的”出現500次，“足球”共出現300次，但顯然足球更能表示體育分類，而“的”反而影響體育分類的結果。

去除停用詞的操作我們直接呼叫ml包中的StopWordsRemover類：

    //讀取停用詞資料
    val stopWordArray = spark.sparkContext.textFile(params.stopwordFilePath).collect()
    //設定停用詞模型
    val remover = new StopWordsRemover()
      .setStopWords(stopWordArray)
      .setInputCol(segmenter.getOutputCol)   //讀取"tokens"欄位
      .setOutputCol("removed")               //輸出刪除停用詞後的欄位"removed"
    //刪除停用詞
    val removedDF = remover.transform(segDF)
    removedDF
  }
複製程式碼

1.6特徵向量化

由於目前常用的分類、聚類等演算法都是基於向量空間模型VSM（即將物件向量化為一個N維向量，對映成N維超空間中的一個點），VSM將資料轉換為向量形式，便於對大規模資料進行矩陣操作等，也可以通過計算超空間中兩個點之間的距離（一般是餘弦距離）來計算兩個向量之間的相似度。因此，我們需要將經過處理的語料轉換為向量形式，這個過程叫做向量化。

這裡我們也呼叫spark提供的向量化類CountVectorizer類進行向量化操作：

 /**
   * 特徵向量化處理，包括詞彙表過濾
   * @param data   輸入向量化的欄位"removed"
   * @param params 配置引數
   * @return 向量模型
   */
 def vectorize(data: DataFrame, params: PreprocessParam): CountVectorizerModel = {
   //設定向量模型
   val vectorizer = new CountVectorizer()
     .setVocabSize(params.vocabSize)
     .setInputCol("removed")
     .setOutputCol("features")
   val parentVecModel = vectorizer.fit(data)
   //過濾停用詞中沒有的數字features
   val numPattern = "[0-9]+".r
   val vocabulary = parentVecModel.vocabulary.flatMap {
     term => if (term.length == 1 || term.matches(numPattern.regex)) None else Some(term)
   }
   val vecModel = new CountVectorizerModel(Identifiable.randomUID("cntVec"), vocabulary)
     .setInputCol("removed")
     .setOutputCol("features")
   vecModel
 }
複製程式碼

將欄位"content"先進行分詞和去除停用詞得到"removed",再將所有詞作為特徵，進行特徵向量化得到"features"欄位：

在模型中可以設定出現次數最多的前5000個詞作為分類用的特徵，下圖5000後有兩個陣列，第一個數值表示對應前5000個詞的第幾個詞，第二組表示對應第一組出現的詞在本條資料中的出現的次數，取出一條完整的資料看看：

1.7資料處理模型訓練、儲存和呼叫

為了方便每個模型單獨訓練和預測，將預處理也作為資料處理的模型進行訓練，儲存和呼叫，方法如下：

 /**
    * 訓練預處理模型
    * @param filePath 資料路徑
    * @param spark SparkSession
    * @return (預處理後的資料，索引模型，向量模型）
    *          資料包括欄位: "label", "indexedLabel", "title", "time", "content", "tokens", "removed", "features"
    */
  def train(filePath: String, spark: SparkSession): (DataFrame, StringIndexerModel, CountVectorizerModel) = {

    val params = new PreprocessParam             //預處理引數
    val cleanDF = this.clean(filePath, spark)    //讀取DF，清洗資料
    val indexModel = this.indexrize(cleanDF)     //呼叫索引模型
    val indexDF = indexModel.transform(cleanDF)  //標籤索引化
    val segDF = this.segment(indexDF, params)    //將內容欄位分詞
    val vecModel = this.vectorize(segDF, params) //呼叫向量模型
    val trainDF = vecModel.transform(segDF)      //內容分詞特徵向量化
    this.saveModel(indexModel, vecModel, params) //儲存模型

    (trainDF, indexModel, vecModel)
  }

  /**
    * 擬合預處理模型
    * @param filePath 資料路徑
    * @param spark SparkSession
    * @return (預處理後的資料，索引模型，向量模型）
    */
  def predict(filePath: String, spark: SparkSession): (DataFrame, StringIndexerModel, CountVectorizerModel) = {

    val params = new PreprocessParam                    //預處理引數
    val cleanDF = this.clean(filePath, spark)           //讀取DF，清洗資料
    val (indexModel, vecModel) = this.loadModel(params) //載入索引和向量模型
    val indexDF = indexModel.transform(cleanDF)         //標籤索引化
    val segDF = this.segment(indexDF, params)           //內容欄位分詞
    val predictDF = vecModel.transform(segDF)           //內容分詞特徵向量化

    (predictDF, indexModel, vecModel)
  }
複製程式碼

2.多分類模型訓練和超引數調優

本文選用了常用的4中多分類模型對文字資料進行訓練，利用了管道Pipeline + 網格搜尋Gridsearch + 交叉驗證CrossValidator 進行引數調優，直接將引數調優放在了訓練模型裡，將得到的最優模型儲存。

2.1樸素貝葉斯

樸素貝葉斯演算法原理

樸素貝葉斯演算法是基於貝葉斯定理與特徵條件獨立假設的分類方法。

條件概率

P(A|B)表示事件B已經發生的前提下，事件A發生的概率，叫做事件B發生下事件A的條件概率。其基本求解公式為：

貝葉斯定理便是基於條件概率，通過P(A|B)來求P(B|A)：

特徵條件獨立假設

樸素貝葉斯模型

常用的模型主要有3個，多項式、伯努利和高斯模型：

• 當特徵是離散的時候，使用多項式模型。
• 伯努利模型也適用於離散特徵的情況，所不同的是，伯努利模型中每個特徵的取值只能是1和0，以文字分類為例，某個單詞在文件中出現過，則其特徵值為1，否則為0，而本文是把單詞出現的次數作為特徵，所以不適應於伯努利模型
• 當特徵是連續變數的時候，多項式模型及時加入平滑係數也很難描述分類特徵，因此需要使用高斯模型

平滑係數

超引數平滑係數α，作用是防止後驗概率為0，當α = 1時，稱作Laplace平滑，當0 < α < 1時，稱作Lidstone平滑，α = 0時不做平滑。本文主要對平滑係數進行調參。

  /**
    * NB模型訓練處理過程
    * @param data 訓練資料集
    * @return nbBestModel
    */
  def train(data: DataFrame): NaiveBayesModel = {
    val params = new ClassParam
    //NB分類模型管道訓練調參
    data.persist()
    data.show(5)
    //NB模型
    val nbModel = new NaiveBayes()
      .setModelType(params.nbModelType) //多項式模型或者伯努利模型
      .setSmoothing(params.smoothing)   //平滑係數
      .setLabelCol("indexedLabel")
      .setFeaturesCol("features")
    //建立管道，模型只有一個 stages = 0
    val pipeline = new Pipeline()
      .setStages(Array(nbModel))
    //建立網格搜尋
    val paramGrid = new ParamGridBuilder()
      //.addGrid(nbModel.modelType, Array("multinomial", "bernoulli"))
      //伯努利模型需要特徵為01的資料
      .addGrid(nbModel.smoothing, Array(0.01, 0.1, 0.2, 0.5))
      .build()
    //建立evaluator,必須要保證驗證的標籤列是向量化後的標籤
    val evaluator = new BinaryClassificationEvaluator()
      .setLabelCol("indexedLabel")
    //建立一個交叉驗證的評估器，設定評估器的引數
    val cv = new CrossValidator()
      .setEstimator(pipeline)
      .setEvaluator(evaluator)
      .setEstimatorParamMaps(paramGrid)
      .setNumFolds(2)
    //執行交叉驗證評估器，得到最佳引數集的模型
    val cvModel = cv.fit(data)
    //獲取最優邏輯迴歸模型
    val bestModel = cvModel.bestModel.asInstanceOf[PipelineModel]
    val bestNBModel = bestModel.stages(0).asInstanceOf[NaiveBayesModel]
    println("類的數量(標籤可以使用的值): " + bestNBModel.numClasses)
    println("模型所接受的特徵的數量: " + bestNBModel.numFeatures)
    println("最優的modelType的值為: "+ bestNBModel.explainParam(bestNBModel.modelType))
    println("最優的smoothing的值為: "+ bestNBModel.explainParam(bestNBModel.smoothing))
    //更新最優樸素貝葉斯模型，並訓練資料
    val nbBestModel = new NaiveBayes()
      .setModelType(bestNBModel.getModelType) //多項式模型或者伯努利模型
      .setSmoothing(bestNBModel.getSmoothing) //平滑係數
      .setLabelCol("indexedLabel")
      .setFeaturesCol("features")
      .fit(data)

    this.saveModel(nbBestModel, params)
    data.unpersist()
    nbBestModel
  }
複製程式碼

後續的三個演算法原理網上都有很多，訓練的程式碼也類似，本文只給出模型調參的部分程式碼。

2.2邏輯迴歸

    //LR模型
    val lrModel = new LogisticRegression()
      .setMaxIter(bestLRModel.getMaxIter)    //模型最大迭代次數
      .setRegParam(bestLRModel.getRegParam)  //正則化引數
      .setElasticNetParam(params.elasticNetParam) //L1正規化比例, L1/(L1 + L2)
      .setTol(params.converTol)          //模型收斂閾值
      .setLabelCol("indexedLabel")       //設定索引化標籤欄位
      .setFeaturesCol("features")        //設定向量化文字特徵欄位

    //建立網格搜尋
    val paramGrid = new ParamGridBuilder()
      .addGrid(lrModel.maxIter, Array(5, 10))
      .addGrid(lrModel.regParam, Array(0.1, 0.2))
      .build()
複製程式碼

2.3決策樹

    //決策樹模型
    val dtModel = new DecisionTreeClassifier()
      .setMinInfoGain(params.minInfoGain)  //最小資訊增益閾值
      .setMaxDepth(params.maxDepth)        //決策樹最大深度
      .setImpurity(params.impurity)        //節點不純度和資訊增益方法gini, entropy
      .setLabelCol("indexedLabel")         //設定索引化標籤欄位
      .setFeaturesCol("features")          //設定向量化文字特徵欄位
    //建立網格搜尋
    val paramGrid = new ParamGridBuilder()
      .addGrid(dtModel.minInfoGain, Array(0.0, 0.1))
      .addGrid(dtModel.maxDepth, Array(10, 20))
      .addGrid(dtModel.impurity, Array("gini", "entropy"))
      .build()
複製程式碼

2.4隨機森林

隨機森林模型常常需要除錯以提高演算法效果的兩個引數：numTrees，maxDepth

• numTrees：增加決策樹的個數會降低預測結果的方差，這樣在測試時會有更高的accuracy。訓練時間大致與numTrees呈線性增長關係
• maxDepth：限定決策樹的最大可能深度。最終的決策樹的深度可能要比maxDepth小
• minInfoGain：最小資訊增益（設定閾值），但由於其它終止條件或者是被剪枝的緣故小於該值將不帶繼續分叉
• maxBins：連續特徵離散化時選用的最大分桶個數，並且決定每個節點如何分裂。（25，28，31）
• impurity：計算資訊增益的指標,熵和gini不純度("entropy", "gini")
• minInstancesPerNode：如果某個節點的樣本數量小於該值，則該節點將不再被分叉。（設定閾值）
• auto：在每個節點分裂時是否自動選擇參與的特徵個數
• seed：隨機數生成種子

實際上要想獲得一個適當的閾值是相當困難的。高閾值可能導致過分簡化的樹，而低閾值可能簡化不夠。

預剪枝方法 minInfoGain、minInstancesPerNode 實際上是通過不斷修改停止條件來得到合理的結果，這並不是一個好辦法，事實上 我們常常甚至不知道要尋找什麼樣的結果。這樣就需要對樹進行後剪枝了（後剪枝不需要使用者指定引數，是更為理想化的剪枝方法）

//隨機森林模型（不加fit）
    val rfModel = new RandomForestClassifier()
      .setMaxDepth(params.maxDepth)          //決策樹最大深度
      .setNumTrees(params.numTrees)          //設定決策樹個數
      .setMinInfoGain(params.minInfoGain)  //最小資訊增益閾值
      .setImpurity(params.impurity)        //資訊增益的指標,選擇熵或者gini不純度
      //.setMaxBins(params.maxBins)          //最大分桶個數，用於連續特徵離散化時決定每個節點如何分裂
      .setLabelCol("indexedLabel")           //設定索引化標籤欄位
      .setFeaturesCol("features")            //設定向量化文字特徵欄位
//建立網格搜尋
    val paramGrid = new ParamGridBuilder()
      .addGrid(rfModel.maxDepth, Array(5, 10, 20))
      .addGrid(rfModel.numTrees, Array(5, 10, 20))
      .addGrid(rfModel.minInfoGain, Array(0.0, 0.1, 0.5))
      .build()
複製程式碼

3.多分類模型預測和模型評估

3.1模型評估類MulticlassClassificationEvaluator

機器學期一般都需要一個量化指標來衡量其效果：這個模型的準確率、召回率和F1值(這3個指標是評判模型預測能力常用的一組指標)，spark提供了用於多分類模型評估的類MulticlassClassificationEvaluator，並將3個指標同時輸出

object Evaluations extends Serializable {
  /**
    * 多分類結果評估
    * @param data 分類結果
    * @return (準確率, 召回率, F1)
    */
  def multiClassEvaluate(data: RDD[(Double, Double)]): (Double, Double, Double) = {
    val metrics = new MulticlassMetrics(data)
    val weightedPrecision = metrics.weightedPrecision
    val weightedRecall = metrics.weightedRecall
    val f1 = metrics.weightedFMeasure

    (weightedPrecision, weightedRecall, f1)
  }
}
複製程式碼

3.2四個多分類模型預測結果和模型評估

以邏輯迴歸為例，預測結果如下圖，"probability"中4個值表示4個類別的預測概率：

4個分類模型的評估結果如下：

評估模型程式碼：

/**
  * Description: 多分類模型預測結果評估對比
  * Created by wy in 2019/4/16 10:07
  */
object MultiClassEvalution {

  def main(args: Array[String]): Unit = {

    Logger.getLogger("org.apache.spark").setLevel(Level.ERROR)
    Logger.getLogger("org.apache.eclipse.jetty.server").setLevel(Level.OFF)
    Logger.getLogger("org").setLevel(Level.ERROR)

    val spark = SparkSession
      .builder
      .master("local")
      .appName("Multi_Class_Evaluation_Demo")
      .getOrCreate()

    val filePath = "data/dataTest/predict"

    //預處理(清洗、分詞、向量化)
    val preprocessor = new Preprocessor
    val (predictDF, indexModel, _) = preprocessor.predict(filePath, spark)

    predictDF.select("content","removed", "features").show(1, truncate = false)
    //樸素貝葉斯模型預測
    val nbClassifier = new NBClassifier
    val nbPredictions = nbClassifier.predict(predictDF, indexModel)

    //邏輯迴歸模型預測
    val lrClassifier = new LRClassifier //import Classification.LogisticRegression.LRClassifier
    val lrPredictions = lrClassifier.predict(predictDF, indexModel)

    //決策樹模型預測
    val dtClassifier = new DTClassifier
    val dtPredictions = dtClassifier.predict(predictDF, indexModel)

    //隨機森林模型預測
    val rfClassifier = new RFClassifier
    val rfPredictions = rfClassifier.predict(predictDF, indexModel)

    //多個模型評估
    val predictions = Seq(nbPredictions, lrPredictions, dtPredictions, rfPredictions)
    val classNames = Seq("樸素貝葉斯模型", "邏輯迴歸模型", "決策樹模型", "隨機森林模型")

    for (i <- 0 to 3) {
      val prediction = predictions(i)
      val className = classNames(i)

      val resultRDD = prediction.select("prediction", "indexedLabel").rdd.map {
        case Row(prediction: Double, label: Double) => (prediction, label)
      }

      val (precision, recall, f1) = Evaluations.multiClassEvaluate(resultRDD)
      println(s"\n========= $className 評估結果 ==========")
      println(s"加權準確率：$precision")
      println(s"加權召回率：$recall")
      println(s"F1值：$f1")
    }
  }
}
複製程式碼