miércoles, 11 de junio de 2014

Estudio - Python como alternativa a Matlab o R como lenguaje de programación científico


Instalar Python

Distribuciones orientadas al mundo de la ciencia:

Comenzar el aprendizaje de Python

Módulos/paquetes/librerias de análisis matemático y visualización

  • Numpy: manejo de matrices y la realización de operaciones matriciales y vectoriales de forma sencilla y eficiente (puede usar MKL y BLAS para mejorar el rendimiento).
     
  • Scipy: es la biblioteca científica y usa Numpy como base. Con Scipy se añaden todas las funcionalidades que un ingeniero, estadísta, matemático,… puede querer para el tratamiento de señales, creación de nuevos algoritmos, etc.
     
  • Matplotlib: gráficas muy completas para mostrar los resultados de tus pruebas.
     
  • Scikit-learn: librería centrada en machine learning: de clasificadores o regresores, hasta selección automática de modelos y análisis de resultados.

domingo, 8 de junio de 2014

Ampliación del curso: "Machine Learning" de Stanford University

MOOC en  Coursera - Machine Learning

 
   Como ya comenté hace unas semanas en el blog, ya finalicé el MOOC de la universidad Stanford (impartido por Andrew Ng) denominado "Machine Learning" incluido en la plataforma Coursera (el 16 de Junio comienza otra edición del curso por si alguno le interesa realizarlo). La semana pasada se calcularon las notas finales del curso y nos proporcionaron un certificado de cumplimiento a todos los que realizamos el curso y obtuvimos una nota mayor a un 80% (donde 2/3 de la nota provienen de los ejercicios prácticos y 1/3 de los exámenes tipo test):


Asignatura CS229 - Machine Learning de la Universidad de Stanford

   Este mismo curso ampliado y con mayor rigor matemático que el impartido en la plataforma Coursera puede encontrarse en la página de la escuela online de Stanford, correspondiendose con la asignatura CS 229 - Machine Learning. Se pueden descargar (o ver online) 20 videos con las clases impartidas por el profesor Andrew Ng en la universidad de Stanford (1 h 15 min aprox. cada uno), así como el temario, problemas y diferentes documentos de repaso en pdf.

   Durante estas semanas lo he estado siguiendo, ya que tiene un temario más amplio que el MOOC de Coursera, con nuevos conceptos, técnicas y algoritmos que no se mencionan en el MOOC, aportando además un mayor rigor matemático, incluyendo paso por paso todos los pasos y las formulas, teorémas y aproximaciones utilizadas a la hora de obtener los algoritmos.

lunes, 2 de junio de 2014

Matlab - Optimización, procesado paralelo y distribuido --> machine learning y procesado Big Data

Matlab es un lenguaje de alto nivel y un entorno interactivo para el cálculo numérico, la visualización y la programación. Mediante MATLAB, es posible analizar datos, desarrollar algoritmos y crear modelos o aplicaciones. Por lo tanto, constituye una herramienta de software matemático que ofrece un entorno de desarrollo integrado (IDE) con un lenguaje de programación propio (lenguaje M).

Optimización en Matlab

Matlab incorpora una libreria llamada  "Optimization Toolbox" que incorpora algoritmos para optimización, tanto para problemas estandar como para problemas a gran escala. Proporciona algoritmos para resolver problemas continuos o discretos, tanto con  restricciones o sin ellas:
"Linear programming", "quadratic programming", "binary integer programming", "nonlinear optimization", "nonlinear least squares", "systems of nonlinear equations" y "multiobjective optimization".  
En muchos problemas nos encontramos que los algoritmos de optimización pueden conducir a mínimos o máximos locales. Matlab incorpora una libreria llamada "Global Optimization Toolbox" que incorpora  técnicas y algoritmos para la búsqueda y obtención de soluciones globales, evitando mínimos/máximos locales:
"Global search", "multistart", "pattern search", "genetic algorithm" y "simulated annealing solvers".

Procesado paralelo y distribuido

Matlab incorpora librerias para facilitar al usuario la programación de algoritmos que sean capaces de correr en paralelo utilizando procesadores multinúcleo, GPUs o clusters de ordenadores:
Muchas de las funciones de optimización incorporadas pueden configurarse para hacer uso de estas herramientas de procesado paralelo y distribuido, tanto para acelerar el proceso, como para la resolución de problemas a gran escala (Big Data).
Recomiendo darle un vistazo a estos dos trabajos donde se utilizan estas librerias en problemas de optimización y de procesado de datos:
"Programación Matlab en paralelo sobre clúster computacional",
"Parallel Optimization in Matlab"

Minería de datos y machine learning

Matlab puede ser usado para realizar tareas de minería de datos y machine learning, incluyendo una gran cantidad de algoritmos implementados en diferentes Toolboxes. Por ejemplo, incluye algoritmos de clasificación (support vector machine (SVM), boosted and bagged decision trees, k-nearest neighbor, Naïve Bayes, discriminant analysis, neural networks...), de regresión (linear model, nonlinear model, regularization, stepwise regression, boosted and bagged decision trees, neural networks, adaptive neuro-fuzzy learning,...) y de clustering (k-means, hierarchical clustering, Gaussian mixture models, hidden Markov models, self-organizing maps, fuzzy c-means clustering, subtractive clustering...).

Big data en Matlab

Matlab incorpora una serie de funcionalidades y herramientas que ayudan a realizar labores de análisis y procesado de datos en problemas Big Data, por ejemplo:
  • Disk Variables. The matfile function lets you access MATLAB variables directly from MAT-files on disk, using MATLAB indexing commands, without loading the full variables into memory. This allows you to do block processing on big data sets that are otherwise too large to fit in memory.
  • Intrinsic Multicore Math. Many of the built-in mathematical functions in MATLAB, such as fft, inv, and eig, are multithreaded. By running in parallel, these functions take full advantage of the multiple cores of your computer, providing high-performance computation of big data sets.
  • GPU Computing. If you’re working with GPUs, GPU-optimized mathematical functions in Parallel Computing Toolbox provide even higher performance for big data sets.
  • Parallel Computing. Parallel Computing Toolbox provides a parallel for-loop that runs your MATLAB code and algorithms in parallel on multicore computers. 
  • Distributed Computing: you can execute in parallel on clusters of machines that can scale up to thousands of computers.
  • Cloud Computing. Cloud computing lets you process big data without having to buy or maintain your own cluster or data center.
  • Distributed Arrays. Using Parallel Computing Toolbox and MATLAB Distributed Computing Server, you can work with matrices and multidimensional arrays that are distributed across the memory of a cluster of computers.
  • Streaming Algorithms.  you can perform stream processing on incoming streams of data that are too large or too fast to hold in memory. In addition, you can generate embedded C/C++ code from your MATLAB algorithms using MATLAB Coder, and run the resulting code on high-performance real-time systems.

miércoles, 28 de mayo de 2014

Curso M101J: "MongoDB for Java Developers" por MongoDB University

Me he inscrito en la página de MongoDB University para realizar el curso "MongoDB for Java Developers".
 
Este curso es gratuito, comenzó ayer día 27 de mayo y se extenderá durante 7 semanas; terminará el día 15 de Julio. Cada semana se cuelga en la página una nueva lección, con una serie de ejercicios para realizar y ser subidos a la web antes del comienzo de la siguiente lección. Al final del curso se debe realizar un examen online. Los ejercicios prácticos contarán un 50% y el examen el otro 50%, obteniendo un certificado de completación del curso si se obtiene una nota final por encima del 65%.

Los ejercicios propuestos están relacionados con la creación de un Blog como aplicación web, utilizando MongoDB, Spark y Freemarker.  En la primera lección se realiza una introducción sobre como instalar y utilizar estas herramientas.

Instalando MongoDB

  
En mi caso trabajaré en Ubuntu 12.04. En este caso la instalación se puede realizar a través del sistema de paquetería de la distribución:
$ sudo apt-get update
$ sudo apt-get install mongodb-server mongodb-clients
He optado por descargar los binarios desde la propia web oficial de MongoDB www.mongodb.org. En estos momentos la última versión es la 2.6.1. Descargamos el archivo mongodb-linux-x86_64-2.6.1.tgz y lo descomprimimos:
astwin@astwin-H87-HD3:~$ tar xzf mongodb-linux-x86_64-2.6.1.tgz

Con mongod inicializamos MongoDB. mongo inicializa el shell para interactuar desde la consola de comando con MongoDB. Antes de inicializar MongoDB se necesita especificar el directorio donde se alojará la base de datos. Por defecto, MongoDB buscará el directorio /data/db y si no lo encuentra, se producirá un error. Lo creamos:
astwin@astwin-H87-HD3:~/mongodb-linux-x86_64-2.6.1/bin$ sudo mkdir -p /data/db
astwin@astwin-H87-HD3:~/mongodb-linux-x86_64-2.6.1/bin$ sudo chmod 777 /data/db/
Ejecutamos MongoDB:
astwin@astwin-H87-HD3:~/mongodb-linux-x86_64-2.6.1/bin$ ./mongod
 
Podemos abrir el shell de MongoDB:
astwin@astwin-H87-HD3:~/mongodb-linux-x86_64-2.6.1/bin$ ./mongo
Comprobamos que funciona correctamente. Creamos una nueva colección llamada nombre, añado el mio, lo muestro y la borro:
 

Hola Mundo: Maven, Eclipse y el driver de MongoDB para Java

 
Dependencias del driver Java para incluir en el pom.xml:
    <dependency>
        <groupId>org.mongodb</groupId>
        <artifactId>mongo-java-driver</artifactId>
        <version>2.12.2</version>
    </dependency>
Creamos una colección llamada hola y añadimos un documento desde el shell:
 
 
Creamos un proyecto Maven desde Eclipse y añadimos el driver de Java en el pom.xml. Creamos la clase hola_mundo_mongoDB que se conectará al servidor de MongoDB (en mi caso en local), obtendrá acceso a la base de datos test, a la colección hola y mostrará el contenido del único documento añadido:
 

Hola mundo: Framework Spark para aplicación web

 
Repositorio y dependencias del framework Spark (actualmente van por la version 2.0, pero en el curso se utiliza la 0.9.4):
    <repositories>
        <repository>
            <id>Spark repository</id>
            <url>http://www.sparkjava.com/nexus/content/repositories/spark/</url>
        </repository>
    </repositories>

  <dependencies>
       <dependency>
          <groupId>spark</groupId>
          <artifactId>spark</artifactId>
          <version>0.9.9.4-SNAPSHOT</version>
    </dependency>
Creamos una nueva clase, donde se utiliza Spark para mostrar "Hola mundo desde Spark":
 
 
Abrimos el navegador con la dirección http://localhost:4567/ y podemos ver que la aplicación web que hemos creado muestra la frase "Hola mundo desde Spark".
 

Hola mundo: Freemarker como motor de plantillas

 
Durante el curso se utilizará Freemarker como motor de plantillas para generar el código HTML. FreeMarker es un motor de plantilla, lo que significa que es una herramienta que crea texto como resultado. Está destinado a ser utilizado con el lenguaje de programación Java, especialmente con aplicaciones de Model View Controller. Éste separa la lógica del programa, la interfaz y los datos de un sitio web. FreeMarker permite a los diseñadores de interfaz realizar cambios sin necesidad de la parte lógica del programa para hacerlo.

Dependencias para añadir Freemarker a un proyecto Maven:
<dependency>
  <groupId>org.freemarker</groupId>
  <artifactId>freemarker</artifactId>
  <version>2.3.19</version>
</dependency>
Creamos una plantilla de código html en el archivo "hola.ftl":
<html>
<head>
    <title>¡Bienvenido!</title>
</head>
<body>
    <h1>Hola ${nombre}</h1>
</body>
</html>
Mediante Freemarker procesamos la plantilla para cambiar el valor de la variable ${nombre} y añadir nuestro nombre:
 


Hola mundo: Uniendo Spark y Freemarker

 
Unimos Spark y Freemarker:
 

Ahora al abrir http://localhost:4567/, Spark captura la petición get al entrar a la raíz de la página ("/"), Freemarker procesa la plantilla html y se devuelve al navegador:

  

Hola mundo: Spark, Freemarker y MongoDB

 
Ahora se integran todos, de manera que a la hora de procesar la plantilla y obtener el valor para la variable ${nombre}, nos conectamos a la base de datos MongoDB y obtenemos el documento que introdujimos en la colección hola:



Homeworks: Lección 1

 
En esta primera lección existen 4 tareas a realizar y subir a la plataforma del curso:
  1. La primera de ellas consiste en utilizar la aplicación mongorestore para cargar una base de datos con varias colecciones en MongoDB, realizar una query en una de ellas y subir el valor que contiene la clave "answer" del documento JSON obtenido. 
  2. La segunda es un test donde se muestran 5 posibles documentos JSON y tienes que seleccionar los que están escritos de forma correcta. 
  3. La tercera consiste en compilar y ejecutar un proyecto Maven, conteniendo una aplicación Java que devuelve un resultado numérico que debes introducir en la plataforma. 
  4. La última es otro proyecto Maven que integra MongoDB (los datos se han cargado en la realización del primer ejercicio), Spark y Freemarker, que una vez compilado y ejecutado te permite abrir una web en local que contiene el último código a subir en la plataforma. 
Una vez realizados, podemos comprobar como los 4 ejercicios se han completado de forma correcta:
 



viernes, 23 de mayo de 2014

Laboratorio - Probando Pig

Para una primera toma de contacto con Pig seguí un pequeño ejemplo que se encuentra en el libro 'Hadoop: The Definitive Guide, 3rd Edition'.
 
Contenido de archivo 'sample.txt': datos extraídos de sensores de temperatura, donde registro de temperatura +9999 indica una lectura errónea y el código de calidad debe ser 1, 4, 5 o 9 para considerar una medida fiable. Queremos obtener la temperatura máxima que hizo en cada uno de los años.
1950    0     1
1950    22    4
1950    -11   1
1950    9999  1
1950    22    4
1950    -11   3
1949    111   1
1949    78    1
1949    9999  4
1949    78    1

Corriendo Pig desde el Shell Grunt

Iniciamos Pig en local desde el terminal:
$ pig -x local
Cargamos datos de este archivo en Pig:
grunt> registros = LOAD 'sample.txt' AS (anyo:chararray, temperatura:int, calidad:int);
Mostramos las tuplas almacenadas en la relación registros:
grunt> DUMP registros;
Filtramos los registros:
grunt> registros_filtrados = FILTER registros BY (temperatura != 9999) and (calidad==1 or calidad==4 or calidad==5 or calidad==9);
Agrupamos los registros por año:
grunt> registros_agrupados = GROUP registros_filtrados BY anyo;
Se crean tuplas que están compuestas por cada uno de los años y una 'bag' (colección desordenada de tuplas). Cada tupla corresponde a un año. Para cada una de ellas generamos una nueva relación que contiene el año de la tupla y la máxima temperatura de la bag:
temp_max = FOREACH registros_agrupados GENERATE group AS anyo, MAX(registros_filtrados.temperatura) AS temperatura;
Observamos el resultado:
grunt> DUMP temp_max;
(1949,111)
(1950,22)
Podemos observar el esquema de cada relación con el comando Describe:
grunt> DESCRIBE registros;
registros: {anyo: chararray,temperatura: int,calidad: int}
grunt> DESCRIBE registros_filtrados;
registros_filtrados: {anyo: chararray,temperatura: int,calidad: int}
grunt> DESCRIBE registros_agrupados;
registros_agrupados: {group: chararray,registros_filtrados: {(anyo: chararray,temperatura: int,calidad: int)}}

Ejecutando un script en Pig

Almacenamos los comandos anteriores en un archivo 'max_temp.pig':
--- Busca la máxima temperatura por años
registros = LOAD 'sample.txt' AS (anyo:chararray, temperatura:int, calidad:int);
registros_filtrados = FILTER registros BY (temperatura != 9999) and (calidad==1 or calidad==4 or calidad==5 or calidad==9);
registros_agrupados = GROUP registros_filtrados BY anyo;
temp_max = FOREACH registros_agrupados GENERATE group AS anyo, MAX(registros_filtrados.temperatura) AS temperatura;
dump temp_max;
Desde el terminal podemos correr el script:
$ pig -x local max_temp.pig
 

Estudio: Capítulo 11 - PIG

He estado estudiando Pig siguiendo el capítulo 11 del libro "Hadoop: The Definitive Guide, 3rd Edition".
 

MapReduce: en algunos casos, ajustar el procesado de datos siguiendo un esquema de funciones Map y Reduce puede ser complejo para un desarrollador, ya que puede requerir programar muchas etapas MapReduce.
 
Pig incrementa el nivel de abstracción en el procesado de datos, con estructuras más ricas y transformaciones de datos más poderosas. Utiliza un lenguaje de definición de flujo de datos (data flow) llamado Pig Latin, que transforma las operaciones realizadas en los datos en trabajos Mapreduce.

 

1 – Instalando y ejecutando PIG

1.1 – Tipos de ejecución

1.1.1 – Local: (ejecuta una única JVM, sistema de ficheros local). % pig –x local
1.1.2 –MapReduce (cluster  o  pseudo-distribuido).  % pig –x mapreduce  ó % x  (mapreduce por defecto)

1.2 – Ejecutando programas en Pig

1.2.1 – Script
1.2.2 – Grunt
1.2.3 – Embebidos

1.3 – Grunt

1.4 – Editores de Pig Latin

2 – Ejemplo

2.1 – Generando un ejemplo con una muestra del conjunto de datos: ILLUSTRATE

3 – Comparación con una base de datos

 

4 – Lenguaje: Pig Latin

4.1 – Estructura

4.2 – Declaraciones

4.3 – Expresiones

4.4 – Tipos de datos

4.5 – Esquemas

4.5.1 – Validaciones y valores NULL
4.5.2 – Unión de esquemas

4.6 – Funciones

4. 7 – Macros

5 – Funciones definidas por el usuario (UDF: User-Defined Functions)

5.1 – Filtros

5.2 – Evaluación

5.3 – Carga de datos

6 – Operadores de procesado de datos

6.1 – Cargando y almacenando datos

6.2 – Filtrando datos

6.2.1 – FOREACH…GENERATE
6.2.2 – STREAM

6.3 – Agrupando y uniendo datos

6.3.1 – JOIN
6.3.2 – COGROUP
6.3.3 – CROSS
6.3.4 – GROUP

7 – Pig en la práctica

7.1 – Paralelismo

7.2 – Sustitución de parámetros

lunes, 19 de mayo de 2014

Coursera - Machine Learning, by Andrew Ng, Universidad de Standford

Llevo un par de semanas realizando un curso online (MOOC) en la plataforma Coursera sobre Machine Learning, creado por Andrew Ng:
Andrew Ng is a co-founder of Coursera and the director of the Stanford AI Lab. In 2011 he led the development of Stanford University’s main MOOC (Massive Open Online Courses) platform and also taught an online Machine Learning class that was offered to over 100,000 students, leading to the founding of Coursera.
Visitar la página del curso:   Machine Learning, por Andrew Ng, Univ. Standford.

Contenido del curso:
  1. Introduction to Machine Learning. Univariate linear regression. (Optional: Linear algebra review.)
  2. Multivariate linear regression. Practical aspects of implementation. Octave tutorial.
  3. Logistic regression, One-vs-all classification, Regularization.
  4. Neural Networks.
  5. Practical advice for applying learning algorithms: How to develop, debugging, feature/model design, setting up experiment structure.
  6. Support Vector Machines (SVMs) and the intuition behind them.
  7. Unsupervised learning: clustering and dimensionality reduction.
  8. Anomaly detection.
  9. Recommender systems.
  10. Large-scale machine learning. An example of an application of machine learning.
       Este es uno de los motivos principales por los que he realizado este curso, ya que se trata el tema de la aplicación de técnicas de machine learning cuando se dispone de datasets masivos.
       Se introducen técnicas de optimización para mejorar la velocidad de entrenamiento (por ejemplo el descenso de gradiente estocástico), se habla del aprendizaje online y se expone la filosofía map-reduce para utilizar paralelismo (tanto si disponemos de un cluster de ordenadores, como para utilizar procesadores multicore) en las técnicas de machine learning.

Planificación del curso:
El curso está planificado para realizarse durante 10 semanas: comenzó el 3 de Marzo y acaba el 26 de Mayo (esta semana es la última). El 16 de Junio vuelve a comenzar una nueva edición del curso. Me ha parecido un curso muy interesante, completo, útil, muy bien estructurado y todo perfectamente explicado, lo recomiendo.
A cada semana se ha subido a la plataforma uno o dos temas (compuesto por una serie de vídeos y documentos pdf/powerpoint). Se han diseñado dos tipos de ejercicios realizar conforme suben los temas: un pequeño examen de 10 preguntas cada semana y ocho sesiones de ejercicios prácticos (se implementan y ejecutan algoritmos en Matlab y, a través de un script se envían los resultados a la plataforma del curso, donde se puede observar el resultado de la evaluación).
Yo comencé el curso hace dos semanas y hoy lo acabo de terminar, habiendo realizado todos los ejercicios prácticos y exámenes (por subirlos fuera de cada plazo, es decir, por no realizarlos en el plazo de cada una de las 10 semanas, te penalizan con un 20% de la nota).



martes, 13 de mayo de 2014

Fin del curso online de Datastax: "Java Development with Apache Cassandra"

Ya he terminado el curso online de Datastax "Java Development with Apache Cassandra":

He realizado el examen online hoy día 13/05/2013, habiendo contestado 53 de las 60 preguntas correctamente:
 
Podemos ver un seguimiento del curso, dividido en 7 lecciones (6 de ellas en las que se incluyen practicas), más el test final online. Entre los días 5,6 y 7 de este mes observé los videos de cada lección, tomé apuntes y me hice un resumen. Desde el día 8 hasta hoy día 13 he realizado las prácticas, y hoy el examen:


Aquí podemos ver el certificado que se consigue con este curso online:



Curso Datastax: Cassandra - Practica 6

En esta última practica se añaden vistas estadísticas y se utilizan características avanzadas de Cassandra para optimizar algunas partes de la aplicación.


Ejercicio 1 - Usando contadores para recolectar estadísticas

 
Añadimos la tabla de estadísticas:
CREATE TABLE statistics (counter_name text PRIMARY KEY, counter_value counter);
Implementamos el método StatisticsDAO.increment_counter y SatisticsDAO.decrement_counter. Para incrementar o decrementar un contador debe utilizarse una instrucción update:

 
Comprobamos que la pagina de estadísticas de la aplicación web funciona correctamente; nos dice que tenemos 2 usuarios y 5 playlist, lo comprobamos en el shell:
 
SELECT * FROM users;
username | password | playlist_names
----------+----------+-------------------------------
  astwin1 |     test |            {'test1', 'test2'}
  astwin2 |     test | {'test''3', 'test1', 'test2'}

Ejercicio 2 - Verificando logins leyendo con un mayor nivel de consistencia (quorum)

 
Una de las características de las que dispone Cassandra es que permite escoger el nivel de consistencia que se desee. Por defecto, sólo requiere que una de las replicas de los datos entre los nodos sea leída en una consulta. Se puede escoger un valor más elevado de consistencia, requiriendo que más de una de las replicas de los datos sea leída, comprobada (comprobar que todos los nodos contienen la misma información actualizada) y poder obtener el valor más reciente de un valor.


Debemos modificar el método UserDAO.getUserWithQuorum para añadir un nivel de consistencia de quorum en la consulta:

Ejercicio 3 - Usando paginación

 
Automatic paging introduced in Cassandra 2.0, allows the developer to iterate on an entire ResultSet without having to care about its size: some extra rows are fetched as the client code iterate over the results while the old ones are dropped. The amount of rows that must be retrieved can be parameterized at query time. In the Java Driver this will looks like:
Statement stmt = new SimpleStatement("SELECT * FROM images");
stmt.setFetchSize(100);
ResultSet rs = session.execute(stmt);

Modificar el método  TracksDAO.listSongsByGenre para obtener 200 entradas cada vez (paginación):

Ejercicio 4 - Mejorando el rendimiento de las consultas con una cache de registros

 
En las tablas que más se lean se puede activar una caché para almacenar la últimas consultas. Si las consultas se realizan muy a menudo a esa tabla se puede obtener ventaja, leyendo de la caché en vez tener que traer los datos otra vez del cluster.

Utilizar la herramienta nodetool y el comando info para ver que el tamaño de caché de registros es 0 (también aparecen las estadísticas de la caché):
 

Aumentamos a 50 MB la caché de registros modificando el archivo cassandra.yaml:
astwin@astwin-H87-HD3:~$ sudo gedit /etc/cassandra/cassandra.yaml
# Default value is 0, to disable row caching.
row_cache_size_in_mb: 50
Activamos la caché en alguna de las tablas. Lo hacemos en la de tracks_by_genre por ejemplo:
cqlsh> ALTER TABLE playlist.track_by_genre WITH caching='rows_only';
cqlsh> use playlist ;
cqlsh:playlist> describe KEYSPACE;
 
Reiniciamos Cassandra:
astwin@astwin-H87-HD3:~$ sudo service cassandra restart
Miramos unas cuantas veces la misma consulta en la web de canciones por género y comprobamos las estadísticas de la caché de registros (rows) para ver que sí se ha utilizado la caché (y se habrá obtenido un beneficio en rendimiento en las consultas):
Row Cache        : size 12964446 (bytes), capacity 52428800 (bytes), 27 hits, 32 requests, 0,844 recent hit rate, 0 save period in seconds 

Ejercicio 5 - Variable estática para 'PreparedStatement'

 
Uno de los beneficios de utilizar un PreparedStatement en la API de Java para realizar consultas, es que se puede instanciar el objeto una única vez y reutilizarlo en las posteriores consultas. Se nos pide crear una variable estática de este tipo para que sólamente se tenga que instanciar una única vez:

 

 

lunes, 12 de mayo de 2014

Curso Datastax: Cassandra - Practica 5

En esta práctica se pretende implementar el código para poder añadir y quitar canciones de las playlists creadas por los usuarios.

Ejercicio 1 - Añadir la tabla playlist_tracks

CREATE TABLE playlist_tracks (username TEXT, playlist_name TEXT, sequence_no TIMESTAMP, artist TEXT, track_name TEXT, genre TEXT, track_length_in_seconds INT, track_id UUID, PRIMARY KEY ((username, playlist_name), sequence_no ));

Ejercicio 2 - Método de añadir una canción al playlist

 

Ejercicio 3 - Método de eliminar una canción del playlist

 


Ejercicio 4 - Borrando una playlist entera usando un bloque atómico 

 
Tenemos que completar el método deletePlaylist:
 

Debemos crear una consulta en un bloque atómico que se encargue de borrar la playlist de las tablas users y playlist_tracks:
 

Ejercicio 5 - Comprobar desde cqlsh si todo funciona bien

 
Playlist con dos canciones desde aplicación web:
 
Comprobamos las tablas en el shell:

Borramos una cancion en app. web y las revisamos:
 







 
Borramos la playlist completa:
 









Ejercicio 6 - Utilizando DEVcenter para realizar algunas consultas
 

Creamos un indice secundario en la tabla playlist_tracks:
CREATE INDEX playlist_track_by_genre ON playlist_tracks(genre);
Ejecutamos un par de consultas:


 

 

   

   
 

Búsqueda  de canciones por duración mayor a 120 segundos. Necesitamos un nuevo indice secundario y una consulta con ALLOW FILTERING:
 


Curso Datastax: Cassandra - Practica 4

En esta sesión se pretende agregar cuentas de usuario, donde cada uno de ellos pueda añadir su propio playlist.

Ejercicio 1 - Añadir tabla users

CREATE TABLE users (username TEXT PRIMARY KEY, password TEXT);

Ejercicio 2 - Implementando el método addUser()

Debemos implementar una Ligthweight transaction para asegurarnos que sólo inscribimos a un usuario si no se encuentra en la base de datos ya su username:

Comprobamos que funciona creando un usuario (llamado astwin):
 
 

 





  

Ejercicio 3 - Añadir un Set a la tabla users para almacenar playlist personal

alter table users add playlist_names set<text>  ;

Ejercicio 4 - Código para añadir y eliminar playlists

Tenemos que modificar el código del método PlaylistDAO.createPlayList:
 
 
También el código del método PlaylistDAO.deletePlayList:
 
En el caso de insertar elementos en colecciones, como son los Set, no se pueden crear "Bound Stataments", sino que hay agregar los valores directamente en el string de la consulta CQL. Para evitar el problema que existe con las comillas en un string se cambian por dos comillas, así no existe problema al realizar una consulta mediante el API de java (por ejemplo si la variable nombre de lista es test'3, debemos cambiarla en el código por test''3). Mostramos el código del método createPlayList:

Comprobamos como funciona correctamente (incluso con nombres que contengan una comilla simple '):
 
 
Ahora implementamos el método deletePlayList:

 Comprobamos que funciona eliminando listas desde la aplicación web:

 

 

 

 


Curso Datastax - Cassandra: Práctica 3

Añadiendo funcionalidades a la aplicación web: Playlist

Se pretende añadir la capacidad de ordenar la búsqueda por artista, poder incluir las canciones favoritas seleccionando una estrella y limitar el número de filas que se muestran cuando se realiza una búsqueda por género.

Preparando la práctica

Se propone el uso de un script que borre el keyspace playlist, lo cree de nuevo con todas las tablas y las rellene, en definitiva, que nos permita resetear la base de datos. Se nos indica que añadamos otra nueva tabla track_by_id para poder realizar consultas de canciones por track_id.

Creamos archivo 'playlist.cql':
use system;
// Borramos el keyspace playlist anterior
drop keyspace playlist;

// Creando el keyspace
CREATE KEYSPACE playlist WITH replication = {'class': 'SimpleStrategy', 'replication_factor': 1 };
USE playlist;

// Creamos las tablas
create table track_by_id (track text, artist text, track_id UUID, track_length_in_seconds int, genre text,music_file text, primary key (track_id));
create table track_by_artist (track text, artist text, track_id UUID, track_length_in_seconds int, genre text,music_file text, primary key (artist, track, track_id));
create table track_by_genre (track text, artist text, track_id UUID, track_length_in_seconds int, genre text,music_file text, primary key (genre, artist, track, track_id));

create table artists_by_first_letter (first_letter text, artist text, primary key (first_letter, artist));

// Rellenamos las tablas
copy track_by_id (track_id, genre, artist, track, track_length_in_seconds, music_file) FROM '/home/astwin/Escritorio/Cassandra/Leccion 3/scripts/songs.csv' WITH DELIMITER = '|'  AND HEADER=true;
copy track_by_artist (track_id, genre, artist, track, track_length_in_seconds, music_file) FROM '/home/astwin/Escritorio/Cassandra/Leccion 3/scripts/songs.csv' WITH DELIMITER = '|'  AND HEADER=true;
copy track_by_genre (track_id, genre, artist, track, track_length_in_seconds, music_file) FROM '/home/astwin/Escritorio/Cassandra/Leccion 3/scripts/songs.csv' WITH DELIMITER = '|'  AND HEADER=true;

copy artists_by_first_letter (first_letter, artist) from '/home/astwin/Escritorio/Cassandra/Leccion 3/scripts/artists.csv' WITH DELIMITER = '|';
Para poder ejecutar un scrip desde el terminal cqlsh:
cqlsh:playlist> source '/home/astwin/Escritorio/Cassandra/Leccion 3/scripts/playlist.cql';

Ejercicio 1 - Añadiendo una clausula "ORDER BY" a un comando SELECT

Se ha añadido en la aplicación web en el apartado de artistas ordenado por letra, dos botones de flecha arriba y abajo para poder ordenar la consulta.  Cuando se pulsa uno de estos botones se pasa un parámetro booleano llamado 'desc' al método ArtistsDAO. listArtistByLetter. Si éste parámetro es true los resultados de deben presentar en orden alfabético descendente, y ascendente si es false. 
Modificamos la función añadiendo la clausula ORDER BY a la consulta:
Podemos comprobar como podemos ordenar el resultado de formas ascendente o descendente:



 




 

Ejercicio 2 - Eligiendo el número de resultados de la búsqueda

En la búsqueda por género existe una gran cantidad de canciones. Se pretende limitar el número de resultados de la consulta. Se debe modificar el método TracksDAO.listSongsBygenre():

Modificamos la función añadiendo una clausula LIMIT a la consulta:

Comprobamos que funciona en la aplicación web:


Ejercicio 3 - Canción 'Hot'

Se quiere añadir la funcionalidad de categorizar una canción como 'hot' en el playlist clickeando en la estrella que aparece en la aplicación web al lado de cada canción.
 
Añadir un campo boolean a las tablas que lo necesiten para indicar cuando una canción es 'hot' o no:
cqlsh:playlist> alter table track_by_artist add hot boolean ;
cqlsh:playlist> alter table track_by_genre add hot boolean ;
Modificar el constructor TracksDAO(Row row):

Debemos modificar el método star() para que cambie el estado del campo hot:

Comprobamos que todo funciona bien (la estrella se enciende y se actualiza en la base de datos el valor booleano):


 Ejercicio 4 -Limitar temporalmente que una canción sea 'hot'

  Añadir clausula TTL para que la categorización de hot sólo dure 30 segundos: