Web scraping con Java

Posted on julio 25, 2015 por admin

Actualmente me encuentro desarrollando mi proyecto final de máster, el cual consiste en crear un modelo de aprendizaje automático que arroje predicciones acerca de partidos de futbol de la liga de primera división española. Para ello he necesitado entre otras cosas tener los resultados de todas las jornadas de las ultimas ligas. Aunque recientemente conseguí un paquete de R (enlace) que contenía los resultados desde 1929, este no me proporcionaba toda la información que yo buscaba, así que me decidí por obtener yo mismo esa información sacándola de las paginas deportivas y es lo que quiero compartir con ustedes.

En un principio pense en hacerlo en python con la biblioteca lxml, pero haciendo una búsqueda rápida por Internet encontré un proyecto en Java llamado Jsoup y debo decir que este si me simplifico la tarea.

Primero como todos saben es necesario que demos un repaso a la estructura del documento que vamos a scrapear y confirmar que hay un patron.

Como pueden ver en la imagen, podemos detallar que todas las filas de las tablas de las jornadas comparten el atributo itemtype=»http://schema.org/SportEvent», así que este fue el que utilicé para obtener todas las filas y a partir de allí obtener los nombres de los equipos, el resultado y el enlace para ir al detalle del partido.

package com.josedeveloper.WebScrapingExample;

import java.io.IOException;

import org.jsoup.Jsoup;
import org.jsoup.nodes.Document;
import org.jsoup.nodes.Element;
import org.jsoup.select.Elements;

public class App 
{
    public static void main( String[] args ) throws IOException
    {
    	final String url = "http://resultados.as.com/resultados/futbol/primera/2014_2015/calendario";
    	
    	Document doc = Jsoup.connect(url).get();
    	
    	//Obtenemos todas las filas identificadas como evento deportivo
    	//ya que con este atributo es como se identifican los partidos
    	Elements matches = doc.select("tr[itemtype$=\"http://schema.org/SportsEvent\"]");
    	
    	for (Element match: matches) {
    		
    		//Obtenemos los equipos de cada partido utilizando también expresiones
    		Elements teams = match.select("td[itemtype$=\"http://schema.org/SportsTeam\"]");
    		
    		//obtenemos el enlace al detalle del partido
    		Elements score = match.select("a[class=\"resultado resul_post\"]");
    		
    		String localTeam = teams.get(0).text();
    		String visitorTeam = teams.get(1).text();
    		String statsLink = score.first().attr("href");
    		
    		String[] goals = score.first().text().split("-");
    		int localGoals = Integer.parseInt(goals[0].trim());
    		int visitorGoals = Integer.parseInt(goals[1].trim());
    		
    		System.out.println(localTeam + " vs " + visitorTeam + ": " + localGoals + "-" + visitorGoals + " -&gt; " + statsLink);
    	}
    }
}

package com.josedeveloper.WebScrapingExample;

import java.io.IOException;

import org.jsoup.Jsoup;

import org.jsoup.nodes.Document;

import org.jsoup.nodes.Element;

import org.jsoup.select.Elements;

public class App

{

public static void main( String[] args ) throws IOException

{

final String url = "http://resultados.as.com/resultados/futbol/primera/2014_2015/calendario";

Document doc = Jsoup.connect(url).get();

//Obtenemos todas las filas identificadas como evento deportivo

//ya que con este atributo es como se identifican los partidos

Elements matches = doc.select("tr[itemtype$=\"http://schema.org/SportsEvent\"]");

for (Element match: matches) {

//Obtenemos los equipos de cada partido utilizando también expresiones

Elements teams = match.select("td[itemtype$=\"http://schema.org/SportsTeam\"]");

//obtenemos el enlace al detalle del partido

Elements score = match.select("a[class=\"resultado resul_post\"]");

String localTeam = teams.get(0).text();

String visitorTeam = teams.get(1).text();

String statsLink = score.first().attr("href");

String[] goals = score.first().text().split("-");

int localGoals = Integer.parseInt(goals[0].trim());

int visitorGoals = Integer.parseInt(goals[1].trim());

System.out.println(localTeam + " vs " + visitorTeam + ": " + localGoals + "-" + visitorGoals + " -> " + statsLink);

}

Par de cosas que quisiera comentar con respecto al código:

Podemos aplicar expresiones sobre elementos de antemano obtenidos, por ejemplo como se hizo para obtener los equipos que intervienen en el partido.
Existe otra forma además de la anteriormente explicada (usando expresiones) para obtener elementos del árbol DOM de la página Web, si damos un vistazo a la API de la biblioteca del partido, existe un método getElementsByAttributeValue, entonces para obtener el elemento score, este se pudo haber obtenido también de la siguiente manera
Elements score = match.getElementsByAttributeValue(«class», «resultado resul_post»)
Por último si quisiéramos obtener mas datos por ejemplo del detalle del partido (ya que logramos obtener el url), esta biblioteca nos permite seguir navegando (haciendo conexiones), y sería cuestión de realizar otra conexión y de nuevo empezar a extraer elementos.
Document detalleDelPartido = Jsoup.connect(statsLink).get()

Aquí les dejo el enlace al repositorio GitHub y espero que les pueda ser de utilidad.

Estadística simple con Spark

Posted on julio 11, 2015 por admin

Hace unos 20 días lei un articulo titulado «Simple Data Analysis Using Spark» (no publico el enlace ya que el mismo desapareció de dzone de la zona de Big Data y el mismo blog ya no existe, corroborarlo buscando por Internet), lo interesante de este articulo es que el autor hacía cálculos de estadística simple, es decir, calculaba, media, máximo y mínimo, y fue casualidad que justo en ese momento acaba de leer acerca de las operaciones numéricas de los RDD, es esta la razón que me movió a querer hacer un ejercicio similar, con estadística simple pero quería hacerlo con una información que yo considerara valiosa.

Fue entonces que me decidí a buscar alguna fuente de open data española, ya que quería arrojar u obtener datos reales, o no se quizás quería sencillamente obtener algo significativo que se acercara a una tarea real, fue así que llegue al Portal de datos abiertos de la comunidad de Madrid y después de revisar el catalogo me decidí por el padrón municipal, un fichero csv de 22 MB.

He aquí el código:

package com.josedeveloper

import org.apache.spark.SparkContext
import org.apache.spark.SparkContext._

case class Padron(codDistrito: String, descDistrito: String, codDistBarrio: String,
             descBarrio: String, codBarrio: String, codDistSeccion: String, spainMen: Integer,
             spainWomen: Integer, foreignerMen: Integer, foreignerWomen: Integer) {

  def numberOfPeople() : Int = {
    return spainMen + spainWomen + foreignerMen + foreignerWomen;
  }

}

object ScalaApp extends App {

  val sc = new SparkContext("local", "Simple Application", "$SPARK_HOME"
    , List("target/SimpleApp-0.1.jar"))

  val file = sc.textFile("Rango_Edades_Seccion_201506.csv")

  val data = file.map(line =&gt; line.split(";").map(_.trim))
      //the csv header is excluded
      .mapPartitionsWithIndex((idx, iter) =&gt; if (idx == 0) iter.drop(1) else iter).persist()

  //Map to Padron objects
  val dataMapped = data.map(line =&gt; (line(1), new Padron(line(0), line(1),
    line(2), line(3), line(4), line(5),
    getIntValue(line(8)),
    getIntValue(line(9)),
    getIntValue(line(10)),
    getIntValue(line(11)))))

  //Groupped by district
  val grouppedData = dataMapped.reduceByKey((x: Padron, y: Padron) =&gt; new Padron(x.codDistrito, x.descDistrito,
    x.codDistBarrio, x.descBarrio, x.codBarrio, x.codDistSeccion, x.spainMen + y.spainMen,
    x.spainWomen + y.spainWomen, x.foreignerMen + y.foreignerMen,
    x.foreignerWomen + y.foreignerWomen))

  //sorted list total spanish men by district
  grouppedData.collect().sortBy(_._2.spainMen)
    .foreach(x =&gt; println(x._2.descDistrito + "-&gt;" + x._2.spainMen))

  //statistics and numerics sparks RDD values
  val spainMaleValeByDistrict = grouppedData.map(tupla =&gt; tupla._2.spainMen.doubleValue()).cache()
  val media = spainMaleValeByDistrict.mean()
  val stddev = spainMaleValeByDistrict.stdev()
  val max = spainMaleValeByDistrict.max()
  val min = spainMaleValeByDistrict.min()

  println("Media de Españoles varones por distrito: " + media.toInt)
  println("Desviación estandar de españoles varones por distrito: " + stddev.toInt)
  println("Num maximo de españoles varones en un distrito: " + max.toInt)
  println("Num minimo de españoles varones en un distrito: " + min.toInt)


  //sorted list total number of people by district
  grouppedData.collect().sortBy(_._2.numberOfPeople)
    .foreach(x =&gt; println(x._2.descDistrito + "-&gt;" + x._2.numberOfPeople))

  val numberOfPeopleByDistrict = grouppedData.map(tupla =&gt; tupla._2.numberOfPeople.doubleValue).cache()
  val media2 = numberOfPeopleByDistrict.mean()
  val stddev2 = numberOfPeopleByDistrict.stdev()
  val max2 = numberOfPeopleByDistrict.max()
  val min2 = numberOfPeopleByDistrict.min()

  println("Media de personas por distrito: " + media2.toInt)
  println("Desviación estandar de personas por distrito: " + stddev2.toInt)
  println("Num maximo de personas en un distrito: " + max2.toInt)
  println("Num minimo de personas en un distrito: " + min2.toInt)

  def getIntValue(s:String) : Integer = {
    val value = s.substring(1, s.length - 1)
    if (value.isEmpty)
      return 0
    return Integer.parseInt(value)
  }

}

package com.josedeveloper

import org.apache.spark.SparkContext

import org.apache.spark.SparkContext._

case class Padron(codDistrito: String, descDistrito: String, codDistBarrio: String,

descBarrio: String, codBarrio: String, codDistSeccion: String, spainMen: Integer,

spainWomen: Integer, foreignerMen: Integer, foreignerWomen: Integer) {

def numberOfPeople() : Int = {

return spainMen + spainWomen + foreignerMen + foreignerWomen;

}

object ScalaApp extends App {

val sc = new SparkContext("local", "Simple Application", "$SPARK_HOME"

, List("target/SimpleApp-0.1.jar"))

val file = sc.textFile("Rango_Edades_Seccion_201506.csv")

val data = file.map(line => line.split(";").map(_.trim))

//the csv header is excluded

.mapPartitionsWithIndex((idx, iter) => if (idx == 0) iter.drop(1) else iter).persist()

//Map to Padron objects

val dataMapped = data.map(line => (line(1), new Padron(line(0), line(1),

line(2), line(3), line(4), line(5),

getIntValue(line(8)),

getIntValue(line(9)),

getIntValue(line(10)),

getIntValue(line(11)))))

//Groupped by district

val grouppedData = dataMapped.reduceByKey((x: Padron, y: Padron) => new Padron(x.codDistrito, x.descDistrito,

x.codDistBarrio, x.descBarrio, x.codBarrio, x.codDistSeccion, x.spainMen + y.spainMen,

x.spainWomen + y.spainWomen, x.foreignerMen + y.foreignerMen,

x.foreignerWomen + y.foreignerWomen))

//sorted list total spanish men by district

grouppedData.collect().sortBy(_._2.spainMen)

.foreach(x => println(x._2.descDistrito + "->" + x._2.spainMen))

//statistics and numerics sparks RDD values

val spainMaleValeByDistrict = grouppedData.map(tupla => tupla._2.spainMen.doubleValue()).cache()

val media = spainMaleValeByDistrict.mean()

val stddev = spainMaleValeByDistrict.stdev()

val max = spainMaleValeByDistrict.max()

val min = spainMaleValeByDistrict.min()

println("Media de Españoles varones por distrito: " + media.toInt)

println("Desviación estandar de españoles varones por distrito: " + stddev.toInt)

println("Num maximo de españoles varones en un distrito: " + max.toInt)

println("Num minimo de españoles varones en un distrito: " + min.toInt)

//sorted list total number of people by district

grouppedData.collect().sortBy(_._2.numberOfPeople)

.foreach(x => println(x._2.descDistrito + "->" + x._2.numberOfPeople))

val numberOfPeopleByDistrict = grouppedData.map(tupla => tupla._2.numberOfPeople.doubleValue).cache()

val media2 = numberOfPeopleByDistrict.mean()

val stddev2 = numberOfPeopleByDistrict.stdev()

val max2 = numberOfPeopleByDistrict.max()

val min2 = numberOfPeopleByDistrict.min()

println("Media de personas por distrito: " + media2.toInt)

println("Desviación estandar de personas por distrito: " + stddev2.toInt)

println("Num maximo de personas en un distrito: " + max2.toInt)

println("Num minimo de personas en un distrito: " + min2.toInt)

def getIntValue(s:String) : Integer = {

val value = s.substring(1, s.length - 1)

if (value.isEmpty)

return 0

return Integer.parseInt(value)

}

Hay una cosa que quiero resaltar, Lo simple y corto del código en Scala, tanto para la definición de la clase Padron como en las transformaciones hechas en los RDD, ya Scala esta en mi lista de cosas por aprender porque se que con Java hubiese sido el doble de código.

Por último les dejo parte de la información obtenida, la lista ordenada de población por distrito:

BARAJAS: 46166
VICALVARO: 69709
MORATALAZ: 94785
VILLA DE VALLECAS: 101011
MONCLOA-ARAVACA: 116581
RETIRO: 118390
CENTRO: 131805
USERA: 133579
CHAMBERI: 137454
VILLAVERDE: 141457
CHAMARTIN: 142334
SALAMANCA: 143123
ARGANZUELA: 151061
TETUAN: 152142
SAN BLAS-CANILLEJAS: 153303
HORTALEZA: 176320
CIUDAD LINEAL: 212626
PUENTE DE VALLECAS: 227183
LATINA: 234842
FUENCARRAL-EL PARDO: 234883
CARABANCHEL: 242032

¿Te ha parecido interesante? ¿Qué le agregarías o quitarías al código?

Si quieres acceder al GitHub donde he colgado el código pincha aquí

Primer ejemplo con apache spark

Posted on junio 12, 2015 por admin

Hace algunas semanas atrás que empezamos a trabajar con apache spark en el máster, brevemente les contare mis impresiones desde mi punto de vista como principiante.

Apache spark me gusto, ¿por qué? porque se puede programar en Scala (además de Python y Java), la API de Scala lo simplifica mucho y la cantidad de código a teclear es (considerablemente) menor a la necesaria para hacer la misma tarea en Java, aunque aquí debo hacer un paréntesis, ya que con la entrada de Java 8 y las lambda expresión la cantidad de código será menor pero insisto la API de Scala a mi modo de ver lo hace mas sencillo.

Nos permite hacer operaciones con mucha data (quizás no Big Data, es decir no hablamos de TeraBytes) sin necesidad de usar Hadoop, me gustaría hacer hincapié en esto ya que muchos piensan que Big Data es Hadoop y NO, no es así, mi concepto de Big Data es un poco mas amplio y contempla mas cosas, aquí me refiero específicamente a la API MapReduce de Hadoop la cual es mas complicada de usar que la de Spark, no obstante si necesitamos trabajar con una cantidad de datos considerable que requiera del uso de HDFS, podemos desde Spark acceder a este sistema de archivo u algún otro como por ejemplo Amazon S3.

Por último decirles que Spark es mas rapido, esto se debe a su arquitectura, ya que este trabaja en memoria (todo en memoria si tiene la capacidad de cargar todos los datos por completo) y pues si llegamos a hacer varias tareas (lo que técnicamente sería reutilizar los RDD ya guardados en memoria) con los datos en memoria es cuando mas jugo se le sacará a Spark.

Sinceramente si alguien discrepa de mi o coincide me entusiasmaría mucho que comparta su opinión ya que todo este mundo que envuelve el Big Data me tiene super enganchado.

Ahora bien vamos con los ejemplos, estas formaban parte de la primera tarea de Spark que tuvimos que realizar, y consiste en 2 ejemplos:

Dado un fichero de texto en formato csv con información de medallistas olímpicos, obtener el numero de medallas por edad.
Dado el mismo fichero de texto anterior, y un esquema de puntuación por tipo de medalla obtener un ranking de medallistas olímpicos.

He aqui el código:

package org.dummy

import org.apache.spark.SparkContext
import org.apache.spark.SparkContext._

object ScalaApp extends App {
  val logFile = "OlympicAthletes.csv"
  val sc = new SparkContext("local", "Simple", "$SPARK_HOME"
    , List("target/spark-ejercicio-1.0.jar"))

  //Todo el fichero csv es cargado en este RDD
  val file = sc.textFile(logFile)

  //linea a linea se aplica un split o separacion utilizando la ","
  //eso nos arrojara un arreglo de palabras (o numeros)
  //y construimos una instancia del tipo OlympicMedalRecords
  val olympicMedalRecordsRDD = file.map(x =&gt; {
    val arr = x.split(",")
    new OlympicMedalRecords(arr(0), Integer.parseInt(arr(1)), arr(2)
      , Integer.parseInt(arr(3)), arr(5), Integer.parseInt(arr(6)),
      Integer.parseInt(arr(7)), Integer.parseInt(arr(8)))
  }
  )


  //Mis ejercicios
  //Ejercicio 1
  //mapeo del tipo (edad, num de medallas), val medal es un RDD
  val medal = olympicMedalRecordsRDD.map(record =&gt; (record.getAge, record.getGoldMedals + record.getSilverMedals + record.getBronzeMedals))

  //creamos un nuevo RDD el cual manejara la suma de todas las madellas por edad
  val sum = medal.reduceByKey((acc: Int,value: Int)=&gt;acc+value)
  println("Lista de Medallas ordenado por Edad")

  //ordenamos, juntamos y luego recorremos para mostrar todos los valores
  sum.sortBy(_._1).collect.foreach(println)


  //Ejercicio 2 hacer un ranking por atleta
  // ya que oro = 3 ptos, plata = 2ptos, bronce = 1pto
  //sportGuy es otro RDD y aqui hacemos un mapeo del tipo (nombre_atleta, puntos_por_medalla)
  val sportGuy = olympicMedalRecordsRDD.map(record =&gt; (record.getName, 3*record.getGoldMedals + 2*record.getSilverMedals + record.getBronzeMedals))

  //ranking es a su vez otro RDD  y de igual manera como se hizo en el ejemplo anterior se agrupa por nombre de atleta
  // y también utilizamos una variable acumuladora acc donde vamos sumando los ptos de un determinado atleta
  val ranking = sportGuy.reduceByKey((acc,value)=&gt;acc+value)
  println("Ranking de deportistas")
  // ordenamos en sentido inverso y mostramos  los atletas con mas ptos
  ranking.sortBy(_._2, false).collect.foreach(println)
}

package org.dummy

import org.apache.spark.SparkContext

import org.apache.spark.SparkContext._

object ScalaApp extends App {

val logFile = "OlympicAthletes.csv"

val sc = new SparkContext("local", "Simple", "$SPARK_HOME"

, List("target/spark-ejercicio-1.0.jar"))

//Todo el fichero csv es cargado en este RDD

val file = sc.textFile(logFile)

//linea a linea se aplica un split o separacion utilizando la ","

//eso nos arrojara un arreglo de palabras (o numeros)

//y construimos una instancia del tipo OlympicMedalRecords

val olympicMedalRecordsRDD = file.map(x => {

val arr = x.split(",")

new OlympicMedalRecords(arr(0), Integer.parseInt(arr(1)), arr(2)

, Integer.parseInt(arr(3)), arr(5), Integer.parseInt(arr(6)),

Integer.parseInt(arr(7)), Integer.parseInt(arr(8)))

}

)

//Mis ejercicios

//Ejercicio 1

//mapeo del tipo (edad, num de medallas), val medal es un RDD

val medal = olympicMedalRecordsRDD.map(record => (record.getAge, record.getGoldMedals + record.getSilverMedals + record.getBronzeMedals))

//creamos un nuevo RDD el cual manejara la suma de todas las madellas por edad

val sum = medal.reduceByKey((acc: Int,value: Int)=>acc+value)

println("Lista de Medallas ordenado por Edad")

//ordenamos, juntamos y luego recorremos para mostrar todos los valores

sum.sortBy(_._1).collect.foreach(println)

//Ejercicio 2 hacer un ranking por atleta

// ya que oro = 3 ptos, plata = 2ptos, bronce = 1pto

//sportGuy es otro RDD y aqui hacemos un mapeo del tipo (nombre_atleta, puntos_por_medalla)

val sportGuy = olympicMedalRecordsRDD.map(record => (record.getName, 3*record.getGoldMedals + 2*record.getSilverMedals + record.getBronzeMedals))

//ranking es a su vez otro RDD y de igual manera como se hizo en el ejemplo anterior se agrupa por nombre de atleta

// y también utilizamos una variable acumuladora acc donde vamos sumando los ptos de un determinado atleta

val ranking = sportGuy.reduceByKey((acc,value)=>acc+value)

println("Ranking de deportistas")

// ordenamos en sentido inverso y mostramos los atletas con mas ptos

ranking.sortBy(_._2, false).collect.foreach(println)

}

Una última cosa que es bueno saber para aquellos que como yo están empezando con Spark y sus RDD, Los RDD tienen 2 tipos de operaciones: transformaciones y acciones, las primeras son operaciones que como resultado nos devuelven otro RDD y las acciones son aquellas que hacen «algo» sobre los datos como por ejemplo el foreach de mi código, utilizado para mostrar por pantalla los valores finales, además los RDD (como hasta ahora lo entiendo) son las instrucciones a realizar sobre los datos, mas no almacenan la información, además estás instrucciones no se realizan de inmediato, sino que al contrario estos tienen un funcionamiento lazy, esto significa que se ejecutan cada vez que se realiza una operación de tipo acción.

Otra sugerencia, no duden en cacharrear con la consola de spark, de hecho el primer ejercicio lo llegue a hacer por la consola (sin los JavaBeans) y el practicar por aquí si que ayuda a conocer los operaciones a utilizar sobre los RDD.

Aquellos interesados en descargar el código, les dejo la dirección del ejercicio en mi repositorio github

El esqueleto del ejercicio esta en el repositorio del que fue nuestro profesor y pueden acceder a el haciendo clic aquí.

Cualquier material, idea o contenido que quieres compartir, no dudes en hacerlo, ya que bien recibido será. Ahora si para cerrar les dejo el enlace a un libro que hasta ahora me esta pareciendo muy bueno para aprender Spark (además con ejemplos elaborados en Java, Scala y Python).

Qué es Big Data

Posted on junio 12, 2015 por admin

Hace una semana en una clase del máster mas enfocada a negocio, retos y oportunidades del Big Data, hicimos un ejercicio bastante interesante, este consistió en que cada uno de nosotros brevemente plasmara su definición de Big Data, donde podría aplicarse y que beneficios podría arrojarnos.

Pudimos ver las definiciones de algunos compañeros, coincidir y discrepar en algunos puntos pero para mí fue una actividad muy enriquecedora sin importar si coincidíamos o no, es por eso que comparto con ustedes mi definición de Big Data.

¿Qué es Big Data?

Big Data contempla las nuevas herramientas, tecnologías y (nuevos) los conceptos relacionados con la adquisición de (mucha) data (volumen), de distinto tipo (variedad) que a su vez podría estar no estructurada, con unos aspectos opcionales pero que también puede marcar la diferencia para definirlo como “really Big Data” como la movilidad (por ejemplo la adquisición de información mediante IoT o dispositivos móviles) y el tiempo real. De hecho contemplo el Big Data como unas 2 vertientes que pueden o no trabajar en conjunto:

Ingeniería: Enfocado en el uso de las herramientas por ejemplo al tratar verdaderamente mucha data con poco o nada de análisis, un rol de esta vertiente sería el Data Arquitect, esa persona encargada de manipular estructurar los datos, manipularlos, masticarlos y dejarlos bien preparados para aquellos encargados de hacer análisis sobre los datos, esta persona trabajaría con Hadoop, Pig, Spark.
Científica: Donde sin que estrictamente se tenga que trabajar con muchísima data (podría ser tanto small Data como Big Data) se lleva a cabo análisis mayormente de tipo estadístico como análisis predictivos, construyendo modelos, un rol de esta vertiente sería la del Data scientist, esa persona encargada de hacer data mining, machine learning, etc.

Y ¿yo qué quiero? ¿qué busco?

YO aspiro a convertirme en un Big Data Architect y seguir aprendiendo y profundizando mis conocimientos en Data mining, Machine learning, estadísticas e investigación de operaciones para forjarme un perfil mas científico.

¿Qué es lo que mas me ha interesado?

Aprendizaje automático (machine learning) y los nuevos enfoques para el procesamiento y almacenamiento de grandes volúmenes de datos (Spark, Flink, Hadoop, Cassandra, HBase).

¿Donde creo que podría aplicarse?

A nivel de ingeniería para almacenamiento por ejemplo de data del hogar (IoT), por ejemplo un termostato inteligente y configurable donde poder gestionar a través de una plataforma de Internet poder gestionar cuando se encienda/apague la calefacción, ver histórico de funcionamiento de la calefacción y sobre estos datos hacer análisis estadísticos.

¿Qué beneficios podría arrojar ?

En base al ejemplo anterior Dinero (ahorro de energía siguiendo con el ejemplo del termostato) o clientes (sistemas de recomendación de productos), otros casos serian por ejemplo tiempo (aprendizaje automático para la elaboración de prestamos preconcebidos o análisis de un cliente al momento de solicitar una hipoteca o préstamo por internet).

Ahora bien, una vez conocido mi concepto de Big Data ¿Coincides con mi definición? ¿discrepas?, ¿Cual es tu concepto del Big Data?

El Blog de Jose

Blog de tecnología, software y programación

Archivo de la categoría: Big Data

Web scraping con Java

Estadística simple con Spark

Primer ejemplo con apache spark

Qué es Big Data

Uso de cookies