UNIVERSIDAD POLITECNICA DE MADRIDoa.upm.es/56397/1/TFG_ANTONIO_JIMENEZ_HERNANDEZ.pdf · Hadoop data source, including Cassandra databases. In addition, the main algorithms of Machine

UNIVERSIDAD POLITECNICA DE MADRID

Proyecto de Fin de GradoGrado en Ingenierıa de Software

Online Clustering con STREAMING K-MEANS usando SPARK Streaming

Autor: Antonio Jimenez Hernandez

Tutores:

Sandra Gomez Canaval

Alberto Mozo Velasco

ESCUELA TECNICA SUPERIOR DE INGENIERIA DE SISTEMAS

INFORMATICOS

ii

iii

Resumen

En los ultimos anos, debido al Internet de las Cosas (IoT), los avances en las comuni-

caciones y la generacion de grandes volumenes de datos o Big Data, nuestra sociedad

esta continuamente produciendo cantidades ingentes de datos con informacion valiosa

sobre nuestro comportamiento, nuestros habitos, el uso que damos a los dispositivos

electronicos que tenemos en casa, en el trabajo y en nuestra mano. IoT se caracteriza,

entre muchos otros aspectos, en que los aparatos electricos y electronicos que utiliza-

mos a diario estan conectados a Internet y generan trazas de informacion que ayudan

a hacernos mas facil nuestra vida y que por otro lado, generan informacion de mercado

y tendencias de uso a los fabricantes. Todos esos flujos de informacion que han sido

capturados por diversos sensores y luego transmitidos vıa Internet podrıan ser analiza-

dos (normalmente por parte de los fabricantes) para hacer minerıa de datos. Si bien es

cierto que las tecnicas de data mining (como parte del Machine Learning) estan amplia-

mente desarrolladas y probadas en montones de contextos y dominios, tambien es cierto

que estos algoritmos pueden realizar tares supervisadas o no supervisadas teniendo en

disco toda la informacion y procesando en memoria todos los subconjuntos de esta que

sean necesario. El caso para los flujos de informacion que se producen en la IoT tienen

otras caracterısticas, por ejemplo: se producen millones de flujos a diario, la informa-

cion que viaja en esos flujos es la informacion directa que muchos sensores envıan sin

filtro alguno, ejecutar algoritmos sobre un dataset que cada minuto esta actualizandose

utilizando las tecnicas de data mining tradiciones serıa casi imposible. Por tanto, la

comunidad cientıfica, academica e industrial se ha interesado por adaptar estos algorit-

mos tradicionales a las caracterısticas de estos flujos de datos. Como consecuencia se

han propuesta, desarrollado e implementado adaptaciones a data streaming de los al-

goritmos de data mining mas conocidos y se han propuesto otros nuevos. Este Proyecto

de Fin de Grado pretende estudiar tecnicas de clasificacion no supervisada para desa-

rrollar un sistema de Machine Learning para clustering de data streaming utilizando el

algoritmo streaming k-means. El algoritmo streaming K-means es un algoritmo basado

en clusters tradicional en el area de data mining y que como todos estos algoritmos,

han sido extendidos para ser aplicados sobre flujos de datos. Para el desarrollo de la

aplicacion y la implementacion del algoritmo streaming K-means en este proyecto se va

iv

a utilizar la plataforma computacional ultra-escalable Apache Spark. Esta plataforma

de computacion es capaz de administrar clusteres de ordenadores y ha sido disenada

para ser rapida y de proposito general. Spark esta disenado para ser altamente acce-

sible, ofreciendo una interfaz de programacion de aplicaciones en varios lenguajes de

programacion como Java, Scala o Python, ası como en SQL, ademas, posee una gran

cantidad de librerıas. En particular, Spark puede correr en clusters Hadoop y acceder

a cualquier fuente de datos de Hadoop, incluyendo bases de datos Cassandra. Ademas,

se han identificado los principales algoritmos de Machine Learning para data streaming

junto con sus principales caracterısticas. Este Proyecto finaliza mostrando algunos re-

sultados sobre la implementacion realizada sobre Spark ası como tambien analizando

estos a traves de un dataset publico mediante el cual vamos a probar el funcionamiento

del algoritmo, extraer conclusiones sobre los datos y analizar los resultados obtenidos

desde las metricas de calidad del clustering obtenido.

v

Abstract

In recent years, due to the Internet of Things (IoT), advances in communications

and the generation of large volumes of data or Big Data, our society is continuously

producing huge amounts of data with valuable information about our behavior and our

habits, the use we give to electronic devices that we have at home, at work and in

our hand. IoT is characterized among many other aspects, in that the electrical and

electronic devices we use every day are connected to the Internet and generate traces

of information that help make our lives easier and that, on the other hand, generate

market information and usage trends which are useful to the manufacturers. All those

information flows that have been captured by various sensors and then transmitted via

the Internet could be analyzed (usually by manufacturers) to do data mining. While it

is true that data mining techniques (as part of Machine Learning) are widely developed

and tested in lots of contexts and domains, it is also true that these algorithms can

perform supervised or unsupervised tasks with all the information on disk and proces-

sing in memory all subsets of it that are necessary. The case for information flows that

occur in the IoT have other characteristics, for example: millions of flows are produced

daily, the information that travels is those flows is the direct information that many

sensors send without any filter, execute algorithms on a dataset that every minute

is being updated using data mining techniques would be almost impossible. Therefo-

re, the scientific, academic and industrial community has been interested in adapting

these traditional algorithms to the characteristics of these data flows. As a result, we

have proposed, developed and implemented data streaming adaptations of the most

known data mining algorithms and new ones have been proposed. This Final Project

is made with the purpose of study unsupervised classification techniques to develop a

Machine Learning system for data streaming clustering using the K-means streaming

algorithm. The K-means streaming algorithm is a traditional cluster-based algorithm in

the area of data mining and, like all these algorithms, has been extended to be applied

to data flows. For the development of the application and the implementation of the

K-means streaming algorithm in this project, the ultra-scalable computing platform

Apache Spark will be used. This computing platform is capable of managing computer

clusters and has been designed to be fast and general purpose. Spark is designed to be

vi

highly accessible, offering an application programming interface in several programming

languages such as Java, Scala or Python, as well as in SQL, in addition, it has a large

number of libraries. In particular, Spark can run on Hadoop clusters and access any

Hadoop data source, including Cassandra databases. In addition, the main algorithms

of Machine Learning for data streaming have been identified together with their main

characteristics. This Project ends by showing some results about the implementation

carried out on Spark as well as analyzing these through a public dataset through which

we will test the functioning of the algorithm, draw conclusions about the data and

analyze the results obtained from the quality metrics of the clustering obtained.

Indice

Resumen III

Abstract V

Indice VII

Indice de Tablas X

Indice de Figuras XI

1. Introduccion 1

1.1. Motivacion y Justificacion . . . . . . . . . . . . . . . . . . . . . . . . . 2

1.2. Objetivos . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . 3

1.2.1. Objetivo general . . . . . . . . . . . . . . . . . . . . . . . . . . 3

1.2.2. Objetivos especıficos . . . . . . . . . . . . . . . . . . . . . . . . 3

1.3. Estructura del documento . . . . . . . . . . . . . . . . . . . . . . . . . 4

2. Marco Teorico 5

2.1. Introduccion al Machine Learning . . . . . . . . . . . . . . . . . . . . . 5

2.1.1. Tipos de aprendizaje . . . . . . . . . . . . . . . . . . . . . . . . 6

2.2. Conceptos teoricos sobre Data Streaming . . . . . . . . . . . . . . . . . 8

2.3. Clasificacion de los Algoritmos de Clustering . . . . . . . . . . . . . . . 9

2.3.1. Problemas del Data Stream Mining . . . . . . . . . . . . . . . . 9

2.4. Algoritmos de Stream Clustering . . . . . . . . . . . . . . . . . . . . . 13

2.4.1. Hoeffding Tree for Streaming Classification (Arboles de decision) 14

vii

viii INDICE

2.4.2. CLUSTree (Microclustering) . . . . . . . . . . . . . . . . . . . . 15

2.4.3. DenStream (Microclustering basado en densidad) . . . . . . . . 15

2.4.4. D-Stream (Basado en densidad) . . . . . . . . . . . . . . . . . . 15

3. Estado del Arte 17

3.1. Streaming K-means: Adaptacion del algoritmo K-means a streaming . . 17

3.2. Apache Spark . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . 18

3.2.1. Spark Core . . . . . . . . . . . . . . . . . . . . . . . . . . . . . 19

3.2.2. Spark Streaming . . . . . . . . . . . . . . . . . . . . . . . . . . 20

3.2.3. MLLIB . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . 20

3.2.4. Spark SQL . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . 21

3.2.5. Instalacion de Spark en Windows . . . . . . . . . . . . . . . . . 21

4. Desarrollo de la Aplicacion 23

4.1. Analisis de Requisitos . . . . . . . . . . . . . . . . . . . . . . . . . . . . 23

4.1.1. Requisitos Funcionales . . . . . . . . . . . . . . . . . . . . . . . 23

4.1.2. Requisitos no Funcionales . . . . . . . . . . . . . . . . . . . . . 25

4.2. Descripcion del algoritmo streaming K-means . . . . . . . . . . . . . . 26

4.3. Definicion del modelo del Sistema de Machine Learning . . . . . . . . . 27

4.3.1. Serializacion . . . . . . . . . . . . . . . . . . . . . . . . . . . . . 29

4.3.2. Ajuste de Parametros . . . . . . . . . . . . . . . . . . . . . . . . 29

4.4. Definicion de la arquitectura del sistema . . . . . . . . . . . . . . . . . 32

4.5. Diseno de pruebas unitarias del sistema . . . . . . . . . . . . . . . . . . 33

5. Implementacion y Pruebas 48

5.1. Implementacion y Set Up del Sistema . . . . . . . . . . . . . . . . . . . 48

5.1.1. Implementacion . . . . . . . . . . . . . . . . . . . . . . . . . . . 48

5.1.2. Uso de librerıas externas . . . . . . . . . . . . . . . . . . . . . . 50

5.1.3. Setup . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . 51

5.2. Ejecucion de Pruebas y Estudio de Escalabilidad . . . . . . . . . . . . . 53

5.2.1. Pruebas de Variables de Entorno . . . . . . . . . . . . . . . . . 54

5.2.2. Pruebas de Kafka . . . . . . . . . . . . . . . . . . . . . . . . . . 56

INDICE ix

5.2.3. Pruebas de Streaming K-Means . . . . . . . . . . . . . . . . . . 59

5.3. Eleccion de los datasets publicos . . . . . . . . . . . . . . . . . . . . . . 63

5.3.1. S-Set 1 . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . 65

5.3.2. S-Set 2 . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . 65

5.3.3. S-Set 3 . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . 66

5.3.4. S-Set 4 . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . 66

5.3.5. A-Set 3 . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . 67

5.3.6. Birch 1 . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . 67

6. Resultados 70

6.1. Experimentos . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . 70

6.1.1. Estudio del parametro “decay factor”del algoritmo . . . . . . . 70

6.1.2. Estudio de la aleatoriedad de las predicciones del algoritmo . . . 79

6.1.3. Estudio del rendimiento del algoritmo . . . . . . . . . . . . . . . 80

7. Conclusiones y trabajo futuro 84

7.1. Conclusiones . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . 84

7.1.1. Conclusiones Generales . . . . . . . . . . . . . . . . . . . . . . . 84

7.1.2. Conclusiones Personales . . . . . . . . . . . . . . . . . . . . . . 86

7.2. Impacto. Etica y responsabilidad profesional . . . . . . . . . . . . . . . 87

7.3. Trabajo futuro . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . 88

Bibliografıa 89

Indice de Tablas

4.1. Requisitos Funcionales del Sistema . . . . . . . . . . . . . . . . . . . . 24

4.2. Requisitos No Funcionales del Sistema . . . . . . . . . . . . . . . . . . 25

4.3. PYT-1 Test . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . 34

4.4. JAV-1 Test . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . 34

4.5. SPA-1 Test . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . 35

4.6. ZOO-1 Test . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . 36

4.7. KAF-1 Test . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . 37

4.8. KAF-2 Test . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . 38

4.9. KAF-3 Test . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . 39

4.10. SKM-1 Test . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . 40

4.11. SKM-2 Test . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . 41

4.12. SKM-3 Test . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . 42

4.13. SKM-4 Test . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . 43

4.14. SKM-5 Test . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . 44

4.15. SKM-6 Test . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . 45

4.16. SKM-7 Test . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . 46

4.17. SKM-8 Test . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . 47

x

Indice de Figuras

2.1. Aprendizaje supervisado . . . . . . . . . . . . . . . . . . . . . . . . . . 6

2.2. Aprendizaje no supervisado . . . . . . . . . . . . . . . . . . . . . . . . 7

2.3. Data Stream . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . 8

2.4. Data Stream Clustering . . . . . . . . . . . . . . . . . . . . . . . . . . 10

2.5. Data Stream Classification . . . . . . . . . . . . . . . . . . . . . . . . . 11

2.6. Frequent Pattern Mining . . . . . . . . . . . . . . . . . . . . . . . . . . 11

2.7. Change Detection . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . 12

4.1. Modelado Machine Learning . . . . . . . . . . . . . . . . . . . . . . . . 28

4.2. Modelo Machine Learning . . . . . . . . . . . . . . . . . . . . . . . . . 28

4.3. Modelo de Serializacion . . . . . . . . . . . . . . . . . . . . . . . . . . . 29

4.4. Parametros de entrada . . . . . . . . . . . . . . . . . . . . . . . . . . . 31

4.5. Procesamiento del sistema . . . . . . . . . . . . . . . . . . . . . . . . . 32

4.6. Arquitectura del sistema . . . . . . . . . . . . . . . . . . . . . . . . . . 33

5.1. PYT-1 . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . 54

5.2. JAV-1 . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . 55

5.3. SPA-1 . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . 55

5.4. ZOO-1 . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . 56

5.5. KAF-1 . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . 57

5.6. KAF-2 . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . 57

5.7. KAF-3 PRODUCER . . . . . . . . . . . . . . . . . . . . . . . . . . . . 58

5.8. KAF-3 CONSUMER . . . . . . . . . . . . . . . . . . . . . . . . . . . . 58

5.9. SKM-2 . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . 59

xi

xii INDICE DE FIGURAS

5.10. SKM-1 . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . 60

5.11. SKM-3 . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . 61

5.12. SKM-4 . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . 62

5.13. SKM-5 . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . 62

5.14. SKM-6 . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . 63

5.15. SKM-8 . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . 64

5.16. S-Set 1 . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . 65

5.17. S-Set 2 . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . 66

5.18. S-Set 3 . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . 67

5.19. S-Set 4 . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . 68

5.20. A-Set 3 . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . 68

5.21. Birch 1 . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . 69

6.1. S-Set 1 Decay Factor: 1 . . . . . . . . . . . . . . . . . . . . . . . . . . . 71

6.2. S-Set 1 Decay Factor: 0.5 . . . . . . . . . . . . . . . . . . . . . . . . . . 72







6.9. Tiempo de ejecucion S-Set 1 . . . . . . . . . . . . . . . . . . . . . . . . 81

6.10. Tiempo de ejecucion A-Set 3 . . . . . . . . . . . . . . . . . . . . . . . . 82

6.11. Tiempo de ejecucion Birch 1 . . . . . . . . . . . . . . . . . . . . . . . . 83

Capıtulo 1

Introduccion

En este Proyecto Fin de Grado se ha tratado de compactar una gran parte de los

ambitos y disciplinas trabajadas a lo largo del Grado de Ingenierıa de Software con la

intencion de demostrar, como broche final del grado, el conjunto de conocimientos y

competencias logrados durante estos 4 anos.

Este proyecto se basa en la implementacion y el desarrollo de un algoritmo de anali-

sis de datos que incorpora tecnicas de Machine Learning y que esta disenado para el

trabajo en streaming, esto quiere decir que, el algoritmo es capaz de procesar de una

manera eficiente streams de datos (flujos de datos recibidos en tiempo real). Para la

implementacion de dicho algoritmo se procedera a utilizar un framework muy utilizado

en proyectos parecidos, Apache Spark.

Previamente a la eleccion de este algoritmo se va a realizar un breve estudio de las

diferentes problematicas y soluciones existentes en el ambito del analisis masivo de da-

tos, ası como las diferentes tecnicas y aproximaciones que se utilizan en los algoritmos

de Machine Learning. Finalmente, se realizara un estudio de los diferentes algoritmos

de Machine Learning existentes para estos problemas en la actualidad, de los cuales se

elegira el estudiado en este trabajo.

Para la implementacion del algoritmo se va a utilizar el lenguaje de programacion Scala,

ya que es uno de los lenguajes con los que mayor facilidad se puede trabajar en el fra-

mework Spark. Antes del desarrollo de la aplicacion, se llevara a cabo una planificacion

y diseno con varias fases tıpicas de la Ingenierıa del Software como la extraccion de re-

1

2 CAPITULO 1. INTRODUCCION

quisitos, el modelado del sistema o el diseno de la arquitectura del sistema. Como se ha

explicado anteriormente, la implementacion se apoyara en el framework Apache Spark,

haciendo especial hincapie en su modulo para data streaming (Spark Streaming), del

cual se estudiara su funcionamiento y sus caracterısticas.

Finalmente, se disenaran una serie de pruebas y se llevara a cabo un estudio del desem-

peno del algoritmo implementado, donde se analizaran los resultados obtenidos del

algoritmo en terminos de escalabilidad, rendimiento, eficiencia y calidad de los resul-

tados obtenidos. Para realizar estas pruebas se utilizara un dataset publico con el cual

para medir y comparar las metricas de pruebas mas importantes.

1.1. Motivacion y Justificacion

Hay ciertas motivaciones que me han guiado a la eleccion de este Proyecto Fin de

Grado, siendo la principal de ellas el interes personal que he desarrollado durante los 4

anos en los temas de estudio del proyecto, la Inteligencia Artificial y el “data science”.

Sobre la inteligencia artificial mi interes viene de lejos, antes de empezar el grado ya

sentıa atraccion por este campo. Ademas, hoy en dıa es un tema que se encuentra muy

de moda, teniendo noticias constantes sobre ella incluso en medios de prensa general.

A parte de su popularidad me interesan sus aplicaciones, pienso que la IA se encuentra

todavıa muy verde y aun hay muchos avances por hacer.

Respecto a la ciencia de los datos (“data science”), mi interes surge de forma parecida

a la Inteligencia Artificial, cada dıa se generan una elevada cantidad de datos y estos

datos tienen que ser tratados, por lo que la demanda profesional en este campo se en-

cuentra en constante crecimiento.

Otra de las motivaciones que me llevaron a hacer este trabajo fue la utilizacion de he-

rramientas con las que no tengo experiencia previa, como Apache Spark. Este proyecto

es una oportunidad para mi para el aprendizaje de esta herramienta que es amplia-

mente utilizada en proyectos similares. Spark es una herramienta open-source lo que le

anade un plus de interes. Ademas, puede servir para la realizacion de futuros estudios

o trabajos con ella.

En este contexto, cabe destacar la existencia de otros proyectos desarrollados en la

1.2. OBJETIVOS 3

ETS de Ingenierıa de Sistemas Informaticos guiados por los tutores de este Proyecto,

los cuales estan relacionados con el estudio de tıcnicas y algoritmos de analisis de datos

en streaming. En principio, este conjunto de trabajos ha sido pensado como base para

futuros trabajos en los que se pueda profundizar y/o comparar las diferentes tecnicas

y algoritmos estudiados [Brana, 2018].

1.2. Objetivos

En este apartado se enumeran los objetivos a alcanzar y a los cuales se dirige es-

te proyecto. En primer lugar, se expone el objetivo general del proyecto. Despues se

explicaran otros objetivos mas especıficos y concretos que derivan del objetivo general.

1.2.1. Objetivo general

El objetivo general es el desarrollo de una aplicacion de clasificacion no supervisada

usando el algoritmo streaming K-means para analizar agrupamientos de flujos de datos

(Data Streams) dentro de una plataforma de computacion ultra-escalable.

1.2.2. Objetivos especıficos

1. Estudio del estado del arte del Machine Learning aplicado al Data Streaming.

2. Estudio y analisis de los algoritmos existentes de clustering para Data Streaming.

3. Estudio del algoritmo streaming K-means para el desarrollo de la aplicacion ob-

jetivo de este Proyecto.

4. Desarrollar un sistema de Machine Learning codificando o utilizando una imple-

mentacion del algoritmo en Spark utilizando el modulo Spark Streaming.

5. Realizar las pruebas pertinentes utilizando datasets publicos y probar el compor-

tamiento del sistema con los parametros estandar que miden la calidad de los

resultados.

4 CAPITULO 1. INTRODUCCION

6. Probar el funcionamiento del sistema de Machine Learning dentro de la plataforma

Spark.

7. Analisis de los resultados obtenidos en la clasificacion de los datasets publicos.

1.3. Estructura del documento

Este documento se estructura de la siguiente manera. En primer lugar, el Capıtulo 1

introduce los conceptos teoricos que subyacen al desarrollo de este Proyecto. El Capıtulo

2 expone los conceptos teoricos del Machine Learning y del Data Streaming, en este

capıtulo tambien se explican algunos de los algoritmos utilizados en estos campos. En

el capıtulo 3 se desarrolla el Estado del Arte, en este apartado se explica el algoritmo

escogido para este proyecto, conceptos de Spark y las librerıas que se van a utilizar.

El cuarto capıtulo se trata de la extraccion de requisitos, modelado y desarrollo de

la aplicacion. En el quinto capıtulo se expone la implementacion del algortimo y las

pruebas a las que se va a someter, ası como un estudio de la escalabilidad. El Capıtulo

6 consta de los resultados obtenidos. Por ultimo, se introducen las conclusiones y el

trabajo futuro derivado del desarrollo de este Proyecto.

Capıtulo 2

Marco Teorico

2.1. Introduccion al Machine Learning

El aprendizaje automatico (Machine Learning) es el campo de estudio de la Inteli-

gencia Artificial que brinda a los ordenadores la habilidad de aprender sin ser explıci-

tamente programados (Arthur Samuel, 1959). Por lo tanto, el Machine Learning trata

sobre hacer que los ordenadores modifiquen o adapten sus acciones para que cada vez

se vuelvan mas precisas, donde la precision es medida por como de “bien” las acciones

elegidas se corresponden con las acciones correctas [Marsland, 2009].

La complejidad computacional de los metodos de Machine Learning es tambien de es-

pecial interes a la hora de desarrollar un algoritmo. Es particularmente importante al

usar metodos en datasets muy grandes, que los algoritmos que tengan una complejidad

polinomial o superior en adelante no supongan un problema de tratamiento compu-

tacional. La complejidad es frecuentemente dividida en dos partes: la complejidad del

entrenamiento, y la complejidad al aplicar el algoritmo entrenado. El entrenamiento

no es algo que se este realizando siempre, por lo que no es crıtico en el tiempo, pero

aun ası, puede suponer un tiempo elevado. Sin embargo, a menudo queremos tener una

solucion intermedia (punto de prueba) mientras el algoritmo sigue procesando datos, y

hay potencialmente muchos puntos de prueba cuando un algoritmo esta en uso, por lo

que este necesita tener bajo costo computacional [Marsland, 2009].

5

6 CAPITULO 2. MARCO TEORICO

2.1.1. Tipos de aprendizaje

Al ser el aprendizaje automatico un dominio amplio, el campo del Machine Learning

puede ser dividido en varios subcampos. A continuacion, se describen diferentes criterios

con los que se pueden clasificar los paradigmas de aprendizaje.

El aprendizaje supervisado utiliza conjuntos de datos de entrenamiento etiquetados

con el objetivo de aprender la funcion que mapea el vector formado por las variables

(x1 , x2 , ..., xn) de entrada con la variable de salida (y).

y = f (~x)

Los problemas del aprendizaje supervisado pueden ser de clasificacion o de regre-

sion.

El aprendizaje no supervisado utiliza conjuntos de datos de entrenamiento no eti-

quetados con el objetivo de aprender la estructura subyacente en los mismos, consi-

derando unicamente las variables de entrada. Los problemas del aprendizaje no su-

pervisado pueden ser de asociacion, de agrupacion (clustering), o de reduccion de la

dimensionalidad [Arroyo, 2018].

Figura 2.1: Aprendizaje supervisado

2.1. INTRODUCCION AL MACHINE LEARNING 7

Figura 2.2: Aprendizaje no supervisado

Los paradigmas de aprendizaje pueden variar segun el rol tomado por el algoritmo.

Se distinguen entre algoritmos activos y pasivos. Un algoritmo activo interactua con

el medio en tiempo de entrenamiento, mientras que un algoritmo pasivo solo observa la

informacion ofrecida por el medio sin la influencia directa del mismo [Shalev-Shwartz

and Ben-David, 2014].

La ayuda del supervisor es determinante a la hora del buen funcionamiento del algorit-

mo de Machine Learning. La informacion que le proporciona el supervisor al algoritmo

es crucial para el objetivo de aprendizaje.

Algunos algoritmos de Machine Learning tan solo tienen componente en batch, otros

tienen componente online y componente en batch.


2.2. Conceptos teoricos sobre Data Streaming

Recientemente, las nuevas tecnologıas han permitido a las organizaciones almacenar

y registrar grandes flujos de datos de transacciones. Estos conjuntos de datos que crecen

de manera continua y rapida con el tiempo son conocidos como “streams”. Mientras

que la minerıa de datos se ha convertido en un campo bien establecido en la actualidad,

el problema de los data streams plantea nuevos desafıos que los metodos tradicionales

de data mining no resuelven facilmente, para lo cual se necesitan adaptaciones. El tema

de los data streams es muy reciente y su crecimiento ha sido muy rapido, teniendo hoy

un gran volumen de publicaciones sobre el tema.

Figura 2.3: Data Stream

Definicion 1 Los data streams se definen como volumenes de datos generados a altas

velocidades que con un correcto tratamiento y procesamiento pueden suponer una fuente

de conocimiento a la hora de tomar decisiones en tiempo real [Aggarwal, 2007].

Los avances en la tecnologıa hardware han facilitado la tarea de recoger datos anoni-

2.3. CLASIFICACION DE LOS ALGORITMOS DE CLUSTERING 9

mos continuamente. Transacciones simples del dıa a dıa como utilizar una tarjeta de

credito, una llamada de telefono o navegar en la web desencadenan el almacenamien-

to automatico de datos. Ası, los avances en las tecnologıas de las comunicaciones han

provocado grandes cantidades de flujos de datos a traves de redes IP. En muchos ca-

sos, estas cantidades masivas de datos pueden ser minadas para extraer informacion

relevante e importante para su posterior aplicacion en diferentes aspectos. Cuando el

volumen es verdaderamente grande, la elaboracion de este proceso conlleva una serie

de retos computacionales y de minerıa de datos:

Con el incremento del volumen de los datos, ya no es posible procesar los datos

eficientemente realizando multiples pasadas sobre ellos. Mas bien, solo se puede

procesar un ıtem de datos como maximo una vez. Esto provoca problemas a la hora

de la implementacion de un algoritmo de extraccion. Por lo tanto, los algoritmos

de Stream Mining tienen que ser disenados para que solo se realice una pasada

sobre los datos.

En la mayorıa de los casos, existe un componente temporal inherente para el

proceso de Stream Mining. Esto es debido a que el dato puede cambiar a lo largo

del tiempo. Este comportamiento de los data streams es conocido como localidad

temporal. Por lo tanto, una adaptacion de los algoritmos de data mining de una

pasada puede no ser efectiva a la hora de solucionar esta tarea. Los algoritmos

de Stream Mining necesitan ser cuidadosamente disenados con un foco claro en

la evolucion de los datos que se van a procesar.

2.3. Clasificacion de los Algoritmos de Clustering

2.3.1. Problemas del Data Stream Mining

En esta seccion se presentan los principales problemas del Stream Mining y los

principales desafıos de cada problema.

Definicion 2 El Data Stream Mining consiste en el tratamiento y procesamiento de

cantidades abundantes de datos en tiempo real.


Data Stream Clustering

El Data Stream Clustering consiste en el agrupamiento de objetos similares forman-

do clusters (conjuntos de datos con caracterısticas similares). Se trata de un problema

ampliamente estudiado en el ambito del data mining. Los algoritmos de clustering ar-

bitrario no son faciles de adaptar a Data Streaming porque solo realizan una pasada

sobre los datos. Con estas restricciones puede ser conveniente determinar los clusters

sobre horizontes definidos y no sobre el conjunto completo de los datos. Para resolver

este problema se han desarrollado tecnicas como el micro-clustering [Aggarwal, 2007].

Figura 2.4: Data Stream Clustering

Data Stream Classification

El problema de la clasificacion es quiza uno de los mas estudiados en el contexto de

la minerıa de datos, dado que este se vuelve mas complicado debido a la evolucion de

los data streams. Por lo tanto, se deben crear algoritmos efectivos teniendo en cuenta la

localidad temporal de los datos tratados. Muchos de estos algoritmos son adaptaciones

de los algoritmos clasicos que solo realizan una pasada sobre los datos [Aggarwal, 2007].

2.3. CLASIFICACION DE LOS ALGORITMOS DE CLUSTERING 11

Figura 2.5: Data Stream Classification

Frequent Pattern Mining. El problema de los patrones de frecuencia se basa

en encontrar patrones que se repiten en diferentes tipos de datasets, incluyendo

no estructurados y semi-estructurados. Los patrones puedes ser entre otros se-

cuencias, subarboles o subgrafos. Muchos algoritmos de patrones de frecuencia

han sido desarrollados en la ultima decada [Aggarwal, 2007].

Figura 2.6: Frequent Pattern Mining

Change Detection en Data Streams. Como ya se ha comentado, los patrones

en un data stream pueden evolucionar con el tiempo. En algunos casos, es deseable

seguir y analizar la naturaleza de estos cambios a lo largo del tiempo. Ademas, la

evolucion de los Data Streams tambien puede afectar al comportamiento de los


algoritmos, ya que los resultados pueden quedar obsoletos con el paso del tiempo

[Aggarwal, 2007].

Figura 2.7: Change Detection

Stream Cube Analysis of Multi-dimensional Streams. Muchos de los datos

en stream residen en espacios multidimensionales y con un bajo nivel de abstrac-

cion, mientras que los analistas estan interesados en relativamente altos niveles de

abstraccion con cambios dinamicos en algunas combinaciones de las dimensiones.

Para descubrir caracterısticas evolutivas y dinamicas de alto nivel es necesario la

realizacion de procesamientos analıticos multinivel y multidimensionales en lınea

de Data Streams (OLAP). Esta necesidad es una llamada para la investigacion

de nuevas arquitecturas que podrıan facilitar el procesamiento analıtico online de

Data Streams multidimensionales [Aggarwal, 2007].

Loadshedding in Data Streams. Ya que los Data Streams son generados por

procesos externos a la aplicacion que los procesa, el control de la frecuencia del

stream entrante es imposible. Por lo tanto, es necesario que el sistema tenga

2.4. ALGORITMOS DE STREAM CLUSTERING 13

capacidad de adaptacion a una frecuencia de procesamiento variable. Una de las

tecnicas utilizadas es ((load shedding)) que consiste en la eliminacion de tuplas sin

procesar para reducir la carga del sistema [Aggarwal, 2007].

Slidding Window Computations in Data Streams. Muchas de las estructu-

ras que se utilizan en los algoritmos de data stream mining utilizan todo el data

stream para ser construidas. El modelo computacional Sliding Window (venta-

na deslizante) es motivado por el supuesto de que los datos recientes son mas

importantes en la computacion de los Data Streams. Por lo tanto, el analisis y

procesamiento sobre se hace sobre una parte fijada historica del Data Stream

[Aggarwal, 2007].

Dimensionality Reduction and Forecasting in Data Streams. Debido a la

inherente naturaleza temporal de los Data Streams, los problemas de reduccion

de dimensionalidad y pronostico son particularmente importantes. Cuando hay

un gran cantidad de flujo de datos simultaneos, podemos utilizar correlaciones

entre diferentes flujos de datos con el fin de hacer predicciones efectivas sobre el

comportamiento futuro del flujo de datos [Aggarwal, 2007].

Distributed Mining of Data Streams. En muchas ocasiones, los streams de

datos son generados en multiples nodos de computacion distribuidos. Analizar

y monitorizar los datos en estos entornos requiere tecnologıa de Data Mining

que requiere la optimizacion de una variedad de criterios como el coste de la

comunicacion entre los diferentes nodos [Aggarwal, 2007].

2.4. Algoritmos de Stream Clustering

En esta seccion se procede a analizar cuatro algoritmos de Data Stream Mining

utilizados actualmente. La clasificacion de estos algoritmos depende de las estructuras

de datos que utilizan: microclusters, arboles de conjuntos de datos o matrices.


2.4.1. Hoeffding Tree for Streaming Classification (Arboles de

decision)

La aproximacion para streaming del arbol de decision se llama Hoeffding Tree. El

nombre deriva del lımite de Hoeffding. La idea principal es que el lımite de Hoeffding

proporciona cierto nivel de confiaza en el mejor atributo para dividir el arbol. Los

Hoeffding trees pueden desarrollarse en tiempo constante por cada ejemplo (que en el

peor de los casos es proporcional al numero de atributos) mientras que son casi identi-

cos a los arboles que un learner convencional en batch producirıa teniendo suficientes

ejemplos. La probabilidad de que un Hoeffding tree y un arbol convencional elijan dife-

rentes decisiones en algun nodo disminuye exponencialmente con el numero de ejemplos

analizados. [Domingos and Hulten, 2000]

Hoeffding tree induction algorithm.

for all training examples do

Sort example into leaf l using HT

Update sufficient statistics in l

Increment nl, the number of examples seen at l

if nl mod nmin = 0 and examples seen at l not all of same class then

Compute Gi(Xi) for each attribute

Let Xa be attribute with highest Gl

Let Xb be attribute with second-highest Gl

Compute Hoeffding bound ε =

√R2 ln( 1

δ)

2nl

if Xa 6= X0and(Gl(Xa)−Gl(Xb) > ε or ε < τ) then

Replace l with an internal node that splits on Xa

for all branches of the split do

Add a new leaf with initialized sufficient statistics

end for

end if

end if

end for

2.4. ALGORITMOS DE STREAM CLUSTERING 15

2.4.2. CLUSTree (Microclustering)

ClusTree es un algoritmo de Stream Clustering que se encarga de la agrupacion de

datos semejantes en clusters utilizando la tecnica del microclustering. El algoritmo

almacena el numero de datos, la suma lineal y la suma cuadratica como una tupla. Esta

tupla es un atributo del cluster. El algoritmo le da mayor peso a los datos mas recientes

considerando ası la edad de los objetos. Con las tuplas se puede calcular parametros

estadısticos necesarios para el clustering.

Posteriormente, se crea una estructura para indexar los datos, esta estructura de datos

es del tipo arboles R. Cuando llega un dato, el algoritmo desciende en el arbol tenien-

do en cuenta la distancia mınima entre el dato y la tupla, insertando el dato en el

microcluster a nivel de las hojas mas cercano en ese momento [Hesabi et al., 2015].

2.4.3. DenStream (Microclustering basado en densidad)

Es un algoritmo con una componente online para el mantenimiento del microcluster

y una componente offline que genera los clusters definitivos a demanda del usuario.

El microcluster ((denso)) (llamado core-microcluster) es introducido para resumir los

clusters con tamano arbitrario. El potencial core-microcluster y las estructuras de mi-

crocluster de anomalıas (outliers) son propuestos para mantener y distinguir clusters y

anomalıas [Cao et al., 2006].

2.4.4. D-Stream (Basado en densidad)

Es un algoritmo para clustering de datos en streaming basado en densidad. El al-

goritmo utiliza una componente online que coloca cada dato entrante en una matriz, y

una componente offline que calcula la densidad de la matriz y agrupa basandose en la

densidad.

El algoritmo captura los cambios dinamicos de un Data Stream. Aprovechando las re-

laciones entre el factor de descomposicion, la densidad y la estructura del cluster. Este

algoritmo puede generar y ajustar los clusteres de manera eficiente y efectiva en tiempo

real. Ademas, se ha desarrollado una tecnica teorica solida para detectar y eliminar

matrices esporadicas asignadas por valores atıpicos con el fin de mejorar drasticamente


la eficiencia de espacio y tiempo del sistema. La tecnica hace factible la agrupacion de

flujos de datos de alta velocidad sin degradar la calidad de la agrupacion. Los resultados

experimentales del algoritmo tienen una calidad y eficiencia superiores, puede encon-

trar grupos de formas arbitrarias y puede reconocer con precision los comportamientos

evolutivos de los Data Streams en tiempo real.

D-Stream

tc = 0;

initialize an empty hash table grid list;

while data stream is active do

read record x = (x1, x2, ..., xd);

dtermine the density grid g that contains x;

if (g not in grid list insert g to grid list)

update the characteristic vector of g;

if tc == gap then

call initial clustering(grid list)

end if

if tcmodgap == 0gap then

detect and remove sporadic grids from grid list

call adjust clustering(grid list);

end if

tc = tc + 1;

end while

[Aggarwal, 2013][Chen and Tu, 2007].

Capıtulo 3

Estado del Arte

3.1. Streaming K-means: Adaptacion del algoritmo

K-means a streaming

El algoritmo K-means es uno de lo mas utilizados para resolver el problema de

clustering euclıdeo. El objetivo de este algoritmo es encontrar k centros de clusters

cuya suma de los cuadrados de las distancias de los puntos al centro mas cercano sea

mınima. El problema de resolver este objetivo es NP-completo. Este algoritmo consta

de dos fases, union y reduccion.

La fase de union es realizada por el arbol de conjunto de datos, considerando que este

reduce 2m objetos a m objetos. La fase de reduccion es realizada por otra estructura

de datos, llamada bucket set, que es un conjunto de L buckets (tambien conocidos como

buffers), donde L es un parametro de entrada. Cada bucket puede almacenar m objetos.

Cuando un nuevo objeto llega, es almacenado en el primer bucket. Si el primer bucket

esta completo, todos sus datos se trasladan al segundo bucket. Si el segundo bucket esta

completo, se computa una union, lo que significa que, los m objetos en el primer bucket

se unen con los m objetos del segundo bucket, resultando en 2m objetos, los cuales son

reducidos por la construccion del arbol del conjunto de datos previamente detallado.

Los m objetos resultantes son almacenados en el tercer bucket, a no ser que este ya

se encuentre lleno, en este caso una nueva union-reduccion serıa necesaria [Ackermann

et al., 2012].

17

18 CAPITULO 3. ESTADO DEL ARTE

Streaming K-means

Input: New object xj, bucket set B =⋃Li=1Bi, size m

B0 = B0 ∪ (xj);

if (|B0| ≥ m) then

create temporary bucket Q;

Q = B0;

B0 = 0;

i = 1;

while Bi 6= 0 do

Q = coresetReduction(Bi ∪Q);

Bi = 0;

i = i+ 1;

end while

Bi = Q;

Q = 0;

end if

3.2. Apache Spark

Apache Spark es una plataforma de computacion en cluster disenada para ser rapida

y de proposito general [Karau et al., 2015].

Rapidez: Spark contiene un modelo conocido como MapReduce para soportar

eficientemente un mayor tipo de computaciones, entre las que se encuentran las

consultas interactivas o el procesamiento en stream. La velocidad es importante

a la hora de procesar grandes cantidades de datos ya que puede suponer la dife-

rencia entre explorar los datos interactivamente o esperar minutos u horas. Una

de las principales caracterısticas que Spark ofrece para la velocidad, es la habili-

dad de hacer computos en memoria, pero el sistema es tambien mas eficiente que

MapReduce para aplicaciones complejas corriendo en disco.

3.2. APACHE SPARK 19

Proposito general: Spark esta disenado para cubrir un amplio rango de cargas

de trabajo que previamente requieren de sistemas distribuidos separados, inclu-

yendo aplicaciones en batch, algoritmos iterativos, consultas interactivas y strea-

ming. Soportando estas cargas de trabajo en el mismo motor, Spark hace sencillo

y barato combinar diferentes tipos de proceso, lo que habitualmente es necesario

en la produccion de tuberıas (pipelines) de cargas de trabajo. Ademas reduce

la carga administrativa de mantener diferentes herramientas separadas. El motor

central de Spark es el responsable de programar, distribuir y monitorizar aplicacio-

nes, consistiendo en muchas tareas computacionales a traves de varias maquinas

o un cluster computacional. Estos componentes han sido disenados para poder

utilizarse conjuntamente como si fuesen librerıas.

Spark esta disenado para ser altamente accesible, por lo que ofrece APIs en Python,

Java, Scala y SQL, ademas de una gran cantidad de librerıas. Tambien se integra facil-

mente con otras herramientas Big Data, en particular Spark puede correr en clusters

Hadoop y acceder a cualquier fuente de datos Hadoop, incluyendo Cassandra. El pro-

yecto Spark contine multiples componentes estrechamente integrados

3.2.1. Spark Core

Spark Core contiene la funcionalidad basica de Spark, incluye componentes para las

tareas de planificacion, gestion de memoria, recuperacion ante fallos e interaccion de

sistemas de almacenamiento entre otras. Spark Core es tambien donde reside la API que

define los resilient distributed datasets (RDDs), que son la abstraccion de la estructura

de datos sobre la cual Spark trabaja. Los RDDs representan una coleccion de ıtems

distribuidos a lo largo de muchos nodos computacionales que pueden ser manipulados

en paralelo. Spark Core proporciona distitas APIs para construir y manipular estas

colecciones. Los RDDs soportan dos tipos de operaciones: transformaciones y acciones,

las transformaciones son operaciones que devuelven un nuevo RDD, como map() o

filter() y las acciones son operaciones que devuelven un resultado al driver del programa

o lo almacenan externamente [Karau et al., 2015].


3.2.2. Spark Streaming

Spark Streaming es el componente de Spark que habilita el procesamiento de los

data streams en tiempo real. Permite a los usuarios escribir aplicaciones en streaming

utilizando una API muy similar a los trabajos en batch, ya que reutiliza muchas de las

propiedades, e incluso codigo que se crearon para ellas.

Al igual que Spark utiliza el concepto de RDDs a traves de una abstraccion llamada

DStreams o streams discretizados. Un DStream es una secuencia de datos que llegan a lo

largo del tiempo, cada DStream es representado como una secuencia de RDDs llegando

en cada periodo de tiempo (es por esto que son discretizados). Los DStreams pueden

ser creados desde diferentes fuentes de entrada, como Flume, Kafka o HDFS. Una vez

construidos ofrecen dos tipos de operaciones: transformaciones, que producen un nuevo

DStream, y operaciones de salida, que escriben los datos a un sistema externo.

Los DStreams proporcionan muchas de las operaciones disponibles sobre RDDs, ademas

de nuevas operaciones relacionadas con el tiempo tales como la sliding window.

A diferencia de los programas en batch, las aplicaciones de Spark Streaming necesitan

una puesta a punto adicional para poder operar las 24 horas del dıa.

Spark Streaming esta disponible solo en Java y Scala. En Python se encuentra en una

fase experimental [Karau et al., 2015].

3.2.3. MLLIB

MLlib es la librerıa de funciones de aprendizaje automatico de Spark. Disenada para

funcionar en paralelo en clusters, MLlib contiene una variedad de algoritmos de apren-

dizaje y es accesible desde todos los lenguajes de programacion de Spark.

El diseno y la filosofıa de MLlib es simple: permite invocar varios algoritmos en

datasets distribuidos, representando todos los datos como RDDs. Esta librerıa intro-

duce tipos especıficos de datos que seran utilizados por los algoritmos, como puntos o

vectores.

Un apunte importante sobre MLlib es que contiene solo algoritmos distribuidos que

3.2. APACHE SPARK 21

funcionan bien en clusters. Algunos de los algoritmos clasicos de Machine Learning no

estan incluidos porque no fueron originalmente disenados para plataformas en paralelo.

Por otra parte, MLlib contiene bastantes algoritmos recientes para clusters, como K-

means, bosques aleatorios distribuidos y mınimos cuadrados alternantes. Esto significa

que MLlib esta pensado para ejecutar algoritmos con datasets grandes [Karau et al.,

2015].

3.2.4. Spark SQL

Spark SQL es una interfaz para trabajar con datos tanto estructurados como se-

miestructurados. Un dato estructurado es todo aquel que tiene un schema. Cuando se

tienen datos estructurados, Spark SQL hace mas eficiente y mas sencillo la carga y

consulta de los datos, en particular, Spark SQL ofrece tres caracterısticas principales:

1. Permite una fuerte integracion entre SQL y el codigo, incluyendo la habilidad

de unir RDDs y tablas SQL, exponer funciones personalizadas en SQL y otras

caracterısticas.

2. Permite la carga de datos desde una gran diversidad de fuentes estructuradas

(JSON, Hive, Tables y Parquet).

3. Permite la consulta de datos desde SQL tanto dentro del programa Spark como

desde herramientas externas.

[Karau et al., 2015].

3.2.5. Instalacion de Spark en Windows

Para el correcto funcionamiento de Spark en Windows es necesaria la instalacion/ob-

tencion de diversos componentes, entre los que se encuentran el Java Development Kit

8, el propio Spark y los ficheros binarios de Hadoop correspondientes con la version de

Spark descargada.

El primer paso es descargar el JDK8, correspondiente (32 o 64 bits) desde la pagina

oficial de Oracle [Oracle, 2018] instalarlo y anadir la variable de entorno JAVA HOME,


con la ruta de instalacion.

Posteriormente desde la pagina de Apache Spark [Apache, 2018b] se descarga la re-

lease 2.4.0 con pre-built para Apache Hadoop 2.7, se trata de un archivo con extension

tgz que hay que descomprimir dos veces, se descomprime en la carpeta deseada y se

anade la variable de entorno SPARK HOME, con la ruta correspondiente.

En tercer lugar se descargan los binarios de Hadoop 2.7.1 desde el siguiente reposi-

torio [Steve Loughran, 2018], el ejecutable descargado se coloca dentro de una carpeta

llamada bin, esta a su vez dentro de una llamada winutils, al igual que en los anterio-

res pasos, se anade la variable de entorno HADOOP HOME, con la ruta a la carpeta

winutils.

Una vez winutils este disponible, se crea la carpeta C:\tmp\hive y se le dan permisos

desde un Terminal abierto como administrador, desde la carpeta bin de winutils y se

ejecuta el siguiente comando, para proporcionar permisos de escritura sobre la carpeta:

winutils.exe chmod -R 777 C:\tmp\hive

En este punto se edita la variable de entorno Path, anadiendo %SPARK HOME %\bin.

Si tras estos pasos, en una terminal escribimos spark-shell y nos aparece la Shell

de Scala para Spark, significara que Apache Spark se habra instalado correctamente y

estara listo para su uso.

Capıtulo 4

Desarrollo de la Aplicacion

4.1. Analisis de Requisitos

En este apartado se procede a la documentacion de requisitos del sistema. Los re-

quisitos se van a clasificar en dos categorıas, requisitos funcionales y requisitos no fun-

cionales, a cada requisito se le va a asignar un ID, un nombre, se describira brevemente

y se le asignara una prioridad.

4.1.1. Requisitos Funcionales

Los requisitos funcionales son declaraciones de servicios que el sistema debe pro-

porcionar, como debe reaccionar a particulares entradas de informacion y como debe

comportarse en determinadas situaciones [Sommerville, 2013].

23

24 CAPITULO 4. DESARROLLO DE LA APLICACION

ID NOMBRE DESCRIPCION PRIORIDAD

RF1Generacion de

datos.

El sistema debe recoger datosde un dataset de clustering con datos

sin clasificar y generar registros para serenviados a una plataforma de streaming.

Media

RF2Envıo de

datos.

El sistema debe enviar los registrosgenerados a una plataforma de streaming

para ser utilizados por el algoritmo.Media

RF3Analisis de

datos.

El algoritmo debe analizar losdatos de entrada recogidos y calculara partir de ellos unos agrupamientos

con identidad de cluster.

Alta

RF4Almacenamiento

de resultados.

El algoritmo debe almacenar losresultados deserializados en ficheros

externos.Baja

RF5Configuracion de

produccion dedatos en streaming.

El sistema permite configurar laproduccion de datos, ası como lacantidad de datos enviados y el

dataset utilizado.

Media

RF6Configuracion del

algoritmo.

El sistema permite configurar diferentesparametros del algoritmo relacionadoscon su ejecucion, ası como parametrosde configuracion de Spark Streaming y

de conexion con Kafka.

Media

RF7Generacion iterativa

de datos.

Los datos del sistema se produciran yenviaran iterativamente, imitando a

un data stream.Media

RF8Analisis de datos

iterativos.El algoritmo implementado analizaraiterativamente los datos de entrada.

Alta.

RF9Clasificacion

de datos.El sistema genera ficheros log donde

quedan registradas las tareas que ejecute.Baja

RF10Evaluacion de

resultados.El sistema evaluara la calidad de resultadosdel algoritmo utilizando distintas metricas.

Alta

Tabla 4.1: Requisitos Funcionales del Sistema

4.1. ANALISIS DE REQUISITOS 25

4.1.2. Requisitos no Funcionales

Los requisitos no funcionales son restricciones en los servicios o funciones ofrecidos

por el sistema. Incluyen restricciones de tiempo, en el proceso de desarrollo e impuestas

por estandares. Los requisitos no funcionales frecuentemente afectan al sistema en su

conjunto, en vez de a un determinado servicio o caracterıstica de este [Sommerville,

2013].

ID NOMBRE DESCRIPCION PRIORIDAD

RNF1Paralelismo de analisis

generacion de datos

El algoritmo y los productores debenpoder ejecutarse a la vez.

Los datos que los productores envıanes consumida por el componente Machine

Learning en tiempo real.

Alta

RNF2Ajuste de rendimientode generacion de datos.

Un productor debe poder generary enviar datos a la velocidad que se

especifique como argumento de entrada.Media

RNF3Algoritmo streaming

K-means.

Para la elaboracion del clusteringse debera utilizar el algoritmo

streaming K-means de la librerıaMLLib de Spark.

Alta

RNF4Comunicacion

asıncrona.

El algoritmo y los productoresde datos mantienen una comunicacion

asıncrona para transmitir losdatos generados.

Media

RNF6 Tolerancia a fallos.

El algoritmo debe seguir funcionandoaunque ocurran fallos asumibles en

su ejecucion y provocaruna parada segura si ocurre un fallo

que afecte a la integridad del sistema.

Media

RNF7 Portabilidad.

El algoritmo debe analizar los datosde entrada recogidos y calcular

a partir de ellos unos agrupamientoscon identidad de cluster.

Alta

Tabla 4.2: Requisitos No Funcionales del Sistema


4.2. Descripcion del algoritmo streaming K-means

El algoritmo streaming K-means se trata de una adaptacion del algoritmo K-means

para datos en streaming.

Los algoritmos K-means dividen las instancias de datos de entrada en clusteres de ma-

nera que se minimiza una metrica relativa a los centroides de los grupos. La distancia

total entre todos los objetos y sus centroides es la metrica mas comun utilizada en los

algoritmos K-means.

Informalmente, el algoritmo K-means se describe a continuacion:

1. Colocar los puntos en el espacio de datos que se esta agrupando. Estos puntos

representan los centroides del grupo inicial.

2. Asignar cada instancia de datos de entrada al grupo que tenga el centroide mas

cercano.

3. Cuando todas las instancias de entrada hayan sido asignadas, volver a calcular

las posiciones de cada uno de los k-centroides tomando el promedio de los puntos

asignados para ello

4. Repetir los pasos 2 y 3 hasta que la metrica a minimizar ya no disminuya. [Bifet,

2010]

Sin embargo, este algoritmo no se puede utilizar para datos en streaming, pero existen

adaptaciones para realizar este proposito. Cuando los datos llegan en streams, podemos

querer estimar los clusters dinamicamente, actualizandolos a medida que llegan nuevos

datos. La adaptacion del algoritmo para streaming tiene una serie de parametros para

controlar el factor de “descomposicion” (decay) de las estimaciones. En cuanto a la

actualizacion de los clusters el algoritmo utiliza una aproximacion similar a K-means.

Para cada lote de datos, se asignan todos sus puntos a su cluster mas cercano, se

calculan nuevos centros del cluster y luego se actualiza cada cluster utilizando:

ct+1 = ctntα+xtmtntα+mt

4.3. DEFINICION DEL MODELO DEL SISTEMA DE MACHINE LEARNING 27

nt+1 = nt +mt

Donde ct es el centro anterior para el cluster, nt es el numero de puntos asignados al

cluster hasta ahora, xt es el nuevo centro de cluster del batch actual, y mt es el numero

de puntos agregados al cluster en el batch actual. El factor de descomposicion α puede

ser utilizado para ignorar el pasado: con α = 1, todos los datos se utilizaran desde el

principio, con α = 0 solo se utilizaran los datos mas recientes. Esto es analogo a una

media movil ponderada exponencialmente.

La descomposicion se podra especificar utilizando el parametro halfLife, que deter-

mina el factor de descomposicion correcto, de modo que, para los datos adquiridos en

el tiempo t, su contribucion por el tiempo t + halfLife se haya reducido a 0,5. La

unidad de tiempo se puede especificar como lotes o puntos y la regla de actualizacion

se ajustara como corresponde [Apache, 2018e].

4.3. Definicion del modelo del Sistema de Machine

Learning

Este sistema de Machine Learning es un modelo adapatado a streaming. El sistema

recibe un dataset de entrada por lotes, en datastreams, cada porcion de datos recibida

en un instante de tiempo entrena al modelo machine learning, el conjunto de los modelos

de entrenamiento conforman el modelo entrenado. Al ser una aplicacion en streaming,

el modelo se entrena y se utiliza conforme vayan llegando datastreams tal y como se

puede apreciar en la siguiente figura:


Figura 4.1: Modelado Machine Learning

En este apartado se va a explicar el modelado y estructura del sistema Machine

Learning que se ha desarrollado en la aplicacion. Este sistema esta compuesto por 5

partes diferenciadas, cada una con un proposito unico y distinto a las otras como ilustra

la siguiente figura:

Figura 4.2: Modelo Machine Learning


4.3.1. Serializacion

La serializacion es el componente del sistema que se encarga de que la informacion

de entrada sea codificada de manera correcta para que pueda ser utilizada. Al tratarse

de una aplicacion en streaming la serializacion debe ser eficiente para poder manejar

grandes volumenes de datos.

Los datos de entrada del sistema se introducen a traves de Apache Kafka [Apache,

2018a]. Kafka es un gestor de colas de mensajes que funciona siguiendo un patron

productor-consumidor. El sistema recibe los datos de la cola de Kafka (conocida como

topics) y los solicita.

Todos los registros de Kafka se componen de un clave numerica correpondiente al ti-

mestamp de la insercion del dato en Kafka y un valor correspondiente a un String

compuesto por los valores del registro.

Figura 4.3: Modelo de Serializacion

4.3.2. Ajuste de Parametros

El sistema recibe otros datos de entrada ademas de los datos a utilizar, se trata

de los parametros de configuracion del sistema. Estos datos indican el valor de los

diferentes parametros que pueden ser configurados en el sistema. Modificandolos se

puede parametrizar la ejecucion del sistema Machine Learning. En este sistema los

parametros se dividen en tres grupos:


Parametros de Kafka

Parametros para la configuracion de la conexion con el servidor Kafka:

Host: Direccion IP en la que se encuentra alojada el servidor Kafka.

Port: Puerto en el que se encuentra el servidor Kafka.

Topic: Cola de los registros de Kafka de la cual el consumidor toma los datos.

Replication Factor: El factor de replicacion determina cuantas copias de segu-

ridad desea crear para un topic en el cluster Kafka.

Partitions: Las particiones en Kafka son como grupos dentro de un topic que se

utilizan para mejorar el equilibrio de la carga de trabajo cuando se tratan grandes

cantidades de datos.

Parametros de Spark

Parametros para la configuracion del contexto Spark. En el caso de este sistema se

trata de un contexto Spark Streming:

Master: URL del cluster al que se debe conectar. En nuestro caso sera local[*] ya

que se va a ejecutar en local utilizando la unidad de procesamiento de la maquina

sobre la que corre.

App Name: Nombre de la aplicacion Spark.

Frequency: Frecuencia (en microsegundos )con la que se ejecutan los batches en

la aplicacion. Es la frecuencia con la que la aplicacion ejecuta un procesamiento

entero de la aplicacion con los datos de entrada disponibles hasta ese momento.

Parametros de streaming K-means

Parametros para la configuracion del algoritmo streaming K-means:

k: Es el numero de clusters deseado, hay que tener e cuenta que es posible que

sean devueltos menos clusters que k.


Decay Factor: Es el factor de descomposicion del algoritmo. Este factor deter-

mina lo propensos que son al cambio los centros de los clusters.

Random Centers: Numero de centros aleatorios, se deben indicar el numero de

dimensiones de los datos.

Figura 4.4: Parametros de entrada

Procesamiento

El procesamiento es la parte del sistema que como su nombre indica se encarga

de procesar los datos que le llegan en tiempo real en forma de data-streams. Para

el procesamiento se va a utilizar un paquete de la librerıa MLLib de Spark llamado

StreamingKMeans, que nos proporciona una implementacion del algoritmo a utilizar.

Como la ejecucion de Spark Streaming se realiza a traves de lotes, el procesamiento de

los datos no se produce en el instante preciso en el que llegan sino que se ejecutan todos

los datos que han llegado en el tiempo de carga de cada lote de manera conjunta.


Figura 4.5: Procesamiento del sistema

Salida

Los clusters resultantes de cada ejecucion seran deserializados y guardados. De esta

forma, se simplifica el proceso del analisis de resultados.

4.4. Definicion de la arquitectura del sistema

El sistema software que se va a desarrollar se encuentra soportado por el framework

Apache Kafka. Anteriormente se ha explicado que Spark es un conjunto de herramientas

computacionales ultraescalables y de proposito general para el tratamiento de grandes

volumenes de datos. Spark y su arquitectura esta basado en el modelo MapReduce.

MapReduce es un modelo de programacion funcional pensado para ser utilizado en

clusters de ordenadores para el tratamiento y procesamiento de grandes volumenes de

datos.

La arquitectura del sistema sigue un patron de arquitectura Pipes & Filters. Este patron

consiste en descomponer las tareas que ejecutan procesos complejos en una serie de

4.5. DISENO DE PRUEBAS UNITARIAS DEL SISTEMA 33

elementos separados que pueden ser reusados. A estos elementos se les denomina filtros.

El formato de los datos que los filtros reciben y envıa se encuentra estandarizado, para

ası poder combinar estos filtros dentro de un pipeline (tal y como ocurre con los RDD

de Spark). Ademas, si la entrada y salida de los filtros esta estructurada como un

stream, la ejecucion de cada filtro se puede paralelizar. Cada filtro pasa los resultados

que va generando al siguiente filtro, que los empieza a procesar, sin tener por que haber

terminado el primer filtro su proceso [Brana, 2018].

Figura 4.6: Arquitectura del sistema

4.5. Diseno de pruebas unitarias del sistema

En este apartado se va a desarrollar un conjunto de pruebas que seran aplicadas

sobre el sistema para la comprobacion del correcto funcionamiento del mismo y su es-

calabilidad, ası como pruebas de esfuerzo.

Se ha realizado una seleccion de las pruebas mas significativas aunque se han realizado

muchas otras que no se encuentran reflejadas en el documento.

Las pruebas que se van a llevar a cabo son de caja negra, esto significa que teniendo

unas variables de entrada, se esperan unas variables de salida determinadas, sin saber

en ningun momento lo que ocurre dentro del sistema.


IDENTIFICACION PYT-1 FECHA: 16/12/2018

DESCRIPCION Comprobacion de la correcta instalacion de Python.PRIORIDAD Media

PRECONDICIONES Python instalado.ENTRADAS -

RESULTADOS ESPERADOSRESTRICCIONES

YDEPENDENCIAS

-

CRITERIOSDE

ACEPTACION

Al ejecutar el comando Python -Vse muestra la version de Python.

PASOS DE LA PRUEBA1. Abrir CMD2. Escribir python -V

CASOS DE PRUEBA RELACIONADOS-

Tabla 4.3: PYT-1 Test

IDENTIFICACION JAV-1 FECHA: 16/12/2018

DESCRIPCION Comprobacion de la correcta instalacion de Java.PRIORIDAD Alta

PRECONDICIONES Java instalado.ENTRADAS -


YDEPENDENCIAS

Editar la variable de entorno y anadir JAVA HOME,

CRITERIOSDE

ACEPTACION

Al ejecutar el comando java -versionen cmd, este devuelve la version intalada de java.

PASOS DE LA PRUEBA1. Abrir CMD2. Ejecutar el comando java -version


Tabla 4.4: JAV-1 Test


IDENTIFICACION SPA-1 FECHA: 16/12/2018

DESCRIPCION Comprobacion de la correcta instalacion de Spark.PRIORIDAD Alta

PRECONDICIONESSpark instalado.Java instalado.

ENTRADAS -RESULTADOS ESPERADOS

RESTRICCIONESY

DEPENDENCIAS

Editar la variable de entorno yanadir SPARK HOME y HADOOP HOME.

CRITERIOSDE

ACEPTACION

Al ejecutar el comando spark-shellse abre la consola Spark de Scala.

PASOS DE LA PRUEBA1. Abrir CMD2. Escribir spark-shell


Tabla 4.5: SPA-1 Test


IDENTIFICACION ZOO-1 FECHA: 15/01/2019

DESCRIPCIONComprobacion del correcto funcionamiento dezookeeper.

PRIORIDAD AltaPRECONDICIONES Zookeeper instalado.


RESTRICCIONESY

DEPENDENCIAS

Kafka instalado (ya que en nuestro caso,zookeeper se encuentra dentro de Kafka)

CRITERIOSDE

ACEPTACION

Al ejecutar el comando de inicio del serverzookeeper, este se ejecuta.

PASOS DE LA PRUEBA1. Abrir CMD2. Dirigirse hasta C:\kafka\bin3. Ejecutar el comando: zookeeper-server-start ..\config\zookeeper.properties


Tabla 4.6: ZOO-1 Test


IDENTIFICACION KAF-1 FECHA: 15/01/2019

DESCRIPCIONComprobacion del correcto funcionamiento del servidorKafka.

PRIORIDAD AltaPRECONDICIONES Zookeeper lanzado.


RESTRICCIONESY

DEPENDENCIAS-

CRITERIOSDE

ACEPTACION

Al ejecutar el comando de inicio del serverKafka, este se ejecuta.

PASOS DE LA PRUEBA1. Abrir CMD2. Dirigirse hasta C:\kafka\bin3. Ejecutar el comando:kafka-server-start ..\config\server.properties

CASOS DE PRUEBA RELACIONADOSZOO-1

Tabla 4.7: KAF-1 Test



DESCRIPCIONIntentar lanzar Kafka sin haber lanzado el servidorZookeeper.

PRIORIDAD BajaPRECONDICIONES -


RESTRICCIONESY

DEPENDENCIAS-

CRITERIOSDE

ACEPTACIONFallo al ejecutar el servidor Kafka.

PASOS DE LA PRUEBA1. Abrir CMD2. Dirigirse hasta C:\kafka\bin3. Ejecutar el comando:kafka-server-start ..\config\server.properties

CASOS DE PRUEBA RELACIONADOSZOO-1




DESCRIPCIONCrear un producer y un consumer en Kafka para probarsu funcionalidad.

PRIORIDAD BajaPRECONDICIONES Zookeeper lanzado.


RESTRICCIONESY

DEPENDENCIAS

El producer y el consumer deben trabajar sobre elmismo topic.

CRITERIOSDE

ACEPTACION

Tras crear el producer y el consumer, los mensajes queenvıa el producer, son visualizados en el consumer.

PASOS DE LA PRUEBA1. Abrir CMD2. Dirigirse hasta C:\kafka\bin3. Crear topic:kafka-topics –create –bootstrap-server localhost:9092–replication-factor 1 –partitions 1 –topic test4. Crear productorkafka-console-producer.sh –broker-list localhost:9092 –topic test5. Crear consumidorkafka-console-consumer.sh –bootstrap-server localhost:9092–topic test –from-beginning6. Lanzar mensaje desde el productor.

CASOS DE PRUEBA RELACIONADOSZOO-1 KAF-1



IDENTIFICACION SKM-1 FECHA: 06/03/2019

DESCRIPCIONEjecutar el algoritmo utilizando un dataset de prueba,colocando los ficheros en dos puertos TCP.

PRIORIDAD Media

PRECONDICIONESFicheros colocados en puertos TCP

utilizando ncat.

ENTRADASkmeans-train.txtkmeans-test.txt


YDEPENDENCIAS

El fichero kmeans-train.txt contiene Vectoresy el fichero kmeans-test.txt contiene LabeledPoints.

CRITERIOSDE

ACEPTACIONEl algoritmo imprime los clusters.

PASOS DE LA PRUEBA1. Abrir CMD2. Colocar con ncat los ficheros en los respectivos puertos.3. Lanzar la aplicacion desde el IDE.


Tabla 4.10: SKM-1 Test



DESCRIPCIONEjecutar el algoritmo utilizando un dataset de prueba,colocando los ficheros en dos puertos,uno de los puertos es incorrecto.

PRIORIDAD Baja

PRECONDICIONESFicheros colocados en puertos TCP

utilizando ncat.

ENTRADASk-means-train.txtk-means-test.txt


YDEPENDENCIAS


CRITERIOSDE

ACEPTACION

El algoritmo no es capaz deimprimir los clusters ya que

no encuentra uno de los ficheros.


CASOS DE PRUEBA RELACIONADOSSKM-1




DESCRIPCIONEjecutar el algoritmo utilizando un dataset de prueba,colocando los ficheros en dos puertos,uno de los puertos es incorrecto.

PRIORIDAD Baja

PRECONDICIONESFicheros colocados en puertos TCP utilizando ncat.Uno de los puertos es incorrecto.



YDEPENDENCIAS


CRITERIOSDE

ACEPTACION

El algoritmo no es capaz de imprimir los clusters ya queuno de los ficheros no tiene el formato esperado.


CASOS DE PRUEBA RELACIONADOSSKM-1 SKM-2




DESCRIPCIONEjecutar el algoritmo utilizando un dataset de prueba,utilizando Kafka.

PRIORIDAD AltaPRECONDICIONES Productor Kafka configurado.


RESULTADOS ESPERADOS

RESTRICCIONESY

DEPENDENCIAS

El fichero kmeans-train.txt contiene Vectoresy el fichero kmeans-test.txt contiene LabeledPoints.El algoritmo consume datos delmismo topic en el que Kafka los produce.

CRITERIOSDE

ACEPTACION

El algoritmo no es capaz de imprimir los clusters ya queuno de los ficheros no tiene el formato esperado.

PASOS DE LA PRUEBA1. Configurar productor Kafka para la aplicacion2. Lanzar el algoritmo en el IDE

CASOS DE PRUEBA RELACIONADOSKAF-1




DESCRIPCIONEjecutar el algoritmo utilizando un dataset de prueba,utilizando Kafka. El servidor Kafka no se encuentraactivo.

PRIORIDAD BajaPRECONDICIONES Kafka no lanzado.



YDEPENDENCIAS

El fichero kmeans-train.txt contiene Vectoresy el fichero kmeans-test.txt contiene LabeledPoints.Kafka no esta ejecutandose. produce.

CRITERIOSDE

ACEPTACION

El algoritmo no es capaz de imprimir los clustersya que la conexion a Kafka no puede realizarse.

PASOS DE LA PRUEBA1. Lanzar el algoritmo en el IDE

CASOS DE PRUEBA RELACIONADOSKAF-1 SKM-4




DESCRIPCIONEjecutar el algoritmo consumiendo datos de un topicque no existe.

PRIORIDAD BajaPRECONDICIONES Servidor kafka activo.

ENTRADASkmeans-train.txtkmeans-test.txt


YDEPENDENCIAS

El productor kafka envıa los datos a un topic que nose corresponde con el definido en la aplicacion.

CRITERIOSDE

ACEPTACION

No se puede realizar el clustering ya que el sistema noesta recibiendo datos.

PASOS DE LA PRUEBA1. Configurar 1 productor Kafka en un topic que no es el definido en el sistema2. Lanzar el algoritmo desde el IDE


NOTAS




DESCRIPCIONEjecutar el algoritmo utilizando el metodo predictOn(),en lugar del metodo predictOnValues().

PRIORIDAD AltaPRECONDICIONES Servidor kafka activo.

ENTRADAS s1 train.txtRESULTADOS ESPERADOS

RESTRICCIONESY

DEPENDENCIAS

Hay dos productores de kafka:- Uno para el metodo trainOn()- Otro para el metodo predictOn()

CRITERIOSDE

ACEPTACION

El metodo predictOn() utiliza el modelo entrenadopara hacer clustering sobre datos no etiquetados.Los resultados se muestran en consola.

PASOS DE LA PRUEBA1. Configurar 2 productores Kafka en 2 topics diferentes.2. Lanzar el algoritmo desde el IDE





DESCRIPCIONComprobar el correcto funcionamiento de la impresionde resultados.

PRIORIDAD AltaPRECONDICIONES Servidor kafka activo.

ENTRADAS kmeans-train.txtRESULTADOS ESPERADOS

RESTRICCIONESY

DEPENDENCIASEl productor kafka envıa los datos a spark.

CRITERIOSDE

ACEPTACIONLos datos resultantes son congruentes.

PASOS DE LA PRUEBA1. Configurar 1 productor Kafka.2. Lanzar el algoritmo desde el IDE



Capıtulo 5

Implementacion y Pruebas

5.1. Implementacion y Set Up del Sistema

Tras el estudio y analisis del sistema desarrollado, la definicion de requisitos funcio-

nales y no funcionales, y la descripcion de la arquitectura del sistema y la arquitectura

Machine Learning del mismo, en este capitulo se explicara como integrar todas las par-

tes del sistema, teniendo en cuenta todo lo descrito anteriormente.

En primer lugar se va a describir la implementacion del algoritmo y posteriormente la

utilizacion de librerıas externas y frameworks y scripts que se han utilizado.

5.1.1. Implementacion

Para la implementacion del algoritmo se ha utilizado el lenguaje de programacion

Scala en su version 2.11 [Martin Odersky, 2018] y el IDE Eclipse en su version para

Scala [Eclipse, 2018].

En primer lugar se ha codificado una clase Utilities.scala, en la que se configuran los

logs que apareceran por la consola para evitar que esta no sea usable.

Tras ello se anade al proyecto la clase StreamingKMeans, esta clase ya se encuentra

codificada en Spark, en la librerıa MlLib y puede encontrarse en el repositorio oficial

de Spark, en el siguiente enlace: https://github.com/apache/spark/blob/master/

mllib/src/main/scala/org/apache/spark/mllib/clustering/StreamingKMeans.scala,

la clase representa una implementacion bastante precisa del algoritmo k-means aplica-

48

https://github.com/apache/spark/blob/master/mllib/src/main/scala/org/apache/spark/mllib/clustering/StreamingKMeans.scala

https://github.com/apache/spark/blob/master/mllib/src/main/scala/org/apache/spark/mllib/clustering/StreamingKMeans.scala

5.1. IMPLEMENTACION Y SET UP DEL SISTEMA 49

do a streaming. En tercer, en el objeto Cluster.scala que es donde se van a realizar

las operaciones en streaming, se tienen que importar una serie de librerıas propias de

Spark o de Kafka para poder realizar las tareas de clustering, entre estas librerıas se

encuentran las que se describiran a continuacion:

org.apache.spark.SparkConf: Con esta librerıa podremos setear la configuracion

de Spark.

org.apache.spark.streaming.Seconds, StreamingContext: Necesaria para establecer

el contexto en streaming de Spark.

org.apache.spark.rdd.RDD: Necesaria para hacer tratamientos con RDDs.

org.apache.spark.mllib.linalg.Vectors y

import org.apache.spark.mllib.regression.LabeledPoint: Tipos de datos de MlLib

necesarios para utilizar el algoritmo.

org.apache.spark.streaming.kafka y

kafka.serializer.StringDecoder: Necesario para utilizar Kafka y para deserializar

los datos que llegan en streaming.

Utilities : para definir el nivel de detalle de los logs.

Tras importar las librerıas necesarias se crea una configuracion se Spark, configu-

rando el modo de ejecucion en local y se anade el nombre deseado para la aplicacion.

Posteriormente se crea el contexto de Spark al que se le pasa la configuracion defini-

da previamente. Acto seguido se crea el contexto en Streaming de Spark, pasandole el

contexto de Spark, y el tiempo en el que se recibe cada batch de datos.

Posteriormente se configuran los parametros de Kafka y se definen los topics desde

donde se van a leer los datastreams. Tras esto se parsean los datos y se crea un nuevo

objeto StreamingKMeans con la configuracion deseada, se entrena el modelo y se hacen

las predicciones sobre los datastreams.

Todo el codigo que aparece a continuacion es el necesario para poder visualizar los

resultados:

Obtencion del ultimo modelo con model.latestModel()

50 CAPITULO 5. IMPLEMENTACION Y PRUEBAS

Impresion de la prediccion de los centroides del ultimo modelo con lastModel.clusterCenters()

WSSSE: Obtencion del valor WSSSE que se explicara posteriormente.

Obtencion del peso de los clusters con lastModel.clusterWeights()

Impresion de la prediccion de los ındices para cada registro del dataset.

Por ultimo, respecto a la clase OfflineKMeans, esta se encuentra en el proyecto para

hacer algunas comprobaciones offline, pero no es estrictamente necesaria para el fun-

cionamiento del mismo.

5.1.2. Uso de librerıas externas

En este apartado se van a describir las librerıas utilizadas que no tienen que ver

con Spark, que ya ha sido explicado con anterioridad. Tambien se va a explicar la

herramienta con la que se controlan las dependencias en el proyecto.

Maven

Maven es una herramienta de gestion de proyectos software [Apache, 2018d].

Maven utiliza un Project Object Model (POM) para describir el proyecto de software

a construir, sus dependencias de otros modulos y componentes externos, y el orden de

construccion de los elementos. Viene con objetivos predefinidos para realizar ciertas

tareas claramente definidas, como la compilacion del codigo y su empaquetado.

La aplicacion implementada dispone de un fichero pom.xml en el que se encuentran las

dependencias correspondientes a Spark Core, Spark Streaming, MLLib, Kafka y Scala.

Kafka

En el proyecto se han utilizado APIs para realizar la conexion entre componentes

y ası habilitar la comunicacion entre ellos. Para la comunicacion con Kafka se han

utilizado las siguientes APIs:

5.1. IMPLEMENTACION Y SET UP DEL SISTEMA 51

Kafka-Clients: API de Apache que se encarga de las comunicaciones de Kafka

tanto con los productores como con los consumidores.

Spark-Streaming-Kafka: API especıfico para utilizar Kafka con Spark Strea-

ming.

Scripts de Python

Fuera de la ejecucion del propio sistema, se han desarrollado una serie de scripts

de Python que sirven como utilidades complementarias al proyecto. En el proyecto se

van a utilizar datasets publicos de la web: http://cs.uef.fi/sipu/datasets/. Estos

datasets vienen sin formato y para liberar de carga de trabajo a la aplicacion se les

va a dar el formato antes de la ejecucion. Para ello se han desarrollado dos scripts

que parsean los datos a tipos de datos que pueden user utilizados por las librerıas de

Machine Learning de Spark.

toLabeledPoint.py Recibiendo un dataset de entrada, genera un nuevo fichero

en el que cada registro es un LabeledPoint.

toVector.py Recibiendo un dataset de entrada, genera un nuevo fichero en el

que cada registro es un Vector.

Ademas, se ha realizado un script para visualizar estos datasets antes de ser tratados

y tener una representacion grafica de los mismos.

plot.py Este script recibe un dataset y realiza un plot representando cada punto

en su lugar correpondiente en el eje de ordenadas y de abcisas. En este script se

utiliza la librerıa Matplotlib [Hunter, 2007].

5.1.3. Setup

En este apartado se va a realizar la explicacion sobre como configurar los diferentes

componentes utilizados en el desarrollo para que funcionen de manera correcta conjun-

tamente. Se va a explicar la configuracion de la plataforma de streaming y de la base

de datos.

http://cs.uef.fi/sipu/datasets/


Computador utilizado

Modelo: Asus GL552JX-DM053H

Procesador: Intel(R) Core(TM) i7-4720HQ CPU @ 2.60GHz 2.59GHz (4 Cores

/ 8VCores)

Memoria RAM: 12 GB

GPU: Nvidia GTX950M

Sistema Operativo: Windows 10 Home

Configuracion de Apache Kafka

En esta seccion se explica como configurar correctamente la plataforma de streaming

para que tanto el servidor Kafka como el servidor Zookeeper [Apache, 2018c] que se

encuentra por debajo de este esten operativos y puedan funcionar.

El primer paso es descargar Apache Kafka desde la pagina web oficial [Apache,

2018a]. Tras descargarlo, nos encontramos con un archivo con extension tgz que hay

que descomprimir dos veces, se descomprime el archivo en la carpeta deseada y se anade

la variable de entorno KAFKA HOME, con la ruta correspondiente. Posteriormente,

se modifica el Path anadiendo %KAFKA HOME %\bin\windows ya que estamos tra-

bajando en un entorno Windows y en este directorio se encuentran los ficheros .bat a

ejecutar posteriormente.

Una vez instalado y configurado podemos iniciar el servidor Zookeeper se ejecuta el

siguiente comando:

zookeeper-server-start [properties Zookeeper]

se le debe anadir la direccion del fichero properties de Zookeeper que se encuentra en:

(ruta en la que se encuentre Kafka)\config\zookeeper.properties

Con Zookeeper activado podemos proceder a lanzar el servidor Kafka, para ello se

utiliza el comando:

5.2. EJECUCION DE PRUEBAS Y ESTUDIO DE ESCALABILIDAD 53

kafka-server-start [properties Kafka]

al igual que activando Zookeeper, es necesario un fichero de properties, en este caso de

Kafka, este fichero se puede encontrar en:

(ruta en la que se encuentre Kafka)\config\server.properties

Posteriormente, tras la activacion de Zookeeper y Kafka es necesario crear un topic al

que se puedan enviar datos para luego ser consumidos por el algoritmo, para ello se

utiliza el siguiente comando:

kafka-topics -create -zookeeper [IP: puerto Zookeeper] –replication-factor [factor

replicacion (1 por defecto)] –partitions [numero particiones (1 por defecto)] –topic

[nombre topic]

se debe especificar el puerto en el que se encuentra el servidor Zookeeper (por defecto

es el 2181, por ejemplo: localhost:2181), el factor de replicacion para cada particion del

topic creado, que es 1 por defecto, el numero de particiones creadas en el topic que

tambien es 1 por defecto y el nombre deseado con el que el topic sera identificado.

Configuracion de Interfaces

Las interfaces contienen ciertos parametros configurables. Los parametros de confi-

guracion se encuentran en los ficheros con extension .properties.

KafkaConfig: configuraciones necesarias para la conexion a la plataforma de

streaming Kafka.

SparkConfig: configuraciones necesarias para el correcto funcionamiento de Spark.

5.2. Ejecucion de Pruebas y Estudio de Escalabili-

dad

En este apartado se van a presentar los resultados obtenidos de la ejecucion de las

pruebas y de escalabilidad que se han definido en la Subseccion 4.5.


5.2.1. Pruebas de Variables de Entorno

En este subapartado se describen las pruebas relacionadas con las variables de en-

torno del sistema operativo, necesarias para que el sistema funcione correctamente.

PYT-1

Al realizar este test se prueba la correcta instalacion de Python. Python es necesario

en el sistema si se desea utilizar Spark con Python. Ademas se han realizado diversos

scripts en este lenguaje para el tratamiento de los datasets.

Figura 5.1: PYT-1

JAV-1

Con este test se prueba la correcta instalacion del Java Development Kit. Tanto

Java como su maquina virtual son necesarias para el correcto funcionamiento de Spark.

SPA-1

El siguiente test prueba la correcta instalacion de Spark. En el se ejecuta el coman-

do que lanza la consola de Spark para Scala, para ejecutar el comando desde cualquier


ruta se requiere haber configurado correctamente las variables SPARK HOME y HA-

DOOP HOME en las variables de entorno del sistema.

Figura 5.2: JAV-1

Figura 5.3: SPA-1


5.2.2. Pruebas de Kafka

Pruebas relacionadas con Kafka.

ZOO-1

Con esta prueba se pretende comprobar que el servidor Zookeeper es lanzado sin

problemas. Para ello se ejecuta el comando:

zookeeper-server-start [properties Zookeeper]

Figura 5.4: ZOO-1

KAF-1

En este test se comprueba el correcto funcionamiento del server Kafka, para ello

previamente tiene que haber sido lanzado el servidor Zookeeper. Se ejecuta el server

con el siguiente comando:

(ruta en la que se encuentre Kafka)\config\server.properties


Figura 5.5: KAF-1

KAF-2

Lanzar Kafka sin Zookeeper Con este test se quiere comprobar que no se puede

lanzar el servidor Kafka sin haber lanzado el servidor Zookeeper.

Figura 5.6: KAF-2


En la imagen se observa que el servidor Kafka no puede ser ejecutado.

KAF-3

En esta prueba se quiere comprobar como crear un productor y un consumidor en

Kafka

Figura 5.7: KAF-3 PRODUCER

Figura 5.8: KAF-3 CONSUMER


En las imagenes se puede observar como los mensajes del productor llegan al con-

sumidor.

5.2.3. Pruebas de Streaming K-Means

Pruebas relacionadas con el algoritmo de Machine Learning.

SKM-1

En este test (ver Figura 5.10) se va a utilizar el algoritmo Streaming K-Means con sus

metodos trainOn() y predictOnValues() por lo que se utilizan como entrada un fichero

de entrenamiento (Vector) y otro de test (LabeledPoints). El fichero de entrenamiento

y el fichero de prueba los colocamos en el puerto deseado utilizando el comando:

ncat -kl puerto ¡fichero.txt

SKM-2

El siguiente test es equivalente al test SKM-2 pero uno de los ficheros se ha colocado

en un puerto incorrecto, por lo que el programa no tiene acceso al mismo y devuelve

un error.

Figura 5.9: SKM-2

SKM-3

El siguiente test consiste en pasarle al algoritmo un dataset con formato incorrecto,

provocando ası un fallo en el parseo de los datos. Al igual que en SKM-1 y SKM-2, se

van a utilizar dos ficheros, uno de ellos contiene Vectores y el otro LabeledPoints, que

son dos tipos de datos correspondientes a la librerıa de Machine Learning de Spark.


Figura 5.10: SKM-1En la salida se observan tanto los datos que recibe el algoritmo como la prediccion de

los clusters.


Lo que se hace en este test es utilizar los LabeledPoints en el lugar de los Vectores y

viceversa.

Figura 5.11: SKM-3

SKM-4

En este test (ver Figura 5.12) se utiliza un productor Kafka conectado con Apache

Spark que actuara como consumidor. El Kafka debe producir los datos en el mismo topic

que este configurado Spark, para que este pueda consumir los datos. En la siguiente

figura se puede observar como la aplicacion recibe los datos.

SKM-5

El siguiente test (ver 5.13) prueba el funcionamiento de la aplicacion cuando no

consigue establecer la conexion con el servidor Kafka. Se ha lanzado la aplicacion sin

haber configurado previamente los servidores Zookeeper y Kafka.


Figura 5.12: SKM-4

Figura 5.13: SKM-5

SKM-6

El siguiente test prueba el funcionamiento de la aplicacion cuando trata de establecer

la conexion con Kafka en un topic que no existe. Kafka esta enviando los datos a un

topic diferente al de la aplicacion, por lo que esta es incapaz de recibir datastreams.

5.3. ELECCION DE LOS DATASETS PUBLICOS 63

Figura 5.14: SKM-6

SKM-7

Este test comprueba el correcto funcionamiento de la aplicacion utilizando el meto-

do predictOn() en lugar del metodo predictOnValues(). Este metodo, recibe datos no

etiquetados (Vectores) para hacer las predicciones sobre ellos, a diferencia del metodo

predictOnValues() que recibe datos etiquetados (LabeledPoints).

SKM-8

En este test comprueba el correcto funcionamiento de los metodos de impresion de

los resultados, se puede observar como se imprimen tanto la prediccion de los centroides,

como el valor WSSSE y el peso de los clusters.

5.3. Eleccion de los datasets publicos

Los datasets se han obtenido de una pagina web que proporciona datasets de uso

libre especialmente pensados para clustering [Franti and Sieranoja, 2018].

En estos datasets los datos se representan en 2 columnas separadas por espacios en

blanco, la primera columna representa el eje de abcisas mientras que la segunda columna

representa el eje de ordenadas.


Figura 5.15: SKM-8


5.3.1. S-Set 1

Se trata de un dataset sintetico de dos dimensiones con 5000 registros y 15 clusters

con bajo acoplamiento [Franti and Virmajoki, 2006].

Figura 5.16: S-Set 1

5.3.2. S-Set 2


con acoplamiento medio-bajo [Franti and Virmajoki, 2006].



5.3.3. S-Set 3


con acolamiento medio-alto [Franti and Virmajoki, 2006] (ver Figura 5.18).

5.3.4. S-Set 4


con alto acoplamiento [Franti and Virmajoki, 2006] 5.19).



5.3.5. A-Set 3

Es un dataset sintetico de dos dimensiones, tiene 7500 registros y 50 clusters [Karkkainen

and Franti, 2002] (ver Figura 5.20).

5.3.6. Birch 1

Este dataset es sintetico y de dos dimensiones, tiene 100.000 registros y 100 clusters

distribuidos en forma de matriz 10x10 [Zhang et al., 1997] (ver Figura 5.21).



Figura 5.20: A-Set 3

El por que de la eleccion de estos datasets en concreto tiene una sencilla explica-

cion,se tratan de datasets publicos y sinteticos especialente pensados para tareas de


clustering. Por otra parte, tres de los datasets escogidos son los mismos que utilizo

Sergio Camara en su Proyecto Fin de Grado: Online Clustering Sobre Data Streaming

Usando CluStream [Brana, 2018]. Al utilizar los mismos datasets se podra realizar, si

es necesario, una comparacion de resultados.

Figura 5.21: Birch 1

Capıtulo 6

Resultados

Tras la implementacion, la configuracion y las pruebas del sistema, se procede a

analizar los resultados de la ejecucion del algoritmo. En este apartado se van a realizar

experimentos sobre las caracterısticas del algoritmo.

Todos los experimentos que van a ser realizados en esta seccion se van a llevar a cabo en

un solo equipo, el descrito en el apartado 5.1.3. En estos experimentos se utilizaran todos

los recursos hardware disponibles de la maquina, manteniendo el mınimo de procesos

secundarios activos.

6.1. Experimentos

6.1.1. Estudio del parametro “decay factor”del algoritmo

En este experimento se va a estudiar el ındice de descomposicion del algoritmo,

para ello se van a utilizar los datasets de la serie S-Set [Franti and Virmajoki, 2006]. El

parametro decay factor (o ındice de descomposicion) del algoritmo StreamingKMeans

determina lo propensos que son al cambio los clusters actuales del modelo. Se trata de

un valor entre 0 y 1.

Si el valor es cercano a 0: Los clusters son mas propensos al cambio.

Si el valor es cercano a 1: Los clusters son mas estaticos y menos cambiantes.

70

6.1. EXPERIMENTOS 71

Por ello es importante establecer un factor de descomposicion adecuado para obtener

unas predicciones decentes.

Todos los experimentos se han realizado entrenando el modelo en 50 iteraciones.

Decay Factor: S-Set 1

En esta subseccion se va a probar como afecta el ındice de descomposicion a la hora

de realizar clustering sobre el dataset S-Set 1.

S-Set 1 Decay Factor: 1 Con un ındice de descomposicion 1 y tras 50 iteraciones,

el clustering realizado por el algoritmo es el siguiente:

Figura 6.1: S-Set 1 Decay Factor: 1

Algunos centros de los clusters se encuentran en su lugar mientras que otros estan

72 CAPITULO 6. RESULTADOS

desviados, o entre 2 clusters.

Valor WSSSE:2.7991E13

Peso medio de los Clusters: 17000

S-Set 1 Decay Factor = 0.5 Con un ındice de descomposicion 0.5 y tras 50 itera-

ciones, el clustering realizado por el algoritmo es el siguiente:

Figura 6.2: S-Set 1 Decay Factor: 0.5

A simple vista los centros de los clusters se ajustan al resultado esperado.

Valor WSSSE: 8.9176E12

Peso medio de los Clusters: Valor muy cercano a 0.





S-Set 2 Decay Factor = 1 Con un ındice de descomposicion 1 y tras 50 iteraciones,





Peso medio de los Clusters: Valor muy cercano a 0 (potencia a la -10).







Peso medio de los Clusters: Valor muy cercano a 0 (potencia a la -27).








Los centroides se encuentran muy dispersos, no se corresponden con el resultado

esperado.









Peso medio de los Clusters: 0.10








Los centroides se aproximan al resultado esperado, pero no llegan a ser del todo

precisos.



S-Set 4 Decay Factor = 0.5 Con un ındice de descomposicion 0.5 y tras 50

iteraciones, el clustering realizado por el algoritmo es el siguiente:



Los centroides se ajustan al resultado esperado.


Peso de los Clusters: Valor muy cercano a 0.

Proposicion 1 Tras la realizacion de los experimentos de Decay Factor se ha com-

probado que configurando un ındice de descomposicion distinto de 1 (clusters menos

propensos al cambio) se obtienen mejores resultados por lo que a partir de este momen-

to, todos los experimentos siguientes se realizaran con un decay factor con valor 0.5, a

no ser que el propio experimento requiera lo contrario.


6.1.2. Estudio de la aleatoriedad de las predicciones del algo-

ritmo

En este experimento se va a utilizar el dataset A-Set 3 [Karkkainen and Franti,

2002]. Se va a lanzar la aplicacion 5 veces, con configuraciones identicas y realizando

el mismo numero de iteraciones sobre el conjunto de entrenamiento. Lo que se quiere

comprobar es como la aleatoriedad de los clusters aleatorios escogidos al principio puede

afectar a la predicciones del algoritmo.

Los parametros de entrada seran los siguientes:

k: 50

Decay Factor: 0.5

Random Centers: 2, 0.0

Ejecucion 1

Valor WSSSE: 2.5696893620246845E15

Ejecucion 2

Valor WSSSE: 2.569697214903804E15

Ejecucion 3

Valor WSSSE: 2.569699424405189E15

Ejecucion 4

Valor WSSSE: 2.569697559764988E15

Ejecucion 5

Valor WSSSE: 2.5696973015794435E15


6.1.3. Estudio del rendimiento del algoritmo

En este experimento se va a estudiar la respuesta del algoritmo a los cambios del

tamano del dataset de entrada, estudiando su tiempo de procesamiento. Para ello se

van a utilizar tres datasets diferentes, con diferentes tamanos. El primero de ellos sera

S-Set 1, con 15 clusters y 5000 registros [Franti and Virmajoki, 2006], el segundo sera

A-Set 3, con 50 clusters y 75000 registros [Karkkainen and Franti, 2002]. Por ultimo,

se utilizara el dataset Birch 1, con 100000 registros y 100 clusters distribuidos en forma

de matriz de 10 x 10 [Zhang et al., 1997]. En todos ellos se realizaran 50 iteraciones.

Tiempo de ejecucion S-Set 1

Los parametros del algoritmo utilizados en este experimento para este dataset son

los siguientes:

k: 15

Decay Factor: 0.5


Tras la ejecucion de 50 iteraciones del dataset S-Set 1 se han obtenido los siguientes

resultados:


Figura 6.9: Tiempo de ejecucion S-Set 1

Tiempo de ejecucion A-Set 3


los siguientes:

k: 50

Decay Factor: 0.5


Tras la ejecucion de 50 iteraciones del dataset A-Set 3 se han obtenido los siguientes

resultados:


Figura 6.10: Tiempo de ejecucion A-Set 3

Tiempo de ejecucion Birch 1


los siguientes:

k: 100

Decay Factor: 0.5


Tras el intento de ejecucion de 50 iteraciones del dataset Birch 1, y debido al alto

numero de registros del mismo, la maquina no ha soportado la carga de trabajo y ha


ocurrido una excepcion del tipo timeout, por lo que se ha procedido a realizar tan solo

10 iteraciones con este dataset, obteniendo los siguientes resultados:

Figura 6.11: Tiempo de ejecucion Birch 1

Capıtulo 7

Conclusiones y trabajo futuro

7.1. Conclusiones

7.1.1. Conclusiones Generales

En este Trabajo Fin de Grado se ha desarrollado una aproximacion al streaming del

algoritmo de Machine Learning K-means. El algoritmo resuelve el problema del clus-

tering euclıdeo. La implementacion se ha desarrollado utilizando la plataforma ultra-

escalable de procesamiento masivo de datos Apache Spark. Spark permite paralelizar

ejecuciones del algoritmo desarrollado de una manera sencilla para el usuario, permitien-

do un alto nivel de escalabilidad. En el proyecto se han utilizado diferentes componentes

de los que forman Spark, entre los que se encuentran Spark Streaming y MLlib entre

otras.

Se ha realizado la identificacion de los principales algoritmos de Machine Learning pa-

ra el procesamiento de datos en streaming, siendo la mayorıa de ellos adaptaciones al

streaming de algoritmos clasicos de Machine Learning para cumplir los requisitos y res-

tricciones que conlleva trabajar en entornos de streaming. Ademas, se han identificado

algunas de las principales tecnicas empleadas en estos algoritmos.

Posteriormente se ha realizado la implementacion del algoritmo en el lenguaje de pro-

gramacion Scala, utilizando el IDE Eclipse, configurando las dependencias con Maven

y utilizando un productor de datos Kafka.

84

7.1. CONCLUSIONES 85

Tras la implementacion del algoritmo se han desarrollado una serie de experimentos y

estudios sobre el funcionamiento del mismo. Se ha analizado como afectan los principa-

les parametros configurables del algoritmo a los resultados de clustering y rendimiento

del mismo. Para el desarrollo de los experimetnos se han utilizado una serie de datasets

publicos con diferentes caracterısticas. Las conclusiones generales tras el desarrollo de

los experimentos son los siguientes:

Estudio del parametro “decay factor”:

• En general las predicciones hechas con decayFactor = 0.5 son mas favorables

que las realizadas con decayFactor = 1.0.

• Los valores WSSSE con decayFactor = 0.5 son mucho menores que con de-

cayFactor = 1.0.

• Los pesos de los clusters con decayFactor = 0.5 son cercanos a 0, mientras

que con decayFactor = 1.0 son mas elevados.

• Que los clusters reaccionen a los nuevos datos que entran es positivo.

• En la ejecucion de S-Set 2 los resultados de los centros de los clusters son

similares, esto se debe a la aleatoriedad de la eleccion de los clusters ini-

ciales, esta caracterıstica se explicara en el proximo apartado, aunque con

decayFactor = 0.5 las predicciones siguen siendo mas precisas.

Estudio de la aleatoriedad de las predicciones del algoritmo:

• Ejecutando 5 veces, con configuraciones identicas, se han obtenido resultados

del valor WSSSE bastante similares.

• Aunque estos resultados son similares no llegan a ser identicos ya que estan

elevados a la potencia 15, por lo que la diferencia en realidad es significativa.

• No son identicos porque los centroides iniciales escogidos son aleatorios, por

lo que ninguna ejecucion puede ser identica a la anterior.

Estudio del rendimiento del algoritmo:

• S-Set 1:

86 CAPITULO 7. CONCLUSIONES Y TRABAJO FUTURO

◦ Registros: 250.000

◦ Media (Registros/s): 3833.55 registros/s

◦ Tiempo procesamiento: 546 ms

• A-Set 3:




• Birch1 (50 iteraciones):

◦ Debido al elevado numero de registros del dataset, la maquina no ha

soportado la carga de trabajo y se ha producido una timeOut exception.

◦ Se ha procedido a reducir el numero de iteraciones para poder realizar

el experimento.

• Birch1 (10 iteraciones):




Tras observar los resultados obtenidos, no se han podido observar cambios

significativos en el rendimiento del procesamiento de los diferentes bathches

de datos.

7.1.2. Conclusiones Personales

En el ambito personal, este Proyecto Fin de Grado me ha servido para iniciarme,

comprender y profundizar mis conocimientos en los campos que se tratan con el mismo,

ası como aprender la utilizacion de herramientas que no habıa utilizado con anteriori-

dad como Apache Spark o Apache Kafka.

Antes de la realizacion del trabajo, mi nivel era basico en estos campos, y la realiza-

cion del mismo me ha servido para aprender y profundizar en conceptos relativos a los

mismos.

7.2. IMPACTO. ETICA Y RESPONSABILIDAD PROFESIONAL 87

Respecto al Machine Learning, he podido aprender como se aplica a la ciencia de los

datos y conceptos sobre los algoritmos que son utilizados para este cometido, ası como

tecnicas que se utilizan en los mismos.

Respecto al Data Science, he podido comprobar de primera mano el significado y la im-

portancia de los data streams, su funcionamiento y comportamiento y las restricciones

que supone trabajar con data streams en vez de datos en batch.

He aprendido como utilizar el framework Spark, este punto lo considero muy impor-

tante ya que considero que los conocimientos de este framework me pueden servir en

un futuro cercano. Ademas, combinando su uso con Kafka se obtiene una herramienta

muy potente sobre la que trabajar.

Sobre el algoritmo, he podido aprender en profundidad su funcionamiento y comporta-

miento.

7.2. Impacto. Etica y responsabilidad profesional

El impacto ambiental de este Proyecto es practicamente inexistente porque la apli-

cacion informatica resultante no implica el uso de maquinas de alto consumo energetico.

Si bien es cierto que en los grandes centros de datos se realiza un consumo elevado de

energıa, con este proyecto no hace uso alguno de ellos y, por lo tanto, podemos afirmar

que nuestra aplicacion no requiere de un alto consumo de energıa.

Con respecto al impacto social, el desarrollo de este Proyecto ha involucrado una

primera fase de exploracion para abordar un conjunto de desafıos relacionados con la

migracion del algoritmo secuencial al paralelo y la migracion a una plataforma Big Data.

Dado que nuestro proyecto no puede ser considerado un proyecto de software comercial,

consideramos que el impacto social solo esta relacionado con los resultados preliminares

obtenidos que podrıan permitir un desarrollo futuro con resultados interesantes para

atacar problemas reales en varios dominios de aplicacion.

Finalmente, con respecto a la Responsabilidad Etica y Profesional, se puede afirmar

que el desarrollo de este Proyecto no esta relacionado con ningun factor que contravenga

estos dos aspectos. Por otro lado, afirmamos que este proyecto se desarrollo con el mayor

respeto por el ejercicio de la profesion y, por lo tanto, se ha considerado tanto etica como

88 CAPITULO 7. CONCLUSIONES Y TRABAJO FUTURO

responsabilidad profesional de manera personal.

7.3. Trabajo futuro

Se plantean dos posibles trabajos futuros para este Trabajo Fin de Grado:

Estudio del comportamiento del algoritmo en un cluster de computado-

res: Este trabajo se ha realizado estudiando el funcionamiento del algoritmo en un

solo computador. Analizar hasta que punto la parelizacion optimiza el algoritmo

serıa un punto interesante.

Comparacion de resultados con otros algoritmos: Comparar los resulta-

dos de este trabajo con otros algoritmos puede brindar informacion interesante

siempre y cuando se haga con un setup similar.

Bibliografıa

[Ackermann et al., 2012] Ackermann, M. R., Martens, M., Raupach, C., Swierkot, K.,

Lammersen, C., and Sohler, C. (2012). Streamkm++: A clustering algorithm for

data streams. J. Exp. Algorithmics, 17:2.4:2.1–2.4:2.30.

[Aggarwal, 2007] Aggarwal, C. C. (2007). Data streams: models and algorithms, volu-

me 31. Springer Science & Business Media.

[Aggarwal, 2013] Aggarwal, C. C. (2013). A survey of stream clustering algorithms. In

Data Clustering, pages 231–258. Chapman and Hall/CRC.

[Apache, 2018a] Apache (2018a). Apache Kafka. https://kafka.apache.org/. Con-

sultada el: 1/12/2018.

[Apache, 2018b] Apache (2018b). Apache Spark. https://spark.apache.org/

downloads.html. Consultada el: 1/12/2018.

[Apache, 2018c] Apache (2018c). Apache Zookeeper. https://zookeeper.apache.

org/. Consultada el: 15/12/2018.

[Apache, 2018d] Apache (2018d). Maven documentation. https://maven.apache.

org/. Consultada el: 10/12/2018.

[Apache, 2018e] Apache (2018e). Streaming k-means. https://spark.apache.

org/docs/latest/mllib-clustering.html#streaming-k-means. Consultada el:

1/12/2018.

[Arroyo, 2018] Arroyo, A. (2018). Diapositivas de la asignatura: Sistemas inteligentes.

89

https://kafka.apache.org/

https://spark.apache.org/downloads.html

https://spark.apache.org/downloads.html

https://zookeeper.apache.org/

https://zookeeper.apache.org/

https://maven.apache.org/

https://maven.apache.org/

https://spark.apache.org/docs/latest/mllib-clustering.html#streaming-k-means

https://spark.apache.org/docs/latest/mllib-clustering.html#streaming-k-means

90 BIBLIOGRAFIA

[Bifet, 2010] Bifet, A. (2010). Adaptive stream mining: Pattern learning and mining

from evolving data streams. In Proceedings of the 2010 conference on adaptive stream

mining: Pattern learning and mining from evolving data streams, pages 1–212. Ios

Press.

[Brana, 2018] Brana, S. C. (2018). Online clustering sobre data streaming usando

clustream.

[Cao et al., 2006] Cao, F., Estert, M., Qian, W., and Zhou, A. (2006). Density-based

clustering over an evolving data stream with noise. In Proceedings of the 2006 SIAM

international conference on data mining, pages 328–339. SIAM.

[Chen and Tu, 2007] Chen, Y. and Tu, L. (2007). Density-based clustering for real-time

stream data. In Proceedings of the 13th ACM SIGKDD International Conference on

Knowledge Discovery and Data Mining, KDD ’07, pages 133–142, New York, NY,

USA. ACM.

[Domingos and Hulten, 2000] Domingos, P. and Hulten, G. (2000). Mining high-speed

data streams. In Kdd, volume 2, page 4.

[Eclipse, 2018] Eclipse (2018). Eclipse ide. https://www.eclipse.org/ide/). Con-

sultada el: 1/12/2018.

[Franti and Sieranoja, 2018] Franti, P. and Sieranoja, S. (2018). K-means properties

on six clustering benchmark datasets. http://cs.uef.fi/sipu/datasets/.

[Franti and Virmajoki, 2006] Franti, P. and Virmajoki, O. (2006). Iterative shrinking

method for clustering problems. Pattern Recognition, 39(5):761–765.

[Hesabi et al., 2015] Hesabi, Z. R., Sellis, T., and Zhang, X. (2015). Anytime concu-

rrent clustering of multiple streams with an indexing tree. In Proceedings of the

4th International Conference on Big Data, Streams and Heterogeneous Source Mi-

ning: Algorithms, Systems, Programming Models and Applications-Volume 41, pages

19–32. JMLR. org.

https://www.eclipse.org/ide/)

http://cs.uef.fi/sipu/datasets/

BIBLIOGRAFIA 91

[Hunter, 2007] Hunter, J. D. (2007). Matplotlib: A 2d graphics environment. Compu-

ting in Science & Engineering, 9(3):90–95.

[Karau et al., 2015] Karau, H., Konwinski, A., Wendell, P., and Zaharia, M. (2015).

Learning Spark: Lightning-Fast Big Data Analytics. O’Reilly Media, Inc., 1st edition.

[Karkkainen and Franti, 2002] Karkkainen, I. and Franti, P. (2002). Dynamic local

search algorithm for the clustering problem. Technical Report A-2002-6, Department

of Computer Science, University of Joensuu, Joensuu, Finland.

[Marsland, 2009] Marsland, S. (2009). Machine Learning: An Algorithmic Perspective.

Chapman & Hall/CRC, 1st edition.

[Martin Odersky, 2018] Martin Odersky (2018). Scala programming language. https:

//www.scala-lang.org/). Consultada el: 1/12/2018.

[Oracle, 2018] Oracle (2018). Java SE Development Kit 8 Downloads. https://www.

oracle.com/technetwork/java/javase/downloads/jdk8-downloads-2133151.

html. Consultada el: 1/12/2018.

[Shalev-Shwartz and Ben-David, 2014] Shalev-Shwartz, S. and Ben-David, S. (2014).

Understanding Machine Learning: From Theory to Algorithms. Cambridge University

Press, New York, NY, USA.

[Sommerville, 2013] Sommerville, I. (2013). Software Engineering: Pearson New Inter-

national Edition. Pearson Education Limited.

[Steve Loughran, 2018] Steve Loughran (2018). Winutils. https://github.com/

steveloughran/winutils. Consultada el: 1/12/2018.

[Zhang et al., 1997] Zhang, T., Ramakrishnan, R., and Livny, M. (1997). Birch: A

new data clustering algorithm and its applications. Data Mining and Knowledge

Discovery, 1(2):141–182.

https://www.scala-lang.org/)

https://www.scala-lang.org/)

https://www.oracle.com/technetwork/java/javase/downloads/jdk8-downloads-2133151.html



https://github.com/steveloughran/winutils

https://github.com/steveloughran/winutils

Documents

UNIVERSIDAD POLITECNICA DE MADRIDoa.upm.es/56397/1/TFG_ANTONIO_JIMENEZ_HERNANDEZ.pdf · Hadoop data source, including Cassandra databases. In addition, the main algorithms of Machine