Comment préparer des données dans un format LibSVM à partir de DataFrame?

Je veux faire libsvm format, j'ai donc fait dataframe pour le format souhaité, mais je ne sais pas comment les convertir pour libsvm format. Le format est tel que montré dans la figure. J'espère que le souhaité libsvm type est utilisateur item:notation . Si vous savez quoi faire dans la situation actuelle :

val ratings = sc.textFile(new File("/user/ubuntu/kang/0829/rawRatings.csv").toString).map { line =>
     val fields = line.split(",")
      (fields(0).toInt,fields(1).toInt,fields(2).toDouble)
}
val user = ratings.map{ case (user,product,rate) => (user,(product.toInt,rate.toDouble))}
val usergroup = user.groupByKey 

val data =usergroup.map{ case(x,iter) => (x,iter.map(_._1).toArray,iter.map(_._2).toArray)}

val data_DF = data.toDF("user","item","rating")

source d'informationauteur Data diaboli

12

Le problème que vous rencontrez peut être divisé en :
- La conversion de vos cotes (je crois) dans LabeledPoint données X.
- Économie de X dans libsvm format.
1. La conversion de vos cotes dans les LabeledPoint données X

Considérons les premières suivantes cotes :
```
val rawRatings: Seq[String] = Seq("0,1,1.0", "0,3,3.0", "1,1,1.0", "1,2,0.0", "1,3,3.0", "3,3,4.0", "10,3,4.5")
```
Vous permet de gérer ces premières notes comme un coordonner la liste de la matrice (COO).

Étincelle met en œuvre une matrice distribuée soutenu par une EDR de ses entrées : CoordinateMatrix où chaque entrée est un n-uplet (i: Longue, j: Longue, valeur: Double).

Remarque : Un CoordinateMatrix doit être utilisé uniquement lorsque les deux dimensions de la matrice sont énormes, et la matrice est très clairsemée. (ce qui est généralement le cas de l'utilisateur/item ratings.)
```
import org.apache.spark.mllib.linalg.distributed.{CoordinateMatrix, MatrixEntry}
import org.apache.spark.rdd.RDD

val data: RDD[MatrixEntry] = 
      sc.parallelize(rawRatings).map {
            line => {
                  val fields = line.split(",")
                  val i = fields(0).toLong
                  val j = fields(1).toLong
                  val value = fields(2).toDouble
                  MatrixEntry(i, j, value)
            }
      }
```
Maintenant, nous allons convertir que RDD[MatrixEntry] à un CoordinateMatrix et d'en extraire les lignes indexées :
```
val df = new CoordinateMatrix(data) //Convert the RDD to a CoordinateMatrix
                .toIndexedRowMatrix().rows //Extract indexed rows
                .toDF("label", "features") //Convert rows
```
2. Enregistrement LabeledPoint données dans libsvm format

Depuis Spark 2.0Vous pouvez le faire en utilisant les DataFrameWriter . Nous allons créer un petit exemple avec un mannequin LabeledPoint de données (vous pouvez également utiliser le DataFrame nous avons créé précédemment) :
```
import org.apache.spark.mllib.linalg.Vectors
import org.apache.spark.mllib.regression.LabeledPoint
val pos = LabeledPoint(1.0, Vectors.dense(1.0, 0.0, 3.0))
val neg = LabeledPoint(0.0, Vectors.sparse(3, Array(0, 2), Array(1.0, 3.0)))

val df = Seq(neg,pos).toDF("label","features")
```
Nous ne pouvons malheureusement pas utiliser le DataFrameWriter directement parce que tandis que la plupart des composants de pipeline en charge la compatibilité descendante pour le chargement de certains DataFrames et les pipelines Étincelle dans les versions antérieures à la 2.0, qui contiennent vecteur ou d'une matrice de colonnes, peuvent être migrés vers la nouvelle étincelle.ml matrice et vecteur de types.

Utilitaires pour la conversion DataFrame les colonnes de mllib.linalg à ml.linalg types (et vice versa) peut être trouvé dans org.apache.spark.mllib.util.MLUtils. Dans notre cas, nous avons besoin de faire ce qui suit (à la fois pour les données factices et les DataFrame de step 1.)
```
import org.apache.spark.mllib.util.MLUtils
//convert DataFrame columns
val convertedVecDF = MLUtils.convertVectorColumnsToML(df)
```
Maintenant, nous allons enregistrer le DataFrame :
```
convertedVecDF.write.format("libsvm").save("data/foo")
```
Et nous pouvons vérifier le contenu des fichiers :
```
$ cat data/foo/part*
0.0 1:1.0 3:3.0
1.0 1:1.0 2:0.0 3:3.0
```
MODIFIER:
Dans la version actuelle de l'étincelle (2.1.0) il n'est pas nécessaire d'utiliser mllib paquet. Vous pouvez simplement sauvegarder LabeledPoint données dans libsvm format comme ci-dessous:
```
import org.apache.spark.ml.linalg.Vectors
import org.apache.spark.ml.feature.LabeledPoint
val pos = LabeledPoint(1.0, Vectors.dense(1.0, 0.0, 3.0))
val neg = LabeledPoint(0.0, Vectors.sparse(3, Array(0, 2), Array(1.0, 3.0)))

val df = Seq(neg,pos).toDF("label","features")
df.write.format("libsvm").save("data/foo")
```

Vous devez vous connecter pour publier un commentaire.