Esempio MapReduce Python
"MapReduce" è uno dei terzi componenti di Hadoop. Questo framework è efficiente per l'elaborazione di grandi dati in parallelo con le altre attività. Lo scopo di base di "mapReduce" è mappare ogni lavoro collettivamente in gruppi, e questo lo ridurrà a eguali compiti per ridurre la formazione del cluster dei processi. L'attività "mapReduce" è divisa in due fasi.
- Fase della mappa
- Ridurre la fase
Mappa riduce il concetto e l'architettura
I dati di input vengono distribuiti in piccoli blocchi per l'elaborazione dei dati attraverso diversi lavoratori. Ogni piccolo pezzo è mappato su una situazione/stato intermedio. Tali dati intermedi vengono quindi raccolti insieme, quindi si verifica il processo di partizionamento che si basa su un valore chiave per mantenere tutto il materiale correlato tra loro. Quindi questo partizionamento di dati porta al set ridotto risultante. Consideriamo il diagramma seguente.
Parti dell'architettura
- Cliente: È quello che è responsabile di portare il lavoro a "mapReduce" per la funzione di elaborazione. Ci può essere la possibilità di più clienti che inviano lavori continuamente per l'elaborazione al gestore "mapReduce".
- Lavoro: è l'attività/lavoro effettivo che il cliente desidera fare che contiene molte attività più piccole che il cliente desidera per l'esecuzione.
- Hadoop MapReduce Master: La funzione di questo maestro è di dividere il lavoro in parti di lavoro più piccole.
- Parti di lavoro: I sotto-job ottenuti dalla funzione di lavoro principale. Il valore risultante di tutte le parti di lavoro costituisce collettivamente un output finale.
- Dati in ingresso: I dati che vengono introdotti al REDUCE MAP per l'elaborazione dei dati.
- Dati di output: Contiene le parole limitate in un risultato.
Le parti del lavoro ottenute dal lavoro vengono quindi trasferite sulla mappa e riducono le attività. Questi due compiti hanno programmi e algoritmi che dipendono dal requisito dell'utente. I dati di input vengono utilizzati e inseriti nell'attività della mappa. L'attività della mappa genererà quindi la coppia di valore chiave intermedio che fungerà da input per la fase di riduzione. Nella fase di riduzione, dopo aver eseguito il processo di riduzione, memorizzare i risultati finali negli HDF. Ora muovendosi verso l'esempio del riduzione della mappa, il codice nell'esempio è spiegato con entrambe le fasi separatamente e anche con il loro output.
Codice di Python MapReduce
L'API di streaming Hadoop viene utilizzata per passare i dati tra la mappa e ridurre il codice tramite stdin e stout. Per leggere i dati di input e stampare l'output, “sys.è usato stdin ”. Altre procedure vengono gestite attraverso lo streaming di Hadoop stesso.
Fase della mappa
L'uso principale della fase della mappa è mappare i dati di input sotto forma di coppie di chiavi. Il valore chiave che abbiamo usato può agire in quanto l'ID è un indirizzo e il valore contiene il valore effettivo che viene mantenuto. Questa fase della mappa genererà un valore intermedio con la chiave come output. Per ridurre la funzione, l'uscita della mappa viene utilizzata come input. Consideriamo il codice per la funzione mappa. Questa funzione è anche nota come mapper.Py.
Dovresti creare un file e salvare il codice in quel file. io.e/home/aqsa/mapper.Py. Lo script della mappa non è in grado di calcolare un valore intermedio delle parole totali che si verifica più volte. Invece, darà le parti dei dati anche le parole ripetute volte multipli nei dati di input. Lasceremo che la funzione riduca il numero di parole calcolando la somma del loro verificarsi. Una cosa che dovrebbe essere tenuta a mente, il file ha l'autorizzazione di esecuzione (CHMOD+X/Home/AQSA/MAPPER.py). Muoversi verso il codice, il primo passo sarà l'importazione del modulo SYS. L'input verrà preso utilizzando un ciclo per stdin.
Per la linea in sys.Stdin:
Questa funzione leggerà quindi riga per riga, spogliano tutte le righe e rimuoverà le spazi bianchi tra loro attraverso la funzione della striscia. Allo stesso modo, ogni riga è divisa in parole usando una funzione divisa. Entrambe le funzioni sono dichiarate all'interno del corpo per loop.
# riga = riga.striscia()# words = riga.diviso() #!/usr/bin/env python
"" "Mapper.py "" "
Import sys
# L'ingresso proviene da stdin (input standard)
per la linea in sys.Stdin:
# Rimuovi lo spazio bianco leader e finali
riga = riga.striscia()
# Dividi la linea in parole
parole = riga.diviso()
# Aumenta i contatori
per parola in parole:
# Scrivi i risultati su stdout (output standard);
# Delimitato da tab; il banale conteggio delle parole è 1
print ('%s \ t%s'%(word, 1))
Dopo che tutte le funzioni vengono eseguite, ogni parola verrà stampata per uno.
I valori intermedi subiscono due processi prima di entrare nella fase di riduzione. Queste due fasi sono la fase di mescolamento e di smistamento.
Fase di mescolamento:
Lo scopo di questa funzione è di associare tutti i valori di una chiave simile. Ad esempio, considera una parola (sì, 1) che si è verificata 4 volte nel file di output. Quindi, dopo questa fase, l'output verrà mostrato come (sì, [1,1,1,1]).
Fase di smistamento:
Quando il processo di mescolanza è completato, i valori di output vengono inviati alla fase di ordinamento. In questa fase, tutte le chiavi e i valori vengono ordinati automaticamente. In Hadoop, il processo di smistamento non richiede alcun algoritmo di smistamento, in quanto è un processo automatico. È a causa dell'interfaccia integrata denominata "writeComPableInterface".
Ridurre la fase
I valori intermedi vengono quindi trasferiti alla funzione di riduzione dopo che sono stati ordinati. Il gruppo di funzioni di riduzione i dati in base alla coppia di valore chiave in base all'algoritmo del riduttore utilizzato dal programmatore.
Il codice che implementeremo viene salvato in un file del percorso “/home/aqsa/riduttore.Py ". Questo file leggerà i risultati dal "mapper.Py ”file da stdin. A tale scopo, il formato del "mapper.File Py "e l'input proveniente dal mapper.Py dovrebbe essere lo stesso. Successivamente, questa funzione prende la somma del verificarsi di ogni parola e l'output finale viene visualizzato tramite stdout.
#!/usr/bin/env python"" "Riduciatore.py "" "
Import sys
Current_word = nessuno
Current_Count = 0
parola = nessuna
per la linea in sys.Stdin:
riga = riga.striscia()
# analizza l'input che abbiamo ricevuto da Mapper.Py
parola, count = riga.split ('\ t', 1)
Tentativo:
count = int (count)
Tranne ValueRror:
Continua
Se current_word == word:
Current_Count += Count
altro:
Se current_word:
# scrivi il risultato su stdout
print ('%s \ t%s'%(current_word, current_count))
Current_Count = Count
Current_word = Word
Se current_word == word:
print ('%s \ t%s'%(current_word, current_count))
Il modulo sys viene importato per primo. Quindi una variabile per il processo di conteggio viene dichiarata 0 come valore iniziale. Abbiamo preso i valori di input usando per loop e le linee sono separate proprio come la funzione della mappa. Per dividere le parole, usiamo entrambe le parole e le variabili.
# Count, word = riga.split ('\ t', 1)Nel corpo di prova, alla variabile conteggio viene assegnato il valore. L'e-stato if viene utilizzato per verificare se la parola in arrivo è uguale alla memorizzazione; La variabile di conteggio viene incrementata.
# Current_Count += CountValore risultante
Per controllare i risultati, vai al terminale di Linux. Qui useremo una stringa che combina parole singole e ripetitive per ottenere risultati versatili.
$ echo "La mappa e la riduzione sono funzionalità efficaci ed efficienti, formano una mappa riduce il framework" | /home/aqsa/mapper.Py | ordina -k1,1 | /home/aqsa/riduttore.Py
Conclusione
'MapReduce Python Esempio' consiste nella funzionalità di base e nell'architettura di Map-Reduce collettivamente e separatamente. La formazione del valore intermedio svolge un ruolo importante a questo scopo. Per ottenere il valore limitato, ogni volta che si desidera gestire i big data, è necessario utilizzare una funzione "mapReduce" nel programma. Leggere questo articolo sarà una fonte di informazioni complete sulla funzione "mapReduce".