SSL/TLS

¿Qué es el SSL/TLS? Veamos un ejemplo sencillo. Si yo quiero contar un secreto a una persona, no lo grito a los cuatro vientos, me acerco a ella y se lo cuento al oído. El hecho de hablar bajo hace que sea difícil que otros se enteren pero, ¿qué pasa si alguien utiliza un sistema de los que usan los espías en las películas para oírnos desde la distancia? La única solución sería hablar en clave, así por mucho que nos escuchen no nos entenderán. Pues en Internet pasa lo mismo, todas las comunicaciones pueden (y son) interceptadas (a veces por usuarios maliciosos y a veces, según lo que dicen los medios, incluso directamente por cuerpos de seguridad y gobiernos). Igual que antes, la solución es hablar en clave, cifrar nuestras comunicaciones.

Y aquí es donde entra el protocolo SSL/TLS. Su funcionamiento es sencillo, cuando voy a enviar un mensaje a un servidor seguro le pido una clave (pública) para cifrar la comunicación que después solo dicho servidor podrá descifrar con su clave (privada). Además, para dar un nivel extra de seguridad, el protocolo comprueba a quién corresponde esa clave y si es de confianza (es decir, que si yo me conecto al dominio “mibanco.com” y me invita a realizar una conexión segura, que las claves efectivamente pertenezcan a quien controla ese dominio). De esto se encarga una tercera entidad, denominada Autoridad Certificadora (CA en inglés), y aquí es dónde se encuentra la magia/problema/negocio: certificar que tú, como administrador, controlas un dominio para generar unos certificados y trabajar con SSL/TLS, cuesta dinero.

La solución gratuita pero no perfecta

Hasta ahora había generalmente dos opciones, la primera de ellas era por supuesto pagar. La segunda, generalmente utilizada por quien no se iba a lucrar con la securización de su sistema, crear una CA propia (es muy fácil hacerlo, os lo prometo) y validar con ella los certificados que se quieran generar. Ejemplo:

#Para simplificar, descargamos el siguiente fichero de configuración de CA
wget https://raw.githubusercontent.com/anders94/https-authorized-clients/master/keys/ca.cnf

#Después creamos nuestra CA
openssl req -new -x509 -days 9999 -config ca.cnf -keyout ca-key.pem -out ca-crt.pem

#Ahora generamos la clave privada del servidor (esta no se comparte con nadie)
openssl genrsa -out server-key.pem 4096

#A continuación debemos generar una petición de firma de certificado, para ello primero descargamos un fichero de configuración para simplificar
wget https://raw.githubusercontent.com/anders94/https-authorized-clients/master/keys/server.cnf

#Y posteriormente generamos la petición
openssl req -new -config server.cnf -key server-key.pem -out server-csr.pem

#Para terminar firmamos la petición con la CA y ya tenemos nuestro certificado listo para montar un servidor que soporte la comunicación segura
openssl x509 -req -extfile server.cnf -days 999 -passin "pass:password" -in server-csr.pem -CA ca-crt.pem -CAkey ca-key.pem -CAcreateserial -out server-crt.pem

Problema, cuando accedemos a un dominio que ha validado sus certificados mediante una CA no reconocida, que no tiene prestigio (¿que no cobra por ellos?), el navegador nos lanza una alerta como esta.

Esto se debe a que el navegador no tiene instalado por defecto el certificado de la CA y, por tanto, no la reconoce. Y esto, por supuesto, no genera demasiada confianza en el usuario…

Let’s Encrypt al rescate

Ya existían otras alternativas gratuitas que hacían de CA, pero su problema era el mismo que cuando generábamos una CA por nuestra cuenta: la confianza (o falta de) del navegador. Y entonces apareció Let’s Encrypt. Básicamente hacen lo mismo, pero esta vez tienen a muchos grandes de la industria apoyando la idea y han conseguido algo clave, la confianza de los navegadores. Para más información en cuanto a cómo obtienen esa confianza y cuáles son los navegadores soportados, os recomiendo visitar este post en su foro.

Si bien existen varias formas de conseguir los certificados para nuestros servidores a través de Let’s Encrypt, todas ellas bien documentadas y también explicadas a través del soporte de la comunidad, vamos a hacer una rápida prueba de concepto para securizar la comunicación con un servidor montado en una Raspberry Pi, uno de los dispositivos más populares en la actualidad con permiso de los Arduino, BeagleBoard o Teensy.

#En primer lugar, debemos asegurarnos de que los puertos 80 y 443 del router donde se encuentre la RPi están abiertos y el tráfico redirigido al servidor (la RPi). Let’s Encrypt los utiliza para validar el dominio.
#Después descargamos la última versión de Let’s Encrypt en /usr/local/src
git clone <a href="https://github.com/letsencrypt/letsencrypt" data-mce-href="https://github.com/letsencrypt/letsencrypt">https://github.com/letsencrypt/letsencrypt</a>

#Para este ejemplo utilizaremos el modo “Standalone” (más información en la documentación de Let’s Encrypt). No olvidarse de modificar el e-mail de contacto, con el que nos notificarán entre otras cosas de la caducidad de certificados (sí! caducan!) y el dominio para el que se quieren generar los certificados.
sudo ~/.local/share/letsencrypt/bin/letsencrypt certonly --agree-tos --email mymail@mail.com&nbsp; --standalone --domains midominio.com

#Los certificados se guardarán en /etc/letsencrypt (las carpetas “archive” y “keys” contienen las claves y certificados generados previamente, mientras que “live” contiene symlinks a las últimas versiones).
#Como se comentaba previamente, los certificados caducan, de hecho cada 90 días según la política de Let’s Encrypt, con lo que habrá que renovarlos, y mejor si es de forma automática.
#Para ello generamos un scrypt en /etc/letsencrypt
sudo nano auto-renewal.sh
#Con el siguiente contenido:
sudo ~/.local/share/letsencrypt/bin/letsencrypt certonly --standalone --domains claorden-home.du$
sudo cp /etc/letsencrypt/live/claorden-home.duckdns.org/fullchain.pem /var/www/rest-api/ssl/
sudo cp /etc/letsencrypt/live/claorden-home.duckdns.org/privkey.pem /var/www/rest-api/ssl/

#Aquí se podría añadir algún subscrypt que nos notifique de la renovación, por ejemplo mandando un mail o una notificación push a nuestro móvil.
#Le damos permisos de ejecución
sudo chmod +x auto-renewal.sh

#Y añadimos a crontab para que se ejecute de forma periódica
crontab -e

#el siguiente contenido:
#Run monthly, also use "@monthly"
0 0 1 * * /etc/letsencrypt/auto-renewal.sh

Con esto ya tenemos listos nuestros certificados. Ahora cuando montemos nuestro servidor en casa, debemos consultar según el sistema (Nginx, Node, Apache, IIS…) cómo realizar la comunicación mediante HTTPS y utilizarlos según las recomendaciones de cada uno. Así, al acceder a nuestro servidor podremos ver ese candado verde al lado de la URL que nos indica que la conexión es segura y quién ha verificado los certificados.

Y recordad, la próxima vez que contéis algún secreto por Internet, mejor decirlo en voz muy baja y al oído, que como diría mi compañero Iskander, el que avisa…

The post HTTPS con Let’s Encrypt, ¡protege tus comunicaciones! appeared first on S3lab.

Para empezar a jugar, vamos a descargar un conjunto de datos que contiene una buena cantidad de muestras de correo electrónico legítimo y correo electrónico ilegítimo (spam): SpamAssassin. Si abrimos este conjunto de datos con WEKA e intentamos realizar alguna clasificación como la vista en los artículos anteriores, veremos que la gran mayoría de algoritmos no están disponibles (aparecen en un tono grisáceo). Si volvemos a la pestaña de pre-procesado y nos fijamos en los atributos del conjunto de datos, podemos observar que solo cuenta con dos: el contenido del e-mail, de tipo texto (text) y la clase, spam/legitimate ($category$). Si bien ya habíamos trabajado anteriormente con el tipo nominal (el tipo de la variable clase) el tipo texto es nuevo, y para poder trabajar con él debemos adaptarlo a las necesidades de los clasificadores. El motivo principal: la gran mayoría de algoritmos con los que vamos a realizar pruebas no “entienden” el texto, con lo que debemos “traducirlo” a variables numéricas.

Y aquí es donde entra el Modelo de espacio vectorial (del inglés, VSM), que se encarga de representar esas palabras que encontramos en el contenido textual en un espacio vectorial de modo que los algoritmos de aprendizaje automático de WEKA puedan trabajar con ellos. Para representar nuestros mails de esta forma, debemos ir al apartado de pre-procesado en WEKA y seleccionar el filtro “StringToWordVector” que podemos encontrar en: filters-unsupervised-attribute.

Lo mejor que podemos hacer para ver las transformaciones es aplicar el filtro con las opciones por defecto, guardar el conjunto de datos transformado (añadiéndole el sufijo “_BOW” por ejemplo, del inglés Bag Of Words) y ver los resultados. Si abrimos el nuevo “Spam_Assassin_BOW” con un editor de textos, veremos que ya no tenemos solo 2 variables. Lo que hemos hecho es conservar la variable que contiene la categoría, el tipo de mensaje, y convertir la variable de tipo texto en todos los términos encontrados en el contenido de todos los mensajes del conjunto de datos. Si bajamos hasta la sección que contiene los datos (@data), podremos observar como cada e-mail se ha representado a través de parejas de números, correspondiendo el primero de ellos al número de atributo y el segundo a la aparición del mismo o no (1 o 0) en dicha instancia. Si bien de esta forma ya podemos representar ese texto de una forma matemática, la simple indicación de si un e-mail contiene o no un término no es un método muy preciso (ya que por ejemplo podría aparecer múltiples veces y no verse aquí reflejado). Así, accediendo a las opciones del filtro podremos incluir nuevas transformaciones que nos proporcionen un conjunto de datos más adecuado.

En primer lugar, nos encontramos con las transformaciones TF e IDF. Con la primera de ellas conseguimos la frecuencia de los términos en los documentos, es decir, la relevancia de cada palabra respecto al documento (al e-mail), en base a la extensión y número de apariciones. Con la segunda, frecuencia inversa de documento, obtenemos la relevancia de cada término respecto a la colección, es decir, si un término es representativo no solo para un documento sino para todo el conjunto.

Juntando ambas transformaciones conseguimos una representación mucho más interesante para nuestro conjunto de datos. Probemos ahora a aplicar cada una de las combinaciones y guardemos los resultados (“Spam_Assassin_TF”, “Spam_Assassin_IDF” y “Spam_Assassin_TFIDF”) para después compararlos abriéndolos con un editor de texto. Si seguimos investigando las opciones nos encontramos con otras como los atributos sobre los que queremos operar (attributeIndices), si queremos obtener las frecuencias de los términos por clase o respecto a toda la colección (doNotOperateOnPerClassBasis), si queremos reducir los términos a su raíz (stemmer), las palabras que queremos eliminar por carecer de valor semántico (stopWords), la forma de obtener los términos (tokenizer) o las palabras a quedarse por cada clase (wordsToKeep). Para obtener más información podemos pinchar en la opción “More”, que nos ofrecerá una descripción de cada una de las opciones disponibles.

Ahora que ya podemos dar por finalizada la representación de nuestro conjunto de datos de forma que los algoritmos de clasificación de WEKA puedan entenderlos, podemos pasar a la pestaña “Classify”, probar algunos de los algoritmos y valorar su funcionamiento siguiendo las medidas de calidad deseadas. No nos olvidemos por cierto de seleccionar el atributo clase antes de iniciar la clasificación (en la misma sección de clasificación) después de seleccionar el algoritmo deseado, o bien de reordenar los atributos como vimos en entradas anteriores. Y con esto ya tenemos el conocimiento básico para crear un clasificador de documentos.

Ahora solo queda decidir a cuál de las múltiples áreas que existen actualmente queremos aplicar estos métodos y, después, descubrir la forma de conseguir la mayor cantidad de datos (a poder ser de forma legal) para entrenarlos y conseguir así el mejor funcionamiento posible. Porque recordad, el conocimiento es poder y hoy en día ese conocimiento se fundamenta en nuestros datos.

The post WEKA, de los datos a la información (Parte III) appeared first on S3lab.

Después de introducción a Weka que vimos hace unas semanas, en el post de hoy trataremos de profundizar un poco más en esta herramienta. Para empezar, vamos a descargar un conjunto de datos nuevo con características sobre la producción vinícola: wine.arff. Para visualizar su contenido, podemos abrirlo directamente y seleccionar Weka como herramienta predeterminada o dentro de la sección Explorer y pestaña Preprocess, abrir el fichero.

Si repasamos los atributos del dataset, vemos que aparece como primero de ellos “class”, la clase de cada uno de los elementos que lo componen. En este caso tenemos las clases 1, 2 y 3, correspondientes a diferentes categorías de vino. Por defecto, Weka entiende que el último atributo será la clase de cada uno de esos elementos, por lo que lo primero que vamos a hacer es jugar un poco con los filtros para transformar nuestros datos. Abrimos entonces la sección Filter dentro de la misma pestaña Preprocess. Ahí vemos una gran cantidad de opciones, veremos algunas de ellas en ésta y en próximas entregas. Ahora seleccionamos unsupervised-attribute-REORDER. Este filtro nos permite ordenar nuestros atributos. Una vez seleccionado pinchamos en el nombre del propio filtro y nos aparecerá una ventana con opciones.

Cambiamos los parámetros de attributeIndices por “2-last,first” y pulsamos OK. Después seleccionamos Apply. Esos parámetros nos permiten reordenar los atributos a nuestro antojo de una forma sencilla (nótese que estos cambios no se han guardado en el fichero del conjunto de datos, están en memoria, si queremos conservarlos, deberemos guardarlos mediante la opción Save). Si el resultado del filtro aplicado no termina de convencernos, siempre podemos volver al estado anterior mediante la opción Undo. Probemos una clasificación rápida (e.g., Naive Bayes) y veamos los resultados. Son buenos pero siempre se puede intentar mejorarlos tratando un poco más nuestro conjunto de datos.

Antes de seguir viendo filtros, vamos a descubrir una nueva funcionalidad disponible en Weka desde la versión 3.7, el gestor de paquetes. Cerramos la ventana del Explorer y dentro de la ventana inicial seleccionamos Tools-Package Manager. Aquí tenemos un listado de módulos que ofrecen nuevas opciones a las ya de por si extensas disponibles por defecto. Busquemos por ejemplo el paquete SMOTE dentro de la categoría Preprocessing y lo instalamos. Este filtro genera nuevas muestras de forma sintética, lo que ayudará en los casos en los que el número de elementos empleados para generar el modelo (el “conocimiento”) no es demasiado extenso, como puede ser el caso de nuestro dataset de vinos. Porque recordemos, al igual que en la vida real, cuanto mayor es nuestro conocimiento mayor es nuestra capacidad de identificar elementos, de clasificarlos.

Volvemos al explorador y buscamos el filtro supervised-instance-SMOTE. Sin cambiar los parámetros de configuración del filtro, lo aplicamos. Vemos que pasamos de 178 instancias (elementos) a 226. Si probamos a clasificar de nuevo con el mismo algoritmo de antes, se puede apreciar una ligera mejoría en los resultados.

Y con ésto terminamos por hoy. Próximamente veremos cómo aplicar este tipo de algoritmos a textos, porque si alguno ha encontrado o generado un conjunto de datos con, por ejemplo, contenido de webs, tweets o e-mails habrá observado que no era posible realizar la clasificación siguiendo los pasos vistos hasta ahora. Con ello empezaremos a adentrarnos en el extenso mundo de la clasificación automática de textos, una de las bases para multitud de herramientas que usamos día a día.

The post WEKA, de los datos a la información (Parte II) appeared first on S3lab.

Bloom Filter es una manera extremadamente eficiente de preguntar si un dato existe en un conjunto o no (lo cual utiliza Cassandra para evitar accesos a disco en vano, que es la parte más lenta del tinglado). ¿La pega? Es un algoritmo probabilista y puede haber falsos positivos (aunque nunca falsos negativos).

Funciona con dos elementos:

• Un array de m bits, inicializado a a cero.
• Un conjunto de k funciones hash que, dado un dato, generarán números entre 0 y m-1.

Cuando insertemos un dato lo pasaremos por las funciones hash, las cuales nos devolverán posiciones del array donde cambiaremos sus valores a 1. Así, cuando lleguen nuevas cadenas, para saber que seguro el elemento no existe en el conjunto, solamente debemos comprobar que alguna de las posiciones en el array generada por alguna de las funciones hash nos devuelve 0.

Para intentar enteder esto mejor vamos a hacerlo con un pequeño juego.

Imaginemos una partida de «¿Quién es quién?», pero con multiples sospechosos. El jugador A añade sospechosos, y el jugador B pregunta al jugador A en base a los atributos de los sospechosos. En este caso los sospechosos serán los datos, sus atributos serán las funciones hash, y la lista total de atributos que guarde el jugador A será el array de bits. Éstos serán nuestros sospechosos.

Pongamos que el jugador A añade como sospechoso a Bill Gates. Eso significa que ahora el jugador A tiene como características «Rico», «Filántropo» y «Gafas». Por lo tanto, cuando el Jugador B pregunte por Steve Jobs, pese a que las propiedades de «Gafas» y «Rico» si que están, la de «Americano» no, así que puede estar seguro de que Steve Jobs no es uno de los sospechosos.

Pero, ¿qué pasa si ahora añadimos a Mark Zuckerberg? Al hacerlo, añadimos dos propiedades nuevas, por lo tanto ahora nuestra lista de características será la siguiente:

«Rico», «Filántropo», «Gafas», «Americano» y «Joven».

Así que, ahora, ¿qué pasa si preguntamos por Steve Jobs otra vez? Como todos sus atributos están en la lista, podríamos pensar que es uno de los sospechosos, pero no es el caso. Es decir, podemos estar seguros de cuándo alguien no es sospechoso, pero nunca de si lo es. Si insertamos a Steve Jobs nuestra lista no se alterará. ¿Qué pasa entonces si preguntamos por Stephen Hawking? Incluso con tres sospechosos ya metidos, como Stephen Hawking tiene dos atributos que aún no han sido insertados, podemos afirmar categóricamente que no está en la lista de sospechosos.

Y así funciona (muy por encima). Si queréis información en mayor profunidad, sobre cómo por ejemplo hacer para reducir el porcentaje de falsos positivos, o cómo lidiar con con borrados aquí tenéis una página interesante.

Why Bloom filters work the way they do

Y si os apetece jugar un poco con él, en esta web podréis encontrar diversas implementaciones en python, que os pueden ser útiles cuando queráis manejar grandes datos, como por ejemplo… datos del Titanic

Fast Non-Standard Data Structures for Python

The post Bloom Filter, un algoritmo como un juego de Hasbro appeared first on S3lab.

Una vez descargado e instalado, antes de comenzar a usarlo, deberemos buscar en el directorio de instalación de WEKA el fichero “RunWeka.ini” y modificar la línea “maxheap=” para aumentar la capacidad de la máquina virtual de Java y posibilitar así trabajar con volúmenes de datos más importantes. Un buen valor podría ser, siempre dependiendo de la cantidad de memoria RAM disponible, 4 gigas, quedando la línea entonces como: “maxheap=4G”. Ahora sí, ejecutamos WEKA. Para empezar, tenemos dos opciones de ejecución, “con” y “sin” consola. El primero nos ofrece constante feedback sobre lo que vayamos haciendo con la herramienta y puede ser de gran utilidad cuando nos encontremos con algún error durante el análisis de nuestros datos. Una vez iniciado WEKA, nos encontramos con varias opciones.La opción Explorer nos ofrece la posibilidad de trabajar con nuestro conjunto de datos, visualizarlo y pre-procesarlo, y por supuesto también realizar análisis y clasificaciones. La opción Experimenter nos permite, una vez tenemos nuestros datos preparados, realizar análisis de forma más automatizada/masiva. KnowledgeFlow es una herramienta que nos ayuda a crear un flujo de análisis de forma muy visual, arrastrando elementos al espacio de trabajo. Por último SimpleCLI nos permite realizar el tratamiento y análisis desde consola. En este artículo, nos limitaremos a conocer un poco la herramienta Explorer, vamos con ello.

Como vemos, nos encontramos diversas pestañas con una serie de opciones para tratamiento (Preprocess), clasificación (Classify-Cluster-Associate-Select attributes) y visualización de datos (Visualize). Por el momento vemos que la mayoría de opciones se encuentran desactivadas, el motivo, necesitamos cargar un conjunto de datos. Uno clásico para pruebas en WEKA es el de Iris, pero podemos escoger cualquiera o crear uno nosotros mismos en alguno de los formatos soportados (entre los que se incluye por ejemplo el formato csv). Si abrimos alguno de los ficheros con formato ARFF (específico de WEKA), podemos observar una primera sección de atributos, definidos mediante “@ATTRIBUTE”, y la sección de los datos propiamente dichos, delimitada por “@DATA”. Cada una de las líneas de la sección de datos (e.g., “5.1,3.5,1.4,0.2,Iris-setosa”) nos indican el valor tomado por cada uno de los atributos, siendo en este caso el último la clase de Iris de esa muestra.

Ahora sí, una vez cargado el conjunto de datos en WEKA, se nos activan todas las opciones y podemos comenzar a jugar con ellos. En la parte izquierda, podemos ver los atributos y si seleccionamos alguno de ellos veremos en la derecha los valores que toman. Por ejemplo, si seleccionamos el atributo “class” WEKA nos mostrará los diferentes tipos de Iris que componen el conjunto de datos: Iris-setosa, Iris-versicolor-Iris-virginica (en este caso con 50 instancias de cada una). En la parte izquierda, podemos ver los atributos y si seleccionamos alguno de ellos veremos en la derecha los valores que toman. Por ejemplo, si seleccionamos el atributo “class” WEKA nos mostrará los diferentes tipos de Iris que componen el conjunto de datos: Iris-setosa, Iris-versicolor-Iris-virginica (en este caso con 50 instancias de cada una). Una opción muy interesante en esta sección es la de Filter, que nos permitirá pre-procesar el conjunto de datos, eliminando atributos, ordenándolos, realizando transformaciones de los datos o, incluso, generando muestras de forma sintética. En próximas entradas iremos analizando estas opciones con más detalle para ver las inmensas posibilidades que ofrecen. Por el momento, y para ir acabando por hoy, pasemos a la pestaña de clasificación.

Aquí nos encontramos en primer lugar con la selección del clasificador (Classifier), donde podremos elegir qué algoritmo será el que determine el valor del atributo que queremos clasificar, en este caso “class”, la clase de Iris. Podemos observar que algunos algoritmos están desactivados, esto se debe al tipo de datos que tenemos cargados (también en próximas entregas, veremos con más detalle las limitaciones que tienen algunos algoritmos de clasificación y cómo solucionarlas). Por último, dentro de las opciones de prueba (Test options) nos encontramos con diversas posibilidades de cara a evaluar el funcionamiento de cada uno de los algoritmos que probemos. Por defecto tenemos seleccionada la validación cruzada (Cross-validation) con 10 folds. Este método divide el conjunto de datos en X subconjuntos, empleando X-1 para entrenar y 1 para comprobar, y realiza X iteraciones (siendo X el número de folds) este proceso.

Cuando se habla de entrenar y testear, muy resumido, los algoritmos analizan las características (atributos) del conjunto de entrenamiento y con eso generan los modelos de clasificación (el “conocimiento”) para después pasar a clasificar las muestras del conjunto de testeo en base a sus características. Ya que todo el conjunto de datos que estamos probando es conocido, es decir, conocemos la clase de Iris de cada una de las muestras, cuando el algoritmo termina de clasificar podemos comprobar si el resultado ha sido correcto. Esto nos indicará lo bien que lo hace cada uno de ellos y así decidir cuál será interesante utilizar cuando queramos emplearlo para clasificar muestras que son realmente desconocidas.

Pasemos entonces a hacer una prueba rápida. Seleccionamos dentro de los clasificadores NaiveBayes, dentro de Bayes, un clásico con una buena relación rendimiento-resultados, y comenzamos la clasificación (Start). A la derecha podremos ver el resultado obtenido por el algoritmo elegido. Aunque hoy no vamos a entrar a analizar en detalle estos resultados, podemos ver que ha conseguido clasificar correctamente un 96% de las muestras de prueba. Esto nos indica que, teóricamente, ante nuevas muestras desconocidas, facilitando atributos como la longitud y anchura de pétalo y sépalo, seríamos capaces de conocer el tipo de Iris que correspondería. Y con esto acabamos una toma de contacto muy rápida con WEKA, una potente herramienta para el tratamiento y análisis de datos. Como decíamos, en próximas entregas iremos profundizando para conocer con más detalle la infinidad de opciones que ofrece. Por el momento, ya podemos empezar a entender cómo funcionan estos sistemas, una de las piezas claves de este siglo XXI, el siglo del flujo de información, el análisis de datos y el profiling de usuarios.

The post WEKA, de los datos a la información (Parte I) appeared first on S3lab.

Hay gente a la que nos encanta jugar con los datos. Ver que nos pueden ofrecer, que podemos obtener con ellos, si podemos adivinar el futuro gracias a ellos, … es realmente una ciencia apasionante. En los últimos años ha crecido el interes por gente que tenga la habilidad de manejar estos datos y poder sacar conclusiones de ellos. Esto se ha vuelto cada vez más necesario, pues hay grandes cantidades de empresas que almacenan datos pero no son capaces de sacar provecho de ellos. Así, ha nacido la figura del «científico de datos» o «data scientist», que no es más que alguién con amplios conocimientos en el campo de las matemáticas y que es capaz de interpretar datos para sacar conclusiones, predicciones o visualizaciones de ellos.

Hoy vamos a jugar un poco con los datos, y con una serie de herramientas que facilitan este manejo. Para empezar, necesitamos dos cosas. En primer lugar, los datos. En esta ocasión tenemos un conjunto de datos del hundimiento más célebre de la historia de la nautica: el Titanic (que además viene con concurso). Los datos nos los podemos bajar de aquí. Por otro lado, necesitamos un objetivo. Vamos a desarrollar una heurística para adivinar si un pasajero sobrevivió o no al hundimiento. En concreto, necesitamos una heurística que tenga una tasa de acierto superior al 80%. Ya tenemos todo lo necesario para empezar.

Para realizar el análisis, podemos usar cualquier herramienta. Nosotros vamos a utilizar Pandas, una biblioteca para el análisis de datos sobre Python. Esta biblioteca permite hacer operaciones sobre los datos y facilita mucho el manejo de ellos.

Antes de empezar a desarrollar una heurística, es importante familirizarse con el problema y con los datos. Pero en este caso, ¿va a ser sencillo, no? Todos sabemos la historia del Titanic, el hundimiento, y hemos visto en el cine o en libros cómo fueron aquellos angustiosos momentos. Veamos entonces el conjunto de datos que tenemos. En concreto, vamos a ver algunas de las variables del conjunto de datos.

• survival: indica si la persona sobrevivió al incidente o no.
• pcclass: indica la clase en la que viajaba el pasajero.
• sex: indica el sexo del pasajero, male para los hombres y female para las mujeres.
• age: edad del pasajero.

El conjunto de datos posee otros dastos, pero este puede ser un buen comienzo. Si hacemos caso al dicho clásico del mar («las mujeres y los niños primero»), con estas variables podemos hacer una buena predicción.

Es el momento de empezar a prepara un pequeño script que nos permita verificar si nuestra heurística es buena. Podemos empezar con este.

import pandas

    def obtener_prediccion(path_csv):
        """Metodo que implementa la heuristica"""
        return None

    if __name__ == '__main__':
        dataset = 'dataset/titanic_data.csv'
        # Obtenemos las predicciones y leemos el conjunto de datos.
        resultado_heuristica = obtener_prediccion(dataset)
        dataset = pandas.read_csv(dataset)

        # Aplicamos magia de Python, para crear un diccionario con el id del
        #  pasajero y si comprobar si ha sobrevivido o no
        sd = dict(zip(dataset.PassengerId, dataset.Survived))
        # Calculamos el porcentaje de supervivientes de nuestra heuristica
        correcto = 0

        for key in set(resultado_heuristica):
            if(resultado_heuristica[key] == sd[key]):
                correcto += 1
        print (100) * (correcto / float(len(resultado_heuristica))), "%"

Y ya tenemos listo nuestro banco de pruebas para probar. Ahora es el momento de probar heurísticas. Dado el conocimiento previo que tenemos, sabemos que si el pasajero es mujer tiene más probabilidades de sobrevivir que si es hombre, luego vamos a probar una heurística muy sencilla:

 def obtener_prediccion(path_csv):
        """Metodo que implementa la heuristica"""

        # Diccionario donde guardamos la predicción
        prediccion = {}

        # Leemos el fichero del csv
        df = pandas.read_csv(path_csv)

        # Por cado uno de ellos, calculamos los valores de la predicción
        for pasajero_index, pasajero in df.iterrows():
            #Agregamos la prediccion
            pasajero_id = pasajero['PassengerId']

            # Si el pasajero es muher, entonces predecimos que ha sobrevivido
            if (pasajero['Sex'] == "female"):
                prediccion[pasajero_id] = 1
            else:
                prediccion[pasajero_id] = 0
        return prediccion

Y con ello obtenemos el siguiente resultado:

78.6756453423 %

¡Ya estamos muy cerca, y sólo en el primer intento! Pero ¿cómo podemos mejorar el resultado? Con nuestro conocimiento de la materia. Por ejemplo, sabemos que no sólo las mujeres tenían preferencia en los botes salvavidas, sino que también los niños. Añadimos la condición a nuestra heurística.

 if (pasajero['Sex'] == "female" or pasajero['Age'] < 12) and (pasajero['Pclass'] == 1 or pasajero['Pclass'] == 2):
     prediccion[pasajero_id] = 1
 else:
     prediccion[pasajero_id] = 0

Y el resultado es:

80.0224466891 %

¡LO CONSEGUIMOS! Hemos desarrollado una heurística que es capaz de predecir si una persona fue superviviente del Titanic sólo sabiendo el sexo, la edad y la clase en la que viajaba.

Este es, de forma resumida, el trabajo de un científico de datos. Primero, es vital conocer el dominio sobre el que estamos trabajando. Posteriormente, es necesario recopilar los datos y adecuarlos para poder trabajar mejor con ellos. También es vital fijarse un objetivo (¿qué queremos saber?) y posteriormente generar los modelos para extraer esa información. Un último paso es utilizar esa información, bien sea a través de la visualización de los datos, a través de informes o dentro de una aplicación para mejorar su rendimiento.

Este trabajo ofrece muchas posibilidades y permite ver los hechos desde una perspectiva distinta. Es un trabajo cada vez más útil, dado el volumen de datos que manejamos. Al final, los datos no son más que el reflejo objetivo de la realidad, pero debemos tener cuidado. Únicamente muestran un parte de la realidad, y a los seres humanos nuestra imaginación y nuestros sesgos a menudo nos juegan malas pasadas.

Y tú, ¿cómo mejorarías la heurística?

PD: Este ejercicio forma parte de un curso de Udacity. Si te interesa adentrarte en este mundo, igual es un buen punto de partida.

The post Comenzando como científico de datos appeared first on S3lab.