Exemple MapReduce Python

Plusieurs fois, tout en traitant des données, nous rencontrons une grande quantité de données. Il existe de nombreuses méthodologies pour gérer ce cas. Mais de nombreuses approches ne sont pas capables de gérer la situation. Nous utilisons donc Map-Reduce pour de telles situations. Un «MapReduce» est un cadre et un modèle de programmation à l'intérieur de l'architecture Hadoop, utilisé pour traiter une grande quantité de données dans les systèmes de fichiers Hadoop.

«MapReduce» est l'une des troisième composantes de Hadoop. Ce cadre est efficace pour le traitement de grandes données en parallèle avec les autres tâches. Le but de base de «MapReduce» est de cartographier chaque travail collectivement en groupe, puis cela le réduira à des tâches égales pour réduire la formation de cluster des processus. La tâche «Mapreduce» est divisée en deux phases.

• Phase de cartographie
• Réduire la phase

Carte Réduire le concept et l'architecture

Les données d'entrée sont distribuées en petits morceaux pour le traitement des données par le biais de différents travailleurs. Chaque petit morceau est mappé à une situation / état intermédiaire. Ces données intermédiaires sont ensuite collectées ensemble, puis le processus de partitionnement se produit qui est basé sur une valeur clé pour garder tout le matériel connexe entre eux. Ensuite, ce partitionnement des données conduit à l'ensemble réduit résultant. Considérons le diagramme ci-dessous.

Parties de l'architecture

• Client: C'est celui qui est chargé de prendre le travail pour «mapreduce» pour la fonction de traitement. Il peut y avoir une possibilité de plusieurs clients qui envoient des travaux en continu pour le traitement au gestionnaire «MapReduce».
• Emploi: c'est la tâche / le travail réel que le client veut faire qui contient de nombreuses tâches plus petites que le client veut pour l'exécution.
• Hadoop Mapreduce Master: La fonction de ce maître est de diviser le travail en parties de travail plus petites.
• Parties de travail: Les sous-emplois obtenus à partir de la fonction de travail principale. La valeur résultante de toutes les pièces de travail forme collectivement une sortie finale.
• Des données d'entrée: Les données qui sont introduites à la carte-réduce pour le traitement des données.
• Des données de sortie: Contient les mots limités dans un résultat.

Les pièces de travail obtenues à partir du travail sont ensuite transférées sur la carte et réduisent les tâches. Ces deux tâches ont des programmes et des algorithmes qui dépendent de l'exigence de l'utilisateur. Les données d'entrée sont utilisées et entrées dans la tâche de carte. La tâche de cartographie générera ensuite la paire de valeurs de clé intermédiaire qui servira d'entrée pour la phase de réduction. Dans la phase de réduction, après avoir effectué le processus de réduction, stockez les résultats finaux dans le HDFS. Se déplaçant maintenant vers l'exemple de Map-Reduce, le code de l'exemple est expliqué avec les phases séparément et leur sortie également.

Code de Python MapReduce

L'API de streaming Hadoop est utilisée pour transmettre des données entre la carte et réduire le code via Stdin et Stout. Pour lire les données d'entrée et imprimer la sortie, «sys.stdin ”est utilisé. D'autres procédures sont gérées par Hadoop streaming lui-même.

Phase de cartographie

L'utilisation principale de la phase de carte est de cartographier les données d'entrée sous forme de paires de touches. La valeur de clé que nous avons utilisée peut agir comme ID est une adresse, et la valeur contient la valeur réelle qui est conservée. Cette phase de carte générera une valeur intermédiaire avec la clé en tant que sortie. Pour réduire la fonction, la sortie de la carte est utilisée comme entrée. Considérons le code de la fonction de carte. Cette fonction est également connue sous le nom de mappeur.py.

Vous devez créer un fichier et enregistrer le code dans ce fichier. je.E / Home / AQSA / Mapper.py. Le script de carte n'est pas en mesure de calculer une valeur intermédiaire des mots totaux qui se produisent plusieurs fois. Au lieu de cela, cela donnera aux parties des données, même les mots répétent les multiples heures dans les données d'entrée. Nous laisserons la fonction réduire le nombre de mots en calculant la somme de leur occurrence. Une chose qui doit être gardée à l'esprit, le fichier a une autorisation d'exécution (Chmod + X / Home / AQSA / Mapper.py). Se dirigeant vers le code, la première étape sera l'importation du module SYS. L'entrée sera prise en utilisant une boucle pour STDIN.

Pour la ligne dans sys.stdin:

Cette fonction lira ensuite la ligne par ligne, dépouillera toutes les lignes et supprimera les espaces blancs entre eux à travers la fonction de bande. De même, chaque ligne est divisée en mots en utilisant une fonction divisée. Les deux fonctions sont déclarées à l'intérieur du corps de boucle pour.

# ligne = ligne.bande()
# mots = ligne.diviser() #!/ usr / bin / env python
"" ".py "" "
importer sys
# l'entrée provient de STDIN (entrée standard)
pour la ligne dans sys.stdin:
# Retirez les espaces blancs de tête et de fin
ligne = ligne.bande()
# diviser la ligne en mots
mots = ligne.diviser()
# augmenter les compteurs
pour mot en mots:
# Écrivez les résultats sur stdout (sortie standard);
# onglet délimité; Le nombre de mots triviaux est 1
imprimer ('% s \ t% s'% (mot, 1))

Une fois toutes les fonctions exécutées, chaque mot sera imprimé un par un.

Les valeurs intermédiaires subissent deux processus avant d'entrer dans la phase de réduction. Ces deux étapes sont le mélange et la phase de tri.

Phase de mélange:

Le but de cette fonction est d'associer toutes les valeurs d'une clé similaire. Par exemple, considérez un mot (oui, 1) qui s'est produit 4 fois dans le fichier de sortie. Donc, après cette phase, la sortie sera présentée comme (oui [1,1,1,1])).

Phase de tri:

Une fois le processus de mélange terminé, les valeurs de sortie sont envoyées à la phase de tri. Dans cette phase, toutes les clés et valeurs sont triées automatiquement. Dans Hadoop, le processus de tri ne nécessite aucun algorithme de tri, car il s'agit d'un processus automatique. C'est à cause de l'interface intégrée nommée «WriteBableCaparable Interface».

Réduire la phase

Les valeurs intermédiaires sont ensuite transférées à la fonction de réduction après leur tri. Le groupe de fonctions de réduction les données en fonction de la paire de valeurs clés selon l'algorithme de réducteur utilisé par le programmeur.

Le code que nous implémenterons est enregistré dans un fichier du chemin «/ home / aqsa / réducteur.py ". Ce fichier lira les résultats du «mappeur.fichier py »du stdin. À cette fin, le format du «Mapper.Fichier py »et l'entrée provenant du mapper.py devrait être le même. Après cela, cette fonction prend la somme de l'occurrence de chaque mot, et la sortie finale est affichée via STDOUT.

#!/ usr / bin / env python
"" "réducteur.py "" "
importer sys
current_word = aucun
current_count = 0
mot = aucun
pour la ligne dans sys.stdin:
ligne = ligne.bande()
# Analyser l'entrée que nous avons obtenue de Mapper.py
mot, count = ligne.Split ('\ t', 1)
essayer:
count = int (count)
sauf ValueError:
continuer
Si current_word == mot:
current_count + = count
autre:
Si current_word:
# Écrivez le résultat à Stdout
print ('% s \ t% s'% (current_word, current_count))
current_count = count
current_word = mot
Si current_word == mot:
print ('% s \ t% s'% (current_word, current_count))

Le module sys est importé en premier. Alors une variable pour le processus de comptage est déclarée 0 comme valeur initiale. Nous avons pris les valeurs d'entrée en utilisant pour la boucle, et les lignes sont séparées tout comme la fonction de carte. Pour diviser les mots, nous utilisons à la fois les mots et les variables de comptage.

# Compter, word = ligne.Split ('\ t', 1)

Dans le corps d'essai, la variable de nombre se voit attribuer la valeur. L'IF-statement est utilisé pour vérifier si le mot à venir est le même que le stocké; La variable de comptage est incrémentée.

# Current_count + = count

Valeur résultante

Pour vérifier les résultats, accédez au terminal de Linux. Ici, nous utiliserons une chaîne qui combine des mots simples et répétitifs pour obtenir des résultats polyvalents.

$ echo «La carte et la réduction sont une fonction efficace et efficace, former une carte réduit le cadre» | / Home / AQSA / Mapper.py | Triez -K1,1 | / home / aqsa / réducteur.py

Conclusion

«MapReduce Python Exemple» se compose de la fonctionnalité et de l'architecture de base de Map-Reduce collectivement et séparément. La formation de valeur intermédiaire joue un rôle important dans cette fin. Pour obtenir la valeur limitée, chaque fois que vous souhaitez gérer les mégadonnées, vous devez utiliser une fonction «MapReduce» dans le programme. La lecture de cet article sera une source d'informations complètes concernant la fonction «MapReduce».