Comment les méthodes `map` et` reduce` fonctionnent-elles dans les RDD Spark?

Code suivant est à partir du guide de démarrage rapide de Apache Spark.
Quelqu'un peut-il m'expliquer ce qu'est la "ligne" de la variable et d'où il vient?

textFile.map(line => line.split(" ").size).reduce((a, b) => if (a > b) a else b)

Aussi, comment un obtenir une valeur de passé dans un b?

Lien vers le guide de démarrage rapide http://spark.apache.org/docs/latest/quick-start.html

source d'informationauteur DesirePRG

  1. 55

    D'abord, d'après votre lien, le textfile est créé comme

    val textFile = sc.textFile("README.md")

    tels que textfile est un RDD[String]c'est à dire à la résilience de l'distribués ensemble de données de type String. L'API d'accès est très similaire à celui de régulier Scala collections.

    Alors maintenant, qu'est-ce map faire?

    Imaginez que vous avez une liste de Strings et que vous voulez convertir en une liste d'Entiers, représentant la longueur de chaque Chaîne.

    val stringlist: List[String] = List("ab", "cde", "f")
val intlist: List[Int] = stringlist.map( x => x.length )

    La map méthode s'attend à une fonction. Une fonction, qui va de String => Int. Avec cette fonction, chaque élément de la liste est transformé. Ainsi, la valeur de intlist est List( 2, 3, 1 )

    Ici, nous avons créé une fonction anonyme de String => Int. C'est x => x.length. On peut même écrire la fonction la plus explicite, comme 

    stringlist.map( (x: String) => x.length )

    Si vous n'utilisez écrivez ci-dessus explicite, vous pouvez

    val stringLength : (String => Int) = {
  x => x.length
}
val intlist = stringlist.map( stringLength )

    Donc, ici, il est absolument évident, que stringLength est une fonction de String à Int.

    Remarque: En général, map est un Foncteur. Lorsque vous donnez une fonction à partir d'Un => B, map de le foncteur (ici la Liste), vous pouvez utiliser cette fonction pour aller de List[A] => List[B]. Cela s'appelle de levage.

    Des réponses à vos questions

    Qu'est-ce que la "ligne" variable?

    Comme mentionné ci-dessus, line est le paramètre d'entrée de la fonction line => line.split(" ").size

    Plus explicite
    (line: String) => line.split(" ").size

    Exemple: Si line est "hello world", la fonction renvoie 2.

    "hello world" 
=> Array("hello", "world")  //split 
=> 2                        //size of Array

    Comment obtenir une valeur de passé dans un b?

    reduce prévoit aussi une fonction de (A, A) => Aoù A est le type de votre RDD. Permet d'appeler cette fonction op.

    Ce n' reduce. Exemple:

    List( 1, 2, 3, 4 ).reduce( (x,y) => x + y )
Step 1 : op( 1, 2 ) will be the first evaluation. 
  Start with 1, 2, that is 
    x is 1  and  y is 2
Step 2:  op( op( 1, 2 ), 3 ) - take the next element 3
  Take the next element 3: 
    x is op(1,2) = 3   and y = 3
Step 3:  op( op( op( 1, 2 ), 3 ), 4) 
  Take the next element 4: 
    x is op(op(1,2), 3 ) = op( 3,3 ) = 6    and y is 4

    Résultat est la somme des éléments de la liste, 10.

    Remarque: En général reduce calcule

    op( op( ... op(x_1, x_2) ..., x_{n-1}), x_n)

    Exemple complet

    D'abord, le texte est un RDD[Chaîne], dit

    TextFile
 "hello Tyth"
 "cool example, eh?"
 "goodbye"

TextFile.map(line => line.split(" ").size)
 2
 3
 1
TextFile.map(line => line.split(" ").size).reduce((a, b) => if (a > b) a else b)
 3
   Steps here, recall `(a, b) => if (a > b) a else b)`
   - op( op(2, 3), 1) evaluates to op(3, 1), since op(2, 3) = 3 
   - op( 3, 1 ) = 3
  2. 6

    Map et reduce sont des méthodes d'EDR de classe, qui a une interface semblable à la scala collections.

    Ce que vous passer à des méthodes map et reduce sont en fait fonction anonyme (avec un param dans la carte, et avec deux paramètres à réduire). textFile appels de fonctions fournies pour chaque élément (ligne de texte dans ce contexte).

    Vous devriez peut-être lire quelques scala, collection de l'introduction de la première.

    Vous pouvez lire plus sur les EDR de classe de l'API ici:
    https://spark.apache.org/docs/1.2.1/api/scala/#org.apache.spark.rdd.RDD

  3. 1

    ce carte fonction n'est, il prend la liste d'arguments et de l'associer à une certaine fonction. Similaire à la carte de fonction en python, si vous êtes familier.

    Aussi, le Fichier est comme une liste de Chaînes de caractères. (pas exactement, mais c'est la façon dont il est itérée)

    Prenons l'est de votre fichier. 

    val list_a: List[String] = List("first line", "second line", "last line")

    Maintenant, nous allons voir comment carte fonction des œuvres.

    Nous avons besoin de deux choses, list of values que nous avons déjà et function à qui nous voulons dresser la carte de ces valeurs. considérons vraiment simple fonction pour la compréhension. 

    val myprint = (arg:String)=>println(arg)

    cette fonction prend simplement le seul argument de Chaîne et impressions sur la console. 

    myprint("hello world")
hello world

    si nous correspondre à cette fonction à votre liste, il va imprimer toutes les lignes

    list_a.map(myprint)

    On peut écrire une fonction anonyme comme mentionné ci-dessous, qui fait la même chose. 

    list_a.map(arg=>println(arg))

    dans votre cas, line est la première ligne du fichier. vous pouvez changer le nom d'argument que vous le souhaitez. par exemple, dans l'exemple ci-dessus, si je change arg à line il serait de travailler sans aucun problème 

    list_a.map(line=>println(line))