Material « Clúster Big Data

1 MapReduce

MapReduce es un modelo de programación y un marco de ejecución para resolver problemas de procesamiento de datos masivos.

Apache MapReduce

1.1 Introduccion MapReduce

Hadoop MapReduce es un framework para escribir fácilmente aplicaciones que procesan grandes cantidades de datos en paralelo en grandes clústeres (miles de nodos) de hardware commodity de manera confiable y tolerante a fallos.

Framework:En MapReduce, los desarrolladores escriben trabajos que consisten principalmente en una función map y una función reduce, y el framework maneja los detalles complejos de paralelizar el trabajo, monitorizar la ejecución o recuperarse ante errores. Debes entender que este tipo de operaciones (monitorización, control de errores, gestión de la concurrencia, etc.) son las más complejas en cualquier sistema de procesamiento masivo de datos, y habitualmente supone el 90% de todo el esfuerzo realizado en el desarrollo de un proceso masivo.De esta manera, los desarrolladores están protegidos de tener que implementar código complejo y repetitivo y, en su lugar, sólo deben centrarse en desarrollar los algoritmos y la lógica de negocio.El framework invoca el código proporcionado por el usuario y no al revés. En este sentido, este paradigma es muy parecido a la mayoría de frameworks de desarrollo web, donde el desarrollador debe desarrollar sólo la lógica de negocio que hay detrás de cada interacción del usuario, y no debe preocuparse en los detalles sobre manejar el protocolo HTTP, la concurrencia de las aplicaciones, la gestión de las sesiones de usuario, etc.
Grandes Cantidades de Datos:MapReduce está diseñado para poder procesar grandes cantidades de datos, ya que sigue una filosofía Divide y Vencerás (DYV), que consiste en que para resolver un problema complejo, la mejor forma de hacerlo es dividirlo en fragmentos muy pequeños que pueden ser solucionados de forma independiente, resolverlo por separado e ir construyendo con las soluciones parciales la solución final.Para el caso del procesamiento de datos de mucho volumen, la aproximación Divide y Vencerás que hace MapReduce consiste en dividir todo el conjunto de datos de entrada en pequeños fragmentos, procesarlos por separado, e ir agrupando los resultados parciales.
Paralelo:MapReduce ejecuta el procesamiento de cada elemento por separado y el paralelo, es decir, la ejecución se divide en partes pequeñas y cada parte pequeña se ejecuta en paralelo, lo que facilita la escalabilidad o la tolerancia a fallos.
Clusteres:MapReduce se ejecuta en paralelo en un modelo de computación distribuida, es decir, cada pieza de ejecución se ejecuta en una máquina diferente, siendo cada máquina un servidor de un clúster Hadoop.YARN se ocupa de los detalles de la ejecución en cuanto a asignación de recursos, nodos disponibles, etc.Asimismo, MapReduce puede ejecutarse en clústers de más de mil nodos, o incluso más, ya que el paradigma no tiene limitaciones en cuanto al número de servidores que pueden ejecutar un trabajo.
Hardware Commodity:MapReduce no requiere unos servidores específicos para su ejecución. De hecho, ¡emplea los mismos servidores de la plataforma Hadoop!
Confiable y Tolerante a Fallos:Uno de las principales ventajas de MapReduce frente a otros modelos de programación más eficientes, es que es confiable, es decir, la ejecución de trabajos siempre obtiene los mismos resultados, y además, tiene una capacidad para sobreponerse a fallos muy buena. Durante la ejecución de un trabajo, en caso de que uno de los nodos falle, MapReduce puede recuperar la tarea que dicho nodo estaba ejecutando y reprocesarla con otro nodo activo.En ocasiones se hace el símil de MapReduce con una apisonadora, en el sentido de que es lenta pero segura, y en contraposición con otros frameworks que aunque tienen una velocidad superior, al utilizar elementos como la memoria, que puede ser volátil, u otro tipo de aceleradores, hace que tengan una tasa de fallos superior a MapReduce, y por ello, habitualmente, los procesos pesados que se ejecutan en ventana nocturna, que no requieren un tiempo de procesamiento corto, se confían a MapReduce ya que tiene mayor garantía de finalización correcta.

Aunque MapReduce ha sido utilizado ampliamente por toda la comunidad de desarrolladores o proyectos Big Data, la realidad es que hoy en día cada vez se usa menos. Pero es importante entender y comprender bien MapReduce por dos motivos:

Utiliza un modelo de programación que es común en otras herramientas o frameworks Big Data.
Muchas herramientas que se ejecutan sobre Hadoop, como puede ser el caso de Hive, pese a que ofrecen funcionalidad de alto nivel, como puede ser la capacidad de hacer consultas en formato SQL, por debajo ejecutan MapReduce. Entender MapReduce es fundamental para poder depurar o resolver problemas en la ejecución de trabajos con este tipo de herramientas.

1.2 Funcionamiento MapReduce

Un trabajo de MapReduce se compone de las siguientes etapas, ejecutadas en orden:

Input (Entrada): agregación de la información textual que se procesará. Envío del trabajo, aceptación y distribución en el clúster.
Splitting (Fracmentacion): Proceso de división de los datos.
Mapping (Mapeo): Mapeo de la información, es decir, la identificación y clasificación de los datos.
Shuffling (Barajar): Reubicación de los datos según su relación y & Order(Ordenación) oredenación de los datos.
Reducing (Reducir): La cúspide de su función es reducir. Hadoop MapReduce lleva a cabo su principal objetivo de reducir la información basándose en los parámetros de análisis de datos.
Final result: Los resultados de la información simplificada.

De todas estas fases debes saber que el programador sólo suele programar la fase map y reduce, siendo el resto de fases ejecutadas de forma automática por MapReduce en base a los parámetros de configuración.

Para explicar el funcionamiento de MapReduce, se va a utilizar el siguiente ejemplo:

Imagina que tenemos un fichero de muchos terabytes de datos con todas las cotizaciones de todas las empresas de todas las bolsas del mundo desde hace 30 años, con una cotización cada minuto.

Tomando una media de 35.000 empresas cotizadas en el mundo, es decir, 35.000 cotizaciones por minuto serían 25.200.000 cotizaciones al día, y un total de 275.940.000.000 líneas en el fichero, que son unos 25 terabytes de datos en un único fichero.

Cada línea del fichero tiene el siguiente formato:

20/01/2021 11:54:34;SANTANDER;4,54;4,49 
14/05/1995 09:54;TELEFONICA;11,90;12,01 
01/01/1997 08:03:21;SANTANDER;11,24;11,49 
19/06/2022 11:54:22;APPLE;111,25;114,89 
23/04/2003 16:32:11;ALPHABET;34,49;36,44 
21/12/2020 10:10:56;TELEFONICA;14,31;14;29 
26/02/1995 14:09:40;MICROSOFT;132,29;133,95 
04/05/1999 11:05:34;WALLMART;34,98;35,05 
...

20/01/2021 11:54:34;SANTANDER;4,54;4,49

14/05/1995 09:54;TELEFONICA;11,90;12,01

01/01/1997 08:03:21;SANTANDER;11,24;11,49

19/06/2022 11:54:22;APPLE;111,25;114,89

23/04/2003 16:32:11;ALPHABET;34,49;36,44

21/12/2020 10:10:56;TELEFONICA;14,31;14;29

26/02/1995 14:09:40;MICROSOFT;132,29;133,95

04/05/1999 11:05:34;WALLMART;34,98;35,05

...

Nuestro objetivo es averiguar cuántas veces ha tenido cada empresa un incremento en su cotización, es decir, si una cotización es superior a su valor anterior, sumaremos uno, y si la cotización es inferior, no lo sumaremos.

Es decir, el resultado sería una lista de la siguiente forma:

SANTANDER 3888981 
TELEFONICA 3331923 
...

SANTANDER 3888981

TELEFONICA 3331923

...

Intentar este cálculo leyendo el fichero de forma secuencial y teniendo un contador para cada empresa sería un proceso que llevaría días de procesamiento, así que vamos a utilizar MapReduce para realizar este proceso.

El primer paso es crear la aplicación, utilizando un lenguaje (Java, R, Python …), y enviar el programa al clúster Hadoop utilizando el API de MapReduce para enviar trabajos.

El ResourceManager de YARN tomará el trabajo y en función de la situación del clúster en cuanto al número de contenedores disponibles, arrancará un ApplicationsMaster que lanzará la aplicación MapReduce.

Una vez arrancada la aplicación, en primer lugar decidirá cómo partir el fichero de entrada en fragmentos para que los datos puedan ser procesados en paralelo. El componente que realiza esta división de los ficheros de entrada se denomina InputFormat.

Por cada fragmento del fichero de entrada, se crea una tarea map que ejecutará la función map desarrollada en diferentes nodos y en paralelo, es decir, cada fragmento será procesado en paralelo por diferentes nodos.

La función map toma cada línea, que es separada por el InputFormat, la lee, y emite un resultado parcial, que seá [Nombre de la empresa, 1], en los casos en los que vea que el valor actual es mayor que el valor anterior. Esta función se ejecutará tantas veces como líneas tenga el fragmento de fichero asignado, y en tantos nodos como fragmentos se haya dividido el fichero.

Es decir, para cada nodo, tendremos, este resultado:

SANTANDER, 1
WALLMART, 1
TELEFONICA, 1
APPLE, 1
ALPHABET, 1
...

SANTANDER, 1

WALLMART, 1

TELEFONICA, 1

APPLE, 1

ALPHABET, 1

...

Y tendremos tantos resultados de estos como fragmentos del fichero haya, y en tantos nodos/servidores como se haya ejecutado la función.

A continuación se ejecutan las fases de shuffle y sort de forma automática y transparente para el desarrollador, donde se toman los resultados parciales, se ordenan por una clave, que en este caso será el nombre de la empresa, se combinan y se ordenan, juntando todos los valores de cada empresa, es decir, teniendo la lista de valores con el siguiente formato:

ALPHABET, 1
ALPHABET, 2
APPLE, 1
APPLE, 4
APPLE, 1
APPLE, 3
SANTANDER, 1
SANTANDER, 3
SANTANDER, 2
SANTANDER, 1
TELEFONICA, 3
TELEFONICA, 2
TELEFONICA, 1
WALLMART, 4
WALLMART, 2
...

ALPHABET, 1

ALPHABET, 2

APPLE, 1

APPLE, 4

APPLE, 1

APPLE, 3

SANTANDER, 1

SANTANDER, 3

SANTANDER, 2

SANTANDER, 1

TELEFONICA, 3

TELEFONICA, 2

TELEFONICA, 1

WALLMART, 4

WALLMART, 2

...

Por último, se divide la lista ordenada en diferentes particiones, siendo cada partición un conjunto de datos con la misma clave, y se llaman a la función reduce desarrollada por el usuario, que tomará los diferentes valores emitidos por la fase map, pero ya ordenados y unidos, e irá haciendo la suma de cada empresa, dando como resultado pares [Nombre de la empresa, número de veces que se ha encontrado una cotización incrementada].

MapReduce, por último tomará todos los resultados de las funciones reduce y las unirá, formando el resultado final, que será la lista total de empresas con el número de veces en las que la cotización sube.

2 EJERCICIO:

Ocurrecia de Palabras en un Fichero (Word Count) escrito en distintos lenguajes (R, Python, Pig y Java):

2.1 R:

WordCount_mapper.R

fichero = open('./MapReduce_Hadoop_Ejemplos/WordCount_mapper.R', 'r')
archivo = fichero.read()
print(archivo)

				1
2
3

						fichero = open('./MapReduce_Hadoop_Ejemplos/WordCount_mapper.R', 'r')
archivo = fichero.read()
print(archivo)

args = commandArgs(trailingOnly=TRUE)

trimWhiteSpace &lt;- function(line) gsub("(^ +)|( +$)", "", line)
splitIntoWords &lt;- function(line) unlist(strsplit(line, "[[:space:]]+"))

if (length(args)&gt;=2){
  print('No se le ha llamado desde linea de comandos!')
  NombreFichero &lt;- args[1]
  NombreFicheroOutput &lt;- args[2]
  FInput &lt;- file(NombreFichero)
  
  com &lt;- paste("wc -l ", NombreFichero, " | awk '{ print $1 }'", sep="")
  nLineas &lt;- system(command=com, intern=TRUE)
  
  Lineas &lt;- readLines(FInput, n = nLineas, warn = FALSE)
  
  ListaResultados &lt;- c()
  for(i in 1:nLineas) {
    line &lt;- Lineas[i]
    
    line &lt;- trimWhiteSpace(line)
    words &lt;- splitIntoWords(line)
    
    for (w in words){
      cat(w, "\t1\n", sep="")
      Resultado &lt;- sprintf('%s\t1',w)
      ListaResultados &lt;- c(ListaResultados,Resultado)
    }
  }
  close(FInput)
  
  # Escribimos a Fichero
  Fichero &lt;-file(NombreFicheroOutput)
  writeLines(ListaResultados, Fichero)
  close(Fichero)
}else{
  con &lt;- file("stdin", open = "r")
  while (length(line &lt;- readLines(con, n = 1, warn = FALSE)) &gt; 0) {
    line &lt;- trimWhiteSpace(line)
    words &lt;- splitIntoWords(line)
    
    for (w in words){
      cat(w, "\t1\n", sep="")
    }
  }
  close(con)
}

args = commandArgs(trailingOnly=TRUE)

trimWhiteSpace <- function(line) gsub("(^ +)|( +$)", "", line)

splitIntoWords <- function(line) unlist(strsplit(line, "[[:space:]]+"))

if (length(args)>=2){

print('No se le ha llamado desde linea de comandos!')

NombreFichero <- args[1]

NombreFicheroOutput <- args[2]

FInput <- file(NombreFichero)

com <- paste("wc -l ", NombreFichero, " | awk '{ print $1 }'", sep="")

nLineas <- system(command=com, intern=TRUE)

Lineas <- readLines(FInput, n = nLineas, warn = FALSE)

ListaResultados <- c()

for(i in 1:nLineas) {

line <- Lineas[i]

line <- trimWhiteSpace(line)

words <- splitIntoWords(line)

for (w in words){

cat(w, "\t1\n", sep="")

Resultado <- sprintf('%s\t1',w)

ListaResultados <- c(ListaResultados,Resultado)

}

close(FInput)

# Escribimos a Fichero

Fichero <-file(NombreFicheroOutput)

writeLines(ListaResultados, Fichero)

close(Fichero)

}else{

con <- file("stdin", open = "r")

while (length(line <- readLines(con, n = 1, warn = FALSE)) > 0) {

line <- trimWhiteSpace(line)

words <- splitIntoWords(line)

for (w in words){

cat(w, "\t1\n", sep="")

}

close(con)

}

WordCount_reducer.R

fichero = open('./MapReduce_Hadoop_Ejemplos/WordCount_reducer.R', 'r')
archivo = fichero.read()
print(archivo)

				1
2
3

						fichero = open('./MapReduce_Hadoop_Ejemplos/WordCount_reducer.R', 'r')
archivo = fichero.read()
print(archivo)

args = commandArgs(trailingOnly=TRUE)

trimWhiteSpace &lt;- function(line) gsub("(^ +)|( +$)", "", line)

splitLine &lt;- function(line) {
  val &lt;- unlist(strsplit(line, "\t"))
  list(word = val[1], count = as.integer(val[2]))
}

env &lt;- new.env(hash = TRUE)

if (length(args)&gt;=2){
  print('No se le ha llamado desde linea de comandos!')
  NombreFichero &lt;- args[1]
  NombreFicheroOutput &lt;- args[2]
  
  FInput &lt;- file(NombreFichero)
  
  com &lt;- paste("wc -l ", NombreFichero, " | awk '{ print $1 }'", sep="")
  nLineas &lt;- system(command=com, intern=TRUE)
  
  Lineas &lt;- readLines(FInput, n = nLineas, warn = FALSE)
  
  for(i in 1:nLineas) {
    line &lt;- Lineas[i]
    
    line &lt;- trimWhiteSpace(line)
    split &lt;- splitLine(line)
    word &lt;- split$word
    count &lt;- split$count
    if (exists(word, envir = env, inherits = FALSE)) {
      oldcount &lt;- get(word, envir = env)
      assign(word, oldcount + count, envir = env)
    }else{ 
      assign(word, count, envir = env)
    }
  }
  close(FInput)
  
  ListaResultados &lt;- c()
  for (w in ls(env, all = TRUE)){
    cat(w, "\t", get(w, envir = env), "\n", sep = "")
    Resultado &lt;- sprintf('%s\t%s',w,get(w, envir = env))
    ListaResultados &lt;- c(ListaResultados,Resultado)
  }
  
  # Escribimos a Fichero
  Fichero &lt;-file(NombreFicheroOutput)
  writeLines(ListaResultados, Fichero)
  close(Fichero)
}else{
  con &lt;- file("stdin", open = "r")
  while (length(line &lt;- readLines(con, n = 1, warn = FALSE)) &gt; 0) {
    line &lt;- trimWhiteSpace(line)
    split &lt;- splitLine(line)
    word &lt;- split$word
    count &lt;- split$count
    if (exists(word, envir = env, inherits = FALSE)) {
      oldcount &lt;- get(word, envir = env)
      assign(word, oldcount + count, envir = env)
    }else{ 
      assign(word, count, envir = env)
    }
  }
  close(con)
  
  for (w in ls(env, all = TRUE)){
    cat(w, "\t", get(w, envir = env), "\n", sep = "")
  }
}

args = commandArgs(trailingOnly=TRUE)

trimWhiteSpace <- function(line) gsub("(^ +)|( +$)", "", line)

splitLine <- function(line) {

val <- unlist(strsplit(line, "\t"))

list(word = val[1], count = as.integer(val[2]))

}

env <- new.env(hash = TRUE)

if (length(args)>=2){

print('No se le ha llamado desde linea de comandos!')

NombreFichero <- args[1]

NombreFicheroOutput <- args[2]

FInput <- file(NombreFichero)

com <- paste("wc -l ", NombreFichero, " | awk '{ print $1 }'", sep="")

nLineas <- system(command=com, intern=TRUE)

Lineas <- readLines(FInput, n = nLineas, warn = FALSE)

for(i in 1:nLineas) {

line <- Lineas[i]

line <- trimWhiteSpace(line)

split <- splitLine(line)

word <- split$word

count <- split$count

if (exists(word, envir = env, inherits = FALSE)) {

oldcount <- get(word, envir = env)

assign(word, oldcount + count, envir = env)

}else{

assign(word, count, envir = env)

}

close(FInput)

ListaResultados <- c()

for (w in ls(env, all = TRUE)){

cat(w, "\t", get(w, envir = env), "\n", sep = "")

Resultado <- sprintf('%s\t%s',w,get(w, envir = env))

ListaResultados <- c(ListaResultados,Resultado)

}

# Escribimos a Fichero

Fichero <-file(NombreFicheroOutput)

writeLines(ListaResultados, Fichero)

close(Fichero)

}else{

con <- file("stdin", open = "r")

while (length(line <- readLines(con, n = 1, warn = FALSE)) > 0) {

line <- trimWhiteSpace(line)

split <- splitLine(line)

word <- split$word

count <- split$count

if (exists(word, envir = env, inherits = FALSE)) {

oldcount <- get(word, envir = env)

assign(word, oldcount + count, envir = env)

}else{

assign(word, count, envir = env)

}

close(con)

for (w in ls(env, all = TRUE)){

cat(w, "\t", get(w, envir = env), "\n", sep = "")

}

Call_WordCount.R

fichero = open('./MapReduce_Hadoop_Ejemplos/Call_WordCount.R', 'r')
archivo = fichero.read()
print(archivo)

				1
2
3

						fichero = open('./MapReduce_Hadoop_Ejemplos/Call_WordCount.R', 'r')
archivo = fichero.read()
print(archivo)

library(callr)

# local tesing
# cd GIT/T_PROI_Cluster_BigData_Hadoop_on_Premises/MapReduce_Hadoop_Ejemplos/
# echo "foo foo quux labs foo bar quux" | Rscript WordCount_mapper.R

if (file.exists(sprintf('%s/MapReduce_Hadoop_Ejemplos/%s',getwd(),'Input.txt')) == TRUE){
  file.remove(sprintf('%s/MapReduce_Hadoop_Ejemplos/%s',getwd(),'Input.txt'))
}

if (file.exists(sprintf('%s/MapReduce_Hadoop_Ejemplos/%s',getwd(),'OutputMap.txt')) == TRUE){
  file.remove(sprintf('%s/MapReduce_Hadoop_Ejemplos/%s',getwd(),'OutputMap.txt'))
}

if (file.exists(sprintf('%s/MapReduce_Hadoop_Ejemplos/%s',getwd(),'OutputReduce.txt')) == TRUE){
  file.remove(sprintf('%s/MapReduce_Hadoop_Ejemplos/%s',getwd(),'OutputReduce.txt'))
}

NombreFicheroInput &lt;- "./MapReduce_Hadoop_Ejemplos/Input.txt"
NombreFicheroOutput &lt;- "./MapReduce_Hadoop_Ejemplos/OutputMap.txt"
Linea1 &lt;- "Hadoop big machine data learning big data machine Map"
Linea2 &lt;- "machine big learning big data machine data data MapReduce"
Linea3 &lt;- "Hadoop data Reduce data machine big data machine"
Linea4 &lt;- "MapReduce data big big machine big machine big big machine data MapReduce"
Linea5 &lt;- "Map Reduce Hadoop MapReduce machine big machine big big machine Map data big MapReduce"

Fichero &lt;-file(NombreFicheroInput)
writeLines(c(Linea1,Linea2,Linea3,Linea4,Linea5), Fichero)
close(Fichero)

commandArgs &lt;- c(NombreFicheroInput,NombreFicheroOutput)
rscript('./MapReduce_Hadoop_Ejemplos/WordCount_mapper.R', cmdargs = commandArgs, echo = TRUE)

# cd GIT/T_PROI_Cluster_BigData_Hadoop_on_Premises/MapReduce_Hadoop_Ejemplos/
# echo "foo foo quux labs foo bar quux" | Rscript WordCount_mapper.R | sort -k1,1 | Rscript WordCount_reducer.R

NombreFicheroInput &lt;- "./MapReduce_Hadoop_Ejemplos/OutputMap.txt"
NombreFicheroOutput &lt;- "./MapReduce_Hadoop_Ejemplos/OutputReduce.txt"
commandArgs &lt;- c(NombreFicheroInput,NombreFicheroOutput)
rscript('./MapReduce_Hadoop_Ejemplos/WordCount_reducer.R', cmdargs = commandArgs, echo = TRUE)

# File tesing
# cd GIT/T_PROI_Cluster_BigData_Hadoop_on_Premises/MapReduce_Hadoop_Ejemplos/
# cat Input.txt | Rscript WordCount_mapper.R

# cd GIT/T_PROI_Cluster_BigData_Hadoop_on_Premises/MapReduce_Hadoop_Ejemplos/
# cat Input.txt | Rscript WordCount_mapper.R | sort | Rscript WordCount_reducer.R

library(callr)

# local tesing

# cd GIT/T_PROI_Cluster_BigData_Hadoop_on_Premises/MapReduce_Hadoop_Ejemplos/

# echo "foo foo quux labs foo bar quux" | Rscript WordCount_mapper.R

if (file.exists(sprintf('%s/MapReduce_Hadoop_Ejemplos/%s',getwd(),'Input.txt')) == TRUE){

file.remove(sprintf('%s/MapReduce_Hadoop_Ejemplos/%s',getwd(),'Input.txt'))

}

if (file.exists(sprintf('%s/MapReduce_Hadoop_Ejemplos/%s',getwd(),'OutputMap.txt')) == TRUE){

file.remove(sprintf('%s/MapReduce_Hadoop_Ejemplos/%s',getwd(),'OutputMap.txt'))

}

if (file.exists(sprintf('%s/MapReduce_Hadoop_Ejemplos/%s',getwd(),'OutputReduce.txt')) == TRUE){

file.remove(sprintf('%s/MapReduce_Hadoop_Ejemplos/%s',getwd(),'OutputReduce.txt'))

}

NombreFicheroInput <- "./MapReduce_Hadoop_Ejemplos/Input.txt"

NombreFicheroOutput <- "./MapReduce_Hadoop_Ejemplos/OutputMap.txt"

Linea1 <- "Hadoop big machine data learning big data machine Map"

Linea2 <- "machine big learning big data machine data data MapReduce"

Linea3 <- "Hadoop data Reduce data machine big data machine"

Linea4 <- "MapReduce data big big machine big machine big big machine data MapReduce"

Linea5 <- "Map Reduce Hadoop MapReduce machine big machine big big machine Map data big MapReduce"

Fichero <-file(NombreFicheroInput)

writeLines(c(Linea1,Linea2,Linea3,Linea4,Linea5), Fichero)

close(Fichero)

commandArgs <- c(NombreFicheroInput,NombreFicheroOutput)

rscript('./MapReduce_Hadoop_Ejemplos/WordCount_mapper.R', cmdargs = commandArgs, echo = TRUE)

# cd GIT/T_PROI_Cluster_BigData_Hadoop_on_Premises/MapReduce_Hadoop_Ejemplos/

# echo "foo foo quux labs foo bar quux" | Rscript WordCount_mapper.R | sort -k1,1 | Rscript WordCount_reducer.R

NombreFicheroInput <- "./MapReduce_Hadoop_Ejemplos/OutputMap.txt"

NombreFicheroOutput <- "./MapReduce_Hadoop_Ejemplos/OutputReduce.txt"

commandArgs <- c(NombreFicheroInput,NombreFicheroOutput)

rscript('./MapReduce_Hadoop_Ejemplos/WordCount_reducer.R', cmdargs = commandArgs, echo = TRUE)

# File tesing

# cd GIT/T_PROI_Cluster_BigData_Hadoop_on_Premises/MapReduce_Hadoop_Ejemplos/

# cat Input.txt | Rscript WordCount_mapper.R

# cd GIT/T_PROI_Cluster_BigData_Hadoop_on_Premises/MapReduce_Hadoop_Ejemplos/

# cat Input.txt | Rscript WordCount_mapper.R | sort | Rscript WordCount_reducer.R

Ejecucion del Script

source("./MapReduce_Hadoop_Ejemplos/Call_WordCount.R", echo = TRUE, max.deparse.length = 10000, keep.source = TRUE, prompt.echo = "[INSTRUCCION] &gt;")
## 
## [INSTRUCCION] library(callr)
## 
## [INSTRUCCION] # local tesing
## [INSTRUCCION] # cd GIT/T_PROI_Cluster_BigData_Hadoop_on_Premises/MapReduce_Hadoop_Ejemplos/
## [INSTRUCCION] # echo "foo foo quux labs foo bar quux" | Rscript WordCount_mapper.R
## [INSTRUCCION] 
## [INSTRUCCION] if (file.exists(sprintf('%s/MapReduce_Hadoop_Ejemplos/%s',getwd(),'Input.txt')) == TRUE){
## +   file.remove(sprintf('%s/MapReduce_Hadoop_Ejemplos/%s',getwd(),'Input.txt'))
## + }
## [1] TRUE
## 
## [INSTRUCCION] if (file.exists(sprintf('%s/MapReduce_Hadoop_Ejemplos/%s',getwd(),'OutputMap.txt')) == TRUE){
## +   file.remove(sprintf('%s/MapReduce_Hadoop_Ejemplos/%s',getwd(),'OutputMap.txt'))
## + }
## [1] TRUE
## 
## [INSTRUCCION] if (file.exists(sprintf('%s/MapReduce_Hadoop_Ejemplos/%s',getwd(),'OutputReduce.txt')) == TRUE){
## +   file.remove(sprintf('%s/MapReduce_Hadoop_Ejemplos/%s',getwd(),'OutputReduce.txt'))
## + }
## [1] TRUE
## 
## [INSTRUCCION] NombreFicheroInput &lt;- "./MapReduce_Hadoop_Ejemplos/Input.txt"
## 
## [INSTRUCCION] NombreFicheroOutput &lt;- "./MapReduce_Hadoop_Ejemplos/OutputMap.txt"
## 
## [INSTRUCCION] Linea1 &lt;- "Hadoop big machine data learning big data machine Map"
## 
## [INSTRUCCION] Linea2 &lt;- "machine big learning big data machine data data MapReduce"
## 
## [INSTRUCCION] Linea3 &lt;- "Hadoop data Reduce data machine big data machine"
## 
## [INSTRUCCION] Linea4 &lt;- "MapReduce data big big machine big machine big big machine data MapReduce"
## 
## [INSTRUCCION] Linea5 &lt;- "Map Reduce Hadoop MapReduce machine big machine big big machine Map data big MapReduce"
## 
## [INSTRUCCION] Fichero &lt;-file(NombreFicheroInput)
## 
## [INSTRUCCION] writeLines(c(Linea1,Linea2,Linea3,Linea4,Linea5), Fichero)
## 
## [INSTRUCCION] close(Fichero)
## 
## [INSTRUCCION] commandArgs &lt;- c(NombreFicheroInput,NombreFicheroOutput)
## 
## [INSTRUCCION] rscript('./MapReduce_Hadoop_Ejemplos/WordCount_mapper.R', cmdargs = commandArgs, echo = TRUE)
## Running /usr/lib/R/bin/Rscript ./MapReduce_Hadoop_Ejemplos/WordCount_mapper.R \
##   ./MapReduce_Hadoop_Ejemplos/Input.txt \
##   ./MapReduce_Hadoop_Ejemplos/OutputMap.txt
## [1] "No se le ha llamado desde linea de comandos!"
## Hadoop   1
## big  1
## machine  1
## data 1
## learning 1
## big  1
## data 1
## machine  1
## Map  1
## machine  1
## big  1
## learning 1
## big  1
## data 1
## machine  1
## data 1
## data 1
## MapReduce    1
## Hadoop   1
## data 1
## Reduce   1
## data 1
## machine  1
## big  1
## data 1
## machine  1
## MapReduce    1
## data 1
## big  1
## big  1
## machine  1
## big  1
## machine  1
## big  1
## big  1
## machine  1
## data 1
## MapReduce    1
## Map  1
## Reduce   1
## Hadoop   1
## MapReduce    1
## machine  1
## big  1
## machine  1
## big  1
## big  1
## machine  1
## Map  1
## data 1
## big  1
## MapReduce    1
## 
## [INSTRUCCION] # cd GIT/T_PROI_Cluster_BigData_Hadoop_on_Premises/MapReduce_Hadoop_Ejemplos/
## [INSTRUCCION] # echo "foo foo quux labs foo bar quux" | Rscript WordCount_mapper.R | sort -k1,1 | Rscript WordCount_reducer.R
## [INSTRUCCION] 
## [INSTRUCCION] NombreFicheroInput &lt;- "./MapReduce_Hadoop_Ejemplos/OutputMap.txt"
## 
## [INSTRUCCION] NombreFicheroOutput &lt;- "./MapReduce_Hadoop_Ejemplos/OutputReduce.txt"
## 
## [INSTRUCCION] commandArgs &lt;- c(NombreFicheroInput,NombreFicheroOutput)
## 
## [INSTRUCCION] rscript('./MapReduce_Hadoop_Ejemplos/WordCount_reducer.R', cmdargs = commandArgs, echo = TRUE)
## Running /usr/lib/R/bin/Rscript \
##   ./MapReduce_Hadoop_Ejemplos/WordCount_reducer.R \
##   ./MapReduce_Hadoop_Ejemplos/OutputMap.txt \
##   ./MapReduce_Hadoop_Ejemplos/OutputReduce.txt
## [1] "No se le ha llamado desde linea de comandos!"
## big  14
## data 11
## Hadoop   3
## learning 2
## machine  12
## Map  3
## MapReduce    5
## Reduce   2
## 
## [INSTRUCCION] # File tesing
## [INSTRUCCION] # cd GIT/T_PROI_Cluster_BigData_Hadoop_on_Premises/MapReduce_Hadoop_Ejemplos/
## [INSTRUCCION] # cat Input.txt | Rscript WordCount_mapper.R
## [INSTRUCCION] 
## [INSTRUCCION] # cd GIT/T_PROI_Cluster_BigData_Hadoop_on_Premises/MapReduce_Hadoop_Ejemplos/
## [INSTRUCCION] # cat Input.txt | Rscript WordCount_mapper.R | sort | Rscript WordCount_reducer.R

				
					
				1
2
3
4
5
6
7
8
9
10
11
12
13
14
15
16
17
18
19
20
21
22
23
24
25
26
27
28
29
30
31
32
33
34
35
36
37
38
39
40
41
42
43
44
45
46
47
48
49
50
51
52
53
54
55
56
57
58
59
60
61
62
63
64
65
66
67
68
69
70
71
72
73
74
75
76
77
78
79
80
81
82
83
84
85
86
87
88
89
90
91
92
93
94
95
96
97
98
99
100
101
102
103
104
105
106
107
108
109
110
111
112
113
114
115
116
117
118
119
120
121
122
123
124
125
126
127
128
129
130
131
132
133

						source("./MapReduce_Hadoop_Ejemplos/Call_WordCount.R", echo = TRUE, max.deparse.length = 10000, keep.source = TRUE, prompt.echo = "[INSTRUCCION] &gt;")
## 
## [INSTRUCCION] library(callr)
## 
## [INSTRUCCION] # local tesing
## [INSTRUCCION] # cd GIT/T_PROI_Cluster_BigData_Hadoop_on_Premises/MapReduce_Hadoop_Ejemplos/
## [INSTRUCCION] # echo "foo foo quux labs foo bar quux" | Rscript WordCount_mapper.R
## [INSTRUCCION] 
## [INSTRUCCION] if (file.exists(sprintf('%s/MapReduce_Hadoop_Ejemplos/%s',getwd(),'Input.txt')) == TRUE){
## +   file.remove(sprintf('%s/MapReduce_Hadoop_Ejemplos/%s',getwd(),'Input.txt'))
## + }
## [1] TRUE
## 
## [INSTRUCCION] if (file.exists(sprintf('%s/MapReduce_Hadoop_Ejemplos/%s',getwd(),'OutputMap.txt')) == TRUE){
## +   file.remove(sprintf('%s/MapReduce_Hadoop_Ejemplos/%s',getwd(),'OutputMap.txt'))
## + }
## [1] TRUE
## 
## [INSTRUCCION] if (file.exists(sprintf('%s/MapReduce_Hadoop_Ejemplos/%s',getwd(),'OutputReduce.txt')) == TRUE){
## +   file.remove(sprintf('%s/MapReduce_Hadoop_Ejemplos/%s',getwd(),'OutputReduce.txt'))
## + }
## [1] TRUE
## 
## [INSTRUCCION] NombreFicheroInput &lt;- "./MapReduce_Hadoop_Ejemplos/Input.txt"
## 
## [INSTRUCCION] NombreFicheroOutput &lt;- "./MapReduce_Hadoop_Ejemplos/OutputMap.txt"
## 
## [INSTRUCCION] Linea1 &lt;- "Hadoop big machine data learning big data machine Map"
## 
## [INSTRUCCION] Linea2 &lt;- "machine big learning big data machine data data MapReduce"
## 
## [INSTRUCCION] Linea3 &lt;- "Hadoop data Reduce data machine big data machine"
## 
## [INSTRUCCION] Linea4 &lt;- "MapReduce data big big machine big machine big big machine data MapReduce"
## 
## [INSTRUCCION] Linea5 &lt;- "Map Reduce Hadoop MapReduce machine big machine big big machine Map data big MapReduce"
## 
## [INSTRUCCION] Fichero &lt;-file(NombreFicheroInput)
## 
## [INSTRUCCION] writeLines(c(Linea1,Linea2,Linea3,Linea4,Linea5), Fichero)
## 
## [INSTRUCCION] close(Fichero)
## 
## [INSTRUCCION] commandArgs &lt;- c(NombreFicheroInput,NombreFicheroOutput)
## 
## [INSTRUCCION] rscript('./MapReduce_Hadoop_Ejemplos/WordCount_mapper.R', cmdargs = commandArgs, echo = TRUE)
## Running /usr/lib/R/bin/Rscript ./MapReduce_Hadoop_Ejemplos/WordCount_mapper.R \
##   ./MapReduce_Hadoop_Ejemplos/Input.txt \
##   ./MapReduce_Hadoop_Ejemplos/OutputMap.txt
## [1] "No se le ha llamado desde linea de comandos!"
## Hadoop   1
## big  1
## machine  1
## data 1
## learning 1
## big  1
## data 1
## machine  1
## Map  1
## machine  1
## big  1
## learning 1
## big  1
## data 1
## machine  1
## data 1
## data 1
## MapReduce    1
## Hadoop   1
## data 1
## Reduce   1
## data 1
## machine  1
## big  1
## data 1
## machine  1
## MapReduce    1
## data 1
## big  1
## big  1
## machine  1
## big  1
## machine  1
## big  1
## big  1
## machine  1
## data 1
## MapReduce    1
## Map  1
## Reduce   1
## Hadoop   1
## MapReduce    1
## machine  1
## big  1
## machine  1
## big  1
## big  1
## machine  1
## Map  1
## data 1
## big  1
## MapReduce    1
## 
## [INSTRUCCION] # cd GIT/T_PROI_Cluster_BigData_Hadoop_on_Premises/MapReduce_Hadoop_Ejemplos/
## [INSTRUCCION] # echo "foo foo quux labs foo bar quux" | Rscript WordCount_mapper.R | sort -k1,1 | Rscript WordCount_reducer.R
## [INSTRUCCION] 
## [INSTRUCCION] NombreFicheroInput &lt;- "./MapReduce_Hadoop_Ejemplos/OutputMap.txt"
## 
## [INSTRUCCION] NombreFicheroOutput &lt;- "./MapReduce_Hadoop_Ejemplos/OutputReduce.txt"
## 
## [INSTRUCCION] commandArgs &lt;- c(NombreFicheroInput,NombreFicheroOutput)
## 
## [INSTRUCCION] rscript('./MapReduce_Hadoop_Ejemplos/WordCount_reducer.R', cmdargs = commandArgs, echo = TRUE)
## Running /usr/lib/R/bin/Rscript \
##   ./MapReduce_Hadoop_Ejemplos/WordCount_reducer.R \
##   ./MapReduce_Hadoop_Ejemplos/OutputMap.txt \
##   ./MapReduce_Hadoop_Ejemplos/OutputReduce.txt
## [1] "No se le ha llamado desde linea de comandos!"
## big  14
## data 11
## Hadoop   3
## learning 2
## machine  12
## Map  3
## MapReduce    5
## Reduce   2
## 
## [INSTRUCCION] # File tesing
## [INSTRUCCION] # cd GIT/T_PROI_Cluster_BigData_Hadoop_on_Premises/MapReduce_Hadoop_Ejemplos/
## [INSTRUCCION] # cat Input.txt | Rscript WordCount_mapper.R
## [INSTRUCCION] 
## [INSTRUCCION] # cd GIT/T_PROI_Cluster_BigData_Hadoop_on_Premises/MapReduce_Hadoop_Ejemplos/
## [INSTRUCCION] # cat Input.txt | Rscript WordCount_mapper.R | sort | Rscript WordCount_reducer.R

					

			

2.2 Python:

WordCount_mapper.py

fichero = open('./MapReduce_Hadoop_Ejemplos/WordCount_mapper.py', 'r')
archivo = fichero.read()
print(archivo)

				1
2
3

						fichero = open('./MapReduce_Hadoop_Ejemplos/WordCount_mapper.py', 'r')
archivo = fichero.read()
print(archivo)

# import sys because we need to read and write data to STDIN and STDOUT
import sys

# reading entire line from STDIN (standard input)
for line in sys.stdin:
    # to remove leading and trailing whitespace
    line = line.strip()
    # split the line into words
    words = line.split()
    
    # we are looping over the words array and printing the word
    # with the count of 1 to the STDOUT
    for word in words:
        # write the results to STDOUT (standard output);
        # what we output here will be the input for the
        # Reduce step, i.e. the input for reducer.py
        print('%s\t%s' % (word, 1))

# import sys because we need to read and write data to STDIN and STDOUT

import sys

# reading entire line from STDIN (standard input)

for line in sys.stdin:

# to remove leading and trailing whitespace

line = line.strip()

# split the line into words

words = line.split()

# we are looping over the words array and printing the word

# with the count of 1 to the STDOUT

for word in words:

# write the results to STDOUT (standard output);

# what we output here will be the input for the

# Reduce step, i.e. the input for reducer.py

print('%s\t%s' % (word, 1))

WordCount_reducer.py

fichero = open('./MapReduce_Hadoop_Ejemplos/WordCount_reducer.py', 'r')
archivo = fichero.read()
print(archivo)

				1
2
3

						fichero = open('./MapReduce_Hadoop_Ejemplos/WordCount_reducer.py', 'r')
archivo = fichero.read()
print(archivo)

from operator import itemgetter
import sys

current_word = None
current_count = 0
word = None

# read the entire line from STDIN
for line in sys.stdin:
    # remove leading and trailing whitespace
    line = line.strip()
    # splitting the data on the basis of tab we have provided in 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 STDOUT
            print('%s\t%s' % (current_word, current_count))
        current_count = count
        current_word = word

# do not forget to output the last word if needed!
if current_word == word:
    print('%s\t%s' % (current_word, current_count))

from operator import itemgetter

import sys

current_word = None

current_count = 0

word = None

# read the entire line from STDIN

for line in sys.stdin:

# remove leading and trailing whitespace

line = line.strip()

# splitting the data on the basis of tab we have provided in 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 STDOUT

print('%s\t%s' % (current_word, current_count))

current_count = count

current_word = word

# do not forget to output the last word if needed!

if current_word == word:

print('%s\t%s' % (current_word, current_count))

Call_WordCount.py

fichero = open('./MapReduce_Hadoop_Ejemplos/Call_WordCount.py', 'r')
archivo = fichero.read()
print(archivo)

				1
2
3

						fichero = open('./MapReduce_Hadoop_Ejemplos/Call_WordCount.py', 'r')
archivo = fichero.read()
print(archivo)

# local testing
# cd GIT/T_PROI_Cluster_BigData_Hadoop_on_Premises/MapReduce_Hadoop_Ejemplos/
# cat Input.txt | python3 WordCount_mapper.py | sort -k1,1 | python3 WordCount_reducer.py

# local testing

# cd GIT/T_PROI_Cluster_BigData_Hadoop_on_Premises/MapReduce_Hadoop_Ejemplos/

# cat Input.txt | python3 WordCount_mapper.py | sort -k1,1 | python3 WordCount_reducer.py

Ejecucion del Script

2.3 Pig:

WordCount.pig

fichero = open('./MapReduce_Hadoop_Ejemplos/WordCount.pig', 'r')
archivo = fichero.read()
print(archivo)

				1
2
3

						fichero = open('./MapReduce_Hadoop_Ejemplos/WordCount.pig', 'r')
archivo = fichero.read()
print(archivo)

input_lines = LOAD './MapReduce_Hadoop_Ejemplos/Input.txt' AS (line:chararray);
words = FOREACH input_lines GENERATE FLATTEN(TOKENIZE(line)) AS word;
filtered_words = FILTER words BY word MATCHES '\\w+';
word_groups = GROUP filtered_words BY word;
word_count = FOREACH word_groups GENERATE COUNT(filtered_words) AS count, group
ordered_word_count = ORDER word_count BY count DESC;
STORE ordered_word_count INTO './MapReduce_Hadoop_Ejemplos/Output.txt';


-- Explicacion
-- 1.- Se abre el fichero sobre el que se quieren contar las ocurrencias de cada palabra.
-- 2.- Se separa cada línea en palabras.
-- 3.- Se filtran las palabras para eliminar signos o blancos.
-- 4.- Se crea un grupo para cada palabra.
-- 5.- Cuenta las ocurrencias de cada grupo (de cada palabra).
-- 6.- Se ordenan las palabras por ocurrencias.
-- 7.- Se almacena la lista de palabras y sus ocurrencias en un fichero.

input_lines = LOAD './MapReduce_Hadoop_Ejemplos/Input.txt' AS (line:chararray);

words = FOREACH input_lines GENERATE FLATTEN(TOKENIZE(line)) AS word;

filtered_words = FILTER words BY word MATCHES '\\w+';

word_groups = GROUP filtered_words BY word;

word_count = FOREACH word_groups GENERATE COUNT(filtered_words) AS count, group

ordered_word_count = ORDER word_count BY count DESC;

STORE ordered_word_count INTO './MapReduce_Hadoop_Ejemplos/Output.txt';

-- Explicacion

-- 1.- Se abre el fichero sobre el que se quieren contar las ocurrencias de cada palabra.

-- 2.- Se separa cada línea en palabras.

-- 3.- Se filtran las palabras para eliminar signos o blancos.

-- 4.- Se crea un grupo para cada palabra.

-- 5.- Cuenta las ocurrencias de cada grupo (de cada palabra).

-- 6.- Se ordenan las palabras por ocurrencias.

-- 7.- Se almacena la lista de palabras y sus ocurrencias en un fichero.

2.4 Java:

WordCount.java

fichero = open('./MapReduce_Hadoop_Ejemplos/WordCount.java', 'r')
archivo = fichero.read()
print(archivo)

				1
2
3

						fichero = open('./MapReduce_Hadoop_Ejemplos/WordCount.java', 'r')
archivo = fichero.read()
print(archivo)

import java.io.IOException;
import java.util.StringTokenizer;

import org.apache.hadoop.conf.Configuration;
import org.apache.hadoop.fs.Path;
import org.apache.hadoop.io.IntWritable;
import org.apache.hadoop.io.Text;
import org.apache.hadoop.mapreduce.Job;
import org.apache.hadoop.mapreduce.Mapper;
import org.apache.hadoop.mapreduce.Reducer;
import org.apache.hadoop.mapreduce.lib.input.FileInputFormat;
import org.apache.hadoop.mapreduce.lib.output.FileOutputFormat;

public class WordCount {
    
    public static class TokenizerMapper
        extends Mapper&lt;Object, Text, Text, IntWritable&gt;{

            private final static IntWritable one = new IntWritable(1);
            private Text word = new Text();
    
            public void map(Object key, Text value, Context context
                            ) throws IOException, InterruptedException {       
                StringTokenizer itr = new StringTokenizer(value.toString());
    
                while (itr.hasMoreTokens()) {
                    word.set(itr.nextToken());
                    context.write(word, one);
                }
            }
    }

    public static class IntSumReducer
        extends Reducer&lt;Text,IntWritable,Text,IntWritable&gt; {
    
            private IntWritable result = new IntWritable();
    
            public void reduce(Text key, Iterable&lt;IntWritable&gt; values,
                                Context context
                              ) throws IOException, InterruptedException {
                int sum = 0;
                for (IntWritable val : values) {
                    sum += val.get();
                }result.set(sum);
                context.write(key, result);
            }
    }

    public static void main(String[] args) throws Exception {    
        Configuration conf = new Configuration();    
        Job job = Job.getInstance(conf, "word count");    
        job.setJarByClass(WordCount.class);    
        job.setMapperClass(TokenizerMapper.class);    
        job.setCombinerClass(IntSumReducer.class);    
        job.setReducerClass(IntSumReducer.class);    
        job.setOutputKeyClass(Text.class);    
        job.setOutputValueClass(IntWritable.class);    
        FileInputFormat.addInputPath(job, new Path(args[0]));    
        FileOutputFormat.setOutputPath(job, new Path(args[1]));    
        System.exit(job.waitForCompletion(true) ? 0 : 1);
    }
}

import java.io.IOException;

import java.util.StringTokenizer;

import org.apache.hadoop.conf.Configuration;

import org.apache.hadoop.fs.Path;

import org.apache.hadoop.io.IntWritable;

import org.apache.hadoop.io.Text;

import org.apache.hadoop.mapreduce.Job;

import org.apache.hadoop.mapreduce.Mapper;

import org.apache.hadoop.mapreduce.Reducer;

import org.apache.hadoop.mapreduce.lib.input.FileInputFormat;

import org.apache.hadoop.mapreduce.lib.output.FileOutputFormat;

public class WordCount {

public static class TokenizerMapper

extends Mapper<Object, Text, Text, IntWritable>{

private final static IntWritable one = new IntWritable(1);

private Text word = new Text();

public void map(Object key, Text value, Context context

) throws IOException, InterruptedException {

StringTokenizer itr = new StringTokenizer(value.toString());

while (itr.hasMoreTokens()) {

word.set(itr.nextToken());

context.write(word, one);

}

public static class IntSumReducer

extends Reducer<Text,IntWritable,Text,IntWritable> {

private IntWritable result = new IntWritable();

public void reduce(Text key, Iterable<IntWritable> values,

Context context

) throws IOException, InterruptedException {

int sum = 0;

for (IntWritable val : values) {

sum += val.get();

}result.set(sum);

context.write(key, result);

}

public static void main(String[] args) throws Exception {

Configuration conf = new Configuration();

Job job = Job.getInstance(conf, "word count");

job.setJarByClass(WordCount.class);

job.setMapperClass(TokenizerMapper.class);

job.setCombinerClass(IntSumReducer.class);

job.setReducerClass(IntSumReducer.class);

job.setOutputKeyClass(Text.class);

job.setOutputValueClass(IntWritable.class);

FileInputFormat.addInputPath(job, new Path(args[0]));

FileOutputFormat.setOutputPath(job, new Path(args[1]));

System.exit(job.waitForCompletion(true) ? 0 : 1);

}

DESCRIPCIÓN

Objetivo

Cargar datos trasformados del consumo energético en el Clúster para después analizarlos y generar predicciones futuras del consumo Energético.

Explicación

Los datos de los medidores se registran en una base de datos de Serie Temporal (InfluxDB) registrando el consumo del medidor (kWh) con una frecuencia de 1 minuto.
Para obtener los datos del consumo de una hora o de un día hay que sacar la diferencia.
El reto consisten en realizar un proceso ETL para cargar los datos al Clúster periódicamente (cada semana “lunes a la mañana la carga de la semana anterior” o cada mes “primer día de cada mes”) para que después extraigamos los datos deseados y hagamos predicciones de consumos energéticos futuros.

TAREAS

	Carga de datos en HDFS tras proceso ETL: Cargar los datos almacenados en la base de datos de serie temporal (InfluxDB), con un job o cron (cada semana, cada mes, …) para importarlos al Clúster. Se tendrá que realizar un script que ejecute las siguientes tareas. Capturar y Trasformar los Datos: Capturar los datos, agruparlos por horas o días, calcular los consumos, y obtener un Dataframe con las comunas deseadas. Limpiar los Datos: Limpiar los datos faltantes y valores atípicos (conviene realizar técnicas de imputación de datos en vez de quitarlos) Enriquecer los Datos: Con calendarios (festivos, …) y datos meteorológicos de las estaciones mas cercanas (Python metostat) Ajustar la Predicción: Genera un script para que se hagan predicciones de consumos energéticos futuros. Extraer los datos de HDFS Dividir Datos en Entrenamiento y Test Aplicar distintos Algoritmos de Regresión (DecisionTree, RandomFores, XGboost, …) Análisis Exploratorio de modelos y Datos Análisis Visual de Resultados Crear Job para ejecución de Script elegido: Crear Script con el algoritmo seleccionado para que se entrene con unos datos X (los últimos 3 meses, un año) y realice predicciones futuras periódicamente (cada cambio de mes, el siguiente mes) Ajustar Script para que obtenga los datos de un periodo concreto para el Entrenamiento: Generar modelo con el algoritmo seleccionado, y guardar el modelo. Añadir predicciones al Dataframe de Entrenamiento y al Dataframe Test (Futuro). Visualizar los datos de forma Gráfica, Real vs. Predicción.

Ejemplos Visuales de Entrenamiento, Test y Predicciones Futuras.

Entrenamiento

Test

Futuro

INTRODUCCIÓN AL RETO:

Big Data es un concepto que se crea a raíz de la capacidad de almacenamiento de gran cantidad de datos, normalmente generados por empresas u otro tipo de organismos (facturas, datos de usuarios o clientes, stocks de material…) o con el avance de tecnologías como IoT (directamente por objetos que generan información desde sensores) que si es analizada (mediante algoritmos tipo machine learning u otros métodos convencionales) pueden generar “insights” útiles para tomar decisiones (en negocios, investigaciones científicas, salud y muchos sectores).

La Inteligencia Artificial y el Big Data se complementan perfectamente ya que crean un círculo de retroalimentación: con los datos se pueden alimentar los sistemas de AI para obtener resultados, el sistema aprende y se vuelve más inteligente, mientras que los resultados obtenidos se convierten en nuevos datos de entrada para el sistema.

Un programa no tiene inteligencia, hace exactamente lo que le piden. La IA no se basa en órdenes, si no en datos de entrada y resultados basados en probabilidades de éxito.

El Aprendizaje Automático es la capacidad de un sistema, de un software, para aprender por sí solo.

Existen algoritmos de machine learning orientados a lograr este aprendimiento.

DESCRIPCIÓN:

El objetivo de este reto es que creéis un proyecto, pensado por vosotros mismo, con las herramientas vistas en clase tanto de Big Data como de Inteligencia Artificial.

Fase del proyecto:

Comunicación

Entre los integrantes del grupo piensan en la propuesto y presenta su solicitud de desarrollo de software.

Planificación y análisis

El desarrollo de software comienza con una fase inicial de planificación incluyendo un análisis de requisitos. Se indaga en profundidad. Los requisitos se agrupan en requisitos del proyecto, requisitos funcionales y requisitos del sistema.

Estudio de viabilidad

Después de la recolección de requisitos, se idea un plan para procesar el software. Se analiza que parte del software cubre los requisitos de cada usuario. Se investiga la viabilidad tecnológica.

Análisis del sistema

En este paso el equipo del proyecto asigna recursos y planifica el tiempo de duración del proyecto. Se buscan limitaciones del producto y se identifican los impactos del proyecto sobre toda la organización en su conjunto.

Diseño

En esta fase ya se comienza a visualizar la solución con la ayuda de las anteriores fases. Se hace un diseño lógico y otro físico. Se crean metadatos, diagramas o pseudocódigos. La duración de esta fase varía de un proyecto a otro.

Codificación

Esta fase también denominada ‘fase de programación’ o ‘fase de desarrollo’ es en la que elige el lenguaje de programación más conveniente, y se desarrollan programas ejecutables y sin errores de manera eficiente. Al final de esta fase se puede obtener un PMV (Producto mínimo viable) o el software completamente desarrollado y listo para implementarse.

Integración

El Software puede necesitar estar integrado con bibliotecas, bases de datos o con otros programas. Esta fase del SDLC integra el software con las entidades del mundo exterior.

Pruebas

Esta fase junto con la fase de desarrollo entra en un ciclo continuo hasta que se completan el desarrollo y las pruebas. Probamos, probamos y luego volvemos a probar tanto como sea necesario hasta que la funcionalidad sea del 100%.

Además, se hacen evaluaciones para evitar errores, incluyendo la evaluación de módulos, programas, productos, y finalmente evaluación con el profesor. Encontrar errores y su arreglarlos a tiempo es la clave para conseguir un software confiable y eficiente.

Presentación

Esta es la fase más interesante, ¡La presentación!

DESCRIPCIÓN

Objetivo: Realizar un análisis integral de la red de sonómetros en Bilbao para comprender y caracterizar los niveles de ruido en diferentes áreas de la ciudad.

Datos: Datos de los sonómetros y geoespaciales.

Open data Euskadi (los sonómetros y su geolocalización):

https://www.bilbao.eus/aytoonline/jsp/opendata/movilidad/od_sonometro_mediciones.jsp?idioma=c&formato=json
https://www.bilbao.eus/aytoonline/jsp/opendata/movilidad/od_sonometro_ubicacion.jsp?idioma=c&formato=geojson

Ayuntamiento de Bilbao (tráfico de Bilbao):

https://www.bilbao.eus/aytoonline/srvDatasetTrafico?formato=geojson

Pasos:

1. Importar y Limpiar Datos: Importa los datos de sonómetros y realiza una limpieza inicial. Asegúrate de que los datos estén completos, trata valores atípicos y asegúrate de que la información geoespacial este correctamente asociada.

2. Análisis Exploratorio: Calcula estadísticas descriptivas de los niveles de ruido, como medias, desviaciones estándar y rangos. Visualiza la variación temporal y espacial de los niveles de ruido.

3. Mapeo de Niveles de Ruido: Utiliza herramientas de mapeo para representar los niveles de ruido en diferentes áreas de la ciudad. Puedes considerar mapas de calor para resaltar las zonas con mayores niveles de ruido.

4. Correlaciones Espaciales: Investiga las correlaciones espaciales entre los niveles de ruido en diferentes ubicaciones. ¿Existen patrones geográficos en los niveles de ruido?

5. Análisis Temporal: Examina la variación de los niveles de ruido a lo largo del tiempo. Puedes identificar patrones diurnos/nocturnos, así como eventos especiales que puedan afectar los niveles de ruido entre otros.

6. Comparación con Parámetros Regulatorios: Compara los niveles de ruido registrados con los estándares y regulaciones locales. Identifica áreas que podrían requerir intervenciones para cumplir con los límites establecidos.

7. Informe y Visualización de Resultados: Crea un Power BI que incluya visualizaciones significativas. Utiliza gráficos, mapas y tablas para comunicar claramente los patrones y conclusiones encontrados. Crea un informe con todas las conclusiones encontradas.

Al menos, tu programa en R debe de contestar a las siguientes cuestiones:

1. ¿Cuántos registros hay en la base de datos de los sonómetros de Bilbao?

2. Mostrar calles en Bilbao que cuentan con sonómetros

3. ¿Cuántas veces ha contado un sonómetro en cada calle?

4. ¿Cuál es el promedio de la calle con los decibelios más altos?

5. ¿Cuál es el promedio de la calle con los decibelios más bajos?

6. ¿Cuál es el registro más alto en decibelios de un sonómetro?

7. ¿Cuál es el registro más bajo en decibelios de un sonómetro?

8. Imprimir calles ordenadas de mayor a menor por promedio de decibelios

9. ¿En cual franja horaria (hora) se producen más decibelios?

10. ¿En cual franja horaria (hora) se producen menos decibelios?

11. ¿En qué fecha se han producido más decibelios?

12. ¿En qué fecha se han producido menos decibelios?

13. ¿En qué fecha y hora se han producido más decibelios?

14. ¿En qué fecha y hora se han producido menos decibelios?

15. Promedio de decibelios de todo Bilbao

16. Análisis de los parámetros más necesarios para realizar predicciones

17. Distintas predicciones del ruido que van a generar los sonómetros, en base a los parámetros importantes.

18. Análisis de la calidad del predictor y de su margen de error

DESCRIPCIÓN

La multinacional Metflis desea realizar un estudio detallado de las películas que sus clientes ven y las calificaciones que otorgan a estas películas. El objetivo principal de este estudio es mejorar la calidad y la relevancia del contenido que se ofrece a los usuarios.

Para llevar a cabo esta tarea, crearemos una base de datos relacional utilizando PostgreSQL que permitirá a Metflis rastrear las preferencias de los usuarios, las películas disponibles y las calificaciones de las películas. Además, implementaremos secuencias para generar identificadores únicos, triggers para mantener automáticamente la calificación promedio de las películas y al menos un procedimiento almacenado para agregar películas a las listas de reproducción de los usuarios.

1. Modelo E/R: En Metflis , puedes tener usuarios, películas y listas de reproducción. Los usuarios pueden agregar películas a sus listas de reproducción y también pueden marcar películas como vistas o no vistas. Además, cada película tiene una calificación promedio dada por los usuarios.
2. Creación de tablas en PostgreSQL: Cada primary_key de cada tabla será una secuencia.
3. Triggers: Actualiza la calificación de promedio de una película cada vez que un usuario la califique
4. Las creaciones de registros se realizan a través de procedimientos almacenado

A continuación, cada grupo propondrá un proyecto que tendrá que tener las siguientes características mínimas:

El programa tiene que utilizar la base de datos creada anteriormente.
Si el alumno/grupo de alumnos considera hacer limpieza de la base de datos (eliminar información innecesaria, borrar columnas, eliminar columnas, etc.) lo podrá hacer justificando dicha limpieza.

El programa se realizará en Python.

A poder ser se realizará en Google Colab salvo que las necesidades del proyecto requieran un cambio de plataforma.
El programa deberá de tener como mínimo las siguientes funcionalidades del lenguaje Python: uso de bucles, cadenas, condicionales, listas, tuplas, diccionarios, funciones, control de excepciones, uso de programación orientada a objetos.
Se valorará positivamente el uso de nuevas funcionalidades de Python no mencionadas anteriormente.
Se recomienda la realización de un menú o un diseño intuitivo para que a la hora de ejecutar sea lo más ‘user friendly’ posible.
Relacionar la base de datos usada con una de las siguientes áreas

Relacionar el programa realizado con la afectación que tendría en la sociedad. El proyecto tendrá que ser lo suficientemente largo para que todos los integrantes del grupo puedan participar en él.

Una vez se haga la propuesta del proyecto, el profesor lo validará y se podrá comenzar con el mismo.

Finalmente, se recomienda y se valorará positivamente la realización de una documentación explicando las características principales del proyecto realizado

DESCRIPCIÓN

Pertenecemos al departamento de informática de la multinacional IA&BD Consulting, la cual presta servicios a una conocida tele operadora de telefonía móvil.

Con la intención de actualizar la empresa a los nuevos tiempos, se ha contratado un nuevo Director General que nada más llegar ha comenzado a pedir una serie de informes de situación para poder hacerse una idea lo más clara posible de con qué se va a encontrar.

Por otro lado, el cliente necesita desarrollar un sistema que sea capaz de alertar de si un cliente está a punto de darse de baja.

SISTEMAS DE BIG DATA

El departamento financiero nos han facilitado una excel con los datos administrativos, lo cual, resulta bastante engorroso a la hora de querer hacer consultas y analítica.

Las tareas a realizar son las siguientes:

– Crear una base de datos en MongoDB con sus colecciones y documentos.

– Un informe ejecutivo en Power BI para el gerente con todos los datos relevantes.

BIG DATA APLICADO

El cliente dispone de gran volumen de datos por los que deciden usar un entorno hadoop.

Las tareas a realizar son las siguientes:

– Los datos estarán guardados en Hive. Crear una base de datos y guardar todos los datos que se encuentran en el fichero.

– Desde spark se va a acceder a los datos de hive para realizar una serie de cálculos:

Para poder acceder desde spark a hive se debe buscar el archivo hive-site.xml en el directorio spark y reemplazarlo por el archivo hive-site.xml que se encuentra en el directorio hive.

Realizar los siguientes cálculos desde spark y guardarlos en Hive.

– Calcular mediante un map reduce el número de llamadas por zona (sumar dia y noche)

– Calcular el número de carga por plan de voz (Voice mail plan)

SISTEMAS DE APRENDIZAJE AUTOMÁTICO

Usad bigML para hacer la predicción: determinar qué algoritmo es más adecuado para solucionar el problema (supervisado o no supervisado). Usar más de un algoritmo supervisado y utilizar la mayor cantidad de funcionalidades de bigML.

Hay que explorar y analizar los datos con bigML. Finalmente, hay que argumentar el uso de cada algoritmo.

PROGRAMACIÓN DE INTELIGENCIA ARTIFICIAL

Haced el limpiado y adecuación de la BD en Python. Usar la plataforma de Kaggle de apoyo y utilizar ejemplos realizados en las actividades de clase.

Elegir el algoritmo que mejores resultados haya dado en bigML y realizar la predicción en Python. Para ello utilizar la librería scikit-learn, numpy, pandas, matplotlib y utilizar la programación estructurada.

DOCUMENTACIÓN A ENTREGAR

Documentación a entregar:

Portada con el nombre del estudiante y el título de la actividad-reto, el número de la evaluación y la fecha de entrega.
Índice principal.
Referencias bibliográficas.
Anexos: estos son apartados opcionales que contienen elementos que complementan o amplían la información del trabajo.
La documentación deberá estar escrita en tamaño de página A4 con los siguientes márgenes:

Izquierdo: 3,0 cm.

Derecho: 2,0 cm.

Superior e inferior: 2,5 cm.

Texto principal:

Arial 12, justificado, interlineado 1,5.

Notas al pie:

Arial 10, justificado.

Tablas, figuras, imágenes:

Título en la parte inferior: Arial 12, negrita, centrado.

Encabezado y pie de página:

Todas las páginas llevarán un encabezado con el nombre completo del estudiante y el título de la actividad-reto.

Todas las páginas llevarán también un pie de página con el número de página.

Presentación del reto: usar transparencias por ejemplo para ello.

Creación de Tópicos, Productores y Consumidores

1. Conectarse a Zoopeker:
2. Para comprobar la conexión: bin/zkCli.sh -server localhost:2181
3. Conectarse a kafka en segundo plano con daemon:
4. Creación de nuevo topics:
5. Visualización de los topics existentes:
6. Para producir (pantalla de la izquieda) y consumir (pantalla de la derecha) mensajes desde shell (TEST).
  Existen dos maneras de producir mensajes:
  Esto quedará reflejado en el consumidor con un null o la clave.
7. Para producir mensajes desde Spark Streaming (Scala):
8. Para consumir mensajes desde Spark Streaming (Scala):

¿Qué es ZooKeper?

ZooKeeper es el servicio de coordinación centralizada para aplicaciones distribuidas.

Soluciona problemas como:

Almacenamiento de configuración.
Bloqueos distribuidos.
Elección de líder.

Proporciona una estructura similar a la que se encuentra en un sistema de ficheros.

Cada elemento de la estructura es conocido como Znode y puede contener información en su interior como por ejemplo un JSON.

1.1. ¿Características de ZooKeper?

El servicio esta formado por distintos nodos cada uno con un servidor.
Uno de los servidores actúa como leader. Encargado de la coordinación interna.
Siempre tiene que existir Quórum, para validar las escrituras.

¿Qué es Kafka?

Kafka es una plataforma de streaming de mensajes diseñada para ser altamente escalable y tolerante a fallos. Es muy utilizada para procesar grandes cantidades de datos en tiempo real y puede ser utilizada en una amplia gama de aplicaciones consumidores.

2.1. Productores y consumidores

Los productores de Apache Kafka puede ser cualquier aplicación que necesite enviar datos a un sistema distribuido. Son aplicaciones que envían mensajes a uno o varios tópicos de Kafka.

Los consumidores de Kafka son aplicaciones que se suscriben a tópicos de Kafka y procesan los mensajes que se envían a esos tópicos.

En Kafka, las colas se llaman “tópicos” (topics). Los tópicos son similares a las colas tradicionales, pero con algunas diferencias clave. En lugar de tener un único consumidor por mensaje, como ocurre en una cola tradicional, los tópicos de Kafka pueden tener múltiples consumidores que pueden leer los mensajes publicados en el tópico de forma simultánea. Esto permite a Kafka escalar de forma más eficiente y procesar grandes volúmenes de datos de forma rápida.

Además, los tópicos de Kafka tienen un historial de mensajes, lo que significa que se guardan durante un período de tiempo determinado (configurable por el usuario) y pueden ser leídos por cualquier consumidor que se conecte al tópico en cualquier momento durante ese período de tiempo.

2.2. Modelo publicador-suscriptor

El modelo publicador-suscriptor es un patrón de diseño comúnmente utilizado en sistemas de mensajería y se aplica a Kafka en el contexto de tópicos y mensajes.

Kafka utiliza un modelo publicador-suscriptor en el cual existen tres actores principales:

Publicadores: son los que envían mensajes a un tópico.
Tópicos: son los que almacenan y distribuyen los mensajes a los suscriptores.
Suscriptores: son los que reciben los mensajes publicados en un tópico.

Cuando un publicador envía un mensaje a un tópico, el tópico lo almacena y lo distribuye a todos los suscriptores que estén suscritos al tópico. Los suscriptores pueden leer los mensajes en tiempo real mientras se publican o pueden leer los mensajes en un momento posterior.

El modelo publicador-suscriptor permite a los publicadores y suscriptores interactuar de manera asíncrona, lo que significa que no necesitan estar conectados al mismo tiempo para enviar o recibir mensajes. Esto hace que Kafka sea adecuado para aplicaciones que necesitan procesar grandes volúmenes de datos en tiempo real y que pueden tener picos de actividad.

2.3. Brokers

Los brokers de Kafka son los servidores que almacenan y transmiten los mensajes a través de la red. En un cluster de Kafka, puede haber varios brokers para permitir la escalabilidad y la tolerancia a fallos.

Cuando un publicador envía un mensaje a un tópico, el mensaje se almacena en uno o más brokers, dependiendo de la configuración del tópico. Cuando un suscriptor se suscribe a un tópico, los brokers envían los mensajes al suscriptor en tiempo real.

Los brokers también tienen la responsabilidad de replicar los mensajes a través del cluster para garantizar la tolerancia a fallos. Si un broker falla, otro broker puede tomar el control y seguir enviando mensajes a los suscriptores sin interrupción.

Los brokers se sincronizan utilizando Apache ZooKeper.

2.4. Tópicos

Los tópicos de Kafka son los elementos centrales de la plataforma. Son los que almacenan y distribuyen los mensajes publicados por los publicadores a los suscriptores.

Cada tópico tiene un nombre único y puede tener múltiples consumidores que se suscriben a él.

Los mensajes publicados en un tópico se almacenan en el cluster de Kafka y se distribuyen a todos los consumidores suscritos al tópico. Los consumidores pueden leer los mensajes en tiempo real mientras se publican o pueden leer los mensajes en un momento posterior.

Los tópicos también tienen una historia de mensajes, lo que significa que se guardan durante un período de tiempo determinado (configurable por el usuario) y pueden ser leídos por cualquier consumidor que se conecte al tópico en cualquier momento durante ese período de tiempo. Esto hace que Kafka sea útil para el procesamiento de datos en tiempo real y la replicación de datos entre sistemas.

2.4.1. Las particiones

Las particiones de los tópicos de Kafka son una característica clave de la plataforma que permite aumentar la capacidad y la escalabilidad del sistema.

Cada tópico de Kafka se divide en un número configurable de particiones. Cada partición contiene una secuencia ordenada de mensajes y puede almacenar y distribuir mensajes de forma independiente de las otras particiones del mismo tópico. Esto permite a Kafka procesar grandes volúmenes de mensajes de manera eficiente.

En Kafka, la carga se balancea a través de las particiones de los tópicos. Cada tópico se divide en un número configurable de particiones y cada partición puede ser almacenada y replicada en diferentes brokers del cluster.

Cuando un publicador envía un mensaje a un tópico, Kafka distribuye el mensaje a una partición específica del tópico basándose en la clave de partición del mensaje. Esto permite a Kafka distribuir los mensajes de forma equilibrada entre las particiones y aumentar la capacidad del sistema.

Cuando un consumidor se suscribe a un tópico, puede leer los mensajes de cualquiera de las particiones del tópico. Esto permite a los consumidores procesar los mensajes de forma paralela y aumentar la velocidad de procesamiento.

Cada partición es un fichero que se encuentra en el disco.

Los ficheros son denominados logs.
Internamente cada mensaje dentro de log es identificado por un offset.

2.4.2. Las replicas

En Kafka, las réplicas son copias de seguridad de las particiones de los tópicos. Cada partición de un tópico puede tener un número configurable de replicas, que se almacenan en diferentes brokers del cluster.

Las replicas tienen dos funciones principales:

Proporcionar tolerancia a fallos: Si un broker falla, otra replica de la partición puede tomar el control y seguir proporcionando acceso a los mensajes de la partición. Esto permite a Kafka garantizar la disponibilidad de los mensajes incluso en caso de fallos.

Mejorar la rendimiento: Las replicas permiten a los consumidores leer los mensajes de forma paralela de diferentes brokers, lo que aumenta la velocidad de procesamiento y el rendimiento del sistema.

Kafka gestiona las replicas de forma automática y puede replicar las particiones a través de diferentes brokers del cluster para garantizar la tolerancia a fallos y el rendimiento. El usuario puede configurar el número de replicas de cada partición y Kafka se encargará de mantenerlas sincronizadas y actualizadas.

Un tópico con 3 particiones, que cada una de ellas va a un broker, y no hay réplicas:

Un tópico con 3 particiones, que cada una de ellas va a un broker, y 2 réplicas:

Un tópico con 3 particiones, que cada una de ellas va a un broker, y 3 réplicas:

Máximas replicas == Numero de brokers.

❖ Al incrementar las replicas hacemos el sistema mas robusto ante caídas.

❖ Las replicas implican un incremento del uso del ancho de banda entre los brokers.

❖ Las réplicas provocan la disminución de la tasa de producción de mensajes por segundos a un topic, si se activa el asentimiento por replica.

Apache Spark es un marco informático de clúster de código abierto para el procesamiento en tiempo real. Tiene una próspera comunidad de código abierto y es el proyecto Apache más activo en este momento. Spark proporciona una interfaz para programar clústeres completos con paralelismo de datos implícito y tolerancia a fallas.

Fue construido sobre Hadoop MapReduce y extiende el modelo MapReduce para usarlo de manera más eficiente y con más tipos de cálculos.

Las característica de Spark son las siguientes:

Políglota:
- Spark proporciona un API de alto nivel en Java, Scala, Python y R. El código de Spark se puede escribir en cualquiera de estos cuatro lenguajes.
- Proporciona un shell en Scala y en Python.
- Desde el directorio instalado se puede acceder al shell de Scala y al shell de Python a través de ./bin/spark-shell y de ./bin/pyspark respectivamente.
Velocidad:
- Para el procesamiento de datos a gran escala, Spark se ejecuta hasta 100 veces más rápido que Hadoop MapReduce.
- Spark puede lograr esta velocidad a través de la partición controlada.
- Administra los datos mediante particiones que ayudan a paralelizar el procesamiento de datos distribuidos con un tráfico de red mínimo.
Evaluación perezosa :
- Apache Spark retrasa su evaluación hasta que sea absolutamente necesario. Este es uno de los factores clave que contribuyen a su velocidad.
- Spark agrega las transformaciones a un DAG (Gráfico acíclico dirigido) de cálculo y solo cuando el controlador solicita algún dato se ejecuta el DAG.
Integración Hadoop :
- Apache Spark proporciona una compatibilidad fluida con Hadoop.
- Spark es un reemplazo potencial para las funciones de MapReduce de Hadoop.
- Para la programación de recursos, Spark tiene la capacidad de ejecutarse sobre un clúster de Hadoop existente usando YARN.
Aprendizaje automático :
- MLlib de Spark es el componente de aprendizaje automático, útil cuando se trata de procesamiento de Big Data.
- Erradica la necesidad de usar múltiples herramientas; una para procesamiento y otra para aprendizaje automático.
- Spark proporciona a los ingenieros y científicos de datos un motor potente y unificado rápido y fácil de usar.

Clúster Big Data

Conoce y accede a toda la información sobre el proyecto de despliegue de un clúster Hadoop en el CPD de Tartanga

Category Archives: Material

WordCount: Distintos Lenguajes

1 MapReduce

1.1 Introduccion MapReduce

1.2 Funcionamiento MapReduce

2 EJERCICIO:

2.1 R:

2.2 Python:

2.3 Pig:

2.4 Java:

Predicción Demanda Eléctrica

DESCRIPCIÓN

Objetivo

Explicación

TAREAS

¡¡Hasta el infinito y más allá!!

Análisis de relación entre la red de sonómetros de Bilbao y el nivel de ruido en la ciudad

Meflis: Mejorando la Experiencia del Usuario

IA&BD Consulting

Apache Kafka y Spark Streaming

Apache Kafka y ZooKeeper

Apache Spark