El Projecte | Sobre nosaltres | Contribuir | Donacions | Llicència
HOME Els meus cursos Finalitzats
◄ Anterior
◄

MapReduce

Següent ►
►

Introducció a MapReduce

MapReduce és un model de programació i una plataforma de processament de dades massives desenvolupada per Google. És especialment útil per processar grans volums de dades de manera distribuïda i paral·lela. El model es basa en dos passos fonamentals: Map i Reduce.

Conceptes Clau

  1. Map: Aquest pas pren un conjunt de dades i el transforma en un altre conjunt de dades, on els elements individuals es descomponen en parelles clau-valor.
  2. Reduce: Aquest pas pren les sortides del pas Map i les combina en un conjunt més petit de parelles clau-valor.

Flux de Treball de MapReduce

  1. Entrada: Les dades d'entrada es divideixen en fragments més petits.
  2. Map: Cada fragment es processa per generar parelles clau-valor intermèdies.
  3. Shuffle and Sort: Les parelles clau-valor intermèdies es barregen i ordenen per clau.
  4. Reduce: Les parelles clau-valor ordenades es processen per generar la sortida final.
  5. Sortida: Les dades processades es guarden en un sistema d'emmagatzematge.

Exemple Pràctic

Problema: Comptar la freqüència de paraules en un conjunt de documents

Pas 1: Map

El pas Map llegeix cada document i emet una parella clau-valor per cada paraula, on la clau és la paraula i el valor és el número 1.

def map_function(document):
    for word in document.split():
        emit(word, 1)

Pas 2: Shuffle and Sort

Les sortides del pas Map es barregen i ordenen per clau (paraula).

Pas 3: Reduce

El pas Reduce suma els valors per a cada clau (paraula) per obtenir el compte total de cada paraula.

def reduce_function(word, counts):
    total = sum(counts)
    emit(word, total)

Implementació en Hadoop

Hadoop és una plataforma que implementa el model MapReduce. A continuació es mostra un exemple de com implementar el comptador de paraules en Hadoop utilitzant Python.

Mapper

import sys

# Input comes from standard input (stdin)
for line in sys.stdin:
    # Remove leading and trailing whitespace
    line = line.strip()
    # Split the line into words
    words = line.split()
    # Increase counters
    for word in words:
        # Write the results to standard output
        print(f'{word}\t1')

Reducer

import sys

current_word = None
current_count = 0
word = None

# Input comes from standard input (stdin)
for line in sys.stdin:
    # Remove leading and trailing whitespace
    line = line.strip()
    # Parse the input we got from mapper.py
    word, count = line.split('\t', 1)
    # Convert count (currently a string) to int
    try:
        count = int(count)
    except ValueError:
        # Count was not a number, so silently ignore/discard this line
        continue

    # This IF-switch only works because Hadoop sorts map output
    # by key (here: word) before it is passed to the reducer
    if current_word == word:
        current_count += count
    else:
        if current_word:
            # Write result to standard output
            print(f'{current_word}\t{current_count}')
        current_count = count
        current_word = word

# Do not forget to output the last word if needed!
if current_word == word:
    print(f'{current_word}\t{current_count}')

Exercici Pràctic

Exercici 1: Comptar la Freqüència de Caràcters

Implementa una versió de MapReduce que compti la freqüència de cada caràcter en un conjunt de documents.

Solució

Mapper

import sys

for line in sys.stdin:
    line = line.strip()
    for char in line:
        print(f'{char}\t1')

Reducer

import sys

current_char = None
current_count = 0
char = None

for line in sys.stdin:
    line = line.strip()
    char, count = line.split('\t', 1)
    try:
        count = int(count)
    except ValueError:
        continue

    if current_char == char:
        current_count += count
    else:
        if current_char:
            print(f'{current_char}\t{current_count}')
        current_count = count
        current_char = char

if current_char == char:
    print(f'{current_char}\t{current_count}')

Errors Comuns i Consells

  1. No ordenar les sortides del Mapper: Assegura't que les sortides del Mapper estiguin ordenades per clau abans de passar-les al Reducer.
  2. No gestionar correctament les excepcions: Sempre gestiona les excepcions, especialment quan converteixes tipus de dades.
  3. No optimitzar el codi: Utilitza estructures de dades eficients i evita operacions innecessàries per millorar el rendiment.

Conclusió

MapReduce és una tècnica poderosa per processar grans volums de dades de manera distribuïda i paral·lela. Comprendre els passos fonamentals i saber implementar-los en plataformes com Hadoop és essencial per a qualsevol professional que treballi amb dades massives.

◄ Anterior
◄
Següent ►
►

Processament de Dades Massives

Mòdul 1: Introducció al Processament de Dades Massives

Mòdul 2: Tecnologies d'Emmagatzematge

Mòdul 3: Tècniques de Processament

Mòdul 4: Eines i Plataformes

Mòdul 5: Optimització de l'Emmagatzematge i Processament

Mòdul 6: Anàlisi de Dades Massives

Mòdul 7: Casos d'Estudi i Aplicacions Pràctiques

Mòdul 8: Bones Pràctiques i Futur del Processament de Dades Massives

El Projecte | Sobre nosaltres | Contribuir | Donacions | Llicència
© Copyright 2024. Tots els drets reservats