Creando modelos predictivos con Knime: 3. Tratamiento y Conversiones de Datos

En este apartado vamos a realizar un filtrado de datos. En mi caso, he visto conveniente tratar los “Missings” y los “Outliers”, una selección por ciudad, así como una serie de conversiones de datos que vamos a ver a continuación.


1. Tratamiento de Missings

En mi caso, he tratado los Missings eliminando en caso de tratarse de valores de tipo String y sustituyendo por el siguiente valor al missing en caso de tratarse de un valor numérico.

Esta decisión me ha parecido la más interesante puesto que las temperaturas no suelen variar mucho por lo general de un día a otro.

Un missing no es más que un dato que no tenemos en nuestro dataset, ya sea por fallos en sensores (en este caso de temperaturas), o de cualquier otro fallo, ya sea humano o tecnológico. Dichos fallos, hay que tratarlos o eliminarlos (depende de la estrategia que quieras usar) para que beneficie a nuestro modelo.

2. Tratamiento de Outliers

Para la eliminación de Outliers he optado por eliminar aquellos outliers para la variable “Casos Totales”, puesto que al realizar pruebas de outliers para todas las variables se perdía demasiada información valiosa para generar el modelo predictivo.

Un Outlier (fuera de serie, por cierto, os recomiendo este libro de Malcom Gladwell), es un dato en nuestro dataset que está muy lejos de la media representativa en ese conjunto de datos. Aunque es un término estadístico, lo podríamos explicar de forma sencilla con el siguiente ejemplo: Imagina que las temperaturas que tenemos para los 7 días de la semana son 20 23 25 22 57 25 23. En este caso 57 sería un outlier. Ojo! aunque los outliers pueden ser errores humanos o errores en determinados medidores de los datos, también puedes ser representativos en nuestro modelo, por eso conviene estudiarlos muy detenidamente dependiendo de los datos con los que estemos trabajando.

3. Conversiones

Otro paso necesario ha sido el de las conversiones. Puesto que los datos de temperaturas estaban en grados Kelvin y en grados Celsius, he convertido todas las variables con valores en Kelvin a Celsius con el objetivo de poder compararlos mejor.

4. Selección (por ciudad)

Quizás el paso más sencillo del modelo. Simplemente dividimos por ciudad para generar de forma independiente diferentes submodelos. Esto lo realizo porque considero que es interesante puesto que las condiciones geográficas y climáticas de ambas ciudades (San Juan y Iquitos) son muy diferentes.

Creando modelos predictivos con Knime: 2. Origen de datos y diccionarios

En este punto pasamos a describir el modelo realizado para la solución del problema: 

“DengAI: Predicting Disease Spread”

1. Origen de los Datos

El primer paso para comenzar con nuestro modelo es obviamente la entrada de los datos con los que vamos trabajar. 

En este caso se proporcionaron dos archivos, uno con toda la información referente a temperaturas y condiciones climáticas y geográficas, y otro archivo con la información referente a los casos totales de dengue.

Sendos archivos se fusionan para conseguir un dataset coherente para su posterior análisis

2. Diccionario de Datos

Con motivo de conseguir una mayor legibilidad y entendimiento de nuestros datos, en el segundo paso hemos creado un diccionario de datos. Dicho diccionario sirve para cambiar los nombres de variables a nuestro antojo y el cual se realiza de forma muy sencilla mediante un archivo xls con los nombres que queramos asignarles. 

Un ejemplo sería:
  • Dato origen → Dato post-diccionario
  • t_cases → casos_totales



Creando modelos predictivos con Knime: 1. Introducción y Datasets

En esta serie de artículos vamos a ver paso a paso cómo crear un modelo predictivo con el software Knime, así que antes de nada te invito a que vayas a este artículo donde te hice un tutorial sobre este software paso a paso.

Como os decía, vamos a crear un modelo predictivo con el software Knime para un problema real, propuesto en la web de drivendata.org en el que vamos a poder obtener archivos de entrenamiento y test para crear nuestro modelo y posteriormente podremos subir un archivo submission con nuestras predicciones para comprobar cuanto error tiene nuestro modelo predictivo, o también conocido como MAE (Mean Absolute Error).

1. Crear cuenta en drivendata.org

El primer paso será crearnos una cuenta en drivendata.org.

2. Descargar los datos para usarlos en Knime

Para ello es tan sencillo como irnos a "Competitions" y buscar un reto.
En nuestro caso hemos elegido "DengAI: Predicting Disease Spread". A continuación haremos clic en "Data Download para descargar los datos y trabajar posteriormente con ellos.
Como podemos ver en este apartado podremos descargar los diferentes Datasets y ver las instrucciones de dicha "competition".
Aunque este es el primer artículo, y volviendo al software Knime, os enseño para ir abriendo boca, la siguiente imagen de lo que va a ser la estructura de nuestro modelo dentro de este software.

En la imagen pueden verse los diferentes pasos secuenciales que he realizado para generar mi modelo. Espero pueda verse con claridad la estructura principal del mismo. A continuación (en siguientes posts), vamos a ver de forma más detallada (entrando dentro de cada metanodo) para que pueda observarse con mayor detalle.

Primeros pasos en Knime, el mejor software para minería de datos

Hoy vamos a dar los primeros pasos con Knime, un excelente software de analisis de Data Mining, Minería de datos en español o para la explotación de Big Data. Se trata de un software gratuito que puedes desde descargar aquí

Qué vamos a ver sobre Knime en este artículo

En este artículo aprenderemos a hacer las siguientes cosas con Knime:
  • Importar Datasets
  • Creación de Diccionarios
  • Ampliación de estadísticas
  • Conversiones de tipo

Nodos que vamos a usar

En este artículo usaremos los siguientes nodos de Knime
  • Nodos de entrada de datos
  • Boxplot
  • Statistics
  • Numeric to String

Datasets que usaremos

En este artículo vamos a usar un Dataset del Titanic y el de Iris

Dataset del Titanic

Importar Datasets en Knime

Importar Datasets en Knime es realmente sencillo. Dependiendo del tipo de archivo que sea (xls, csv...) usaremos uno de los nodos que Knime nos ofrece. En este caso vamos a Importar el dataset de Iris que es un archivo xls con el nodo "Excel Reader (XLS)".
  1. Buscamos el nodo en "Node Repository"
  2. Arrastramos el nodo a la pizarra para trabajar con el.

Importar Datasets en Knime

A continuación:
  1. Hacemos clic derecho > Configure para configurar el nodo (este proceso será igual para todos los nodos).
  2. Elegiremos la ruta de nuestro equipo donde esté el dataset.

Importar Datasets en Knime

Podemos marcar o no la casilla que os muestro a continuación, dependiendo del dataset.

Importar Datasets en Knime

Creación de Diccionarios en Knime

Crear un diccionario en Knime, nos ayudará a darle mejor visibilidad y legibilidad a nuestro dataset. Teniendo en cuenta que lo más probable es que sean datos que nos den, podremos modelar un archivo xls para darle nuevos nombres a las variables de nuestro dataset como vemos en la siguiente imagen. En este caso estamos haciendo uso del dataset de Titanic.



Ahora vamos a hacer uso del nodo "Insert Column Header" para añadir las columnas y del "Excel Reader (XLS)" para añadir nuestro diccionario. Hay que tener cuenta que en este caso el dataset está añadido desde el nodo "CSV Reader".



Como podemos ver, en la imagen de arriba, tendremos que seleccionar la ruta del diccionario.


Configuramos el nodo "Insert Column Header" y como podemos ver, los datos nos aparecerán con una nueva cabecera, justo la que hemos creado con el diccionario de datos.


Analizar distribuciones para variables específicas en Knime

A continuación, vamos a ver gracias al nodo "Conditional Box Plot" el boxplot o también llamado Caja de Bigotes para conocer entre otros datos de interés los quartiles de nuestros datos para variables específicas. En este caso para el dataset de Iris.



En este caso podemos ver claramente como la altura del sépalo varía mucho de un tipo de Iris a otra.


Ampliación de estadísticas en Knime

Un nodo muy interesante y con el cuál podremos conocer innumerables datos e incluso histogramas es "Statistics" que nos ofrece datos estadísticos sobre nuestros datos. Entre muchos otros el máximo, mínimo, media, varianza, kurtosis...

Estadísticas en Knime
Estadísticas en Knime

Conversiones de tipo en Knime

Cuando trabajamos con Knime, a veces, es necesario cambiar el tipo de dato, como por ejemplo, de String a Numérico o viceversa y para ello tendremos sendos nodos que nos ayudarán en las conversiones de tipo de forma muy sencilla.

Conversiones de Tipo en Knime
Conversiones de Tipo en Knime

Créditos

Agradecimientos por la ayuda a Juanma Ucero Calderón (Linkedin Aquí)

Recursividad en Java - Torres de Hanoi #4

Hoy os voy a enseñar a resolver el juego de las Torres de Hanoi en Java con un método recursivo. Si aún no sabes qué es recursividad, puedes ver este post donde te los explico.

Método recursivo en Java para el juego de las Torres de Hanoi

El juego de las Torres de Hanoi es un Rompecabezas muy conocido inventado por el matemático francés Edouard Lucas. Si quieres saber más sobre el juego, cómo solucionarlo, o si ni siquiera sabes en qué consiste, puedes consultar este enlace de Wikipedia.

Nosotros vamos al grano, vamos a solucionar el problema de las torres de Hanoi con un método en Java para n discos de forma recursiva.

    public void torresHanoi(int discos, int torre1, int torre2, int torre3){
        // Caso Base
     
        if (discos==1){
            System.out.println("Mover disco de Torre " + torre1 + " a Torre " + torre3);
        } else {
            // Dominio
         
            // Llamamos a la función de tal forma que decrementamos
            // el número de discos, y seguimos el algoritmo
            // (origen, destino, auxiliar)
            torresHanoi(discos-1, torre1, torre3, torre2);
            System.out.println("Mover disco de Torre " + torre1 + " a Torre " + torre3);
            // En esta ocasión siguiendo el algoritmo hacemos lo siguiente
            // (auxiliar, origen, destino)
            torresHanoi(discos-1, torre2, torre1, torre3);
        }
     
    }

Como podemos comprobar, método nos devolverá los pasos de los discos que tenemos que ir moviendo y la torre a donde deben moverse. Por lo que si hacemos problema.torresHanoi (3, 1, 2, 3) el resultado sería el siguiente:

Mover disco de Torre 1 a Torre 3
Mover disco de Torre 1 a Torre 2
Mover disco de Torre 3 a Torre 2
Mover disco de Torre 1 a Torre 3
Mover disco de Torre 2 a Torre 1
Mover disco de Torre 2 a Torre 3
Mover disco de Torre 1 a Torre 3

Puedes comprobar que la solución al juego es correcta en este enlace.

Recursividad en Java - Sucesión de Fibonacci #3

Hoy os voy a enseñar cómo hallar el La sucesión de Fibonacci en Java con un método recursivo. Si todavía esto de la recursividad te resulta muy lioso, puedes echarle un vistazo a este post donde te lo explico de forma sencilla.

Método recursivo en Java para calcular la sucesión de Fibonacci

La sucesión de Fibonacci en matemática es la siguiente sucesión infinita de números naturales:

       

La sucesión comienza con 0 y 1 y a raíz de estos cada término siguiente es la suma de los dos anteriores, así de sencillo. Pues bien, sabiendo esto vamos a modelar en Java y de forma recursiva la sucesión de Fibonacci.

    public int fibonacciRecursivo (int numero){
        // Caso base
        if (numero == 1 || numero == 2)
            return 1;
        else
            return fibonacciRecursivo(numero-1) + fibonacciRecursivo(numero-2);
    }

En este caso vemos como el "Caso base" sería cuando el número entero que le pasamos sea "1" o "2", ya que en ese caso el resultado sería 1. Por otra parte el dominio, o "Caso recursivo", sería la suma del "número entero - 1" + "número entero - 2". Si no lo has entendido, intenta pensar que si le pasamos por ejemplo "10", empezaría haciendo la suma de la sucesión de Fibonacci de los dos números anteriores, es decir, iría del número más alto hasta el más bajo. El resultado si hacemos System.out.println("La sucesion fibonacci es " + problema.fibonacciRecursivo(10)) sería el siguiente.

La sucesion fibonacci es 55

Más ejercicios de Recursividad en Java 




Recursividad en Java - Factorial de un número #2

Hoy os voy a enseñar cómo hacer el Factorial de un número en Java con un método recursivo. Si aún no sabes qué es la recursividad, te invito a que le eches un vistazo a este artículo donde te lo explico de forma sencilla.

Método recursivo en Java para calcular el Factorial de un número


En nuestro caso tomamos como "Caso base" cuando el número sea menor que "0", por tanto, los demás casos los tomará como "Caso recursivo o Dominio". Es decir, hasta que no sea menor que 0, el método irá decrementando el número introducido.

public int factorialRecursivo(int numero) {
        // Validar que no sea menor que 0
        if (numero < 0) {
            return 0;
        // Caso base
        } else {
            if (numero == 0){
                return 1;
            // Dominio
            } else {
                return numero * factorialRecursivo(numero - 1);
            }
        }
}

A continuación vemos el resultado al hacer System.out.println("El factorial es " + problema.factorialRecursivo(10))

El factorial es 3628800

Más ejercicios de Recursividad en Java 


Recursividad en Java - Bajar una escalera #1

Hoy os vamos a explicar qué es la recursividad en programación, en este caso vamos a ver ejemplos en lenguaje Java para que entendáis cómo funciona y para qué podemos usarla.

¿Qué es la recursividad?

La recursividad es una técnica usada en programación que nos permite que un bloque de instrucciones, una función u operación se realice un cierto número de veces (predeterminadas por nosotros). Gracias a que muchos lenguajes, como por ejemplo Java nos permiten que los métodos puedan llamarse a sí mismos podemos realizar operaciones recursivas.

Caso Base y Caso Recursivo

Todo método recursivo puede dividirse en "Caso base", que sería algo así como el criterio de parada y "Caso recursivo" que converge al caso base (es decir, que se va acercando al caso base). La recursividad sirve como sustituto de una ireración, por ejemplo un bucle while o for, y en muchos casos siendo menos costoso. 

Método recursivo en Java para bajar una escalera

Es el caso del siguiente ejemplo, donde vamos a ver cómo bajar una escalera con un método recursivo, de tal modo que cuando al método le pasamos un entero "10" por ejemplo, tras pasar por el if, iría al "Caso recursivo" donde volvería a llamar al método con un entero "10-1" es decir "9", y así hasta llegar a 0, donde daríamos por hecho que la escalera se ha bajado.

    public void bajarEscalera (int escalones){
        // Caso Base, Respuesta Explícita
        if (escalones == 0){
            System.out.println("La escalera se ha bajado");
        } else {
            System.out.println("Bajando escalon " + escalones);
            // Hacemos uso de la recursividad
            bajarEscalera(escalones-1);
        }
     
    }

El resultado del método al ejecutarlo problema.bajarEscalera(10) sería el siguiente:

Bajando escalon 10
Bajando escalon 9
Bajando escalon 8
Bajando escalon 7
Bajando escalon 6
Bajando escalon 5
Bajando escalon 4
Bajando escalon 3
Bajando escalon 2
Bajando escalon 1
La escalera se ha bajado

Más ejercicios de Recursividad en Java