trabajo fin de grado - trabajos academicos de la...
TRANSCRIPT
1
2
Trabajo Fin de Grado Curso 2017 – 2018
ANÁLISIS DE DATOS Y EXTRACCIÓN DE
CONOCIMIENTO UTILIZANDO BIG DATA
Alumno: Verjaga Felgueras, María Elena
Tutor: Muñoz Expósito, José Enrique
Departamento: Ingeniería de Telecomunicación
Firma de la autora Firma del tutor
3
ÍNDICE
íNDICE DE ILUSTRACIONES ………………………………..………………………………………………………………..……… 6
ÍNDICE DE TABLAS ..…………………………………………………………………………………………………………………….. 9
GLOSARIO DE TÉRMINOS …………………………………………………………………………………………………………… 10
1. RESUMEN ................................................................................................................................. 11
2. INTRODUCCIÓN ........................................................................................................................ 12
2.1. Justificación y contexto del TFG ....................................................................................... 12
2.2. Estructura del documento................................................................................................ 13
3. OBJETIVOS ................................................................................................................................ 15
4. ESTADO DEL ARTE .................................................................................................................... 16
4.1. Big Data ............................................................................................................................ 16
4.1.1. Definición ................................................................................................................. 16
4.1.2. Enfoque de funcionamiento ..................................................................................... 18
4.1.3. Aplicaciones .............................................................................................................. 20
4.1.4. Antecedentes ........................................................................................................... 24
4.1.5. Tipos de proyectos ................................................................................................... 25
4.1.6. Tecnologías que utiliza Big Data. .............................................................................. 26
4.1.7. Técnicas de análisis de datos ................................................................................... 31
4.2. Algoritmos ........................................................................................................................ 34
4.2.1. Algoritmos de Machine Learning. ............................................................................ 35
4.2.1.1. Regresión lineal ................................................................................................ 36
4.2.1.2. Clasificación ...................................................................................................... 37
4.2.1.3. Clústering.......................................................................................................... 41
4.2.2. Optimización ............................................................................................................ 42
4.2.2.1. Algoritmos genéticos ........................................................................................ 42
4.2.2.2. PSO (Particle Swarm Optimization) .................................................................. 44
4.2.2.3. Pittsburgh y Michigan approach ...................................................................... 45
4.2.3. Toma de decisiones .................................................................................................. 48
4.3. Apache Spark .................................................................................................................... 50
4.3.1. Qué es Apache Spark ................................................................................................ 51
4.3.2. Quien usa Spark ........................................................................................................ 51
4.3.3. Para que se utiliza Spark........................................................................................... 52
4
4.3.4. Visión general de la arquitectura de Apache Spark ................................................. 52
4.3.4.1. Lenguajes .......................................................................................................... 53
4.3.4.2. Opciones de almacenamiento .......................................................................... 54
4.3.4.3. RDD (Resilient Distribuited Datasets) ............................................................... 54
4.3.4.4. Componentes de Spark .................................................................................... 56
4.3.4.5. API (Interfaz de Programación de Aplicaciones) .............................................. 57
4.3.4.6. Arquitectura de un clúster ............................................................................... 58
4.3.5. Notebooks para Spark .............................................................................................. 60
4.3.6. Seguridad .................................................................................................................. 61
4.3.7. Ventajas y desventajas ............................................................................................. 62
5. DESARROLLO DEL PROYECTO ................................................................................................... 63
5.1. Máquinas virtuales ........................................................................................................... 64
5.1.1. Características y requisitos ....................................................................................... 64
5.1.2. Topología de red ...................................................................................................... 65
5.1.3. Instalación máquina virtual ...................................................................................... 66
5.2. Computadores físicos ....................................................................................................... 70
5.2.1. Características y requisitos ....................................................................................... 70
5.2.2. Topología de red ...................................................................................................... 71
5.3. Preparación entorno ........................................................................................................ 71
5.3.1. Instalación Java ........................................................................................................ 72
5.3.2. Instalación Anaconda (Pyhon) .................................................................................. 72
5.3.3. Instalación Spark ...................................................................................................... 75
5.3.4. Instalación Hadoop (opcional) ................................................................................. 77
5.3.5. Acceso SSH ............................................................................................................... 78
5.3.6. FindSpark .................................................................................................................. 80
5.3.7. Py4j ........................................................................................................................... 80
5.3.8. Jupyter Notebook ..................................................................................................... 80
5.4. Configuración y puesta en marcha ................................................................................... 82
5.4.1. Iniciar el servidor maestro ........................................................................................ 82
5.4.2. Conectar esclavos ..................................................................................................... 84
5.4.3. Crear primera aplicación Spark ................................................................................ 85
5.5. Concluir sesiones .............................................................................................................. 87
5.6. Resumen de pasos para iniciar y finalizar clúster ............................................................ 88
6. PRUEBAS Y RESULTADOS .......................................................................................................... 89
5
6.1. Prueba “TextClassificationmini” ....................................................................................... 95
6.2. Prueba “TextClassificationmaxi” ...................................................................................... 98
6.3. Resultados ...................................................................................................................... 101
6.4. Problemas a lo largo del trabajo .................................................................................... 103
6.5. Conclusiones................................................................................................................... 103
7. ESTUDIO ECONÓMICO ........................................................................................................... 104
7.1. Costes de Hardware ....................................................................................................... 105
7.2. Costes de Software ......................................................................................................... 105
7.3. Honorarios ...................................................................................................................... 106
7.4. Resumen con costes totales ........................................................................................... 106
8. CONCLUSIONES SOBRE EL TFG Y TRABAJOS FUTUROS .......................................................... 107
9. BIBLIOGRAFÍA ......................................................................................................................... 107
9.1. Referencias ..................................................................................................................... 107
9.2. Otras fuentes consultadas .............................................................................................. 110
9.2.1. Enlaces .................................................................................................................... 110
9.2.2. Videotutoriales ....................................................................................................... 115
6
ÍNDICE DE ILUSTRACIONES
Ilustración 1. Ampliar capacidades DWH corporativo ..................................................................... 19
Ilustración 2. Mejorar DataWarehouse ............................................................................................ 19
Ilustración 3. IBM Social Media Analytics Framework ..................................................................... 22
Ilustración 4. Apache hadoop .......................................................................................................... 26
Ilustración 5. Arquitectura HDFS ...................................................................................................... 27
Ilustración 6. Arquitectura MapReduce ........................................................................................... 27
Ilustración 7. Arquitectura YARN ..................................................................................................... 27
Ilustración 8. Hadoop EcoSystem ..................................................................................................... 28
Ilustración 9. Apache Spark .............................................................................................................. 30
Ilustración 10. Relación entre tipos de algoritmos y variables ........................................................ 35
Ilustración 11. Regresión lineal ........................................................................................................ 36
Ilustración 12. Redes neuronales ..................................................................................................... 38
Ilustración 13. SVM, clase 1 y clase 2 con frontera de decisión ....................................................... 39
Ilustración 14. Algoritmo knn ........................................................................................................... 40
Ilustración 15. Algoritmo árboles de decisión .................................................................................. 40
Ilustración 16. Fórmula k-means ...................................................................................................... 41
Ilustración 17. Diagrama Algoritmo k-means ................................................................................... 42
Ilustración 18. Estructura algoritmo genético simple ...................................................................... 43
Ilustración 19. Algoritmo genético, ciclo reproductivo .................................................................... 44
Ilustración 20. Pseudocódigo ........................................................................................................... 45
Ilustración 21. Esquema Pittsburgh approach ................................................................................. 46
Ilustración 22. Esquema Michigan approach, sistema clasificador .................................................. 47
Ilustración 23. Estructura básica de un controlador Fuzzy .............................................................. 50
Ilustración 24. RDD transformaciones ............................................................................................. 55
Ilustración 25. Componentes de Spark ............................................................................................ 56
Ilustración 26. Arquitectura de un clúster ....................................................................................... 59
Ilustración 27. Jupyter ...................................................................................................................... 60
Ilustración 28. Apache Zeppelin ....................................................................................................... 61
Ilustración 29. Spark Notebook ........................................................................................................ 61
Ilustración 30. Instalación máquina virtual ...................................................................................... 66
Ilustración 31. Instalación máquina virtual, tamaño de memoria ................................................... 66
Ilustración 32. Instalación máquina virtual, disco duro ................................................................... 66
Ilustración 33. Instalación máquina virtual, tipo almacenamiento.................................................. 67
Ilustración 34. Instalación máquina virtual, tipo disco duro. ........................................................... 67
Ilustración 35. Instalación máquina virtual, ubicación y tamaño .................................................... 67
Ilustración 36. Instalación máquina virtual, crear disco duro virtual ............................................... 67
Ilustración 37. Arranque Ubuntu ..................................................................................................... 67
Ilustración 38. Arranque Ubuntu cargado ........................................................................................ 68
Ilustración 39. Arranque Ubuntu, selección de ISO del sistema operativo ..................................... 68
Ilustración 40. Install Ubuntu ........................................................................................................... 68
Ilustración 41. Entrada Dispositivo CD/DVD vacía ........................................................................... 68
Ilustración 42. Clonar ....................................................................................................................... 69
7
Ilustración 43. Clonar, nombre ......................................................................................................... 69
Ilustración 44. Clonación .................................................................................................................. 69
Ilustración 45. Clonar, tipo de clonación .......................................................................................... 69
Ilustración 46. Java version .............................................................................................................. 72
Ilustración 47. Instalar Anaconda ..................................................................................................... 73
Ilustración 48. Anaconda .bashrc ..................................................................................................... 73
Ilustración 49. Python version .......................................................................................................... 73
Ilustración 50. Version Pyhton con Anaconda ................................................................................. 74
Ilustración 51. Versión conda ........................................................................................................... 74
Ilustración 52. Spark Download ....................................................................................................... 75
Ilustración 53. Archivo .bashrc Spark ............................................................................................... 76
Ilustración 54. Verificación instalación Spark................................................................................... 76
Ilustración 55. Hadoop Download .................................................................................................... 77
Ilustración 56. Archivo .bashrc Hadoop ........................................................................................... 78
Ilustración 57. Verificación instalación Spark con Hadoop .............................................................. 78
Ilustración 58. SSH clave RSA ........................................................................................................... 79
Ilustración 59. Copiar RSA a slaves ................................................................................................... 80
Ilustración 60. Lanzar jupyter notebook con spark .......................................................................... 81
Ilustración 61. Lanzar jupyter notebook .......................................................................................... 81
Ilustración 62. Entorno jupyter en navegador ................................................................................. 81
Ilustración 63. Configuración red ..................................................................................................... 82
Ilustración 64. Iniciar servidor maestro ........................................................................................... 83
Ilustración 65. Interfaz de usuario web, localhost ........................................................................... 83
Ilustración 66. Interfaz de usuario web, otro dispositivo ................................................................ 83
Ilustración 67. Iniciar Slave ............................................................................................................... 84
Ilustración 68. Interfaz de usuario web, slaves conectados ............................................................ 84
Ilustración 69. Script ejecutado python prueba1 ............................................................................. 85
Ilustración 70. Interfaz web de la aplicación (ejecutores) ............................................................... 86
Ilustración 71. Interfaz web con running applications ..................................................................... 86
Ilustración 72. Interfaz web, completed Applications ..................................................................... 87
Ilustración 73. Apagar slave ............................................................................................................. 87
Ilustración 74. Apagar servidor maestro .......................................................................................... 88
Ilustración 75. Lectura datos TextClassificationmini ........................................................................ 90
Ilustración 76. Lectura de datos TextClassificationmaxi .................................................................. 91
Ilustración 77. Web gestión de clústers ........................................................................................... 91
Ilustración 78. Interfaz de aplicación ............................................................................................... 92
Ilustración 79. Descripción detallada de uno de los trabajos de la aplicación ................................ 92
Ilustración 80. Grafo de una tarea perteneciente a una aplicación ................................................. 93
Ilustración 81. Ejecutores aplicación corriendo(I) ............................................................................ 94
Ilustración 82. Ejecutores aplicación corriendo (II) .......................................................................... 94
Ilustración 83. Aplicación finalizada ................................................................................................. 95
Ilustración 84. Time código .............................................................................................................. 96
Ilustración 85. Gráfico total TextClassificationmini ......................................................................... 97
Ilustración 86. Gráfico segundos TextClassificationmini .................................................................. 97
Ilustración 87. Gráfico minutos TextClassificationmini .................................................................... 98
8
Ilustración 88. Gráfico tiempos totales TextClassificationmini ........................................................ 98
Ilustración 89. Gráfico total TextClassificationmaxi ......................................................................... 99
Ilustración 90. Gráfico segundos-minutos TextClassificationmini ................................................. 100
Ilustración 91. Gráfico horas TextClassificationmaxi ..................................................................... 100
Ilustración 92. Gráfico tiempos totales TextClassificationmaxi ..................................................... 100
Ilustración 94. Gráfico tiempos finales en escala porcentual ........................................................ 102
9
ÍNDICE DE TABLAS
Tabla 1. Topología de red máquinas virtuales ................................................................................. 65
Tabla 2. Tabla topología de red ordenadores físicos ....................................................................... 71
Tabla 3. TextClassification mini (1) ................................................................................................... 96
Tabla 4. TextClassification mini (2) ................................................................................................... 96
Tabla 5. TextClassificationmaxi (1) ................................................................................................... 99
Tabla 6. TextClassificationmaxi (2) ................................................................................................... 99
Tabla 7. Resultados tiempos finales ............................................................................................... 101
Tabla 8. Resultados tiempos finales escala porcentual ................................................................. 101
Tabla 9. Costes Hardware............................................................................................................... 105
Tabla 10. Costes Software .............................................................................................................. 105
Tabla 11. Honorarios ...................................................................................................................... 106
Tabla 12. Costes totales ................................................................................................................. 106
10
GLOSARIO DE TÉRMINOS
Clúster. Conjunto de ordenadores independientes interconectados por diversos medios,
que funcionan como un solo recurso computacional
Competencias Digitales. Conocimientos y capacidades para utilización segura y critica
de la gama completa de tecnologías digitales de información, comunicación y resolución
de problemas.
Conocimiento explícito. [12] Es el conocimiento que sabemos, tenemos y somos
plenamente conscientes cuando lo ejecutamos. Estructurado
Conocimiento tácito. [12] Conocimiento que permanece en un nivel inconsciente e
implementamos y ejecutamos de manera mecánica. No estructurado.
Dataframe. [20] Es un conjunto de datos organizado en columnas con nombre
Espacio euclídeo. Espacio bidimensional o tridimensional en el que se cumplen los
axiomas de Euclides. También llamado espacio cartesiano.
Heurístico. Técnica que busca solución de un problema mediante la indagación y el
descubrimiento.
Identación. Hacer espacios hacia la derecha para mover una línea de código
Kernel. Núcleo del sistema operativo que realiza la comunicación entre el software y
hardware.
Mesos. Kernel administrador de clúster de código abierto
Pipeline. Elementos que procesan datos conectados en serie que transforman la salida en
la entrada del siguiente.
Reporting. Procesos, procedimientos, sistematización o flujo de información manual o
semi-manual, que genera y facilita el acceso de las personas adecuadas a la información
adecuada.
11
1. RESUMEN
El presente trabajo de fin de grado, tiene como objetivo principal hacer un estudio
sobre Big Data y tecnologías que sirvan de soporte para el tratamiento de datos, haciendo
una comparación entre Spark y Hadoop que son las más utilizadas hoy en día. El estudio
se llevará a cabo teórica y prácticamente.
La parte teórica se centra en una profunda descripción de Big Data donde se
detallarán aplicaciones, tipos de proyectos, tecnologías que utilizan Big Data y su
comparación y técnicas para el análisis de los datos. También se describen algunos de los
algoritmos más utilizados en el tratamiento de datos. Por último, se profundiza en la
tecnología Spark describiendo su arquitectura y algunos de sus aspectos más relevantes.
La parte práctica constará de varias fases. La primera será la preparación del
entorno de trabajo con Apache Spark en la que se realizarán todas las instalaciones y
configuraciones necesarias para el correcto funcionamiento. Una vez esté el entorno de
trabajo preparado, se procederá a la creación del clúster donde se podrán incorporar tantos
nodos como workers queramos. Esto se ha hecho en dos escenarios distintos:
En máquinas virtuales para poder experimentar con Spark desde mi ordenador
ejecutando varios algoritmos en el clúster Spark y comprobando su funcionamiento.
En computadores físicos donde se llevará a cabo la prueba real ejecutando en un
clúster Spark un algoritmo que incluye técnicas de machine learning (aprendizaje
automático), variando número de nodos que lo componen y la carga de trabajo
introducida.
Se evaluará la eficacia de Spark haciendo un estudio comparativo teniendo en
cuenta principalmente los tiempos de ejecución y considerando la distribución de las tareas.
12
2. INTRODUCCIÓN
En este capítulo se presenta el contexto en el que se sitúa este trabajo y las
circunstancias que han originado su desarrollo.
2.1. Justificación y contexto del TFG
Hoy en día tenemos información de todo tipo de fuentes ya sea procedente de
internet (búsquedas en Google, publicaciones y likes en Facebook, twitter, blogs, tags,
videos reproducidos etc.) o captada en cualquier dispositivo (geoposicionamiento de
coches o personas, frecuencia de tareas, estadísticas, numero de compras de un
determinado artículo, sensores, datos meteorológicos etc.). Con toda esta información
podemos hacer combinaciones y análisis de datos para sacar diferentes conclusiones y
utilizar convenientemente.
Las empresas en general tienen mucha información de la cual la gran mayoría
(80%) es información no estructurada. Están tomando decisiones y trabajando con grandes
volúmenes de datos, pero el 80% no se están tratando por tanto se obtiene la necesidad
de trabajar esta información de una forma fácil y económica.
Big Data es un concepto muy prometedor ya que, con la visión adecuada de
empresas y organizaciones, pueden utilizar los datos convenientemente para garantizar
que cubren las necesidades del consumidor y situándose con una gran ventaja en el ámbito
comercial.
Las principales características que engloba Big Data son volumen, velocidad y
variedad. Estas establecen un reto en el dominio y control de la calidad de los datos
estructurados y sin estructurar, que se incorporan al almacén de información digital. Es
fundamental que la calidad de los datos esté garantizada para tener información de valor y
asegurar buenos resultados del procesamiento analítico de los datos.
Para la realización de este proyecto se ha utilizado la tecnología Spark, un
framework con el que se podrán crear clústers de una forma muy fácil y rápida.
Con el objetivo de que se optimice en tiempo lo máximo posible y sea algo más
visual, una de las elecciones personales ha sido trabajar a través de un notebook web
13
(jupyter notebook) en lugar de hacerlo de la forma convencional por la Shell. Esto garantiza
mucha flexibilidad a la hora de probar y ejecutar cualquier código deseado.
2.2. Estructura del documento.
Este documento consta de una serie de capítulos en lo que se hace un estudio de
Big Data y la tecnología Spark, detallando el proceso de implementación de la plataforma
junto con las instrucciones para un correcto funcionamiento. Concretamente, la distribución
del contenido de este trabajo es la siguiente:
Capítulo 1. Resumen. Se relacionarán de forma muy sintética los objetivos de este
trabajo.
Capítulo 2. Introducción. En este capítulo se establece el contexto en el que surge
la necesidad de la utilización de esta tecnología como solución a un problema de
partida.
Capítulo 3. Objetivos. Se detallarán los propósitos que se desean conseguir con
este TFG.
Capítulo 4. Estado del arte. Recoge la información de un estudio realizado a nivel
teórico del entorno Big Data, algoritmos y las tecnologías, profundizando más en
una de ellas (Apache Spark).
Capítulo 5. Desarrollo del proyecto. Muy detalladamente se explica paso a paso
todo lo necesario para una correcta instalación y puesta en marcha de la tecnología
utilizada en el TFG.
Capítulo 6. Pruebas y resultados. En este capítulo se llevan a cabo una serie de
pruebas para la extracción de datos y para comprobar el funcionamiento de Spark
en diversas situaciones. Todo ello para concluir hasta donde deja de ser útil y
productiva esta tecnología y conocerla un poco más para poder sacarle el máximo
partido.
Capítulo 7. Estudio económico. Se hará un estudio sobre los costes totales que
ha supuesto realizar este trabajo teniendo en cuenta los costes de Hardware,
Software y los honorarios.
14
Capítulo 8. Conclusiones sobre el TFG y trabajos futuros. Se exponen las
conclusiones extraídas a lo largo del desarrollo del trabajo, así como una idea de
trabajos futuros.
Capítulo 9. Bibliografía. Reseñas a libros, documentos online, revistas,
videotutoriales y sitios web que se han consultado durante la realización del TFG.
15
3. OBJETIVOS
En este proyecto se hará una investigación y se trabajará con Apache Spark
utilizando Python como lenguaje. Concretamente los objetivos de este proyecto son:
Estudio del arte de Big Data, conocer sus plataformas de desarrollo y utilización
estudiando y comparando con otra tecnología Opensource, profundizando en
Apache Spark.
Con el resultado de este estudio y conocimientos adquiridos, puesta en marcha del
entorno necesario para la creación y configuración de un clúster con Apache Spark
para la ejecución de códigos utilizando el entorno web jupyter notebook. Todo ello
en sistema operativo Linux (distribución Ubuntu 17.10).
Poner a prueba las competencias de Spark para extraer conocimientos sobre un
conjunto de datos utilizando MLlib con un código programado en Python.
Obtener conclusiones del resultado obtenido evaluando el funcionamiento
(paralelización de tareas) y eficacia (reducción de tiempos) de Spark.
Los objetivos planteados se resumen en aplicar técnicas de Big Data para estudiar
y extraer conocimiento de colecciones de datos aplicando distintas estrategias
(programando algunas aplicaciones) y manejando plataformas específicas de Big Data.
16
4. ESTADO DEL ARTE
En este apartado se ha hecho un estudio teórico del entorno Big Data, de los
algoritmos más utilizados para el tratamiento de datos y la profundización en la tecnología
escogida para trabajar que es Apache Spark.
Todo ello para la mejor comprensión de los motivos que llevan la realización de este
trabajo y el aprendizaje teórico del framework Apache Spark.
4.1. Big Data
Este apartado es el punto de partida de este trabajo. Se explicará que es Big Data,
sus aplicaciones y porque tenerlo en consideración en el mundo actual es tan importante.
Con ello se llegará a comprender la idea de desarrollar tecnologías para el
tratamiento de datos que aporten con su utilización ventajas competitivas.
4.1.1. Definición
El término Big Data es reciente y ha ido adquiriendo importancia y fuerza en el
mundo de las TIC (Tecnologías de la información y comunicación) a causa de la evolución
tecnológica que estamos viviendo.
En la actualidad no hay una definición oficial de Big Data, aunque existen varias
enfocadas desde diferentes perspectivas, todas ellas complementarias, presentadas a
continuación:
Datos demasiado voluminosos o muy desestructurados para ser gestionados y
analizados a través de medios tradicionales. “Kwon (2014)”. [1]
Se refiere al conjunto de datos cuyo tamaño está más allá de la habilidad de
herramientas típicas de banco de datos en capturar, gestionar y analizar. “Di
Martino et al. (2014)”. [2]
17
Son un conjunto de datos que tan grandes que se tornan difíciles de trabajar con el
uso de herramientas actualmente disponibles. “Rajesh (2013)”. [3]
Haciendo síntesis entre las definiciones se puede concluir que Big Data son grandes
volúmenes de datos, estructurados o no, y diferentes procedimientos y tratamientos de
estos datos de diversas fuentes, que deben ser gestionados y analizados de una forma
peculiar con objetivo de conseguir valiosa información de los mismos.
Además de esto, existen otras características apuntadas por el Analista de Gartner,
Doug Laney, que introdujo el famoso concepto de 3 V en su publicación de 2001
Metagroup: Volumen, variedad y velocidad:
Volumen: Se refiere esencialmente a las grandes cantidades de datos que se
generan de forma continua. Según las previsiones de Gartner, en 2020 más de 25
mil millones de dispositivos estarán conectados a Internet, acrecentando un
volumen de datos superior a los 40 zettabytes en el planeta.
Variedad: Big Data combina datos de diferentes orígenes y formatos no
homogéneos ni predefinidos.
Velocidad: No solamente es la alta frecuencia con la generan los datos sino a la
necesidad de dar respuesta en tiempo real.
Cabe resaltar que Big Data, en su gran mayoría, es un conjunto de datos creciente
en el que a cada milésima de segundo son introducidos datos nuevos, siendo así, el mundo
actual de los datos digitalizados contiene una inimaginable cantidad de informaciones.
Esto hace que el tratamiento de esta información cree problemas de procesamiento
y no pueda realizarse de la forma tradicional. No es solución un hardware más potente
porque, aunque procesemos la información más rápido, la velocidad de acceso al disco no
es tan rápida proporcionalmente hablando por lo que tenemos “cuello de botella”.
Actualmente hay dos enfoques generales para Big Data:
Divide y conquista usando Clústers: el enorme conjunto de datos se divide en partes
más pequeñas y se procesa en paralelo usando muchos servidores.
Brute Force: Un servidor muy poderoso con almacenamiento masivo se usa para
comprimir el conjunto de datos en una sola unidad.
La solución más factible es un procesamiento distribuido a través de arquitecturas
en clúster formado por distintos nodos que serán los encargados del procesado de datos.
La construcción de los ordenadores del clúster es más fácil y económica debido a
su flexibilidad. Para que funcione es necesario proveer un sistema de manejo del clúster
18
que interactúe con cada usuario y sus procesos correspondientes para optimizar el
funcionamiento.
Los clústers serán más eficientes cuanto mejor cumplan las siguientes
características:
Escalabilidad y capacidad de expansión
Balanceo de carga
Rápidas comunicaciones de red
Alto rendimiento
Alta disponibilidad
En estas arquitecturas clúster también surgen algunos problemas a resolver:
sincronización, consistencia de datos, Ancho de banda y tratamiento de errores.
4.1.2. Enfoque de funcionamiento
La tecnología de Big Data permite tratar de una forma económica estos datos. Se
tienen los datos y la tecnología. ¿Qué camino tomar?.
Primero preguntarse qué información se tiene disponible. Muchas empresas no son
conscientes de la información que poseen ni como la pueden explotar. Hay que saber que
datos se tienen, calidad de esos datos y que volumen se están trabajando. Hay que tener
un análisis detallado de que se posee y que valor nos puede aportar.
Al iniciar un proyecto de Big Data se puede poner una plataforma propietaria en
Cloud que permite rápidamente sin gran inversión disponer de un entorno Big Data y se
puede crear nuestra infraestructura y comprar servidores económicos que requieren
mantenimiento, espacio, infraestructura.
La siguiente decisión es que tecnología o plataforma se va a utilizar (Sobre hadoop,
Spark, otras tecnologías opensource, etc.).
Una vez se ha visto la disponibilidad de datos y la plataforma que se utilizará, dentro
de esa plataforma, se verá como enriquecer nuestro almacén de datos corporativo (Data
Warehouse) con toda esa información que hasta ahora no se estaba tratando.
La propuesta es ampliar las capacidades del Data Warehouse corporativo con esa
información no estructurada que se puede obtener con las herramientas de la plataforma
19
Ilustración 1. Ampliar capacidades DWH corporativo
Ilustración 2. Mejorar DataWarehouse
que utilicemos. Se busca, analiza y trata la información que nos aporta valor, hacemos un
análisis de sentimiento y el resultado de todo esto lo añadimos a nuestro Data Warehouse
para que esté disponible para el usuario final para enriquecer su análisis de datos y su
reporting. Esta es la visión más fácil de proyectos de Big Data.
Ampliar las capacidades del DWH corporativo:
Dentro del mismo entorno es posible utilizar Big Data para mejorar el
Datawarehouse. Se puede poner la información histórica que no queremos perder pero
que no se utiliza y pasarla a un entorno Big Data que es más económico que un motor de
base de datos tradicional. Se reducen costes y se mejora rendimiento sin perder esa
información. Para el día a día se utiliza información del Datawarehouse y para las consultas
puntuales de datos históricos se puede atacar el entorno de Big Data.
20
Otra consideración es optimizar esos procesos que las herramientas están llevando
a cabo, pero requieren muchos recursos. Se utiliza mapReduce y el procesamiento en
paralelo además de las capacidades de Big Data para intentar que todo se agilice. Se
incrementa la velocidad añadiendo nodos en nuestro entorno de Big Data.
4.1.3. Aplicaciones
Big Data lentamente se está volviendo omnipresente. Cada entorno de negocios,
salud o estándares generales de vida ahora pueden implementar análisis de Big Data. Las
principales aplicaciones de Big Data son:
Visualización de datos (El tercer ojo): Las organizaciones en todo el mundo están
reconociendo la importancia del análisis de Big Data. Es la solución definitiva para
la ejecución de diferentes trabajos beneficiosos para estas que antes eran
imposibles de llevar a cabo, como pueden ser el estudio de sus clientes y sus
comportamientos o el descubrimiento de actividades fraudulentas.
La visualización de datos ha hecho que empresas como Facebook, Google o Twitter
empleen las capacidades de Big Data asegurando así un retorno de inversión
mucho mayor lo que les proporcionará una estabilidad en el negocio.
Integración. Las empresas debido a la integración de las competencias digitales se
están reformando, lo que les está aportando más precisión y velocidad y les hace
poder evolucionar y desarrollarse de una manera más rápida. El análisis Big Data
está siendo un factor importante ayudando a incrementar los ingresos y disminuir
los costes.
Big Data en la asistencia sanitaria: Big Data está presente en todos los aspectos
desde el diagnóstico de posibles riesgos para la salud hasta la investigación médica
compleja. Dispositivos como pulseras de actividad o smartwatch entre otros,
permiten al usuario rastrear y cargar datos que se compilarán y pondrán a
disposición de los médicos, lo que los ayudará en el diagnóstico. IBM ha tomado la
iniciativa a gran escala para implementar Big Data en sistemas de salud,
colaborando con Fletcher Allen o con la Premier Health Alliance para cambiar la
forma en que los datos clínicos no estructurados pero útiles están disponibles para
más médicos. Sundar Ram de Oracle declaró, las soluciones Big Data pueden
ayudar a la industria a adquirir y organizar estos datos para optimizar la asignación
21
de recursos, eliminar ineficiencias, reducir el costo del tratamiento, mejorar el
acceso a la atención médica y avanzar en la investigación médica.
Big Data también se puede utilizar en importantes ensayos clínicos como la cura
para diversas formas de cáncer y el desarrollo de medicamentos a medida para
pacientes individuales de acuerdo con su composición genética.
Big Data y las finanzas: Para entender mejor los resultados financieros y evitar
pérdidas, se necesitan herramientas tecnológicas capaces de lidiar con grandes
volúmenes de datos. [4] En Warwick Business School basándose en los
documentos de Google, MTurk (Amazon Mechanical Trunk) y Wikipedia entre 2004
y 2012 estudiaron la relación que había entre las búsquedas sobre política o
negocios y los movimientos de mercado, revelándose que cuando se producen
muchas búsquedas de contenido político seguidamente se produce una caída del
mercado financiero. En general, Big Data va a tener un gran éxito innovando el
sector de las finanzas.
Big Data para la detección de fraude: El fraude es un problema global que causa
pérdidas billonarias. Prevenirlo es un factor importante para el éxito de las
empresas y la respuesta está en la utilización de Big Data. Actualmente su uso en
este ámbito es muy bajo debido a la falta de información y experiencia sobre el
tratamiento de datos en este tema y la carencia de tecnología.
[5] Un enfoque de 10 pasos ha sido sugerido por Infosys para implementar análisis
para detección de fraude:
1. Realice un análisis DAFO (Debilidades, Amenazas, Fortalezas y
Oportunidades,) de los paradigmas existentes de detección de fraude.
2. Construir un equipo dedicado a la gestión de fraude.
3. Desarrollar o comprar un software de análisis de datos apropiado.
4. Integrar datos y eliminar ineficiencias en los procesos.
5. Elaborar reglas de obligaciones comerciales relevantes.
6. Proyectar los umbrales para la detección de errores o discrepancias.
7. Implementar un análisis predictivo para determinar posibles discrepancias y
fraudes.
8. Utilizar el análisis de redes sociales para determinar actividades
fraudulentas.
22
Ilustración 3. IBM Social Media Analytics Framework
9. Desarrollar un sistema integrado de gestión de casos que aproveche las
redes sociales.
10. Continuar con una extensa investigación para integrar los sistemas
existentes de detección de fraude con un nuevo conjunto de técnicas
desarrolladas.
Big Data y análisis de sentimiento: El análisis de sentimiento es, de lejos, la
aplicación de Big Data más utilizada. En la actualidad, se producen millones de
conversaciones en las redes sociales, que cuando se aprovechan pueden ayudar
a cualquier empresa a determinar nuevos patrones, proteger su imagen de marca
y visualizar la base de consumidores para mejorar la comercialización del producto
y la experiencia general del cliente.
IBM ha desarrollado IBM Social Media Analytics [6] que es una poderosa solución
SaaS (software como servicio). Captura datos estructurados y no estructurados de
los sitios de redes sociales para desarrollar una comprensión integral de las
actitudes, opiniones y tendencias. Seguidamente, aplica herramientas de análisis
predictivo para determinar el comportamiento y mejorar la experiencia del cliente.
Esto puede ayudar a la empresa a crear campañas y promociones personalizadas
para aumentar la base de consumidores.
Ha presentado su marco de trabajo como el siguiente:
Big Data y la industria alimentaria: Tanto para mantener la calidad de los alimentos
de grandes cadenas de comida rápida en cualquier parte del mundo o como para
23
entender las grandes demandas de los consumidores, Big Data es la solución
siendo capaz de impulsar todas las fases de producción desde el cultivo de
alimentos hasta la venta. Empresas se benefician del análisis de Big Data para
investigar en las preferencias de los clientes dependiendo de su condición, sexo u
localización y proponer ofertas personalizadas con el objetivo de agradarles lo
máximo posible y afiliar nuevos clientes.
Big Data para la industria de las telecomunicaciones: Con el fin de mejorar el
servicio al cliente y la satisfacción, los conceptos de Big Data y Machine Learning
se están implementando progresivamente. Los beneficios de usar tales tecnologías
son inmensos ya que las interrupciones operacionales pueden ser pronosticadas,
prevenidas y recuperadas. Los datos procesados en tiempo real se pueden usar
para asignar dinámicamente el ancho de banda para reducir la congestión y las
interrupciones.
Para conocer algunos ejemplos, varios de los proyectos que ya están arrancados
son:
- Gestión de transportes y flotas: TomTom está desarrollando proyecto Big
Data en tiempo real que analiza donde están situados sus GPS, volumen de
tráfico y tiene en cuenta en tiempo real densidad de tráfico en función de
sus dispositivos.
- Gestión de redes, mantenimiento de preventivo de redes, análisis demanda
de agua y energía.
- Proyectos en áreas de call center para analizar calidad de servicio y
sentimientos.
- Banca con detección de fraude y visión 360 del cliente.
- Tecnología informática con los backups, archiving de datos históricos,
análisis de logs y optimización de procesos.
- Smart cities, edificios inteligentes, análisis de medio ambiente, transporte y
educación e intentan ampliar añadiendo dispositivos como sonómetros,
cámaras y tratar la información que puede generar una ciudad.
- Recogida y explotación de información útil sobre jugadores y tiempos en el
mundo futbolístico.
En resumen, Big Data ya está aquí, es una tecnología nueva y económica que ya
está en el mercado y se está haciendo uso de ella. Es una tecnología económica que se
puede arrancar con opensource y nos permite ir creciendo a medida que lo necesitamos
sin necesidad de que los proyectos sean grandes proyectos con grandes inversiones en
24
infraestructura y software. Hay que conseguir que los proyectos tengan un retorno a corto
plazo y estén alineados con las expectativas de negocio y generen valor poco a poco.
4.1.4. Antecedentes
Inicialmente, se hace necesario un entendimiento de las relaciones básicas entre
datos, información y conocimiento. Según Batra [7], esta relación jerárquica tiene orígenes
en el área de tecnología de información (IT), pues comprender la distinción entre datos e
informaciones es un prerrequisito para la disciplina de sistema de información.
El sistema de procesamiento de datos tiene dos componentes: la entrada, que son
los datos y la salida que es la información que se analiza a través del sistema y ha sido
tratada. Siempre que una decisión es tomada y que es cumplida, esto lleva a una
transacción o una serie de operaciones que están ocurriendo. Así, el resultado secundario
de cualquier transacción concluida es la generación de datos, y dependiendo de la
naturaleza del sistema de procesamiento de transacciones (sea online, en tiempo real u
off-line), las informaciones como la salida también son actualizadas, y este proceso cíclico
continua.
[8] La información es convertida en conocimiento, una vez que ella es procesada
en la mente del individuo y el conocimiento se transforma en información al articularse y
mostrase en forma de gráficos, textos, palabras y otros símbolos. Siendo así, la gestión del
conocimiento se ha concentrado en aspectos del conocimiento que pueden volverlo más
fácil o más difícil de ser capturado y compartido, por ejemplo, por medio de la
transformación del conocimiento tácito en explícito. Seguidamente, para que las
organizaciones tengan éxito, deben estar capacitadas para capturar, integrar, crear y
utilizar el conocimiento de manera disciplinada, sistemática y estratégica.
La creación de conocimiento organizacional refleja la capacidad de la organización
de generar nuevos conocimientos, distribuirlos e incorporarlos. Nonaka y Takeuchi (1997)
[8] defienden que comprende dos dimensiones: una epistemológica y otra ontológica. La
dimensión epistemológica se basa en la diferenciación entre el conocimiento tácito y el
conocimiento explícito. Ya la dimensión ontológica se refiere a los niveles de creación del
conocimiento como individual, grupal y organizacional.
La gestión del conocimiento surge cuando la organización es capaz de reunir,
almacenar y transferir conocimientos, proporcionando el acceso a las fuentes de
25
conocimiento por medio de mecanismos de identificación y recuperación de informaciones,
visando a la aplicación del conocimiento a las necesidades específicas de la organización.
Los autores Alavi y Leidner, [9] consideran una clasificación amplia conteniendo
cuatro procesos básicos: creación, almacenamiento/recuperación, transferencia y
aplicación del conocimiento. Tal propuesta fue hecha con el objetivo de investigar el papel
de la tecnología de la información en el soporte a los procesos de gestión de conocimiento.
HANSEN, M. T. et al. [10] sugieren que la estrategia de gestión de conocimiento
sea un mix de codificación (enfocada en las tecnologías) y de personalización (enfocada
en los recursos):
Estrategia de codificación: Tiene como objetivo capturar y codificar el conocimiento
tácito en una forma explícita (manuales, documentos, procedimientos) y dejarlo
disponible para la reutilización de toda la organización.
Estrategia de personalización: Busca desarrollar las relaciones interpersonales de
modo que estas promuevan compartir el conocimiento tácito en toda la
organización.
Todavía lo que se observa es el rápido crecimiento de los varios esfuerzos
analíticos y de inteligencia. Con eso, los activos intangibles potencialmente valiosos son
encontrados en una variedad de lugares, en el interior y fuera de la empresa [11]. Esto
puede indicar una potencial ligación con el Big Data. Para ilustrar ese punto, se tiene la
jerarquía apuntada entre datos, información y conocimiento, pero cuando se habla en
grandes volúmenes de datos, no está claro si esa relación se mantiene. Por tanto, se
evidencia la necesidad de avanzar en los estudios sobre la relación entre gestión de
conocimiento y Big Data.
4.1.5. Tipos de proyectos
Existen varios tipos de proyectos Big Data para implementar que pueden aportar
valor de negocio. Estos se pueden estructurar en:
Análisis de sentimientos en redes sociales. Una red social como Twitter puede ser
una fuente de información excelente para extraer estadísticas sociales ya que la
gente utiliza esta plataforma para expresar ideas y opiniones públicamente y
cualquier persona o compañía puede beneficiarse de toda esta información.
26
Tratar información de dispositivos (sonómetro, TomTom, etc.). El tratamiento de
información de dispositivos en tiempo real como un GPS o un sonómetro puede
mejorar la gestión del ruido y tráfico y a su vez la calidad ambiental de las ciudades
convirtiéndolas en Smart Cities.
Optimización de datawarehouse. Como he explicado anteriormente, la información
que no se quiere perder se pasa a un entorno Big Data reduciendo costes y
mejorando el rendimiento. Este tipo de proyecto es el desarrollado en este trabajo.
Tratamiento de imágenes, audio, análisis de texto.
4.1.6. Tecnologías que utiliza Big Data.
Existen diversas tecnologías opensource que están especializadas en el
tratamiento de datos, como pueden ser Flink Apache, SAP HANA entre otras, pero se
pueden destacar principalmente estos dos frameworks:
APACHE HADOOP: [13] Es un framework que permite el almacenamiento y el
procesamiento distribuido de grandes conjuntos de datos en
clústers de computadores utilizando modelos de
programación simple que brinda a las organizaciones la
oportunidad obtener conocimiento rápidamente a partir de
grandes cantidades de datos. El marco de Hadoop es de
código abierto, brinda aplicaciones de confiabilidad y
movimiento de datos e implementa MapReduce , donde la
aplicación divide el trabajo en pequeñas partes que pueden ser ejecutadas en el
nodo del clúster que se desee. Este proyecto es administrado por Apache Software
Foundation.
Esta tecnología fue creada por Doug Cutting, el creador de Apache Lucene, la
biblioteca de búsqueda de texto ampliamente utilizada. Hadoop radica en Apache
Nutch, un motor de búsqueda de código abierto, que se basa proyecto Lucene.
La arquitectura de Hadoop, cuyos componentes principales se muestran a
continuación está compuesta por los siguientes módulos:
- Sistema de ficheros: El funcionamiento de Hadoop se basa HDFS (Hadoop
Distributed File System), un sistema de ficheros distribuido.
Ilustración 4. Apache hadoop
27
Ilustración 5. Arquitectura HDFS
Ilustración 6. Arquitectura MapReduce
Ilustración 7. Arquitectura YARN
- Hadoop MapReduce: El motor de Hadoop se compone de un planificador
de tareas MapReduce, con nodos que cumplen con los trabajos.
- Hadoop YARN: Entorno encargado de la planificación de tareas y gestión
de recursos del clúster.
28
Ilustración 8. Hadoop EcoSystem
La idea de YARN es dividir las dos principales responsabilidades de
JobTracker/TaskTracker en entidades separadas: un Resource Manager
global, un ApplicationMaster por aplicación, un NodeManager esclavo por
nodo y un contenedor por aplicación ejecutándose en un NodeManager.
- Hadoop Common: Hace posible la integración de subproyectos de Hadoop.
Estos módulos están diseñados con la suposición fundamental de que las fallas de
hardware son comunes y deben ser manejadas automáticamente en el software por
el marco.
Este es el ecosistema básico de Apache Hadoop.
Un clúster hadoop está compuesto por un nodo maestro y vario nodos esclavos.
Hadoop tiene tres formas de ejecución:
- Modo local / standalone: (En un solo nodo) No hay servicios, el modo
predeterminado es no-distribuido como un único proceso Java y es útil para
el proceso de depuración.
29
- Modo pseudo-distribuido: (En un solo nodo) Cada servicio Hadoop se
ejecuta en un proceso Java diferente.
- Modo distribuido: (En un clúster) Cada servicio se ejecuta sobre su propio
servicio Java en un clúster aprovechando toda la potencia de Hadoop
Hadoop tiene recursos para [14]:
- Acceso a Datos: Garantiza una gran accesibilidad ya que posibilita que en
tiempo real se interactue con los datos y de diversas maneras. Las
aplicaciones de Hadoop que lo consiguen son: Apache Hive, MapReduce,
Apache Pig, Apache HCatalog, Apache Hive, Apache HBase, Apache
Storm, Apache Kafka, Apache Mahout y Apache Accumulo.
- Gestión de datos: con HDFS es posible tratar y almacenar infinidad de datos
en en una capa de almacenamiento. HDFS trabaja con Apache Hadoop
HILO que es un entorno que ofrece la posibilidad de planificar y gestionar
las tareas y recursos.
- Gobernabilidad e integración de datos: Permite cargar rápida y
eficientemente los datos con la ayuda de: Apache Falcon (encargado de
gestionar el procesamiento y la vida los de datos), Apache Flume y Apache
Sqoop (mueve datos dentro y fuera de la plataforma).
- Seguridad y confidencialidad: Apache Knox, en un clúster, ofrece
autorización y acceso a los servicios.
- Operaciones: Apache Ambari facilita una interfaz junto con APIs, Apache
Zookeeper coordina procesos distribuidos y Apache Oozie nos garantiza
una lógica de trabajo.
Sus principales cualidades son:
- Escalabilidad: Un clúster puede crecer simplemente añadiendo nodos,
permitiendo un crecimiento fácil. Gracias al procesamiento distribuido
MapReduce, los archivos se dividen en bloques de forma sencilla
- Velocidad: Permite ejecutar procesamientos y realizar análisis de manera
rápida y eficaz.
- Efectividad en costes: La inversión de almacenamiento por terabyte decrece
pudiendo ser incluso 100 veces menor. Esto es debido a la forma de
almacenaje de datos, descartando por completo la manera tradicional en
30
filas y columnas y asignando datos categorizados a través de múltiples
computadoras baratas.
- Flexibilidad: Al incrementar los nodos, también incrementa la capacidad de
almacenamiento y procesamiento, siendo posible agregar o acceder a
nuevas fuentes de datos, añadir herramientas e integrar otros aspectos. Con
esto es posible adaptarse a las necesidades del negocio y
consecuentemente es capaz de dar soluciones ante cualquier decisión u
adversidad.
- Tolerante a fallos: Es posible recuperar datos de forma segura ya que cada
nodo contiene la información y réplicas en otros nodos del clúster.
APACHE SPARK: Al igual que hadoop es un framework
que se utiliza para el análisis y procesado de grandes
cantidades de datos. Está explicado detalladamente a
continuación, en el apartado 4.3. Apache Spark.
Estos dos frameworks llevan a cabo muchas tareas de la misma forma, pero hay
sectores donde ambos difieren. Para hacer una comparativa más objetiva, se van a
clasificar en 3 formas:
1. Facilidad de uso: Apache Spark puede contar con APIs fáciles de utilizar en algunos
de sus lenguajes como son Python, Scala, Spark SQL y Java.
Por otro lado, Apache Hadoop que utiliza MapReduce hace que sea necesaria más
programación, lo que lo hace más complicado, aunque tiene utensilios como Hive y
Pig que facilitan su uso.
2. Rendimiento: No es tan fácil deducir algo claro en cuál de los dos logra un mayor
desempeño ya que cada uno procesa los datos de manera diferente.
Hadoop:
- Contra: Los datos están almacenados en el disco por lo que lo torna más
lento.
- Ventaja: Necesita menos memoria de almacenamiento.
- Ventaja: Al eliminar datos cuando no se necesitan cuando trabaja con
aplicaciones pesadas, el rendimiento se queda intacto.
Ilustración 9. Apache Spark
31
Spark:
- Contra: Necesita más memoria de almacenamiento.
- Contra: Como utiliza aplicaciones pesadas, puede disminuir su rendimiento.
- Ventaja: Trabaja in memory, por lo que los procesos se aceleran.
3. Seguridad: En este ámbito, Hadoop gana con creces:
- HDFS al admitir la autorización solamente a nivel de servicio nos garantiza
el permiso apropiado para el cliente a nivel de archivo.
- Tiene Hadoop YARN.
- Hay desarrollos en otros proyectos de seguridad de Hadoop que les
proporcionan beneficios.
En cambio, Spark necesita ejecutar HDFS para conseguir permisos de nivel de
archivo y necesita Hadoop YARN para su seguridad.
También cabe considerar que Spark fue diseñado para solucionar muchos
problemas que se nos presentaban con Hadoop.
Sabiendo todo esto, se demuestra que en su propia área uno destaca por encima
del otro, por lo que se puede concluir que la mejor elección cuando tienes poco tamaño de
memoria y muchos datos es Hadoop, aunque Spark es lo mejor cuando necesitas fluidez
y ligereza en el tratamiento de datos.
Spark ya cuenta con numerosos proyectos exitosos y ha tenido una buena acogida
ya que ofrece muchas posibilidades a las empresas que utilizan grandes cantidades de
datos. Esto ha puesto de manifiesto la ventaja competitiva que ofrece.
4.1.7. Técnicas de análisis de datos
Los datos son almacenados con distintas tecnologías de almacenamiento por lo que
necesitamos distintas técnicas de análisis de datos. A continuación, se describen algunos
conceptos y algoritmos clave explotados en el análisis de datos:
Data Mining (minería de datos): Es el conjunto de técnicas y tecnologías que
permiten explorar grandes bases de datos para encontrar patrones repetitivos,
tendencias o reglas para explicar un comportamiento de datos en un determinado
contexto. Involucra campos como la estadística, inteligencia artificial, matemáticas
y la administración o manipulación de base de datos.
32
La diferencia entre minería de datos tradicional en data warehouse tradicionales y
la minería de datos en Big Data radica en procesos similares, pero si se trata de
información heterogénea o no estructurada de diversos orígenes entonces es
imprescindible utilizar tecnologías Big Data.
Para la minería de datos, existe el modelo Cross Industry Standard Process for Data
Mining (CRISP-DM) y consta de los siguientes procesos: Entendimiento comercial
y determinación de objetivos, entendimiento de datos, preparación de datos,
modelado, evaluación y despliegue del plan.
Asociación: Son un conjunto de técnicas que permiten descubrir relaciones
interesantes entre diferentes variables, hechos comunes dentro de un determinado
conjunto de datos. Aplican una variedad de algoritmos para generar y testear pautas
posibles.
Test A/B: Técnica que se utiliza para comparar un elemento con una variedad de
elementos de test para evaluarlos y apreciar cambios o mejoras en base a una
variable. A/B/N testing compara con N variables.
Clasificación o aprendizaje supervisado: suministrando datos de entrada y la salida
que se espera del algoritmo, en función de los datos suministrados el algoritmo se
entrena, siendo liberado posteriormente proporcionándole datos de entrada reales
para que obtenga salidas en base al aprendizaje inicial. A medida que se usa se va
perfeccionando.
Agrupación, análisis de clúster (clústering): Clasifica objetos dividiendo grupo en
partes más pequeñas compuestas por objetos semejantes, siendo así que divide
grupos de individuos en grupos más pequeños para encontrar similitudes entre ellos
y encontrar cualidades que lo definen.
Es muy usado en departamento de marketing para hacer segmentaciones de
mercados, clasificar perfil de riesgo de un cliente en un seguro, análisis de
imágenes, redes sociales etc. Existen clases de algoritmos de clústering: K-means,
C-means, agrupación jerárquica, que buscan el agrupamiento óptimo mediante
iteraciones y densidad en el espacio euclídeo.
Métodos de previsión: técnicas que se basan en datos históricos para estimar los
valores futuros. Pueden ser métodos paramétricos o no paramétricos.
Metodología muy utilizada para hacer previsiones económicas, aprovisionamientos
en una cadena de producción, previsiones en ventas y meteorológicas entre otras.
Crowdsourcing o filtrado colaborativo: técnica de recolección de datos basada en la
colaboración de los usuarios, en la que un conjunto de personas conectadas en red
33
realizan una tarea. Se trata de buscar patrones y utilizarlos para ayudar a la gente
a buscar intereses tanto positivos como negativos.
Fusión e integración de datos: Proceso en el que integran y analizan múltiples
conocimientos y datos de diversas fuentes para realizar una representación de la
información de una forma más coherente y precisa que si se analizaran con una
sola fuente. Un ejemplo puede ser la recolección de datos de sensores conectados
en el “internet de las cosas” y combinarlos para integrarlos con el rendimiento de
una producción alimentaria.
Aprendizaje ensemble (ensemble learning): Utiliza varios modelos predictivos
desarrollados estadísticos o machine learning para conseguir más rendimiento. Es
un aprendizaje supervisado.
Algoritmos genéticos: Con el objetivo de optimizar datos, esta técnica está basada
en la base genética de la evolución biológica, la supervivencia del mejor adaptado.
Los mejores serán codificados como cromosomas y estos se seleccionan y
combinan genéticamente para cruzarlos y mutar. A continuación, se pone a prueba
su supervivencia en un entorno característico donde se observan las fortalezas y
debilidades delos individuos creados.
Este tipo de algoritmos son ideales para la resolución de problemas no lineales
aplicado en campos como optimización logística, análisis lingüístico, previsión de
conducta en mercados financieros, etc.
Aprendizaje automático (Machine Learning): Perteneciente al ámbito de inteligencia
artificial, diseña, crea y desarrolla algoritmos que permite revisar datos y predecir
futuros comportamientos basados en datos empíricos. El objetivo principal es que
mejoren de forma autónoma a lo largo del tiempo siendo capaces de reconocer
patrones complejos y tomar sus propias decisiones. El ejemplo más reconocido por
la mayoría de personas es Siri o Google Now, integrados en sus smartphones.
Redes neuronales: son modelos matemáticos que al igual que las conexiones
cerebrales, llevan a cabo tareas y reconocen patrones entre datos. La red tiene un
primer conjunto de nodos de entrada, seguida de diferentes capas de nodos
intermedias y ocultas y un último conjunto de nodos de salida. Cada nodo tiene un
valor en las decisiones del proceso. Se les proporciona datos a los nodos de entrada
que por ensayo el algoritmo ajusta el valor de cada nodo hasta conseguir un criterio
de parada definido.
34
Son ideales para técnicas de optimización y para la búsqueda de patrones no
lineales. Es usado en aplicaciones meteorológicas, reconocimiento facial,
reconocimiento de texto, detección de fraude, etc.
Análisis de redes: Técnicas analizan relaciones entre nodos de una red completa y
los caracterizan en un gráfico o red. En redes sociales se puede determinar quien
ejerce mayor influencia y como fluye la información.
Algunas de sus aplicaciones prácticas pueden ser identificar líderes según sus
relaciones y utilizarlos para el comercio o registrar flujos de información de las
compañías para poder detectar algún posible cuello de botella.
Análisis de sentimiento: Incluye técnicas analíticas para la identificación y
extracción de información. Comúnmente utilizado en redes sociales para el estudio
de reacciones ante un producto u anuncio.
Análisis espacial: Técnicas estadísticas que analizan la información geográfica
recogida mediante con sistemas de información característicos y que sirven para
conocer los intereses de mercado en una determinada localización.
Análisis de grafos: El objetivo es hacer una representación de los datos y sus
relaciones para facilitar detección de relaciones o dependencias e identificar
conexiones entre nodos.
La aplicación de este tipo de algoritmo puede ser en representación de redes de
telecomunicaciones, identificación de patrones, planificación de rutas, problemas
logísticos, etc.
Análisis de texto (text analytics): Permite extraer información de los textos
generados por personas en correos, web o contenidos para modelar temas o
predecir palabras.
4.2. Algoritmos
La inmensa cantidad de datos que encontramos en Big Data son tratados mediante
algoritmos. A continuación, se describen los algoritmos más utilizados en el tratamiento de
datos.
35
Ilustración 10. Relación entre tipos de algoritmos y variables
4.2.1. Algoritmos de Machine Learning.
El objetivo principal de los algoritmos de machine learning es que mejoren de forma
autónoma a lo largo del tiempo siendo capaces de reconocer patrones complejos y tomar
sus propias decisiones.
Se eligen los tipos de algoritmos a utilizar en función de dos variables. La primera
variable la podemos clasificar en:
Discretas: Hay un número de valores de salida concreto (lluvia, niebla, etc.).
Continuas: Ejemplo el precio de una casa.
La segunda variable se clasifica en:
Tipo de aprendizaje supervisado: Las posibles salidas son conocidas y definidas.
Tipo de aprendizaje no supervisado: Las posibles salidas no están definidas, el
sistema las deducirá solo.
En la siguiente imagen encontramos la clasificación:
Los tipos de algoritmos machine learning son: Clasificación, regresión, identificar
similitudes, clústering, agrupar co-ocurrencias (busca asociaciones entre “entidades”
basadas en su coincidencia en transacciones), profiling o comportamientos típicos,
predicción de vínculos, modelado causal (detectar la influencia de unos hechos sobre otros)
y reducción de datos.
36
Ilustración 11. Regresión lineal
4.2.1.1. Regresión lineal
La técnica de regresión lineal pertenece a la categoría de aprendizaje supervisado,
y dentro de ésta es de tipo regresión ya que su salida son valores continuos.
Consiste en la realización de un análisis estadístico con el objetivo de comprobar la
existencia de una relación entre la variable dependiente con una variable independiente
(regresión lineal simple) o varias (regresión lineal múltiple). La relación se obtendrá con
una ecuación que representará el diagrama de dispersión como el mostrado a
continuación.
a es la intersección de la línea con el eje. X media de la variable dependiente.
b pendiente (positiva o negativa). Xt es el pronóstico del periodo t.
t periodo de tiempo. 𝑡̅ media la variable independiente.
Tomando como referencia la línea de regresión, habrá un error asociado a la
distancia entre el valor observado (puntos) y la línea.
Para escoger el modelo se deben entender los requisitos del algoritmo y hay que
ser coherente con lo que acontece en la práctica teniendo en cuenta que el modelo
seleccionado debe ser apropiado tanto en el aspecto de la curva como en el grado para
representar el estudio, y debe tener solamente las variables que son relevantes para
explicarlo.
Unos ejemplos de uso de regresión lineal pueden ser para calcular la demanda de
los productos de una firma y publicidad o para calcular la variación de los sueldos y tasa
de desempleo.
37
4.2.1.2. Clasificación
En los algoritmos de clasificación, como se explicó con anterioridad, suministrando
datos de entrada y la salida que se espera, el algoritmo se entrena, siendo liberado
posteriormente proporcionándole datos de entrada reales para que obtenga salidas en
base al aprendizaje inicial. A medida que se usa se va perfeccionando.
RRNN (redes neuronales):
Como se dijo anteriormente, al igual que las conexiones de las células del cerebro
buscan patrones entre datos. Su funcionamiento tiene un procedimiento simple,
dados unos parámetros se combinan de una manera concreta y se predicen ciertos
resultados.
Funcionan de la siguiente manera: se utilizan varias entradas, por lo que se tendrá
mucha información y son conectadas a varios nodos donde pasan a ser procesadas
y obtenemos una salida, que también puede ser la entrada de otra red neuronal.
Las diferentes posibilidades de conexiones entre capas de nodos pueden generar
n números de estructuras distintas.
Después de definir la red neuronal y su arquitectura, llega la fase de entrenamiento.
La red es capaz de reconocer variaciones de los estímulos entrenados. Si se
observa algún error se comunica y se adapta este nuevo conocimiento para su
futuro uso y la mejora de la precisión de la información.
Son aplicadas en problemas donde:
- La entrada es un valor discreto o real de gran dimensión.
- La salida es un valor discreto o real
- La salida es un vector de valores
- Es desconocida la función objetivo
Las redes neuronales tienen una gran flexibilidad siendo capaces de lidiar con datos
fuzzy, buscar patrones no lineares o ser un gran recurso para optimización.
38
Ilustración 12. Redes neuronales
SVM (Máquinas de vectores de soporte)
Fueron creadas por Vladimir Vapnik y se basan en el aprendizaje estadístico. Al
aplicar esta técnica se obtienen resultados comparables a los obtenido por
algoritmos de aprendizaje.
Fueron pensadas para resolver problemas de clasificación, aunque también
algunas de sus aplicaciones pueden ser para categorización de textos o análisis de
imágenes.
Tienen una primera fase de entrenamiento donde se les informa con múltiples
ejemplos ya resueltos, en forma de pares {problema, solución} y una segunda fase
de uso para resolución de problemas.
¿Cómo funciona? Se mapea un conjunto de entradas para un nuevo espacio de
mayor dimensión llamado espacio de características. Encuentran una frontera de
decisión para la separación del conjunto de datos (clases).
La SVM encuentra la frontera de decisión óptima haciendo un proceso de
optimización continua en que busca encontrar el hiperplano que mejor separa las
dos clases utilizando funciones llamadas kernels. Estos permiten flexibilizar la
frontera permitiendo otras opciones aparte de un separador linear.
39
Ilustración 13. SVM, clase 1 y clase 2 con frontera de decisión
K-NN (k vecinos más cercanos)
Es un algoritmo de clasificación basado en el vecino más próximo. Técnica muy
empleada para reconocer patrones. La clasificación de patrones está dividida en
dos fases:
- Fase de entrenamiento: consiste en, dada una base de entrenamiento,
almacenar en la memoria todos los patrones. El patrón tiene dos
características, un vector de valores y una clase.
- Fase de test: el algoritmo haciendo uso de los K-vecinos más próximos,
evalúa el desempeño del clasificador para la clasificación de nuevos
patrones.
Un nuevo elemento se clasifica en base a sus vecinos existentes pertenecientes a
un conjunto de entrenamiento. Calcula la distancia del elemento dado a cada
elemento de la base de entrenamiento. Los elementos de la base de entrenamiento
se ordenan de menos a más distancia, de los cuales se seleccionan los 5 más
cercanos.
Con el algoritmo K-NN se pueden conseguir suposiciones de valor en la inteligencia
artificial comparando acciones y movimientos con algunos realizados
anteriormente.
Para poder medir la distancia suele utilizarse la distancia Euclídea, δ. Es más fácil
de utilizar.
El aprendizaje de K-NN acontece en instante en que los datos de test son probados.
40
Ilustración 14. Algoritmo knn
Ilustración 15. Algoritmo árboles de decisión
Se utiliza en datamining y aprendizaje automático.
ÁRBOLES DE DECISIÓN
Es un diagrama formado por un conjunto de nodos de decisión y preguntas que
permiten la clasificación de cada caso. Un individuo u organización puede comparar
posibles acciones dependiendo de sus intereses, probabilidades y gustos.
Un árbol de decisión comienza con un solo nodo que se divide en varios posibles
resultados. Estos resultados tendrán nodos adicionales que se van ramificando.
Tiene una toma de entrada que será un objeto o situación descrita por un conjunto
de atributos, que basándose en su valor, regresa una decisión ``verdadero/falso''.
Existen tres tipos de nodos: de probabilidad (señala las probabilidades de algunas
soluciones), de decisión (muestra una decisión siendo tomada) y de término
(muestra el resultado final de un camino de decisión).
Están limitados a hablar de un solo objeto, por lo que no podemos usar los árboles
de decisión para expresar pruebas sobre dos o más objetos diferentes.
Este método permite abordar los problemas de una manera estructurada y
sistemática para llegar a una conclusión lógica siendo uno de los algoritmos más
sencillos y fáciles de implementar y a su vez de los más poderosos.
41
4.2.1.3. Clústering
Como se describió anteriormente, clasifica objetos separando un grupo en grupos
más pequeños de objetos similares, siendo así que divide grupos de individuos en grupos
más pequeños para encontrar similitudes entre ellos y encontrar cualidades que lo definen.
K-MEANS
K-means fue creado por James MacQueen en el año 1967, cuyo objetivo es dividir
un conjunto de datos en grupos intentando minimizar su error. Estos datos serán
divididos en x clústers fijados a priori y cada uno tendrá inicialmente un conjunto
aleatorio de centroides. Su desempeño dependerá de la posición de los centroides
iniciales y será mejor colocarlos lo más lejos el uno del otro. A continuación, se
tomará un punto perteneciente a un conjunto de datos y se asociará al centroide
más cercano y cuando no quede ningún punto por asignar estará completa la fase.
Es un ciclo que no se detendrá hasta que los centroides no tengan ningún punto de
reasignación y no se muevan más o hasta que se cumpla el número de iteraciones
fijado.
[15] El algoritmo tiene en resumen los siguientes pasos:
1. Se toman los centroides iniciales
2. Se toma un punto perteneciente a un conjunto de datos y se asigna al
centroide más cercano.
3. Reasigna los centroides usando:
cj : centroide.
| Cj | : número de elementos en el clúster Cj .
Z: elemento del conjunto de datos, que pertenece al clúster Cj ;
4. Repetir los pasos 2 y 3 hasta que se detenga el ciclo.
Ilustración 16. Fórmula k-means
42
Ilustración 17. Diagrama Algoritmo k-means
4.2.2. Optimización
Cuando se toman decisiones para el diseño y la evaluación de una estrategia hay
que considerar la optimización del mismo. Optimizar es la búsqueda de soluciones a un
problema concreto y elegir la mejor solución entre las alternativas posibles que nos
garantice lo mejor.
Existe una gran dificultad en encontrar la mejor alternativa cuando el volumen de
datos es muy grande. Debido a esto, en las últimas décadas ha ido creciendo el desarrollo
de algoritmos de aproximación utilizando métodos heurísticos que ofrecen soluciones
aceptables en un tiempo de procesamiento compatible con las necesidades.
Si bien este apartado también se podría incluir en algoritmos de machine learning,
se ha darle un espacio único para resaltar la importancia y valor de los problemas de
optimización.
4.2.2.1. Algoritmos genéticos
También conocidos como algoritmos evolutivos, están basados en modelos
biológicos que emulan el proceso natural de evolución y la supervivencia del mejor
43
Ilustración 18. Estructura algoritmo genético simple
adaptado. La evolución natural implementa mecanismos adaptativos de optimización
según la teoría de selección natural Darwin.
Los algoritmos genéticos son métodos computacionales de búsqueda en la que una
población de posibles soluciones para un problema concreto evoluciona y a medida que el
proceso evolutivo continua se presentan mejores soluciones.
Como fue explicado anteriormente, los mejores serán codificados como
cromosomas y estos se seleccionan y combinan genéticamente para cruzarlos y mutar.
Se usan frecuentemente en ingeniería, arquitectura, telecomunicaciones o
medicina. Dependiendo del problema que se quiere resolver distinguimos dos tipos de
algoritmos genéticos:
Algoritmo genético simple o Algoritmo Genético Canónico: Se aplica a
problemas de optimización simples y/o de pequeñas dimensiones en los que el
proceso de búsqueda actúa en una población definida de soluciones potenciales o
candidatas. En este algoritmo la codificación de variables es vinaria y los
operadores que se usan son de evolución, selección, cruzamiento y mutación.
Este tipo es el más utilizado y el que resulta más fácil de desarrollar en
programación.
Esta es la estructura del algoritmo genético simple:
44
Ilustración 19. Algoritmo genético, ciclo reproductivo
Tiene un ciclo reproductivo que utiliza los siguientes mecanismos:
- Seleccionar población: proceso en el que los mejores cromosomas son
seleccionados y copiados para una población nueva en la que se cruzarán
y mutarán.
- Cruzar: se escogen dos cromosomas de la población para cruzarlos y tener
hijos que los van a sustituir en la siguiente generación.
- En la mutación se escoge aleatoriamente un gen y se altera su valor para
introducir diversidad genética.
- Inserción de los dos nuevos descendientes en una nueva generación.
Algoritmos genéticos paralelos: Es una adaptación de la versión simple de los
algoritmos genéticos para obtener mejoras significativas en cuanto a velocidad,
resultados y cantidad de datos a tratar con el algoritmo en paralelo. Existen dos
formas de implementación:
- Método global: se trabaja con una única población que tiene la evaluación
de los individuos distribuida entre los procesadores disponibles
- Método de las islas: cada nodo recibe una subpoblación que cambia
individuos con las otras.
4.2.2.2. PSO (Particle Swarm Optimization)
La optimización por enjambre de partículas (PSO), es un método de optimización
que utiliza agentes (partículas) que forman parte de un enjambre moviéndose en un
espacio en búsqueda de una solución óptima. Cada partícula es una potencial solución
45
Ilustración 20. Pseudocódigo
para un problema que se mantiene en el enjambre. Está basado en principios psico-
sociológicos.
Las partículas vuelan por un espacio de búsqueda multidimensional donde la
velocidad y la posición de cada partícula es ajustada de acuerdo con la experiencia propia
(Factor cognitivo).
También tienen en cuenta el factor social ya que ignoran su propia experiencia y
tienden a moverse a partir del aprendizaje de las partículas vecinas. Funciona de la
siguiente manera:
4.2.2.3. Pittsburgh y Michigan approach
Son técnicas para aplicar métodos de aprendizaje evolutivos, esencialmente, un
conjunto de reglas "si / entonces" para realizar una tarea de manera efectiva.
PITTSBURGH APPROACH
Los individuos representan un conjunto o bases de reglas y evolucionan a través de
técnicas de computación con operadores genéticos que trabajan con un conjunto
de reglas borrosas. El objetivo es encontrar el mejor individuo de la población.
46
Ilustración 21. Esquema Pittsburgh approach
Los que conforman el sistema para obtener el sistema de aprendizaje son:
- La población de base de reglas.
- El sistema de evaluación.
- El sistema de descubrimiento de base de reglas.
MICHIGAN APPROACH
Cada individuo representa una sola regla, y toda la población compone el conjunto
de reglas (base de conocimiento).
El sistema de exploración clasificador está basado en el enfoque de Michigan cuyos
fundamentos fueron establecidos por Holland (1975).
Los sistemas clasificadores son sistemas de reglas de producción que generan
automáticamente poblaciones de reglas que cooperan para lograr una tarea
deseada. Son sistemas paralelos basados en reglas que aprenden a través de la
asignación de recompensas y el descubrimiento de reglas.
Las generalmente operan en entornos que exhiben una o más de las siguientes
características:
1. Eventos novedosos acompañados de grandes cantidades de datos ruidosos
o irrelevantes.
2. Requisitos continuos para la acción, a menudo en tiempo real;
3. Objetivos definidos implícita o inexactamente
47
Ilustración 22. Esquema Michigan approach, sistema clasificador
4. Recompensa escasa o refuerzo obtenible solo a través de largas secuencias
de acción.
Los sistemas clasificadores están diseñados para absorber nueva información de
forma continua desde dichos entornos, ideando conjuntos de hipótesis en
competencia (expresadas como reglas) sin alterar significativamente las
capacidades ya adquiridas.
En contraste con los sistemas expertos tradicionales donde las reglas son hechas
a mano por ingenieros de conocimiento, los sistemas clasificadores usa algoritmos
genéticos como un operador de descubrimiento para generar clasificadores. Cada
clasificador es una regla "si-entonces", con una parte de condición y una parte de
acción. Una lista de mensajes se usa para almacenar el estado ambiental actual y
cualquier mensaje interno.
Existen muchas configuraciones diferentes de CS en la literatura y algunos
aspectos han sido debatidos y aún son tema de debate.
El prototipo de organización es el siguiente y se compone por:
- El sistema de rendimiento.
- El sistema de asignación de credibilidad.
- El sistema de descubrimiento clasificador.
48
En cierto sentido, las dos ideas de aprendizaje tienen campos de aplicación
parcialmente diferentes.
El enfoque de Michigan está principalmente relacionado con el aprendizaje continuo
(en línea) en problemas no inductivos, y está más cerca de la idea de representar el
conocimiento de una sola entidad que aprende a través de su interacción con el entorno (y
en consecuencia su adaptación),
Pittsburgh está particularmente adaptado para el entrenamiento en problemas
inductivos y no inductivos, y está más cerca de la idea de la evolución a través de la
competencia entre individuos y la adaptación al medio ambiente.
Para aclarar las coincidencias y las diferencias entre ambos enfoques, el enfoque
de Pittsburgh se describe utilizando una estructura similar a la utilizada para la de Michigan.
La diferencia más clara, al comparar las cifras, es que en el enfoque de Pittsburg la
población de soluciones candidatas existe como una entidad separada e independiente,
mientras que en el enfoque de Michigan está integrada en el sistema de desempeño. Esta
característica distintiva resulta del hecho de que el enfoque de Pittsburgh emplea una
población de base de reglas que se evalúan dentro del sistema basado en reglas, uno a la
vez.
Una segunda observación es la distribución de los feedbacks dentro del sistema de
evaluación que en el caso de Pittsburgh se asigna directamente a la base de reglas bajo
evaluación (en cada momento solo hay una base de reglas, un individuo de la población
en el trabajo).
4.2.3. Toma de decisiones
FUZZY RULED BASED SYSTEMS (FRBS)
La lógica fuzzy es un concepto matemático que surgió en 1965 a partir del concepto
“conjuntos fuzzy”, que son conjuntos borrosos. A diferencia de los conjuntos
clásicos, los conjuntos fuzzy no son rígidos.
En el concepto de conjuntos fuzzy, un elemento puede pertenecer parcialmente al
conjunto. Así se introducen en el concepto de conjunto los términos relativos y
abstractos.
49
La función de pertinencia define cuanto un elemento pertenece a un conjunto. Es
una curva que define como cada punto de entrada es mapeado en un valor de grado
de pertinencia entre 0 y 1. La importancia de ese concepto matemático es la
relevancia relativa de la imprecisión y la eficiencia de las respuestas imprecisas en
algunos casos.
La lógica Fuzzy ya está presente en muchos sectores productivos como industrias
de aviación, electrodomésticos y agricultura entre otros.
Tiene numerosas ventajas: fácil entendimiento, flexibilidad, tolerancia a la
imprecisión de datos, construida basado en la experiencia de los especialistas,
mezclada con otras técnicas de control y basada en lenguaje natural.
En función del tipo de regla difusa que utilicen se pueden distinguir dos tipos de
sistemas:
- FRBS tipo Mamdani: es el más usado en aplicaciones, dado que tiene una
estructura muy simple de operaciones “mín-max”. Propuesto por Ebrahim
Mamdani en 1975. El proceso se realiza en cuatro pasos: Fuzificación de
las variables de entrada, evaluación de las reglas, agregación de las salidas
de las reglas y defuzificación.
Si X1 es “alto” y X2 es “bajo” entonces Y es “alto”.
Ventajas: facilidad para derivación de reglas
Inconvenientes: no garantizan continuidad en la salida y tiene menos
eficiencia computacional
- FRBS tipo TSK (Takagi, Sugeno y Kang): Los consecuentes de las reglas
son funciones polinomiales de las variables de entrada.
Si X1 es “alto” y X2 es “bajo” entonces Y= f(X1,X2).
Ventajas: incrementan la precisión, mayor eficiencia computacional, no
necesitan defuzzificador y garantizan continuidad en la salida.
Inconvenientes: No proporciona un marco natural para representar el
conocimiento humano, limitan la representación de los principios de lógica
difusa.
Esta es la estructura básica del funcionamiento de un controlador fuzzy tipo
Mamdani:
50
Ilustración 23. Estructura básica de un controlador Fuzzy
Motor de inferencia: realiza el proceso de formular el mapeamiento y razonamiento
de una entrada para estimar la salida usando la lógica fuzzy de acuerdo a una
relación definida a partir del conjunto de reglas borrosas. Su raciocino se basa en
reglas del tipo “si-entonces”.
Fuzzificación: Determinación del grado de pertinencia de cada entrada en relación
a cada conjunto fuzzy. Convierte la entrada nítida a valor borroso.
Base de conocimiento: Compuesto por:
- Base de reglas: Se aplican las reglas y operadores AND y OR. Son las
acciones a realizar dependiendo del estado, utilizando la información de la
base de datos.
- Base de datos: Contiene información de los conjuntos borrosos y la
definición lingüística de las variables.
Defuzzificación: Convierte la salida borrosa a valor nítido concreto.
4.3. Apache Spark
En este apartado, se describe la tecnología Spark en profundidad explicando su
arquitectura y elementos que la componen haciendo una valoración de sus ventajas y
desventajas.
51
4.3.1. Qué es Apache Spark
Spark despegó en 2009 como proyecto dentro de AMPLab en la Universidad de
California ( Berkeley), para afrontar la necesidad de probar el concepto de Mesos, también
creado en AMPLab. Es un conjunto de tecnologías, algoritmos y técnicas (data mining,
Machine Learning, análisis de sentimiento, redes, texto, grafos) junto con sistemas de
conexión a almacenamiento de datos (HDFS, cassandra, Oracle, Amazon S3 HBase,
MapR-DB y MongoDB). Es un motor de procesamiento de datos de uso general, adecuado
para su uso en una amplia gama de circunstancias.
Es un framework montado en un clúster de computación que permite trabajar con
Big Data diseñado para ser rápido, fácilmente accesible y de propósito general otorgándole
la facilidad de uso APIs nativas de Java, Scala, R y Python y bibliotecas de desarrolladores
de Spark. Hay muchas razones para elegir Spark, pero tres son clave: Simplicidad,
velocidad y soporte.
Apache Spark puede funcionar junto a Hadoop, con Apache Mesos o por sí mismo
sobre los sistemas operativos Linux, Windows y OS X.
Desde el principio, Spark fue optimizado para ejecutarse en memoria, ayudando a
procesar datos mucho más rápido que enfoques alternativos como motor de procesamiento
de datos como MapReduce de Hadoop, dándole la capacidad de ser 100 veces más rápido
cuando se utiliza in-memory (corriendo en la memoria) y 10 veces más rápido cuando
procesa datos sobre disco.
Spark es actualmente uno de los proyectos más activos administrados por la
Fundación Apache Software Foundation, y la comunidad que ha crecido en torno al
proyecto incluye tanto colaboradores individuales prolíficos como patrocinadores
corporativos bien financiados como Databricks, IBM y Huawei de China.
4.3.2. Quien usa Spark
Una amplia gama de proveedores de tecnología han apoyado rápidamente a Spark,
reconociendo la oportunidad de extender sus productos de Big Data existentes a áreas
como consultas interactivas y aprendizaje automático, donde Spark ofrece un valor real.
52
Empresas conocidas como IBM y Huawei han invertido sumas considerables en la
tecnología integrándolas en sus propios productos y aportando mejoras y ampliaciones al
proyecto Apache, y un número creciente de nuevas empesas dependen en su totalidad o
en parte de Spark. En 2013 el equipo responsable de la creación de Spark fundó
Databricks, que proporciona una plataforma de datos alojada de extremo a extremo
impulsada por Spark.
Empresas chinas como el motor de búsqueda Baidu y el website de comercio
electrónico Taobao del grupo Alibaba desempeñan operaciones basadas en Spark
generando miles de Terabytes de datos diarios procesadas en clúster de más de 8000
nodos.
La compañía está bien financiada, recibió 47 millones de dólares en dos rondas de
inversión en 2013 y 2014, y los empleados de Databricks continúan desempeñando un
papel destacado en la mejora y ampliación del código fuente abierto del proyecto Apache
Spark.
Los principales proveedores de Hadoop, incluidos MapReduce, Cloudera y
Hortonworks, se han movido para apoyar a Spark junto con sus productos existentes, y
cada uno está trabajando para agregar valor a sus clientes.
4.3.3. Para que se utiliza Spark
Resumiendo, Spark es un motor de procesamiento de datos de propósito general,
un conjunto de herramientas con API que los científicos de datos y los desarrolladores de
aplicaciones incorporan en sus aplicaciones para consultar, analizar y transformar
rápidamente los datos. Es capaz de manejar varios petabytes de datos a la vez, distribuidos
a través de un grupo de miles de servidores físicos o virtuales que cooperan.
4.3.4. Visión general de la arquitectura de Apache Spark
La arquitectura de Apache Spark la componen una serie de factores a tener en
cuenta cómo deben ser los lenguajes de programación que soporta, algunos de los
componentes internos y una serie de atributos descritos a continuación.
53
4.3.4.1. Lenguajes
Los lenguajes de programación admitidos por Spark son: Java, Scala, R, Python y
SQL. Los lenguajes como Python a menudo se consideran como lenguajes de bajo
rendimiento, pero la ligera pérdida de rendimiento se puede compensar en otras partes del
diseño y operación del clúster.
Existen códigos ejemplos para Spark que ofrecen una descripción general rápida
de Spark API. Estos ejemplos contienen código en Python, Scala y Java y podemos
encontrarlos en la página oficial de Spark, https://Spark.apache.org/examples.html.
El lenguaje SQL es ampliamente utilizado en bases de datos por científicos de datos
y otros que están familiarizados con hacer preguntas sobre cualquier sistema de
almacenamiento de datos. Spark SQL ofrece soporte para SQL y simplifica el proceso de
consulta de datos almacenados en el propio modelo RDD de Spark, junto con datos de
fuentes externas, como bases de datos relacionales y data warehouse.
El soporte para el paquete de ciencia de datos, R, es más reciente pero dada la
popularidad de R entre los científicos de datos y los estadísticos, es probable que sea una
adición importante al conjunto de idiomas compatibles de Spark.
¿Python o Scala? Ambos idiomas tienen sus ventajas y desventajas cuando
trabajas con Spark. La decisión de uno u otro depende de las necesidades de sus
proyectos, las capacidades propias o de sus equipos.
Scala gana en términos de rendimiento y concurrencia, es más rápido que Python
cuando trabajas con Spark lo que hace este lenguaje una mejor opción cuando se trabaja
con transmisión de datos, pero no es la única consideración de rendimiento que se puede
realizar. Cuando se trabaja con una API DataFrame no hay mucha diferencia entre Python
y Scala. Python es una mejor opción en términos de curva de aprendizaje y fácil de usar.
Hay algunas características que pueden influir en el uso de Python o Scala. Python
tiene la ventaja principal si se trata de ciencia de datos, ya que proporciona al usuario una
gran cantidad de excelentes herramientas para el aprendizaje automático y el
procesamiento del lenguaje natural, como SparkMLlib.
Python es el lenguaje perfecto para crear prototipos en los campos de Big Data /
Machine Learning.
54
4.3.4.2. Opciones de almacenamiento
Normalmente Spark está vinculado con el sistema de archivos distribuidos de
Hadoop (HDFS), pero puede integrarse con una gama de sistemas de almacenamiento de
datos de terceros ya sean OpenSource o comercial (MapR, Google Cloud, Apache HBase,
Apache Hive, Amazon S3, Apache Cassandra).
4.3.4.3. RDD (Resilient Distribuited Datasets)
RDD es un conjunto de datos cargados en memoria, resultantes de la modificación
a base de operaciones de los originales. Permiten trabajar con grandes cantidades de
datos en clústers de una forma rápida y tolerante a fallos. La eficiencia se logra mediante
la paralelización del procesamiento en múltiples nodos en el clúster y la minimización de la
replicación de datos entre esos nodos.
Las APIs existentes para cada uno de los lenguajes que soporta Spark, nos facilitan
la posibilidad de acceder a los repositorios de datos y crear RDD’s para lo que existen
varias formas: Cargar un archivo (csv, txt, json etc.) y extraer datos, datos almacenados en
memoria o datos ya previamente trabajados y almacenados en otro RDD.
Existen diferentes modelos de RDD definidos por sus características:
Clasificado: Dentro del RDD los datos son definidos por su tipo (String, Int)
Inmutable: Datos del RDD no se pueden modificar excepto si se crea un RDD nuevo
para aplicar modificaciones.
Memoria: Datos del RDD se mantienen en memoria el máximo tiempo posible
Cacheable: Datos por defecto son guardados en memoria o si se desea se pueden
guardar en un disco, aunque esto hace que pierda velocidad de computación.
Particionado: Datos dentro del RDD se dividen entre diferentes nodos del clúster-
Una vez que los datos se cargan en un RDD, se pueden llevar a cabo dos tipos
básicos de operación:
Transformaciones: crean un nuevo RDD al cambiar el original a través de procesos
tales como mapeo y filtrado. El RDD original permanece sin cambios en todo. La
55
Ilustración 24. RDD transformaciones
cadena de transformaciones de RDD1 a RDDn se registra y puede repetirse en
caso de pérdida de datos o falla de un nodo del clúster.
Se dice que las transformaciones se realizan de forma perezosa, lo que significa
que no se ejecutan y se irán guardando hasta que una acción posterior necesita el
resultado y se ejecute. Esto normalmente mejorará el rendimiento, ya que puede
evitar la necesidad de procesar datos innecesariamente. También puede, en
determinadas circunstancias, introducir cuellos de botella de procesamiento que
hacen que las aplicaciones se detengan mientras se espera que concluya una
acción de procesamiento.
Siempre que sea posible, estos RDD permanecen en la memoria, lo que aumenta
en gran medida el rendimiento del clúster, especialmente en casos de uso con
requisitos de consultas o procesos iterativos.
Acciones: nos da un resultado a la aplicación. Un ejemplo puede ser contar
(count()), que cuenta, pero no cambian los datos originales.
Cuando se desea mantener en memoria de cada nodo sus particiones se recurre a
la técnica de persistencia mediante persist() o cache(). Esto hace que se puedan llevar a
cabo otros procesos sin perder lo anteriormente guardado lo que lo convierte en una
herramienta mucho más veloz.
56
Ilustración 25. Componentes de Spark
4.3.4.4. Componentes de Spark
A continuación, se muestran los diferentes componentes de Spark:
Spark es lo siguiente: tenemos Spark SQL structured Data, Spark streaming real-
time MLLIB Machine learning y procesamiento de grafos (GraphX graph processing) que
todos se apoyan en el core de Spark. La ventaja que ofrece esto es que cualquier mejora
que tenga el core se propagará para las API superiores. Lo que hace es conectarse con un
gestor de recursos que puede ser YARN o un estándar de Spark si no tenemos instalados
ninguno de los dos con hadoop.
Spark Core. Ofrece las funcionalidades de gestión de tareas, memoria,
recuperación ante fallos, acceso a sistemas de ficheros. Aquí se definen los RDDs
(Resilient Distributed Datasets) que son colecciones distribuidas que pueden ser
paralelizadas automáticamente en el clúster. Son la unidad fundamental de
abstracción y trabajo en Spark. Es el “corazón” de Spark.
Spark SQL: [16] Módulo que permite consulta de datos estructurados y semi-
estructurados mediante sentencias SQL o una API DataFrame. Integración con
otros sistemas de hadoop como Hive, parquet, json.
Spark SQL incluye un optimizador basado en costos, almacenamiento en columnas
y generación de código para las rápidas consultas.
Spark Streaming: [17] Spark puede proporcionar acceso a un flujo de datos en
tiempo real debido a que su núcleo tiene una alta velocidad de programación y esto
le proporciona un ventaja frente a MapReduce. Gracias a la API que trabaja con
57
Java, Scala y Python, se pueden procesar secuencias combinando streaming con
consultas por lotes e interactivas. Tiene tolerancia a fallos.
MLlib: [18]Es una biblioteca básica de Spark, un framework que tiene algoritmos
de alta calidad que hacen que el aprendizaje automático (machine learning) sea
fácil de utilizar, fácil de implementar y práctico. Tiene algoritmos de clasificación,
regresión, clústering, filtrado colaborativo, Comprobación de hipótesis y cálculo de
estadísticas de ejemplo entre otros, todos programados para que funcionen de
manera distribuida en un clúster de Spark.
GraphX: [19] Es un entorno de procesamiento gráfico. Es la API para gráficos y
computación gráfica paralela. Es flexible y veloz y consta con múltiples algoritmos
gráficos como SVD ++, PageRank entre otros.
Clúster manager: Spark soporta los siguientes clúster managers: YARN(estándar
que se usa con hadoop), Mesos (creado por creadores de Spark) y standalone
scheduler.
4.3.4.5. API (Interfaz de Programación de Aplicaciones)
Un API especifica componentes de software (biblioteca, framework, sistema
operativo, etc.) en términos de funcionalidades. Son un conjunto de comandos, funciones,
clases y protocolos informáticos que hacen que trabajar con las funcionalidades de Spark
sean más sencillas para la creación de programas y el desarrollo de algoritmos. Se optimizó
para manipular datos, con un diseño que redujo las tareas comunes de ciencia de datos de
cientos o miles de líneas de código a solo unas pocas.
Esto es compatible con los cuatro principales entornos de desarrollo de Spark:
(Scala, Java, Python, R), y se proporciona una extensa documentación sobre la
instanciación de la API en cada uno de estos idiomas. La Guía de programación de Spark
proporciona más detalles, con fragmentos de código completos en Scala, Java y Python.
La API de Spark.
Se agregó una API de DataFrames adicional a Spark en 2015 como una extensión
de la API RDD existente con las siguientes características:
De la capacidad de procesar kilobytes de datos en una sola computadora portátil a
petabytes en una gran agrupación.
58
Soporte para una amplia gama de formatos de datos y sistemas de
almacenamiento.
Optimización de vanguardia y generación de código a través del optimizador Spark
SQL Catalyst
Integración perfecta con todas las herramientas e infraestructura de Big Data a
través de Spark
API para Python, Java, Scala y R (y en vía de desarrollo SparkR)
Para aquellos que no estén familiarizados con la API de DataFrames, pero que ya
estén familiarizados con Spark, esta API extendida facilitará el desarrollo de aplicaciones,
al tiempo que ayudará a mejorar el rendimiento a través de optimizaciones y generación
de código.
En la siguiente página se pueden encontrar los documentos Spark Python API:
https://spark.apache.org/docs/latest/api/python/index.html. Aquí se podrán ver los
paquetes Spark junto con sus sub-paquetes y contenidos. Dentro de los contenidos se
encuentran las clases públicas acompañadas por una serie de funciones que podemos
utilizar en función de lo que queramos hacer.
4.3.4.6. Arquitectura de un clúster
Lo interesante de Spark es usarlo en modo distribuido que ya funciona en un clúster.
Spark usa una arquitectura maestro esclavo con un coordinador central y varios
trabajadores. Al inicializar el objeto SparkConext en su programa principal (Driver
Program), las aplicaciones de Spark serán coordinadas en el clúster como procesos que
trabajan independientes del resto distribuidas por cada nodo.
Específicamente, para ejecutar en un clúster, el driver se comunica con el clúster
manager y seguidamente SparkContext se puede conectar a varios tipos
de administradores de clúster (Mesos, YARN o Standalone) que asignan recursos a través
de la aplicación que los organiza. A continuación Spark toma a los ejecutores en cada nodo
trabajador perteneciente al clúster que serán a los que se le asignen procesos, ejecutarán
cálculos y almacenarán datos para su aplicación. Por último, envía su código de aplicación
y SparkContext envía tareas a los ejecutores para que las lleven a cabo.
59
Ilustración 26. Arquitectura de un clúster
En esta arquitectura:
Las aplicaciones tienen su propio proceso de ejecución, permanecen activas
durante toda la aplicación y tienen ejecutándose tareas en subprocesos.
Spark es independiente del administrador de clúster subyacente mientras pueda
adquirir procesos de ejecutor y estos se comuniquen entre sí.
El programa del controlador debe escuchar y aceptar las conexiones entrantes de
sus ejecutores a lo largo de su vida útil y debe ser redireccionable desde los nodos
de trabajador.
Debido a que el controlador planifica tareas en el clúster, debe ejecutarse cerca de
los nodos de trabajadores, preferiblemente en la misma red de área local.
Los tipos de administradores de clústers son:
Standalone: Es el gestor de clúster más sencillo que está incluido con Spark. Este
gestor hace posible la fácil creación y configuración de un clúster.
Apache Mesos: Es el gestor open-source general que asigna y controla recursos de
un clúster. Junto con Mesos también se pueden ejecutar Hadoop MapReduce otras
aplicaciones.
Hadoop YARN: gestor de clústers en Hadoop 2 (segunda generación de Hadoop).
Kubernetes: Aún está en modo experimental.
A la hora de programar se hace de la misma forma para uno que para otro. Se
puede tener un programa programado en modo local, subirlo a un clúster y funcionar
igualmente.
60
4.3.5. Notebooks para Spark
El concepto de “notebook” fue introducido por iPython, que marca la diferencia ya
que en vez de trabajar sobre la Shell directamente, se accede a una interfaz web donde se
crea el entorno de trabajo.
Despues de iPython, vino IPython 3 que fue reconstruido y se creó Jupyter. A partir
de ahí fueron creándose otros notebooks para satisfacer necesidades específicas en cada
tecnología.
Siendo así, los notebooks más utilizados en Apache Spark son:
Jupyter: es una aplicación Web que permite crear y ejecutar un
código que incluye ecuaciones matemáticas, textos, imágenes,
diagramas, visualizaciones, etc. Con jupyter es posible trabajar en
varios lenguajes como Python, Scala, Java, R, etc. La diferencia
entre 'IPython' y 'Jupyter' puede ser confusa. Básicamente, el
equipo de Jupyter ha renombrado 'IPython Notebook' como
'Jupyter Notebook', sin embargo, el shell interactivo todavía se conoce como
'IPython'.
Para escoger el lenguaje con el que se quiere trabajar solamente hay que instalar
el kernel (motor computacional) correspondiente, y lanzar un nuevo código
seleccionando el kernel con el lenguaje deseado.
Jupyter nos proporciona las siguientes características:
- Desde el navegador, creación, edición e inclusión de código.
- Posibilita compartir mediante GitHub y Dropbox los repositorios creados con
códigos y archivos.
- Interfaz intuitiva.
- Destaca automáticamente la sintaxis e hace indentación del código.
- Admiten el completar automáticamente las pestañas en nombres de clase,
funciones, métodos y variables.
- Ofrece mensajes de error más explícitos.
- Mediante el uso de núcleos, se admiten múltiples idiomas.
Apache Zeppelin: es un notebook web interactivo, con funciones de ingestión de
datos, exploración de datos, visualización, uso compartido y colaboración a Hadoop
Ilustración 27. Jupyter
61
Ilustración 29. Spark Notebook
Ilustración 28. Apache Zeppelin
y Spark. Todo ello lo realiza con tecnologías como Shell, Spark, Hive entre otras,
soportando lenguajes como R, Scala y Python. Al estar integrado con Apache
Spark, no es necesario crear un módulo, un complemento o una biblioteca por
separado.
Zeppelin aún está en desarrollo respecto a Jupyter, pero está siendo bastante
apoyado por parte de la comunidad.
Spark Notebook: es editor interactivo basado en web de código abierto centrado en
Scala para la ciencia de datos interactiva y reactiva utilizando Apache Spark. Esta
es una excelente herramienta para crear prototipos de códigos Scala / Spark con
consultas SQL para analizar datos (mediante visualizaciones de datos). Parece
tener visualizaciones de datos más avanzadas (en comparación con Apache
Zeppelin ), y parece más bien enfocado en Scala, SQL y Apache Spark.
La elección en particular para este trabajo ha sido Jupyter Notebook con el lenguaje
de programación Python.
4.3.6. Seguridad
A la seguridad en Spark le falta mucho por mejorar. Se respalda en Hadoop YARN.
Hay una clase Spark responsable de la seguridad. En general, esta clase debe ser
instanciada por SparkEnv y la mayoría de los componentes deben acceder desde allí. Hay
algunos casos donde SparkEnv aún no se ha inicializado y esta clase debe crearse una
instancia directamente.
Spark actualmente es compatible con la autenticación a través de un “shared secret
“(secreto compartido). La autenticación se puede configurar para que esté activada
62
mediante el parámetro de configuración 'spark.authenticate'. Este parámetro controla si los
protocolos de comunicación Spark realizan la autenticación utilizando el secreto
compartido. Todos los nodos (Maestro y Workers) y las aplicaciones deben tener el mismo
secreto compartido para poder comunicarse.
Spark presenta autenticación por clave compartida Las claves ssh nos permiten
realizar una autenticación sin contraseña de forma segura.
Para utilizar SSH se crean un par de claves (privada y pública). Cada nodo tendrá
una copia de la clave privada, para poder autenticarse en cualquier otro nodo, que tendrá
una copia de la clave pública (y, a su vez, la misma clave privada). Esto permite que el
poseedor de la clave pueda acceder a esa máquina.
4.3.7. Ventajas y desventajas
VENTAJAS
1. Spark es más potente que hadoop: nos permite desarrollar grandes proyectos Big
Data con menos inversión y consiguiendo buenos resultados.
2. Es una plataforma de código.
3. Es rápido: Mucho más que Hadoop. Garantiza una buena productividad y mayor
interactividad.
4. Puede compenetrarse con otra arquitectura Big Data: Puede utilizar ficheros de
HDFS o procesos de YARN entre otras.
5. Cuida a los desarrolladores: cuando una persona está utilizando esta tecnología
únicamente debe de tener en mente desarrollar el código u algoritmo que esté
implementando ya que con los lenguajes de programación que ofrece y el fácil
entorno de trabajo no existe otra preocupación.
6. La componen APIs para varios lenguajes y trabajos.
7. Tiene una consola interactiva para poder trabajar con mayor facilidad
8. Gran aliado de la Arquitectura Kappa que la conforman Kafka + Spark + NOSql +
Scala. Es una de las arquitecturas que más se demandan.
9. Encabeza tecnologías Big Data: compañías como IBM, Huawei y Microsoft entre
otras invierten e integran a Spark en sus trabajos.
63
DESVENTAJAS
1. Necesita más memoria de almacenamiento.
2. Como utiliza aplicaciones pesadas, puede disminuir su rendimiento.
5. DESARROLLO DEL PROYECTO
En este proyecto se va a comprobar y analizar el funcionamiento de Spark para Big
Data. Para ello se va a crear un clúster donde se ejecutará un algoritmo de Regresión lineal
distribuido por cada uno de los nodos, que trabajarán en paralelo. La función del algoritmo
utilizando librerías de Machine Learning será la clasificación de texto, en concreto, artículos
de noticias.
Un clúster Spark son computadoras que ejecutan Spark y trabajan juntas. El clúster
se compone por:
Nodo maestro (master): Es la computadora que distribuye el trabajo y se ocupa de
la ejecución del algoritmo.
Nodo esclavo (slave): Está compuesto por las computadoras que realizan el trabajo
(workers). Procesan fragmentos de los conjuntos de datos masivos.
El Apache Spark Clúster Manager (Administrador del clúster Apache Spark) de este
trabajo será Standalone. Esto significa que Spark está instalado en todas las computadoras
involucradas en el clúster.
El proyecto se desarrollará en dos escenarios diferentes:
El primero será crear un clúster en máquinas virtuales que servirá para poder
experimentar con Spark desde un ordenador personal ejecutando varios algoritmos
y comprobando su funcionamiento. Con esto se proporcionará experiencia para
poder hacer las pruebas reales de la mejor forma.
El segundo será la creación del clúster utilizando varios computadores potentes en
el laboratorio de la escuela, y ahí será donde se ejecutará el algoritmo de Regresión
lineal haciendo varios tipos de pruebas y sacando conclusiones, todo ello explicado
a continuación.
64
En este apartado se expondrán las características, requisitos y topología de cada
una de los escenarios. A partir de ahí, se explicará muy detalladamente paso a paso todo
lo necesario para una correcta instalación y puesta en marcha de Apache Spark para poder
crear un clúster y ejecutar un algoritmo distribuido.
5.1. Máquinas virtuales
Aquí se describirán las características y requisitos que tendrán las máquinas
virtuales junto con su topología de red. También se hará un tutorial paso a paso de la
instalación de máquinas virtuales con estas características y el sistema operativo
acordado.
5.1.1. Características y requisitos
Las máquinas virtuales tendrán Ubuntu 17.04 como sistema operativo virtualizadas
con Oracle VM VirtualBox. Las principales características de Hardware son:
MASTER
o Memoria RAM: 1024 MB.
o Número de CPUs : 1 CPU.
o Disco duro: Disco duro virtual VDI (VirtualBox Disc Image) de tamaño fijo de
20 GB.
o Red: Adaptador en puente, Intel PRO/1000 MT Desktop.
SLAVES
o Memoria RAM: 1024 MB.
o Número de CPUs : 1 CPU.
o Disco duro: Disco duro virtual VDI (VirtualBox Disc Image) de tamaño fijo de
20 GB.
65
o Red: Adaptador en puente, Intel PRO/1000 MT Desktop.
Para el funcionamiento correcto del clúster de servidores, Apache Spark necesita
la siguiente lista de software instalada:
Oracle VM VirtualBox.
Java: Versión 8
Spark: Versión 2.2.1-bin-hadoop.2.7.
Hadoop: Versión hadoop-2.9.0
OpenSSH: para permitir el acceso remoto por SSH entre las máquinas.
Python con anaconda: versión 2.7.14 :: Anaconda custom (64bit)
Jupyter Notebook
FindSpark: Biblioteca Python
Py4J para que los programas de Python accedan directamente a los objetos Java.
5.1.2. Topología de red
Para la creación del clúster de servidores con Apache Spark, se han utilizado tres
máquinas virtuales. Una de las máquinas será el servidor principal (Spark-Master) y el resto
servidores esclavos (Spark-WorkerN). Las máquinas utilizadas son:
Hostname IP Función
master 192.168.1.117 Servidor principal master
Worker1 192.168.1.113 Servidor esclavo
Worker2 192.168.1.115 Servidor esclavo
Tabla 1. Topología de red máquinas virtuales
66
Ilustración 30. Instalación máquina virtual
Ilustración 31. Instalación máquina virtual, tamaño de memoria
Ilustración 32. Instalación máquina virtual, disco duro
5.1.3. Instalación máquina virtual
1º Descargar VM VirtualBox e instalar en el equipo
http://www.oracle.com/technetwork/server-
storage/virtualbox/downloads/index.html#vbox
2º Descargar la imagen .iso del sistema operativo Linux. En este caso ubuntu-17.04-
desktop-amd64
3º Crear máquina virtual en VirtualBox e instalar Linux en ella.
a) Crear la máquina virtual
67
Ilustración 33. Instalación máquina virtual, tipo almacenamiento.
Ilustración 34. Instalación máquina virtual, tipo disco duro.
Ilustración 35. Instalación máquina virtual, ubicación y tamaño
Ilustración 36. Instalación máquina virtual, crear disco duro virtual
Ilustración 37. Arranque Ubuntu
b) Agregar arranque de Ubuntu en la máquina virtual creada.
68
Ilustración 39. Arranque Ubuntu, selección de ISO del sistema operativo
Ilustración 38. Arranque Ubuntu cargado
Ilustración 40. Install Ubuntu
Ilustración 41. Entrada Dispositivo CD/DVD vacía
c) Iniciar máquina virtual e instalar Ubuntu 17.04.
d) Una vez instalado, asegurarse de que la entrada del dispositivo CD/DVD está
vacía para que no vuelva a iniciar la instalación e inicie el sistema operativo
directamente.
69
Ilustración 42. Clonar Ilustración 43. Clonar, nombre
Ilustración 44. Clonación Ilustración 45. Clonar, tipo de clonación
4º Clonar tantas veces en función del número de esclavos que queramos.
5º Hacer update y upgrade de cada máquina virtual para actualizar.
$ sudo apt-get update
$ sudo apt-get upgrade
70
5.2. Computadores físicos
Aquí se describirán las características y requisitos que tendrán los computadores físicos
junto con su topología de red.
5.2.1. Características y requisitos
En este escenario se utilizó una nueva versión del sistema operativo (Ubuntu
17.10). Las principales características de Hardware son:
MASTER
o Memoria RAM: 8 GB.
o Procesador: Intel Core i7
o Red: Conexión de área local, Gigabit Ethernet
SLAVES
o Memoria RAM: 8GB
o Procesador: Intel Core i7
o Red: Conexión de área local, Gigabit Ethernet
Para el funcionamiento correcto del clúster de servidores, Apache Spark necesita la
siguiente lista de software instalada:
Java: Versión 8
Spark: Versión 2.2.1-bin-hadoop.2.7.
Hadoop: Versión hadoop-2.9.0
OpenSSH: para permitir el acceso remoto por SSH entre las máquinas.
Python con anaconda: versión 2.7.14 :: Anaconda custom (64bit)
Jupyter Notebook
FindSpark: Biblioteca Python
Py4J para que los programas de Python accedan directamente a los objetos Java.
71
5.2.2. Topología de red
Siguiendo el mismo procedimiento que en máquinas virtuales, para la creación de
un clúster en las computadoras físicas se han utilizado cinco máquinas, una de ellas será
el servidor principal (Master) y las cuatro restantes serán slaves (workers). La topología es
la siguiente:
Tabla 2. Tabla topología de red ordenadores físicos
5.3. Preparación entorno
Con todos los conocimientos que se han adquirido de Spark, es la hora de preparar
un entorno de trabajo. En este apartado se explicarán las instalaciones necesarias a llevar
a cabo para el correcto funcionamiento de Spark. Para ello es necesario tener unos previos
componentes como son Java y Anaconda instalada con la distribución de Python que
proporcionará paquetes importantes para el tratamiento de datos y el acceso al notebook
web de IPython llamado Jupyter.
Una vez teniendo la base, se procederá a instalar Spark junto con unas bibliotecas
de soporte y proporcionar a cada máquina el acceso SSH con el master.
Hostname IP Función
master 192.168.67.334 Servidor principal master
Worker1 192.168.67.333 Servidor esclavo
Worker2 192.168.67.332 Servidor esclavo
Worker3 192.168.67.331 Servidor esclavo
Worker4 192.168.67.330 Servidor esclavo
72
Ilustración 46. Java version
5.3.1. Instalación Java
1º Instalar última versión de Java
$ sudo apt-get install openjdk-8-jdk
2º Comprobar versión actual en el sistema
$ java -version
5.3.2. Instalación Anaconda (Pyhon)
Anaconda se caracteriza por ser una suite libre de código abierto, que abarca
aplicaciones y librerías diseñados para el desarrollo de datos con Python. Instala los
paquetes más importantes para tratamiento de grandes volúmenes de datos, cálculos
científicos y análisis de predicciones. Funciona como gestor de entorno y gestor de
paquetes.
1º Descargar anaconda de su página https://www.anaconda.com/download/ para
Linux la versión Python 2.7 e ir en el terminal al directorio /Descargas:
$ pwd
$ cd /Descargas
2º Instalar y confirmar ubicación:
$ bash ./ Anaconda2-5.0.1-Linux-x86_64.sh
73
Ilustración 49. Python version
Ilustración 47. Instalar Anaconda
Ilustración 48. Anaconda .bashrc
Una vez instalado, en el archivo .bashrc añadir lo siguiente manualmente si no pide
el instalador permiso para añadirlo:
export PATH=/home/master/anaconda2/bin:$PATH”
3º Comprobar la versión de Python.
$ python --version
Si nos devuelve el siguiente mensaje : El programa Python puede encontrarse en
los siguientes paqutes (Python-minimal, python3)
74
Ilustración 50. Version Pyhton con Anaconda
Ilustración 51. Versión conda
Instalar python2:
$ sudo apt install python-minimal
Cerrar el terminal y abrir otro nuevo
4º Hacer update y upgrade y actualizar conda.
$ sudo apt-get update
$ sudo apt-get upgrade
$ conda update --all --yes
5º Comprobar versión de Python con Anaconda una vez instalado.
$ python --version
Cerrar el terminal y volver a abrir otro.
6º Configurar anaconda:
a) Comprobar la versión de conda:
$ conda --version
b) Actualizar:
$ conda update conda
c) Instalar nb_conda_kernels
$ conda install nb_conda_kernels
75
Ilustración 52. Spark Download
d) Comprobar que aparece en la lista de conda:
$ conda list
e) Hacer update y upgrade:
$ sudo apt-get update
$ sudo apt-get upgrade
5.3.3. Instalación Spark
1º Ir a la página oficial de Spark y descargar https://Spark.apache.org/downloads.html
2º Descomprimir y mover a la carpeta home.
$ cd Descargas/
$ mv Spark-2.2.1-bin-hadoop2.7 ~
$ cd ~
$ tar -zxvf Spark-2.2.1-bin-hadoop2.7.tgz
$ rm Spark-2.2.1-bin-hadoop2.7.tgz
3º Establecer la variable de entorno necesaria SPARK_HOME
a) Ir a el directorio home y abrir con el editor de textos el archivo .bashrc.
76
Ilustración 53. Archivo .bashrc Spark
Ilustración 54. Verificación instalación Spark
$ cd ~
$ sudo nano .bashrc
b) Editar el archivo .bashrc y añadir las siguientes líneas al final del archivo:
# Spark
export SPARK_HOME="/home/<your_username>/Spark-2.2.1-bin-
hadoop2.7/"
4º Verificar instalación de Spark.
$ cd Spark-2.2.1-bin-hadoop2.7
$ bin/pySpark
77
Ilustración 55. Hadoop Download
5.3.4. Instalación Hadoop (opcional)
Aclarar que este paso es opcional porque el clúster funcionará igualmente, pero
hace algunas mejoras en el rendimiento del uso de Hadoop nativo sobre algún tipo de
adaptadores.
1º Descargar de la página de Apache Hadoop:
http://apache.rediris.es/hadoop/common/hadoop-2.9.0/
2º Descomprimir y mover a la carpeta home.
$ cd Descargas/
$ mv hadoop-2.9.0.tar.gz ~
$ cd ~
$ tar -zxvf hadoop-2.9.0.tar.gz
$ rm hadoop-2.9.0.tar.gz
3º Añadir líneas al final del archivo .bashrc Editar el archivo .bashrc y añadir las
siguientes líneas al final del archivo:
# Hadoop
export HADOOP_HOME="/home/master/hadoop-2.9.0"
export LD_LIBRARY_PATH=$HADOOP_HOME/lib/native:$LD_LIBRARY_PATH
78
Ilustración 56. Archivo .bashrc Hadoop
Ilustración 57. Verificación instalación Spark con Hadoop
4º Verificar de nuevo la instalación de Spark y Comprobar que desaparece el mensaje:
“WARN NativeCodeLoader: Unable to load native-hadoop library for your platform...
using builtin-java classes where applicable".
$ cd Spark-2.2.0-bin-hadoop2.7
$ bin/pySpark
5.3.5. Acceso SSH
1º. Verificar IP. Como al inicio no está instalado “ifconfig” hacer en ambas máquinas:
$ sudo apt install net-tools
$ ifconfig
79
Ilustración 58. SSH clave RSA
2º. Copiar la dirección ip de cada máquina para trabajar con ellas.
IP master: 192.168.1.117
IP slave1: 192.168.1.113
IP slave2: 192.168.1.115
3º. En las máquinas slave instalar ssh server.
$ sudo apt-get install openssh-server
4º. En la máquina master, generar clave RSA para el acceso remoto de los slaves.
$ ssh-keygen
5º. En la máquina master, copiar en cada uno de los slaves la clave RSA generada en
el master siguiendo el patrón del siguiente comando:
$ ssh-copy-id –i ~/.ssh/id_rsa.pub usuario_slave_1@IPslave1
$ ssh-copy-id –i ~/.ssh/id_rsa.pub usuario_slave_2@IPslave2
En mi caso es:
$ ssh-copy-id –i ~/.ssh/id_rsa.pub [email protected]
$ ssh-copy-id –i ~/.ssh/id_rsa.pub [email protected]
80
Ilustración 59. Copiar RSA a slaves
5.3.6. FindSpark
FindSpark es una biblioteca de Python que permite importar y usar PySpark
automáticamente. Creando un perfil de jupyter para Spark sería una opción alternativa a
utilizar FindSpark pero utilizando esta herramienta es más rápido y más simple.
Para instalar FindSpark ejecutar el siguiente comando:
$ pip install findSpark
5.3.7. Py4j
Instalar Py4J para que los programas de Python se ejecuten y accedan
directamente a los objetos Java.
$ pip install py4j
5.3.8. Jupyter Notebook
Jupyter es un notebook interactivo con el que se podrá escribir código y permitirá
ver los archivos de una forma más entendible e interactiva. Soporta lenguajes como
Python, R y Matlab entre otros. No es necesario instalarlo ya que viene con Anaconda.
81
Ilustración 62. Entorno jupyter en navegador
Ilustración 60. Lanzar jupyter notebook con spark Ilustración 61. Lanzar jupyter notebook
Para lanzar jupyter notebook se puede hacer de dos maneras:
1º Directamente lanzar jupyter notebook:
$ jupyter notebook
Será necesario en el código incluir FindSpark explicado a continuación.
2º Lanzar jupyter notebook con Spark:
$ PYSPARK_DRIVER_PYTHON=ipython
PYSPARK_DRIVER_PYTHON_OPTS=”notebook” Spark-2.2.1-bin-
hadoop2.7/bin/pyspark
Ver que está correctamente instalado porque al ejecutar ese comando, se nos abre
el navegador con la dirección localhost:8888/tree#notebooks.
82
Ilustración 63. Configuración red
5.4. Configuración y puesta en marcha
Teniendo el entorno completamente listo, se procederá a configurar cada nodo para
que estén conectados entre sí. Aquí comienza la creación del clúster, iniciando el servidor
maestro en primer lugar y conectando a este servidor los nodos slaves que desempeñarán
el trabajo.
Con el clúster listo y funcionando, se explica cómo comenzar un código para
utilizarlo con Spark y crear el SparkContext para trabajar con los diferentes nodos que
componen el clúster.
5.4.1. Iniciar el servidor maestro
1º En computadores físicos simplemente hay que tener las máquinas conectadas en la
misma red y en virtualbox, con las máquinas apagadas, configurar la red en bridge
(modo puente).
2º En la máquina master, se inicia el servidor maestro. (En el directorio donde esté la
instalación de Spark, en este caso /home/master/ Spark-2.2.1-bin-hadoop2.7).
$ ./sbin/start-master.sh -h 192.168.1.117
83
Ilustración 64. Iniciar servidor maestro
Ilustración 65. Interfaz de usuario web, localhost
Ilustración 66. Interfaz de usuario web, otro dispositivo
Devolverá el mensaje mostrado a continuación.
3º Comprobar acceso a la interfaz de usuario web del servidor maestro:
Si es en la misma máquina del servidor maestro: localhost:8080
Si es desde cualquier otro dispositivo de la red: 192.168.1.108:8080
84
Ilustración 67. Iniciar Slave
Ilustración 68. Interfaz de usuario web, slaves conectados
Se puede apreciar en la interfaz de usuario una dirección que será nuestra
“dirección master”, ya que será la que se va a necesitar para conectar los esclavos al
clúster. (Spark://192.168.1.117:7077)
5.4.2. Conectar esclavos
Teniendo el servidor maestro ejecutándose, iniciar esclavo. Desde la carpeta de
instalación de Spark: $ ./sbin/start-slave.sh spark://192.168.1.117:7077
Como vemos a continuación, nos devuelve algo similar al maestro.
Para cada esclavo que se quiera conectar al master realizar la misma operación
siguiendo estos pasos.
Comprobar en la interfaz maestro que el esclavo se ha ejecutado como worker.
¡Hasta aquí hay un clúster Spark funcionando completamente!
85
Ilustración 69. Script ejecutado python prueba1
5.4.3. Crear primera aplicación Spark
1. Ejecutar el siguiente script en un nuevo código python:
import findSpark
findSpark.init()
import pySpark
sc = pySpark.SparkContext(master='Spark://192.168.1.117:7077 ',
appName='prueba1')
sc
PySpark puede importar una biblioteca y crear una instancia de Spark Context con
los parámetros URL maestra y el nombre de la aplicación (cualquiera, en este caso
le he llamado prueba1).
Al hacer click en el enlace, se accede a la interfaz web de la aplicación.
86
Ilustración 70. Interfaz web de la aplicación (ejecutores)
Ilustración 71. Interfaz web con running applications
2. Comprobar en la interfaz web del servidor maestro que hay una nueva fila en
Running Applications.
3. Al finalizar la aplicación, se puede ver que ya no hay aplicaciones corriendo y esta
se traslada a aplicaciones completadas
87
Ilustración 72. Interfaz web, completed Applications
Ilustración 73. Apagar slave
5.5. Concluir sesiones
Una vez que el trabajo esté listo y se desee finalizar el clúster, se apagará cada
nodo slave y el servidor maestro. Para ello se deben seguir los siguientes pasos:
1º Para apagar nodos esclavos:
Acceder a cada una de las máquinas mediante ssh, ir al directorio de Spark y
ejecutar el siguiente comando.
$ ./sbin/stop-slave.sh
Si se desea también se puede hacer directamente en la propia máquina sin
necesidad de acceder por ssh.
88
Ilustración 74. Apagar servidor maestro
2º Para apagar el servidor maestro acceder al directorio de Spark y ejecutar el siguiente
comando:
$ ./sbin/stop-master.sh
5.6. Resumen de pasos para iniciar y finalizar clúster
En este apartado se hace un resumen de los pasos necesarios para inicializar un
clúster añadiendo los nodos deseados, quitar nodos a conveniencia y finalizarlo por
completo. Realizando todo desde la máquina máster:
INICIAR CLÚSTER
Desde el directorio /home/master/Spark_2.2.1-bin-hadoop2.7:
$ ./sbin/start-master.sh –h 192.168.1.117 (IP del master)
$ ssh ‘[email protected]’ (IP del slave)
Ir nuevamente al directorio /home/master/Spark_2.2.1-bin-hadoop2.7
$ ./sbin/start-slave.sh spark://192.168.1.117:7077
$ exit
Repetir proceso de ssh en cada slave que tengamos y queramos integrar en el
clúster.
Ahora que están las dos máquinas conectada se inicia el entorno jupyter de
cualquiera de estas dos formas:
- $ jupyter notebook
- $ PYSPARK_DRIVER_PYTHON=ipython
PYSPARK_DRIVER_PYTHON_OPTS=”notebook” Spark-2.2.1-bin-
hadoop2.7/bin/pyspark
89
FINALIZAR CLÚSTER
Detener todas las máquinas del clúster
$ ssh ‘[email protected]’ (IP del slave que se desee quitar del clúster)
Ir al directorio /home/master/Spark_2.2.1-bin-hadoop2.7
$ ./sbin/stop-slave.sh
$ exit
Repetir proceso de ssh en cada slave que tengamos activo.
Desde el directorio /home/master/Spark_2.2.1-bin-hadoop2.7:
$ ./sbin/stop-master.sh
6. PRUEBAS Y RESULTADOS
En este capítulo servirá para concluir a base de pruebas un comportamiento de
Spark en varias situaciones para poder conocer hasta donde deja de ser útil y productiva
esta tecnología y además conocerla un poco más para poder sacarle el máximo partido.
Con el objetivo de demostrar todo lo dicho a lo largo del desarrollo del proyecto y el
correcto funcionamiento de las instalaciones, se han realizado unas pruebas en
computadores. Para poder obtener un resultado de calidad y fiable, se ha ejecutado un
algoritmo con una alta carga de trabajo y para conseguir que el clúster trabajara con fluidez
eran necesarios varios computadores con buen procesador y mínimo 8GB de RAM.
La prueba consiste en ejecutar un algoritmo de Regresión lineal que utiliza librerías
de machine learning “ml”, para la clasificación de artículos de noticias leyendo un fichero
que está incorporado en todos y cada uno de los nodos del clúster. Spark ML se usa para
referirse a la API basada en MLlib DataFrame. En este caso se utilizan los siguientes
módulos pertenecientes a la librería ml:
pyspark.ml. Import pipeline: API de aprendizaje automático basado en DataFrame
que permite ensamblar y configurar rápidamente pipelines de machine learning.
pyspark.ml.classification import LogisticRegression: Se utiliza para la regresión
logística, ya sea binomial o multinomial.
90
Ilustración 75. Lectura datos TextClassificationmini
pyspark.ml.tuning import ParamGridBuilder, CrossValidator: ParamGridBuilder
construye una grilla de parámetros para buscar y CrossValidator evalua varios
modelos en la misma operación identificando el mejor modelo basándose en
estadísticas.
pyspark.ml.evaluation import BinaryClassificationEvaluator: Evaluador para la
clasificación binaria, con dos columnas de entrada.
pyspark.ml. feature import HashingTF,StopWordsRemover,IDF,Tokenizer:
StopWordsRemover es un transformador de funciones que filtra palabras de parada
de entrada, Tokenizer convierte la cadena de entrada en minúsculas y luego la
divide en espacios en blanco, IDF calcula la frecuencia inversa del documento (IDF)
dada una colección de documentos, lo que expresa cuán relevante es una palabra
y HashingTF utilizando el hashing trick convierte valores arbitrarios en vectores.
Para este algoritmo también se hace uso de pyspark.sql donde se incluyen los
siguientes módulos y clases:
pyspark.sql import SQLContext; para trabajar con datos estructurados. Sirve para
crear DataFrames, registrar DataFrames como tablas y ejecutar SQL sobre tablas.
pyspark.sql import Row: Crea una fila de datos (row) en un DataFrame.
En el clúster se ejecutará un mismo código de dos maneras diferentes:
1. La primera será leyendo un archivo de datos de 4.8 MB que consta de 2000
documentos. Tendrá 2.8 GB de procesado. Se le ha llamado
“TextClassificationmini”.
2. La segunda será leyendo un archivo de datos de 46.6 MB que consta de 19997
documentos (prácticamente 10 veces mayor) con 32.3 GB de procesado. Se le ha
llamado “TextClassificationmaxi”.
91
Ilustración 77. Web gestión de clústers
Ilustración 76. Lectura de datos TextClassificationmaxi
En ambas, se ejecutará con diferente número de nodos para observar cómo trabaja
Spark y distribuye el trabajo y poder sacar conclusiones.
El código lee un archivo, un dataset obtenido de la página
“https://archive.ics.uci.edu/ml/datasets.html?area=&att=&format=&numAtt=&numIns=&sor
t=nameUp&task=&type=text&view=table. ”. Lo que varía de una prueba a otra será el
dataset introducido.
Esta prueba se hará en 4 partes, comenzando con un clúster compuesto por un
nodo maestro y 4 nodos workers y reduciendo en cada parte un nodo worker. La gestión
del trabajo la realiza el nodo maestro y los workers son los que realizan las operaciones
que se distribuyen en el clúster.
Para entender mejor la ejecución interna de Spark, se pueden observar a través de
la web de gestión del clúster las tareas activas y completadas con los nodos que tenemos
conectados. En el caso mostrado a continuación se puede apreciar la web de gestión con
3 workers activos.
92
Ilustración 78. Interfaz de aplicación
Ilustración 79. Descripción detallada de uno de los trabajos de la aplicación
Una vez esté la aplicación corriendo, tenemos la oportunidad de entrar dentro de la
interfaz de la aplicación donde es posible ver los trabajos que están llevando a cabo junto
con sus etapas, las características del entorno de trabajo y los ejecutores.
Dentro de cada uno de los trabajos, hay una descripción muy detallada del propio
trabajo:
93
Ilustración 80. Grafo de una tarea perteneciente a una aplicación
Y además se puede ver de forma esquemática el grafo de cada tarea.
Lo más interesante es poder apreciar en la parte de ejecutores los nodos activos,
cuantas tareas están ejecutando, los RDD que tiene cada nodo en un momento
determinado y la carga total de trabajo.
En las siguientes imágenes, se muestran los ejecutores en varias fases a lo largo
de la ejecución de la aplicación, desde que empieza a correr hasta que termina, donde se
puede comprobar que hay una paralelización de las tareas entre nodos:
94
Ilustración 81. Ejecutores aplicación corriendo(I)
Ilustración 82. Ejecutores aplicación corriendo (II)
95
Ilustración 83. Aplicación finalizada
6.1. Prueba “TextClassificationmini”
En primer lugar, se ha ejecutado el algoritmo con una carga de datos menor. Se le
ha llamado “TextClassificationmini” Son 4.8 MB, 2000 noticias repartidas en 20 carpetas
de 100 elementos cada una. Tendrá 2.8 GB de procesado.
Para poder apreciar el reparto de tareas y paralelización de Spark, en cada una de
las celdas en las que está divido el código se ha mostrado el tiempo de ejecución para
poder hacer un estudio lo más exacto posible.
96
Ilustración 84. Time código
Nodos/Celdas 16 17 18 19 20 21 22 23 24 25 26 27 28 Tiempo total
1 Nodo 20,4 0,0758 0,00037 0,00218 4,9E-05 18,6 24,8 12,4 7,06 4,3E-05 0,00047 463 13,7 659,7722057
2 Nodos 18,6 0,0736 0,00049 0,00299 4,5E-05 17 23,9 12,2 6,44 6,8E-05 0,00021 425 12,5 609,1775549
3 Nodos 18,7 0,0796 0,00031 0,00246 2,1E-05 16,6 23,8 12,3 6,74 6,8E-05 0,00031 425 12,3 610,5689349
4 Nodos 18,8 0,188 0,00055 0,00195 2,5E-05 17,2 24,7 12,5 6,45 6,5E-05 0,0004 427 12,5 617,2375301
Nodos/Celdas 1 2 3 4 5 6 7 8 9 10 11 12 13 14 15
1 Nodo 0,445 0,000495 0,0318 0,167 2,52 18,9 13,8 13,5 13,5 0,219 7,29 1,97 7,75 7,34 12,3
2 Nodos 0,429 0,000354 0,0278 0,182 2,79 17,9 12,7 12,4 12,3 0,221 6,93 2,01 7,19 6,78 11,6
3 Nodos 0,467 0,000565 0,0296 0,179 2,73 18,1 13,9 12,5 12,1 0,21 6,51 2,03 6,94 6,95 12,4
4 Nodos 0,336 0,000741 0,0288 0,186 2,72 18,1 13,9 14,1 12,4 0,215 6,86 2,01 7,33 7,21 12,5
Se ha proyectado en las siguientes tablas (Tablas 3 y 4) cada una de las celdas de
este algoritmo (un total de 28 celdas) y sus tiempos expresados en segundos. Estas tablas
se han representado en un gráfico (Ilustración 85).
Tabla 3. TextClassification mini (1)
Tabla 4. TextClassification mini (2)
97
Ilustración 85. Gráfico total TextClassificationmini
Ilustración 86. Gráfico segundos TextClassificationmini
0
100
200
300
400
500
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 28Tie
mp
o e
n s
egu
nd
os
Celdas
Text Classificationmini4,8 MB de archivos, 2,8 Gb de procesado, 2000 documentos
(Total)
1 Nodo 2 Nodos 3 Nodos 4 Nodos
0
5
10
15
20
25
30
5 6 7 8 9 11 12 13 14 15 16 21 22 23 24 28Tie
mp
o e
n s
egu
nd
os
Celdas
TextClassificationmini 4,8 MB de archivos, 2,8 Gb de procesado, 2000 documentos
(Tareas segundos)
1 Nodo 2 Nodos 3 Nodos 4 Nodos
Como los tiempos de cada celda son muy desiguales abarca un rango muy grande
y en el gráfico total no se aprecia muy bien la diferencia entre tiempos, por lo que se ha
decidido hacer dos tipos de gráficos, uno que incluya las celdas de segundos y otro con las
celdas que tengan un tiempo de ejecución superior a un minuto, que en este caso es
únicamente la 27.
No se han representado tiempos inferiores a un segundo ya que es cifra muy
insignificante, aunque si se ha tenido en cuenta para la suma total de tiempos. Por último,
se muestra un gráfico de tiempo total.
98
Ilustración 87. Gráfico minutos TextClassificationmini Ilustración 88. Gráfico tiempos totales TextClassificationmini
580
590
600
610
620
630
640
650
660
670
Tiempo total
Tie
mp
o e
n s
egu
nd
os
TextClassificationmini 4,8 MB de archivos, 2,8 Gb
de procesado, 2000 documentos (Tiempo total)
1 Nodo 2 Nodos 3 Nodos 4 Nodos
400
410
420
430
440
450
460
470
27
Tie
mp
o e
n s
egu
nd
os
Celdas
TextClassificationmini 4,8 MB de archivos, 2,8 Gb
de procesado, 2000 documentos (Celdas
minutos)
1 Nodo 2 Nodos 3 Nodos 4 Nodos
En esta prueba, lo que se puede apreciar es que cuando el algoritmo es ejecutado
con 2 nodos disminuye considerablemente el tiempo de ejecución, pero conforme se va
aumentando el número de nodos el tiempo aumenta también.
6.2. Prueba “TextClassificationmaxi”
En esa ocasión se ha ejecutado el mismo algoritmo, en las mismas condiciones,
pero con una carga de datos mucho mayor. Se le ha llamado “TextClassificationmaxi”. Son
46.6 MB, 19997 noticias repartidas en 20 carpetas. Tendrá 32.3 GB de procesado
Al igual que en la prueba anterior, se ha proyectado en las siguientes tablas (Tablas
5 y 6) cada una de las celdas de este algoritmo (un total de 28 celdas) y sus tiempos
expresados en segundos. Las tablas se han representado en un gráfico (Ilustración 89).
99
Ilustración 89. Gráfico total TextClassificationmaxi
0
500
1000
1500
2000
2500
3000
3500
4000
4500
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
Tie
mp
o e
n s
egu
nd
os
Celdas
TextClassificationmaxi 46,6 MB de archivos, 32,3 GB de procesado, 19997
documentos(Total)
1 Nodo 2 Nodos 3 Nodos 4 Nodos
Nodos/Celdas 1 2 3 4 5 6 7 8 9 10 11 12 13 14 15
1 Nodo 0,273 0,00577 0,0538 0,207 2,82 172 134 134 134 0,261 67 2,32 68 68 19,7
2 Nodos 0,0904 0,00049 0,0287 0,175 2,72 167 122 121 121 0,259 61 2,08 62 62 19,4
3 Nodos 0,333 0,00071 0,0284 0,177 2,78 166 118 120 116 0,28 62 2,04 59,9 62 18,3
4 Nodos 0,199 0,00071 0,0304 0,188 2,89 177 118 127 124 0,252 57,6 2,19 62 62 18,3
Nodos/Celdas 16 17 18 19 20 21 22 23 24 25 26 27 28 Tiempo total
1 Nodo 202 0,0998 0,00027 0,00388 2,12E-05 147 123 61 68 0,00011 0,00037 4052 135 5590,745017
2 Nodos 182 0,0716 0,00066 0,00251 3,41E-05 134 115 58 62 4,79E-05 0,00023 3691 122 5104,828673
3 Nodos 179 0,0795 0,00035 0,00228 3,48E-05 134 118 59,2 62 7,80E-05 0,00023 3671 124 5075,121573
4 Nodos 179 0,0843 0,00046 0,00291 5,29E-05 134 117 58,4 58,4 4,79E-05 0,0003 3636 121 5055,538168
Tabla 5. TextClassificationmaxi (1)
Tabla 6. TextClassificationmaxi (2)
De la misma forma que sucede en la prueba de TextClassificationmini, al ser los
tiempos tan desiguales en el gráfico total no se aprecia muy bien la diferencia entre
tiempos, por lo que se ha decidido hacer dos tipos de gráficos. Esta vez, uno incluirá las
celdas con segundos y minutos y otro gráfico mostrará los tiempos de celdas superiores a
una hora.
100
Ilustración 90. Gráfico segundos-minutos TextClassificationmini
0
50
100
150
200
250
5 6 7 8 9 11 12 13 14 15 16 21 22 23 24 28
Tie
mp
o e
n s
egu
nd
os
Celdas
TextClassificationmaxi 46,6 MB de archivos, 32,3 GB de procesado, 19997
documentos(Celdas segundos-minutos)
1 Nodo 2 Nodos 3 Nodos 4 Nodos
3400
3500
3600
3700
3800
3900
4000
4100
27
Tie
mp
o e
n s
egu
nd
os
Celdas
TextClassificationmaxi 46,6 MB de archivos,
32,3 GB de procesado, 19997 documentos
(Celdas horas)
1 Nodo 2 Nodos 3 Nodos 4 Nodos
4700
4800
4900
5000
5100
5200
5300
5400
5500
5600
5700
Tiempo total
Tie
mp
o e
n s
egu
nd
os
TextClassificationmaxi 46,6 MB de archivos, 32,3 GB de procesado, 19997
documentos(Tiempo total)
1 Nodo 2 Nodos 3 Nodos 4 Nodos
Ilustración 91. Gráfico horas TextClassificationmaxi Ilustración 92. Gráfico tiempos totales TextClassificationmaxi
No se han representado tiempos inferiores a un segundo ya que es cifra muy
insignificante, aunque si se ha tenido en cuenta para la suma total de tiempos. Por último,
se muestra un gráfico de tiempo total.
101
1 2 3 4
TextClassificationmini 100,00% 92,33% 92,54% 93,55%
TextClassificationmaxi 100,00% 91,31% 90,78% 90,42%
ALGORITMO
TAMAÑO
ARCHIVO
TAMAÑO
DE
NODO
WORKER CORES
TIEMPO DE EJECUCIÓN
(segundos)
4.8 MB 2.8 GB 1 8 659,7722057
4.8 MB 2.8 GB 2 16 609,1775549
4.8 MB 2.8 GB 3 24 610,5689349
4.8 MB 2.8 GB 4 32 617,2375301
46.6 MB 32.3 GB 1 8 5590,745017
46.6 MB 32.3 GB 2 16 5104,828673
46.6 MB 32.3 GB 3 24 5075,121573
46.6 MB 32.3 GB 4 32 5055,538168
TextClassificationmini
TextClassificationmaxi
Tabla 8. Resultados tiempos finales escala porcentual
En contraposición, en esta prueba los tiempos de ejecución disminuyen bastante
más que en la prueba anterior y van siendo más bajos conforme se va aumentando el
número de nodos.
6.3. Resultados
Basándose en los tiempos totales de cada ejecución, se ha realizado una tabla de
resultados.
Tabla 7. Resultados tiempos finales
Para poder obtener una gráfica en la que sea visualmente comparable el
funcionamiento de Spark dependiendo de la carga de trabajo introducida en este algoritmo
concreto, se ha decidido convertir los valores de tiempos de ejecución a una escala
porcentual, siendo el 100% el funcionamiento con 1 nodo.
102
84,00%
86,00%
88,00%
90,00%
92,00%
94,00%
96,00%
98,00%
100,00%
102,00%
1 2 3 4
Tiem
po
s en
esc
ala
Número de nodos
Tiempos finales (escala porcentual)
TextClassificationmini TextClassificationmaxi
Ilustración 93. Gráfico tiempos finales en escala porcentual
Con esta escala, se ha realizado el siguiente gráfico:
Como ya se había observado antes, no se obtiene el mismo resultado en cada tipo
de prueba ya que en la prueba en la que se introduce una pequeña carga de datos
(TextClassificationmini), en contraposición a lo esperado, aumenta el tiempo de ejecución
a partir del tercer nodo.
El hecho de que aumente el tiempo aunque tenga más computadores trabajando
se debe a la sobrecarga por paralelismo, en la que el nodo maestro debe distribuir el trabajo
cada vez a un mayor número de nodos y resulta más costoso que la propia naturaleza de
la aplicación que necesita poco tiempo para ejecutarse lo que hace que no se compense
la sobrecarga.
En la prueba TextClassificationmaxi se ha podido comprobar el correcto y buen
funcionamiento de Spark, compensando la sobrecarga por paralelismo y obteniendo muy
buenos tiempos en los resultados en los que se minimiza el tiempo de ejecución conforme
se integra un nodo más en el clúster.
103
6.4. Problemas a lo largo del trabajo
Trabajando con máquinas virtuales han surgido varios problemas:
- Las IP de master y slave a veces cambiaban por alguna circunstancia y se
ha tenido que reconfigurar constantemente para las ips nuevas.
- Cuando se hacía Update y Upgrade, a veces aparecía el siguiente
problema: ”E: No se pudo bloquear /var/lib/dpkg/lock - open (11: Recurso no
disponible temporalmente) E: No se pudo bloquear el directorio de
administración (/var/lib/dpkg/), ¿quizás haya algún otro proceso
utilizándolo?”
Para ello la solución han sido los siguientes comandos:
$ sudo fuser -vki /var/lib/dpkg/lock
$ sudo rm -f /var/lib/dpkg/lock
$ sudo dpkg --configure –a
$ “el proceso que estaba haciendo (sudo apt-get update/upgrade)”
$ sudo apt-get autoremove
Durante la utilización de Spark aparecían errores internos con la creación del
SparkContext si antes se había estado trabajando desde la Shell. No se podía
detener el SparkContext que se crea desde la Shell y había que reiniciar todo.
6.5. Conclusiones
En este trabajo se presentó un estudio comparativo en una de las principales
herramientas de procesamiento distribuido y en paralelo de datos de la actualidad. Fueron
realizadas dos pruebas en un clúster con entradas de datos de tamaños variados y
aumentando el número de nodos de uno en uno.
104
Este trabajo tenía el objetivo de demostrar que Apache Spark es un buen framework
para la manipulación de Big Data, y así ha sido. Es fácil de configurar, dispone de varias
funciones para manipular los datos y tiene muy buen desempeño lo que lo hace adecuado
para el uso en sistemas de machine learning.
Según los resultados obtenidos, se muestra la necesidad de un sistema distribuido
y paralelo para la eficacia del procesamiento de grandes cantidades de datos. También se
concluye que no merece la pena la utilización de un clúster cuando el algoritmo que se
ejecuta tiene una naturaleza de corto tiempo de ejecución y la cantidad de datos a procesar
es poca.
Además de ejecutar un solo algoritmo en varios casos, también se ha podido
comprobar el correcto funcionamiento ejecutando otros algoritmos de machine learning y
optimización.
Este capítulo ha sido sin duda el más gratificante de realizar ya que se ha visto el
fruto de meses de investigación y de trabajo.
7. ESTUDIO ECONÓMICO
En este capítulo se llevará a cabo un estudio económico para determinar el coste
que supondría poder implementar este trabajo con el objetivo de realizar unas bases para
la orientación de personas que puedan estar interesadas.
Se harán los costes en función de los materiales que se han utilizado , sin tener en
cuenta el ordenador portátil y las máquinas virtuales ya que es un coste que se puede omitir
haciéndolo todo directamente en ordenadores físicos.
Se va a subdividir en varios apartados con costes de Hardware, Software,
Honorarios y un resumen con los costes totales.
105
Tabla 9. Costes Hardware
Tabla 10. Costes Software
Unidades Concepto Precio unitario
(IVA 21% incluido)
Subtotal
1 Monitor Acer AL1702 40,00 € 40,00 €
5 Ordenador de mesa
- Procesador Intel Core i7-7700 3.6Ghz
- Memoria RAM 1x8GB DDR4 2400MHz
- Disco duro 1TB Western
- Tarjeta gráfica GeForce GT 730 2GB
- Tarjeta de red Asus PCE-N15 WiFi 11n 300Mbps
620,00 € 3.100,00 €
1 Conmutador CS1308 8-Port PS/2-USB VGA KVM 149,90 € 149,90 €
1 Teclado y ratón 20,00 € 20,00 €
Total 3.309,90 €
Unidades Concepto Precio unitario
(IVA 21% incluido)
Subtotal
1 Sistema Operativo
Linux, distribución
Ubuntu 17.10
- € - €
1 Software Apache
Spark
- € - €
Total - €
7.1. Costes de Hardware
En este apartado se detallan en la siguiente tabla (Tabla 9) los costes de los
materiales que se han necesitado para implementar este trabajo.
7.2. Costes de Software
En este apartado se detallarán los costes del software que se utiliza para el
desarrollo del proyecto en la siguiente tabla (Tabla 10).
106
Tabla 11. Honorarios
Tabla 12. Costes totales
Horas Concepto Precio/hora
(IVA 21% incluido)
Subtotal
480 Honorario ingeniero Telec. 12,30 € 5.904,00 €
Total 5.904,00 €
Unidades Concepto Precio unitario
(IVA 21% incluido)
Subtotal
1 Costes de Hardware 3.309,90 € 3.309,90 €
1 Costes de Software - € - €
1 Costes de Honorarios
5.904,00 € 5.904,00 €
Total 9.213,90 €
7.3. Honorarios
Se estima que la duración del desarrollo del trabajo es aproximadamente 3 meses,
de los cuales laborables son 20 días al mes con un total de 8 horas de trabajo por jornada.
Esto resulta en un total de: 20 días x 3 meses x 8 horas = 480 horas de trabajo
totales. El coste medio por hora de trabajo se estima en 12,30€.
7.4. Resumen con costes totales
Recopilando los costes de las distintas partes del estudio económico se llega a un
presupuesto final mostrado en la siguiente tabla (Tabla 12):
107
8. CONCLUSIONES SOBRE EL TFG Y TRABAJOS
FUTUROS
A lo largo de este trabajo se observa que Spark presenta propiedades interesantes
que ya existían en Hadoop como la tolerancia a fallos, y además de estas, otras nuevas
como la posibilidad del uso de más lenguajes de programación y optimizaciones de
procesamiento.
Teniendo en cuenta las pruebas realizadas en un clúster Spark, cuando se habla
de procesar grandes cantidades de datos se torna necesaria la utilización de un sistema
distribuido donde todos los nodos trabajen en paralelo.
Con el estudio realizado, se concluye que Spark es realmente muy interesante y
tiene todo para cada día ser más utilizado en el mundo Big Data ya que es fácil de
configurar, ofrece diversas funciones para manipular datos y tiene muy buen desempeño.
Sin embargo, no se puede olvidar que todavía es un sistema menos maduro en vías de
desarrollo con necesidad de evolucionar en algunos puntos como en la seguridad.
Como trabajos futuros, en el desarrollo de este proyecto surgió la idea de buscar
formas de predecir de una manera anticipada el tiempo que un algoritmo en concreto
consumiría al ser ejecutado con un determinado tamaño de datos y una determinada
configuración del sistema. Esto podría servir de ayuda para la mejor elección del tipo de
clúster decidiendo cuantos nodos integrar.
9. BIBLIOGRAFÍA
9.1. Referencias
• [1] KWON, O. et al. Data quality management, data usage experience and
acquisition intention of Big Data analytics. International Journal of Information
Management. 2014. [en línea].
108
Disponible en:
https://pdfs.semanticscholar.org/f199/83b3e9b7fe8106c0375ebbd9f73a53295a28.
• [2] DI MARTINO, B. et al. Big Data (lost) in the cloud. International Journal of Big
Data Intelligence., v. 1, n. 1/2, 2014. [en línea].
Disponible en:
https://www.researchgate.net/publication/264156665_Big_Data_lost_in_the_Cloud
• [3] RAJESH, K,V,N. Big Data Analytics: Applications and Benefits. The IUP Journal
of Information Technology, Vol. IX, n. 4, 2013 – introduction [en línea].
Disponible en:
https://search.proquest.com/openview/eab6d70f0b8a2c27dca5e2fd093a582b/1?p
q-origsite=gscholar&cbl=2029987
• [4] Chester Curme, Tobias Preis, Eugene Stanley, Helen Susannah Moat,
―Quantifying the semantics of search behavior before stock market moves‖;
CrossMark, December 2013 [en línea].
Disponible en: http://www.pnas.org/content/pnas/111/32/11600.full.pdf
• [5] Ruchi Verma, Sathyan Ramakrishna Mani. Using Analytics for insurance fraud
detection. Páginas 7 – 8. [en línea].
Disponible en: https://www.the-digital-insurer.com/wp-content/uploads/2013/12/53-
insurance-fraud-detection.pdf
• [6] IBM Watson Analytics for Social Media. [en línea].
Disponible en: http://www-01.ibm.com/software/analytics/solutions/customer-
analytics/social-media-analytics/
• [7] BATRA, S. Big Data Analytics and its Reflections on DIKW Hierarchy. Review of
Management. 4, ½, June 2014 – Introduction. [en línea].
Disponible en:
https://search.proquest.com/openview/3fef4fe0a59039ae439fb4185fcd7671/1?pq-
origsite=gscholar&cbl=906340
• [8] NONAKA, I.; TAKEUCHI, H. The knowledge-creating company”. Oxford
University Press, nueva york. 1997 [en línea].
Disponible en:
https://books.google.es/books?hl=es&lr=&id=tmziBwAAQBAJ&oi=fnd&pg=PA3&dq
=Nonaka,+I.+y+Takeuchi,+H.+(1997):+%E2%80%9CThe+knowledge-
109
creating+company%E2%80%9D.+Oxford+University+Press,+nueva+york&ots=pS
4iCK2GHx&sig=V61q8figJkm44COKHB5qUJUer9M#v=onepage&q&f=false
• [9] ALAVI, M.; LEIDNER, D.E. Review: knowledge management and knowledge
management systems: conceptual foundations and research issues. MIS Quarterly,
v. 25, n. 1, 2001. [en línea].
Disponible en:
https://moodle.ufsc.br/pluginfile.php/950622/mod_resource/content/1/MISQ%2020
01%20Vol%2025%20No.%201%20page%20107%20Alavi%20Leidner.pdf
• [10] HANSEN, M. T. et al. The search-transfer problem: The Role of weak ties in
sharing knowledge across organization subunits. Administrative Science Quarterly,
1999. [en línea].
Disponible en:
https://www.jstor.org/stable/pdf/2667032.pdf?refreqid=excelsior%3A573383e1ed1
1cde1297dffe508f3e155
• [11] ERICKSON, S.; ROTHBERG, H. Big Data and Knowledge Management:
Establishing a Conceptual Foundation. Electronic Journal Of Knowledge
Management. [en línea].
Disponible en: www.ejkm.com/issue/download.html?idArticle=565
[12] Pablo L. Belly. Niveles de conocimiento del capital humano. [en línea].
Disponible en: https://www.gestiopolis.com/niveles-conocimiento-capital-humano/
• [13] Información página oficial de Apache Hadoop. [en línea]. Disponible en:
http://hadoop.apache.org/
• [14] El valor de la gestión de datos. ¿Qué es el Apache Hadoop? [en línea].
Disponible en:
https://blog.powerdata.es/el-valor-de-la-gestion-de-datos/bid/397377/qu-es-el-
apache-hadoop
• [15] Análisis de medidas no supervisadas de calidad en clústers obtenidos por K-
means y Particle Swarm Optimization – Andrea Villagra, Ana Guzmán, Daniel
Pandolfi y Guillermo Leguizamón. [en línea].
Disponible en:
http://dspace.palermo.edu/dspace/bitstream/handle/10226/454/20.pdf?sequence=
1&isAllowed=y
110
• [16] Documentación SQL Apache Spark. [en línea]. Disponible en:
http://spark.apache.org/sql/
• [17] Documentación Streaming Apache Spark. [en línea]. Disponible en:
http://spark.apache.org/streaming/
• [18] Documentación MLlib Apache Spark. [en línea]. Disponible en:
http://spark.apache.org/mllib/
• [19] Documentación Graphx Apache Spark. [en línea]. Disponible en:
http://spark.apache.org/graphx/
• [20] Guía de programación Spark SQL, DataFrames y Datasets. [en línea].
Disponible en: https://spark.apache.org/docs/latest/sql-programming-
guide.html#datasets-and-dataframes
9.2. Otras fuentes consultadas
9.2.1. Enlaces
• International Journal of Advanced Research in Computer and Communication
Engineering Vol. 5, Issue 2, February 2016. [en línea].
Disponible en: https://www.ijarcce.com/upload/2016/february-
16/IJARCCE%2015.pdf
• Bernard Marr, How Big Data Is Changing Healthcare. [en línea].
Disponible en: http://www.forbes.com/sites/bernardmarr/2015/04/21/how-big-data-
is-changing-healthcare/
• Sundar Ram, Why Big Data is the booster shot the healthcare industry needs. [en
línea].
Disponible en: http://www.firstpost.com/business/big-data-booster-shot-healthcare-
industry-needs-2160271.html
• Derek Klobucher, Sentiment Analysis with Big Data, September 20, 2013. [en línea].
Disponible en: http://www.news-sap.com/sentiment-analysis-with-big-data/
• Gil Allouche, The Impact of Big Data on the Food Industry. [en línea].
111
Disponible en: https://datafloq.com/read/big-datas-impact-food-industry/96
• José David Jurado Alonso, Apache Hadoop: Introducción a HDFS. 29 enero, 2013.
[en línea].
Disponible en: http://www.happyminds.es/apache-hadoop-introduccion-a-hdfs/
• Tutorials point Simply Easy Learning, Hadoop – Introducción. [en línea].
Disponible en:
https://www.tutorialspoint.com/es/hadoop/hadoop_introduction_to_hadoop.htm
• Alberto Lorenzo. Arquitectura Hadoop. [en línea].
Disponible en: https://elentornodehadoop.wordpress.com/2015/04/06/arquitectura-
hadoop/
• Sachin P Bappalige. An introduction to Apache Hadoop for Big Data. [en línea].
Disponible en: https://opensource.com/life/14/8/intro-apache-hadoop-big-data
• Documentación Hadoop. Setting up a Single Node Cluster. [en línea].
Disponible en: https://hadoop.apache.org/docs/stable/hadoop-project-dist/hadoop-
common/SingleClúster.html#Standalone_Operation
• El valor de la gestión de datos. Spark vs Hadoop, ¿quién saldrá vencedor? [en
línea].
Disponible en: https://blog.powerdata.es/el-valor-de-la-gestion-de-datos/Spark-vs-
hadoop-quien-saldra-vencedor
• Manuel Zaforas. Spark: un destello en el universo Big Data. Blog tecnología para
Desarrollo. [en línea].
Disponible en: https://www.paradigmadigital.com/dev/Spark-un-destello-en-el-
universo-big-data/
• Sinnexus, Business Intelligence Informática Estragégica. Datamining (minería de
datos) [en línea].
Disponible en: http://www.sinnexus.com/business_intelligence/datamining.aspx
• Baoss. Técnicas de análisis Big Data. 2 junio 2015 [en línea].
Disponible en: https://www.baoss.es/tecnicas-de-analisis-big-data/
• Microsoft Neural Network Algorith [en línea].
Disponible en: https://docs.microsoft.com/es-es/sql/analysis-services/data-
mining/microsoft-neural-network-algorithm
• Redes Neuronales. ¿Qué son y cómo funcionan? 17 noviembre 2016. [en línea].
112
Disponible en: donaldre.com/redes-neuronales-que-son-y-como-funcionan/
• Ana Teresa Freitas. Técnicas de data mining, redes neuronales. [en línea].
Disponible en:
http://web.tecnico.ulisboa.pt/ana.freitas/bioinformatics.ath.cx/bioinformatics.ath.cx/i
ndex0717.html?id=109
• Scientia et Technica Año XI, No 27, abril 2005. UTP. ISSN 0122-1701 67 LAS
MÁQUINAS DE SOPORTE VECTORIAL (SVMs) [en línea].
Disponible en: http://www.redalyc.org/pdf/849/84911698014.pdf
• Ad tech & analytics. El algoritmo K-NN y su importancia en el modelado de datos.
20 julio 2017. [en línea].
Disponible en: http://www.analiticaweb.es/algoritmo-knn-modelado-datos/
• Algoritmos de aprendizaje: knn & kmeans, CG Cambronero, IG Moreno - Intelgencia
en Redes de Comunicación, 2006 [en línea].
Disponible en: http://www.it.uc3m.es/jvillena/irc/practicas/08-09/06.pdf
• Gil Monserrate, árbol de decisiones. [en línea].
Disponible en: http://slideplayer.es/slide/3612396/
• Todo sobre árboles de decisión. Lucidchart. [en línea].
Disponible en: https://www.lucidchart.com/pages/pt/tudo-sobre-%C3%A1rvores-
de-decis%C3%A3o
• José Luis López. Algoritmo de Regresión lineal – Inteligencia Artificial. 28 diciembre
2017. [en línea].
Disponible en: https://planetachatbot.com/algoritmo-de-regresi%C3%B3n-lineal-
inteligencia-artificial-a3afd24eeb2f
• Algoritmo de regresión lineal de Microsoft. [en línea].
Disponible en: https://msdn.microsoft.com/es-es/library/ms174824(v=sql.120).aspx
• Alberto Coronado. Formación machine learning: Algoritmos de machine learning
por tipo de aplicación. 4 enero 2017. [en línea].
Disponible en: https://www.albertcoronado.com/2017/01/04/formacion-machine-
learning-algoritmos-de-machine-learning-por-tipo-de-aplicacion/
• Paloma Recuero. Las 9 tareas del Machine Learning. 13 noviembre 2017. [en línea].
Diponible en: https://blogthinkbig.com/tareas-machine-learning
• Algoritmos Genéticos, ÁK Morales, JG Casas. [en línea].
113
Disponible en:
https://b35e8169-a-62cb3a1a-s-
sites.googlegroups.com/site/unamfcienciascomputoevolutivo/materials/Kuri-
Galaviz-AG.pdf
• Andrés A. García. Métodos de optimización: Algoritmos genéticos. Trandingsys. 16
febrero 2012 [en línea].
Disponible en: http://www.tradingsys.org/metodos-de-optimizacion-algoritmos-
geneticos
• Haupt, R. L. y Haupt, S. E., (2004): “Practical genetic algorithms”. Ed. Wiley (Second
Edition). [en línea].
Disponible en: http://www.csbdu.in/csbdu-old/pdf/Practical_Genetic_Algorithms.pdf
• Mario A. Muñoz, Jesús A. López y Eduardo F. Caicedo. Inteligencia de enjambres:
sociedades para la solución de problemas (una revisión). Revista ingeniería e
investigación vol. 28 no. 2, agosto de 2008 (119-130) [en línea].
Disponible en: http://www.redalyc.org/html/643/64328216/
• Andrea Villagra, Ana Guzman, Daniel Pandolfi, Guillermo Leguizamón. Analisis de
medidas no-supervisadas de calidad en clusters obtenidos por K-means y Particle
Swarm Optimization. [en línea].
Disponible en:
http://dspace.palermo.edu/dspace/bitstream/handle/10226/454/20.pdf?sequence=
1&isAllowed=y
• Fernando Sancho Caparrini. PSO: Optimización por enjambres de partículas. 18
noviembre 2016. [en línea].
Disponible en: http://www.cs.us.es/~fsancho/?e=70
• Jaume Bacardit Peñarroya. Pittsburgh genetic-based machine learning in the data
mining era. [en línea].
Disponible en: https://dialnet.unirioja.es/servlet/tesis?codigo=19529
• Genetic Fuzzy Systems: Evolutionary Tuning And Learning Of Fuzzy Knowledge
Bases, Cordon Oscar, Herrera Francisco, Hoffmann Frank, World Scientific, 13 jul.
2001 - 488 páginas [en línea].
Disponible en:
https://books.google.es/books?id=w2zVCgAAQBAJ&printsec=frontcover&dq=Gen
etic+Fuzzy+Systems:+Evolutionary+Tuning+And+Learning+Of+Fuzzy+Knowledge
114
+Bases,+Cordon+Oscar,&hl=es&sa=X&ved=0ahUKEwj2w6nkjZTZAhULuxQKHeiv
Dg4Q6AEIKzAA#v=onepage&q=Genetic%20Fuzzy%20Systems%3A%20Evolutio
nary%20Tuning%20And%20Learning%20Of%20Fuzzy%20Knowledge%20Bases
%2C%20Cordon%20Oscar%2C&f=false
• Martín De Lima. Introducción a sistemas fuzzy en Matlab y uso de Simulink. [en
línea].
Disponible en: http://slideplayer.com.br/slide/297529/
• ESCOM. Reglas difusas. 21 septiembre 2009. [en línea].
Disponible en: https://es.slideshare.net/mentelibre/5-introduccin-a-los-sistemas-
basados-en-reglas-difusas
Karlijn Willems. Apache Spark in Python: Beginner's Guide. 28 Marzo 2017. [en
línea].
Disponible en: https://www.Datacamp.com/community/tutorials/apache-Spark-
python
Página oficial Apache Zeppelin. [en línea].
Disponible en: https://zeppelin.apache.org/
• Jupyter/IPython Notebook Quick Start Guide. What is the Jupyter Notebook? [en
línea].
Disponible en:
http://jupyter-notebook-beginner-
guide.readthedocs.io/en/latest/what_is_jupyter.html
• APACHE ZEPPELIN, What Zeppelin Does. [en línea].
Disponible en: https://es.hortonworks.com/apache/zeppelin/
• María Botón Fernández. Introducción a Jupyter. 29 Octubre 2015. [en línea].
Disponible en: https://cetatech.ceta-ciemat.es/2015/10/introduccion-a-jupyter/
• Jacek Laskowski. Mastering Apache Spark 2 (Spark 2.2+), Spark Notebook [en
línea].
Disponible en: https://jaceklaskowski.gitbooks.io/mastering-apache-
spark/interactive-notebooks/spark-notebook.html
• Documentación Spark. Cluster Mode Overview [en línea].
Disponible en: https://spark.apache.org/docs/latest/clúster-overview.html
• Robin Moffatt. Linux cluster sysadmin -- SSH keys. 9 Diciembre 2014. [en línea].
115
Disponible en: https://www.rittmanmead.com/blog/2014/12/linux-clúster-sysadmin-
ssh-keys/
• Documentación Apache Spark. Spark configuration. [en línea].
Disponible en: http://Spark.apache.org/docs/latest/configuration.html
• Documentación Apache Spark. Spark Security. [en línea].
Disponible en: https://spark.apache.org/docs/latest/security.html
• Reynold Xin, Michael Armbrust and Davies Liu. Introducing DataFrames in Apache
Spark for Large Scale Data Science. in ENGINEERING BLOG. 17 Febrero 2015 [en
línea].
Disponible en: https://databricks.com/blog/2015/02/17/introducing-dataframes-in-
spark-for-large-scale-data-science.html
• BBVAOPEN4U. Apache Spark: las ventajas de usar al nuevo ‘rey’ de Big Data. 25
septiembre 2015. [en línea].
Disponible en: https://bbvaopen4u.com/es/actualidad/apache-spark-las-ventajas-
de-usar-al-nuevo-rey-de-big-data
• 7 razones por las que deberías usar Apache Spark. El blog de ASPgems. 31 Julio
2015. [en línea].
Disponible en: https://aspgems.com/blog/apache-Spark/7-razones-por-las-que-
deberias-usar-apache-Spark
9.2.2. Videotutoriales
InformaticaCV. Visión general y estado del arte del Big Data. [en línea].
Disponible en: https://www.youtube.com/watch?v=C6L4pIU5bQ8&t=792s
Analytics centro de recursos: Logicalis Spain. Cómo planificar con éxito un proyecto
de Big Data Por Lantares. [en línea].
Disponible en: https://www.youtube.com/watch?v=u-a9xwJ4AR4&t=12s
MundoGEO. Big Data e Cidades Inteligentes [en línea].
Disponible en: https://www.youtube.com/watch?v=oOe9ma--Gps
KeepCoding®. Big Data en Python con PySpark - KeepCoding Webinar [en línea].
Disponible en: https://www.youtube.com/watch?v=SRBih5LwDZw
116
Michael Galarnyk. Install Anaconda on Ubuntu (Python) [en línea].
Disponible en: https://www.youtube.com/watch?v=jo4RMiM-ihs
Michael Galarnyk. Install Spark on Ubuntu (PySpark) + Configure Jupyter Notebook
[en línea].
Disponible en: https://www.youtube.com/watch?v=uhVYTNEe_-A&t=16s