Convertir la sortie scala FP-growth RDD en Data frame

Question

https://spark.apache.org/docs/2.1.0/mllib-frequent-pattern-mining.html#fp-growth

L'échantillon_fpgrowth.txt se trouve ici, https://github.com/apache/spark/blob/master/data/mllib/sample_fpgrowth.txt

J'ai exécuté l'exemple FP-growth dans le lien ci-dessus en scala, il fonctionne bien, mais ce dont j'ai besoin, c'est de savoir comment convertir le résultat qui est dans RDD en cadre de données. Ces deux RDD

 model.freqItemsets and 
 model.generateAssociationRules(minConfidence)

expliquer cela en détail avec l'exemple donné dans ma question.

Answer 1

Il existe de nombreuses façons de créer un dataframe une fois que vous avez un rdd . L'une d'entre elles consiste à utiliser .toDF qui nécessite sqlContext.implicits bibliothèque à être imported como

val sparkSession = SparkSession.builder().appName("udf testings")
  .master("local")
  .config("", "")
  .getOrCreate()
val sc = sparkSession.sparkContext
val sqlContext = sparkSession.sqlContext
import sqlContext.implicits._

Après cela, vous lisez le fpgrowth et le dissimuler dans un fichier texte rdd

    val data = sc.textFile("path to sample_fpgrowth.txt that you have used")
    val transactions: RDD[Array[String]] = data.map(s => s.trim.split(' '))

J'ai utilisé le code de Extraction de motifs fréquents - API basée sur RDD qui est fournie dans la question

val fpg = new FPGrowth()
  .setMinSupport(0.2)
  .setNumPartitions(10)
val model = fpg.run(transactions)

La prochaine étape serait d'appeler .toDF fonctions

Pour le premier dataframe

model.freqItemsets.map(itemset =>(itemset.items.mkString("[", ",", "]") , itemset.freq)).toDF("items", "freq").show(false)

cela aboutira à

+---------+----+
|items    |freq|
+---------+----+
|[z]      |5   |
|[x]      |4   |
|[x,z]    |3   |
|[y]      |3   |
|[y,x]    |3   |
|[y,x,z]  |3   |
|[y,z]    |3   |
|[r]      |3   |
|[r,x]    |2   |
|[r,z]    |2   |
|[s]      |3   |
|[s,y]    |2   |
|[s,y,x]  |2   |
|[s,y,x,z]|2   |
|[s,y,z]  |2   |
|[s,x]    |3   |
|[s,x,z]  |2   |
|[s,z]    |2   |
|[t]      |3   |
|[t,y]    |3   |
+---------+----+
only showing top 20 rows

pour le deuxième dataframe

val minConfidence = 0.8
model.generateAssociationRules(minConfidence)
  .map(rule =>(rule.antecedent.mkString("[", ",", "]"), rule.consequent.mkString("[", ",", "]"), rule.confidence))
  .toDF("antecedent", "consequent", "confidence").show(false)

ce qui aboutira à

+----------+----------+----------+
|antecedent|consequent|confidence|
+----------+----------+----------+
|[t,s,y]   |[x]       |1.0       |
|[t,s,y]   |[z]       |1.0       |
|[y,x,z]   |[t]       |1.0       |
|[y]       |[x]       |1.0       |
|[y]       |[z]       |1.0       |
|[y]       |[t]       |1.0       |
|[p]       |[r]       |1.0       |
|[p]       |[z]       |1.0       |
|[q,t,z]   |[y]       |1.0       |
|[q,t,z]   |[x]       |1.0       |
|[q,y]     |[x]       |1.0       |
|[q,y]     |[z]       |1.0       |
|[q,y]     |[t]       |1.0       |
|[t,s,x]   |[y]       |1.0       |
|[t,s,x]   |[z]       |1.0       |
|[q,t,y,z] |[x]       |1.0       |
|[q,t,x,z] |[y]       |1.0       |
|[q,x]     |[y]       |1.0       |
|[q,x]     |[t]       |1.0       |
|[q,x]     |[z]       |1.0       |
+----------+----------+----------+
only showing top 20 rows

J'espère que c'est ce dont vous avez besoin