Pyspark paire rdd - transformations

Dans Python, Pyspark est un module Spark utilisé pour fournir un type de traitement similaire comme Spark.

RDD signifie ensemble de données distribuées résilientes. Nous pouvons appeler RDD une structure de données fondamentale dans Apache Spark. La paire RDD stocke les éléments / valeurs sous la forme de paires de valeurs clés. Il stockera la paire de valeurs de clé dans le format (clé, valeur).

Nous devons importer RDD à partir du pyspark.module RDD.

Ainsi, dans Pyspark, nous pouvons utiliser la méthode Parallelize () pour créer un RDD,.

Syntaxe:

Spark_App.étincelle.paralléliser (données)

Où,

Les données peuvent être unidimensionnelles (données linéaires) ou deux dimensions (données en row-colonne).

Transformations RDD:

Un RDD de transformation est une opération qui est appliquée à une paire RDD pour créer de nouvelles données à partir de la paire existante RDD. En utilisant des transformations, nous pouvons filtrer la paire RDD en appliquant quelques transformations.

Voyons les transformations qui sont effectuées sur la paire donnée donnée RDD.

Nous en discuterons un par un.

groupbykey

GroupBykey est utilisé pour effectuer une transformation sur une paire RDD en regroupant les valeurs basées sur la clé. Il placera toutes les valeurs groupées dans une liste suivie de la clé.

Syntaxe:

pairrdd_data.GroupBykey ()

Nous utiliserons une boucle pour les clés et les valeurs pour itérer et placer les valeurs dans une liste à l'aide de la fonction list ().

Exemple:

Dans cet exemple, nous avons créé une paire RDD - sujets_rating et effectué une transformation groupbykey () en valeurs de groupe en ce qui concerne la clé. Nous avons donc utilisé une boucle pour itérer les clés et les valeurs, et enfin, nous avons affiché chaque touche et groupe de valeur.

# importer le module Pyspark
Importer Pyspark
#mport Sparkcession pour la création d'une session
de Pyspark.SQL IMPORT SPARKSESSE
# Importer RDD de Pyspark.RDD
de Pyspark.RDD IMPORT RDD
#create une application nommée Linuxhint
Spark_App = Sparkcession.constructeur.appname ('Linuxhint').getorCreate ()
# Créer 6 - Paires de sujets et de notation
sujets_rating = spark_app.étincelle.Parallélize ([('Python', 4), ('JavaScript', 2), ('Linux', 5), ('C #', 4), ('JavaScript', 4), ('Python', 3) ])
#Apply GroupByKey () Transformation sur les sujets ci-dessus_
dictionary_rdd = sujets_rating.GroupBykey ().collecter()
#get les touches et toutes les valeurs WRT aux clés du dictionnaire RDD ci-dessus
Pour les clés, les valeurs dans Dictionary_RDD:
print (clés, "->", liste (valeurs))

Sortir:

Python -> [4, 3]
javascript -> [2, 4]
Linux -> [5]
C # -> [4]

Dans les sujets ci-dessus, la paire RDD, il y a deux valeurs associées à la clé-python et à la clé-javascript et une seule valeur associée à Linux et C #.

moto de sport

SORTBYKEY est utilisé pour effectuer une transformation sur une paire RDD en renvoyant une nouvelle paire RDD dans l'ordre croissant en fonction de la clé. Ainsi, cette transformation trie les éléments de la paire RDD par Key.

Syntaxe:

pairrdd_data.SortBykey ()

Exemple:

Dans cet exemple, nous avons créé une paire RDD - sujets_rating et effectué une transformation SORTBYKEY () pour retourner des valeurs triées basées sur la clé et l'action appliquée collection () pour obtenir la paire triée RDD.

# importer le module Pyspark
Importer Pyspark
#mport Sparkcession pour la création d'une session
de Pyspark.SQL IMPORT SPARKSESSE
# Importer RDD de Pyspark.RDD
de Pyspark.RDD IMPORT RDD
#create une application nommée Linuxhint
Spark_App = Sparkcession.constructeur.appname ('Linuxhint').getorCreate ()
# Créer 6 - Paires de sujets et de notation
sujets_rating = spark_app.étincelle.Parallélize ([('Python', 4), ('JavaScript', 2), ('Linux', 5), ('C #', 4), ('JavaScript', 4), ('Python', 3) ])
#Apply sortByKey () Transformation sur les sujets ci-dessus_rating pour trier les clés dans l'ordre croissant
imprimer (sujets_rating.SortBykey ().collecter())
.

Sortir:

[('C #', 4), ('javascript', 2), ('javascript', 4), ('Linux', 5), ('Python', 4), ('Python', 3)]

Nous pouvons voir que la nouvelle paire triée RDD est renvoyée en triant en fonction de la clé de la paire réelle RDD - Subtes_rating.

Réduisez par la clé

ReduceBykey est utilisé pour effectuer une transformation sur une paire RDD en traitant le parallèle de données pour combiner les valeurs avec des clés similaires. Il a utilisé certaines fonctions comme Lambda () pour combiner les valeurs en fonction de la clé en effectuant une certaine opération dans la fonction.

Syntaxe:

pairrdd_data.Réduisez parykey (fonction lambda)

Fonction Lambda:

Lambda Element1, élément2: opération

Exemple:

Dans cet exemple, nous avons créé une paire RDD - sujets_rating et effectué une transformation RediteByKey () pour effectuer

1. Somme de valeurs similaires en ce qui concerne la clé
2. Différence de valeurs similaires en ce qui concerne la clé
3. Multiplication de valeurs similaires en ce qui concerne la clé
4. Division de valeurs similaires en ce qui concerne la clé

Enfin, nous pouvons utiliser l'action Collect () pour afficher chaque paire transformée RDD.

# importer le module Pyspark
Importer Pyspark
#mport Sparkcession pour la création d'une session
de Pyspark.SQL IMPORT SPARKSESSE
# Importer RDD de Pyspark.RDD
de Pyspark.RDD IMPORT RDD
#create une application nommée Linuxhint
Spark_App = Sparkcession.constructeur.appname ('Linuxhint').getorCreate ()
# Créer 6 - Paires de sujets et de notation
sujets_rating = spark_app.étincelle.Parallélize ([('Python', 4), ('JavaScript', 2), ('Linux', 5), ('C #', 4), ('JavaScript', 4), ('Python', 3) ])
#Apply Réduisez la transformation () sur les sujets ci-dessus_rating pour réduire les clés en ajoutant des valeurs avec des clés similaires
imprimer (sujets_rating.RéduisezBykey (Lambda Element1, élément2: élément1 + élément2).collecter())
#Apply Réduisez la transformation () sur les sujets ci-dessus pour réduire les clés en soustrayant les valeurs des clés similaires
imprimer (sujets_rating.RéduisezBykey (Lambda Element1, Element2: Element1 - Element2).collecter())
#Apply Réduisez la transformation () sur les sujets ci-dessus pour réduire les clés en multipliant les valeurs avec des clés similaires
imprimer (sujets_rating.RéduisezBykey (Lambda Element1, élément2: élément1 * élément2).collecter())
#Apply Réduisez la transformation () sur les sujets ci-dessus_rating pour réduire les clés en divisant les valeurs avec des clés similaires
imprimer (sujets_rating.RéduisezBykey (Lambda Element1, Element2: Element1 / Element2).collecter())

Sortir:

[('Python', 7), ('JavaScript', 6), ('Linux', 5), ('C #', 4)]
[('Python', 1), ('JavaScript', -2), ('Linux', 5), ('C #', 4)]
[('Python', 12), ('JavaScript', 8), ('Linux', 5), ('C #', 4)]
[('Python', 1.3333333333333333), ('javascript', 0.5), ('Linux', 5), ('C #', 4)]
Pour Key-Python: les valeurs sont 4 et 3
La somme: 4 + 3 = 7
La différence est: 4-3 = 1
La multiplication: 4 * 3 = 12
La division est: 4/3 = 1.3333
Pour la clé de clé: les valeurs sont 2 et 4
La somme: 2 + 4 = 6
La différence est: 2-4 = -1
La multiplication: 2 * 4 = 8
La division est: 2/4 = 0.5

Pour Key-Linux et C #: il n'y a qu'une seule valeur pour chacune, donc toutes les opérations résultant sont les mêmes.e.

Conclusion

À partir de cet article RDD de la paire, nous avons vu ce qu'est la transformation et comment appliquer les transformations de la paire RDD. Il y a trois transformations dont nous avons discuté: GroupByKey () est utilisé pour combiner toutes les valeurs en fonction de Key, SortBykey () renvoie un nouveau RDD de paire en triant la paire RDD en fonction des clés dans l'ordre croissant et réduiraykey () combinera des valeurs par rapport à Clé en effectuant une certaine opération en utilisant des fonctions anonymes comme la fonction lambda.