Random Forest es un tipo de Ensamble en Machine Learning en donde combinaremos diversos árboles -ya veremos cómo y con qué características- y la salida de cada uno se contará como “un voto” y la opción más votada será la respuesta del <<Bosque Aleatorio>>.

Random Forest, al igual que el árbol e decisión, es un modelo de aprendizaje supervisado para clasificación (aunque también puede usarse para problemas de regresión).

¿Cómo surge Random Forest?

Uno de los problemas que aparecía con la creación de un árbol de decisión es que si le damos la profundidad suficiente, el árbol tiende a “memorizar” las soluciones en vez de generalizar el aprendizaje. Es decir, a padecer de overfitting. La solución para evitar esto es la de crear muchos árboles y que trabajen en conjunto. Veamos cómo.

Cómo funciona Random Forest?

Random Forest funciona así:

• Seleccionamos k features (columnas) de las m totales (siendo k menor a m) y creamos un árbol de decisión con esas k características.
• Creamos n árboles variando siempre la cantidad de k features y también podríamos variar la cantidad de muestras que pasamos a esos árboles (esto es conocido como “bootstrap sample”)
• Tomamos cada uno de los n árboles y le pedimos que hagan una misma clasificación. Guardamos el resultado de cada árbol obteniendo n salidas.
• Calculamos los votos obtenidos para cada “clase” seleccionada y consideraremos a la más votada como la clasificación final de nuestro “bosque”.

¿Por qué es aleatorio?

Contamos con una <<doble aleatoriedad>>: tanto en la selección del valor k de características para cada árbol como en la cantidad de muestras que usaremos para entrenar cada árbol creado.

Es curioso que para este algoritmo la aleatoriedad sea tan importante y de hecho es lo que lo “hace bueno”, pues le brinda flexibilidad suficiente como para poder obtener gran variedad de árboles y de muestras que en su conjunto aparentemente caótico, producen una salida concreta. Darwin estaría orgulloso

Ventajas y Desventajas del uso de Random Forest

Vemos algunas de sus ventajas son:

• funciona bien -aún- sin ajuste de hiperparámetros
• funciona bien para problemas de clasificación y también de regresión.
• al utilizar múltiples árboles se reduce considerablemente el riesgo de overfiting
• se mantiene estable con nuevas muestras puesto que al utilizar cientos de árboles sigue prevaleciendo el promedio de sus votaciones.

Y sus desjeventajas:

• en algunos datos de entrada “particulares” random forest también puede caer en overfitting
• es mucho más “costo” de crear y ejecutar que “un sólo árbol” de decisión.
• Puede requerir muchísimo tiempo de entrenamiento
• OJO! Random Forest no funciona bien con datasets pequeños.
• Es muy difícil poder interpretar los ¿cientos? de árboles creados en el bosque, si quisiéramos comprender y explicar a un cliente su comportamiento.

Vamos al Código Python

Continuaremos con el ejercicio propuesto en el artículo “desbalanceo de datos” en donde utilizamos el dataset de Kaggle con información de fraude en tarjetas de crédito. Cuenta con 284807 filas y 31 columnas de características. Nuestra salida será 0 si es un cliente “normal” o 1 si hizo uso fraudulento.

Retomaremos el mejor caso que obtuvimos en el ejercicio anterior utilizando Regresión Logística y logrando un 98% de aciertos, pero recuerda también las métricas de F1, precisión y recall que eran las que realmente nos ayudaban a validar el modelo.

Requerimientos para hacer el ejercicio Random Forest

Necesitaremos tener instalado Python 3.6 en el sistema y como lo haremos en una Notebook Jupyter, recomiendo tener instalada la suite de Anaconda que simplificará todo.

¿Cómo instalar el ambiente de desarrollo Python con Anaconda?

Pues vamos con nuestro Bosque!

Creamos el modelo y lo entrenamos

Utilizaremos el modelo RandomForrestClassifier de SkLearn.

from sklearn.ensemble import RandomForestClassifier

# Crear el modelo con 100 arboles
model = RandomForestClassifier(n_estimators=100, 
                               bootstrap = True, verbose=2,
                               max_features = 'sqrt')
# a entrenar!
model.fit(X_train, y_train)

Luego de unos minutos obtendremos el modelo entrenado (en mi caso 1 minuto 30 segundos)

Los Hiperparámetros más importantes

Al momento de ajustar el modelo, debemos tener en cuenta los siguientes hiperparámetros. Estos nos ayudarán a que el bosque de mejores resultados para cada ejercicio. Recuerda que esto no se trata de “copiar y pegar”!

• n_estimators: será la cantidad de árboles que generaremos.
• max_features: la manera de seleccionar la cantidad máxima de features para cada árbol.
• min_sample_leaf: número mínimo de elementos en las hojas para permitir un nuevo split (división) del nodo.
• oob_score: es un método que emula el cross-validation en árboles y permite mejorar la precisión y evitar overfitting.
• boostrap: para utilizar diversos tamaños de muestras para entrenar. Si se pone en falso, utilizará siempre el dataset completo.
• n_jobs: si tienes multiples cores en tu CPU, puedes indicar cuantos puede usar el modelo al entrenar para acelerar el entrenamiento.

Evaluamos resultados

Veamos la matriz de confusión y las métricas sobre el conjunto de test!!! (no confundir con el de training!!!)

Aquí podemos destacar que para la clase “minoritaria”, es decir la que detecta los casos de fraude tenemos un buen valor de recall (de 0.80) lo cual es un buen indicador! y el F1-score macro avg es de 0.93. Logramos construir un modelo de Bosque aleatorio que a pesar de tener un conjunto de datos de entrada muy desigual, logra buenos resultados.

Comparamos con el Baseline

Si comparamos estos resultados con los del algoritmo de Regresión Logística, vemos que el Random Forest nos dio mejores clasificaciones, menos falsos positivos y mejores métricas en general.

Conclusiones

Avanzando en nuestro aprendizaje sobre diversos modelos que podemos aplicar a las problemáticas que nos enfrentamos, hoy sumamos a nuestro kit de herramientas el Random Forest, vemos que es un modelo sencillo, bastante rápido y si bien perdemos la interpretabilidad maravillosa que nos brindaba 1 sólo árbol de decisión, es el precio a pagar para evitar el overfitting y para ganar un clasificador más robusto.

Los algoritmos Tree-Based -en inglés- son muchos, todos parten de la idea principal de árbol de decisión y la mejoran con diferentes tipos de ensambles y técnicas. Tenemos que destacar a 2 modelos que según el caso logran superar a las mismísimas redes neuronales! son XGboost y LightGBM. Si te parecen interesantes puede que en el futuro escribamos sobre ellos.

Suscribete al blog

Recibe los próximos artículos sobre Machine Learning, estrategias, teoría y código Python en tu casilla de correo!

NOTA: algunos usuarios reportaron que el email de confirmación y/o posteriores a la suscripción entraron en su carpeta de SPAM. Te sugiero que revises y que agregues nuestro remitente a tus contactos para evitar problemas. Gracias!

Recursos y Adicionales

Puedes descargar la notebook para este ejercicio desde mi cuenta de GitHub:

• Código en jupyter Notebook en GitHub
• Dataset de Kaggle

Otros artículos sobre Random Forest en inglés:

• Random Forest Simple Explanation
• An Implementation of Random Forest in Python

The post Random Forest, el poder del Ensamble first appeared on Aprende Machine Learning.

La interpretación de las decisiones tomadas por nuestros algoritmos de Machine Learning pasa a un plano muy importante: para comprender el modelo y mejorarlo, evitar “biases” (ó descubrirlos), para justificar nuestra confianza en el modelo y hasta legalmente pues es requerido por leyes como la GDPR -para decisiones delicadas como puede ser dar ó no un crédito a una persona-.

Si nuestro algoritmo tuviera que detectar enfermedades y suponiendo que logramos una tasa de aciertos del 90% ¿no te parecería lógico comprender cómo lo ha hecho? ¿es puro azar? ¿está teniendo en cuenta combinaciones de características que nosotros no contemplamos?

Si de pequeño eras curioso y querías sabes cómo funcionaban las cosas: relojes, autos, ó hasta el mismísimo ordenador… serás un poco como yo… y… no siempre nos convence el concepto de “caja negra”.

Abriendo la Caja negra

El concepto de caja negra a veces es muy beneficioso, en sistemas decimos “yo al método le tiro estos parámetros y me devuelve true ó false”. Genial, con eso nos basta. Podemos trabajar en equipos distribuidos, intercambiar interfaces y listo. Podemos confiar en otras librerías ó paquetes “sin saber cómo lo hacen” pero que nos resuelven problemas. Y las encajamos como piezas de un puzzle.

Los algoritmos de Machine Learning, hasta ahora funcionaban muy de ese modo. Es decir, podemos hacer una red neuronal de 10 capas con 80 neuronas cada una, dropout, recurrencia y que nos dé unas buenas clasificaciones. Pero ¿qué pasa por dentro? ¿cómo hizo? ¿es magia?… esas oscuras épocas de incertidumbre deben acabar y deberemos tomar control de porqué se hacen las cosas como se hacen.

Explainable Machine Learning

Interpretar el Modelos en Machine Learning es la habilidad de explicar su funcionamiento ó presentarlo de manera comprensible al humano.

¿Por qué es importante interpretar los modelos?

Imaginemos que nuestro algoritmo decidirá a qué empleado le daremos un ascenso, dadas sus características e historia en la empresa. Y luego de entrenar el modelo vemos que “aparentemente da buenos resultados” pero… todas las elecciones para puestos gerenciales son siempre para hombres y ninguna mujer…. mmmm.. sospechoso, ¿no?

Ese modelo “aprendió” que durante los últimos 10 años, los cargos gerenciales de esa empresa siempre fueron para hombres. Si ese algoritmo pasa a producción, estará discriminando a las mujeres e impidiendo su ascenso.

Entonces ¿Cómo hacemos para interpretar el modelo?

Respuesta corta: con otro modelo que ayude a los humanos a interpretar los procesos.

Hay que decir que modelos como “1 árbol de decisión pequeño” ó clasificación lineal, pueden llegar a interpretarse por su gráfica y/o fórmula (repito: si son sencillos). Sin embargo un Random Forest ó las Redes Neuronales son complejas y prácticamente imposibles de comprender <<de un vistazo>>.

Los beneficios de la “interpretabilidad de los modelos “son:

• Dar confiabilidad en los resultados.
• Ayudar en el Debugging.
• Informar a la Ingeniería de Características (Feature Engineer).
• Detectar necesidad de colectar nuevas muestras.
• Ayudar a una persona en la toma de decisiones.
• Mayor seguridad/robustez en el modelo obtenido.

Técnicas de Interpretación de modelos

Del análisis de los modelos podemos obtener:

• Características más importantes (features)
• Para una predicción en particular del modelo, el efecto que tuvo en ella cada característica
• Efecto de cada característica en el global de las predicciones del modelo

Veamos algunas de esas técnicas y qué librerías de Python nos brindan estas funcionalidades:

1- Permutation Importance

¿Cuales de las features piensa el modelo que son más importantes? ¿Qué Características tienen mayor impacto en las predicciones? Estos conceptos son conocidos como “Feature Importante” y “Permutation Importance” y nos sirven para calcular nuestras características de entrada al modelo. Nos sirve para poder ver cuando nuestro modelo está funcionando de manera contra-intuitiva y también para demostrar a terceros cuando el funcionamiento es correcto.

Para hacer Permutation Importante debemos primero entrenar un modelo y “encajarlo” (fit). Luego tomamos el set de validación y tomamos las features una por vez: por ejemplo, tomamos la primer columna de entrada y mezclamos todos sus valores entre sus filas (pero el resto de features se mantienen igual). Entonces hacemos predicción usando el mismo modelo entrenado y deberían empeorar los resultados. Si “desmejoran mucho” es que esa feature era muy importante. En cambio, si no afecta demasiado, tampoco variarán mucho las predicciones obtenidas y quiere decir que esa característica no es relevante. Y así lo hacemos con todas las características, desordenando de a una a la vez.

Podemos utilizar la librería ELI5 para Python para visualizar la Permutation Importance

2- Partial Dependence Plots (PDP)

Los PDPs muestran el efecto marginal de una o dos características que tienen sobre la predicción dictada por un modelo. Los PDPs muestran cómo afectan las distintas características a las predicciones. El PDP puede mostrar la relación entre nuestra variable de salida y una ó dos características de entrada.

Lo que hacemos en tomar de a una sola fila, e ir variando los valores de una sola de las features (que queremos investigar) contra un modelo YA entrenado. Entonces veremos en que intervalos esa característica afecta a los resultados del modelo.

Lo podemos hacer hasta con 2 variables a la vez usando “2D Partial Plots” y visualizarlo.

Para esto podemos utilizar la librería PDPBox

3-SHAP Values (en predicciones individuales)

SHAP viene de “Shapley Additive exPlanation” y está basado en la teoría de Juegos para explicar cómo cada uno de los jugadores que intervienen en un “juego colaborativo” contribuyen en el éxito de la partida. Con esto podemos comprender una predicción y como impacta cada feature. Podemos decir que la interpretabilidad que nos ofrecen los valores SHAP es de las mejores.

De manera muy sencilla -e incompleta- de cómo se calculan estos valores podemos imaginar a una grupo de desarrolladores, testers, arquitectos y managers (features) que trabajan en conjunto (“juegan”/colaboran) para crear un Sistema de Software y queremos saber cuánto contribuyó cada uno de ellos en su producción. Lo que haremos es ir intercalando a los participantes en diversos “orden de aparación” ABCD, ABDC, ADBC, etc. e ir midiendo la <<contribución marginal>> de cada participante cada vez. Con ello sacar el promedio de cada uno y tendremos los valores Shapley que nos indican cuánto contribuyo cada jugador a conseguir el resultado obtenido.

Supongamos que tenemos que explicar a una persona por qué se ha rechazado su solicitud de un crédito -esto es, una única predicción, y no “el accuracy global” del modelo- los valores SHAP nos muestran cuales características que alimentan al modelo <<empujan>> a la denegación (ó aceptación) esa petición en concreto.

Utilizamos la librería SHAP para python para obtener estos valores.

4- Usos avanzados de Shap (comprensión global)

Si recopilamos muchos valores Shap podremos tener una mejor comprensión del modelo en su conjunto. De allí aparecen las gráficas “Shap Summary Plot” y “Shap Dependence Contribution Plot”.

Shap Summary Plot

Calculando los Shap Values de cada muestra, podemos obtener esta Visualización que nos muestra cuales características son las más importantes y el rango de valores donde afecta al set de datos.

Shap Dependence Contribution Plot

Esta gráfica es similar a la de los PDPs (vistos en el punto 2) pero nos dan mucho mayor detalle.

No puedo dejar de mencionar a una gran librería para ML Interpretability llamada LIME (Local Interpretable Model Explanation) y que nos ofrece comprensión a humanos para modelos de NLP (destacando visualmente palabras en el texto) y para imágenes clasificadas por una CNN (mostrando las áreas en donde “mira” la red).
También mencionar otra Librería Python llamada Skater -es de Oracle- y aunque aún está en desarrollo, provee de buenas herramientas.

Conclusión

La importancia de la interpretabilidad de los modelos de Machine Learning es crucial para poder justificar y comprender las predicciones y/o resultados obtenidos y hasta legalmente. Es curioso que necesitemos “modelos que expliquen como funcionan los modelos” para poder “bajar” a entendimiento humano la complejidad de lo que ocurre en nuestras máquinas de aprendizaje. Finalmente, aplicando diversos métodos, Permutation Importance, los PDP y los Shap Values logramos obtener transparencia en nuestro desarrollo y un panorama claro sobre cómo funciona nuestro engranaje para obtener los resultados.

Suscribe al Blog

Recibe los nuevos artículos sobre Aprendizaje Automático, teoría y el código Python

NOTA: algunos usuarios reportaron que el email de confirmación a la suscripción entraron en la carpeta SPAM. Te sugiero que revises y recomiendo agregar el remitente a tus contactos. Gracias!

Recursos Adicionales

Te recomiendo sobre todo y para pasar al Código este curso completo en Kaggle: Machine Learning Explainability

Algunos artículos y videos sobre Interpretación de Modelos (en inglés)

• Libro muy bueno! Interpretable Machine Learning 
• artículo Hands-on Machine Learning Model Interpretation
• (artículo) Interpretable Machine Learning
• Video (1:30hs) Open the black box: an intro to model interpretability
• Video (1:30hs) Interpretable ML for Computer Vision
• One Method to Rule Them All: Shap Values
• Derisking ML and Artifitial Intelligence
• The Mythos of Model Interpretability

The post Interpretación de Modelos de Machine Learning first appeared on Aprende Machine Learning.

No olvides seguir los 7 pasos del Machine Learning

Vamos al grano!

Con el objetivo de ilustrar mejor estos consejos, nos centraremos en la aplicación del Machine Learning de Clasificar, pero esto podría servir para otros usos.

Los 3 componentes del Aprendizaje Automático

Supongamos que tienes un problema al que crees que puedes aplicar ML. ¿Qué modelo usar? Deberá ser una combinación de estos 3 componentes: Representación, evaluación y optimización.

• Representación: Un clasificador deberá poder ser representado en un lenguaje formal que entienda el ordenador. Deberemos elegir entre los diversos algoritmos que sirven para resolver el problema. A este conjunto de “clasificadores aptos” se les llamará “espacio de hipótesis del aprendiz”. Ej: SVM, Regresión Logística, K-nearest neighbor, árboles de decisión, Redes Neuronales, etc.
• Evaluación: Se necesitará una función de evaluación para distinguir entre un buen clasificador ó uno malo. También es llamada función objetivo ó scoring function. Ejemplos son accuracy, likelihood, information gain, etc.
• Optimización: necesitamos un método de búsqueda entre los clasificadores para mejorar el resultado de la Evaluación. Su elección será clave. EJ: Descenso por gradiente, mínimos cuadrados, etc.

Lo más importante es lograr la Generalización de la máquina

El objetivo fundamental del Machine Learning es lograr la generalización del conocimiento más allá de las muestras tomadas en el conjunto de entrenamiento. Es es porque por más que entrenemos con muchísimos datos, es poco probable que se vuelvan a dar esos mismos casos al testear nuestra máquina. Por más que usemos “un millón de fotos de gatitos” para entrenar, siempre habrá fotos nuevas ó distintas que nuestro modelo desconoce. Entonces la magia ocurrirá si nuestro algoritmo es capaz de generalizar lo aprendido durante el entrenamiento y puede detectar “al gatito millón uno”. Siempre es conveniente guardar una parte de nuestro set de datos para poder validar lo aprendido durante el entrenamiento, con muestras que la máquina nunca ha visto y comprobar que sigue dando un buen resultado.

Los datos solos, no alcanzan

Siendo la generalización el objetivo del ML trae como consecuencia que sólo con datos “no alcanza”, no importa con cuántos contemos.

¿Entonces cómo podemos pretender que nuestras máquinas aprendan algo? Afortunadamente, en este proceso de inducción que realizamos con los algoritmos logramos llegar a ciertos niveles que nos dan buenos resultados.

El machine learning no hace magia. Sin datos no funcionará. Lo que hace es “sacar más con poco“. Y claro, cuantos más datos mejor. Pero no lo son todo. Deberemos combinar “conocimiento” con los datos.

El Overfitting tiene muchas caras

Si al entrenar nuestro modelo obtenemos resultados <<demasiado buenos>> con 100% aciertos y en el set de test apenas alcanzamos un 50% (ó menos!) es muy probable que nos hayamos topado con en “el gran problema del ML”: el overfitting.

Pero debemos saber que podemos “caer” en el overfitting de diversas maneras, a veces sin darnos cuenta. Dos de sus caras son:

• Bias (ó sesgo): es la tendencia a aprender -equivocadamente- algo falso.
• Varianza: es la tendencia a aprender algo random no relacionado con la realidad.

A veces puede ocurrir que un algoritmo -aprendiz- que “parece menos potente”, obtenga mejor resultado que uno “super poderoso” que cae en overfitting. A tener en cuenta

Es difícil evitar el Overfitting, se puede utilizar Regularización ó la validación cruzada (cross validation), u otras técnicas pero ninguna nos asegura evitarlo del todo. Muchas veces ocurre que al querer corregir la varianza, caemos en Bias… y viceversa. Lograr evitar ambos en simultáneo es “el desafío” que tenemos.

A veces falla “la intuición” con muchas dimensiones

Cuando tenemos muchas features, por ejemplo 100 ó más, puede que alguno de nuestros algoritmos de aprendizaje “se vuelva loco”… es decir, que no logre generalizar ó que lo haga mal. A esto se le llamó “la maldición de la dimensionalidad” (Bellman, 1961). Esto dependerá también de la distribución de los datos de entrada, pero para entenderlo: con k-nearest neighbor es <<fácil visualizar en 2 ó 3 dimensiones>> los clusters. Pero al aumentar dimensiones puede ocurrir que para el algoritmo todos los puntos sean vecinos cercanos unos de otros, devolviéndonos resultados aleatorios.

Debemos tener esto en cuenta y si fuera el caso utilizar algún algoritmo de reducción de dimensiones – PCA, t-SNE- para aplacar el problema.

Que se cumplan supuestos teóricos no nos garantiza nada

Al aprender ML podemos leer en papers, ó en cursos y artículos algunas afirmaciones teóricas que intentan ayudarnos y guiarnos. Bueno, como el ML es un fenómeno muy complejo y depende tanto de cada problema en particular, las dimensiones y los datos de entrada (su distribución), los casos positivos/negativos que tengamos de las muestras y de tantas otras variables, es posible que muchos de esos supuestos teóricos NO nos ayuden en nuestro “problema particular”.

Esto puede sonar muy decepcionante, y en parte lo es. Pero esto debemos saberlo para contrastar nuestros datos y no confiar en que “como a Fulanito le dio así, a mi también me funcionará”. Con sólo variar un parámetro, o un sólo dato de entrada de nuestro conjunto de entrenamiento, podemos obtener resultados completamente distintos. Estar alertas!!!

La clave está en la Ingeniería de Características (Feature Engineer)

Seguramente pasemos mucho más tiempo seleccionando los features, transformando, preprocesando que el tiempo dedicado a preparar/ejecutar el algoritmo de Machine Learning. Muchas veces el desafío será si tenemos pocas dimensiones ser creativos y poder generar nuevas y útiles características, ó en caso de tener muchas poder seleccionar cuales serán realmente valiosas y cuales descartar.

Deberemos ser cuidadosos: si tenemos muchas features, podemos evaluarlas individualmente y pensar que algunas no aportan demasiado valor. Sin embargo, esas mismas características puede que sean imprescindibles si las consideramos en combinación con otras. Eh ahí nuestro ingenio y mucha prueba y error.

Una gran herramienta es la Interpretación de Modelos por Importancia de Features, Los SHAP Values y más gráficas que comento en este nuevo artículo!

Más muestras superan a un algoritmo complejo

Conseguir más muestras para entrenamiento utilizando un algoritmo “simple”, puede ser mejor que un algoritmo complejo que “tarde tanto en ejecutar y no termina nunca”.

En ciencias de la computación, solíamos tener dos limitantes: tiempo y recursos cómo la memoria. Ahora, con el Machine Learning aparece una tercera: los datos de entrenamiento. Actualmente podemos encontrar cantidades masivas de datos y nuestro “cuello de botella” es el tiempo.

Si bien contar con “más y más datos” es bueno y hasta impulsa la creación de modelos (algoritmos) más complejos para aprovecharlos, se da una paradoja: en la práctica algoritmos “más simples” pueden obtener buenos resultados en tiempo razonable contra algoritmos complejos que tardan una eternidad.

Entonces el consejo es: al afrontar un problema, empecemos probando con los modelos más sencillos a más complejos (si hiciera falta!).

Ensamble de Modelos

Está bien aplicar un modelo para resolver el problema. Pero estudios han demostrado que hacer ensamble de modelos muchas veces mejora significativamente los resultados. Esto consiste en combinar más de un modelo (por ej. una red neuronal, K-nn, árboles, etc). Las tres técnicas más utilizadas son (ejemplo para clasificadores de “perros y gatos”):

• Bagging: alimentamos diversos modelos haciendo resamplig de las muestras y finalmente hacemos una votación (voting) con la clasificación obtenida (Supongamos que dos de tres modelos dicen “gato” y uno dice “perro”, ganarían los felinos)
• Boosting: en este caso, utilizamos un modelo “potenciandolo” a detectar únicamente perros y otro a detectar sólo gatitos.
• Stacking: utilizaremos diversos modelos, apilados “uno detrás de otro”, es decir, la salida del primero puede ser la entrada (ó un feature) del siguiente modelo y así sucesivamente. Para una famosa competición de Netflix, el ganador había encadenado más de 100 modelos!!

Simplicidad no implica precisión

Hubo un postulado algo confuso que parecía decir que al aplicar un modelo simple obteníamos la mayor precisión (frente a uno complejo). Sin embargo no hay que confundir: la simpleza no implica mayor precisión, esto se puede comprobar fácilmente con el punto anterior, pues al hacer ensamble de stacking de modelos vemos claramente que no se deteriora el resultado y en todo caso lo puede mejorar. Entonces podemos optar por modelos simples que “ya cuentan” con ventajas intrínsecas -probablemente en tiempo y coste- pero no necesariamente por la precisión del resultado.

Un problema “Representable”, no implica que pueda resolverse con Aprendizaje Automático

Podemos tender a pensar que para cualquier problema que podamos representar podrá ser construida una máquina que lo resuelva. Sin embargo hay problemas que nunca podrán ser “aprendidos” por una máquina, pues por ejemplo no tenemos las muestras suficientes para que generalice. En esos casos, podemos fácilmente encontrar la representación pero no lograremos dar con una solución en ML.

La correlación no implica causa

Para alimentar nuestras máquinas de Aprendizaje Automático utilizamos datos que son “muestras observables” donde la variable predictiva no está bajo control del algoritmo (en contraposición a muestras experimentales). Por esto es que las correlaciones que encontremos pueden ser interpretadas como señales de “responsabilidad” de la causa del problema. La realidad es que no necesariamente esa correlación implica la causa si no que son una buena pista para ponernos a investigar las conexiones que llevan a esos resultados.

Recomendado: Aprende a hacer el Análisis Exploratorio de Datos con Pandas/Python

Conclusión

Este gran paper de Pedro Domingos nos abre un poco los ojos sobre diversas trampas en las que podemos caer al trabajar en Machine Learning. Hace unos -pocos- años surgieron papers sobre Interpretación de Modelos de ML que comento en mi nuevo artículo y que dan luz a poder maniobrar ante situaciones problemáticas.

Moraleja en tiempos de IA

Personalmente creo que la “gran enseñanza” que nos deja es que debemos estar atentos, no confiarnos ni de datos, ni de algoritmos, ni de soluciones mágicas. Debemos ser muy profesionales y científicos, mucha prueba y error, validación y comprobación de los resultados. Y una vez hecho esto… volver a comprobar!

Descarga el paper original desde aquí

Suscripción: Nuevos artículos

Recibe los nuevos artículos sobre Aprendizaje Automático, teoría y práctica Python en tu casilla de correo!

NOTA: algunos usuarios reportaron que el email de confirmación a la suscripción entraron en la carpeta SPAM. Te sugiero que revises y recomiendo agregar el remitente a tus contactos. Gracias!

The post 12 Consejos útiles para aplicar Machine Learning first appeared on Aprende Machine Learning.

En internet encontramos de todo: artículos, noticias, estadísticas e información útil (¿e inútil?), pero ¿cómo la extraemos? No siempre se encuentra en forma de descarga ó puede haber información repartida en multiples dominios, ó puede que necesitemos información histórica, de webs que cambian con el tiempo.

Para poder generar nuestros propios archivos con los datos que nos interesan y de manera automática es que utilizaremos la técnica de WebScraping.

Contenidos:

• Requerimientos para WebScraping
• Lo básico de HTML y CSS que debes saber
• Inspeccionar manualmente una página web
• Al código! Obtener el valor actual del IBEX35® de la Bolsa de Madrid
• Exportar a archivo csv (y poder abrir en Excel)
• Otros casos frecuentes de “rascar la web”

Puedes ver y descargar el código python completo de este artículo desde GitHub haciendo click aquí

Requerimientos

Para poder usar esta técnica hay diversas librerías, pero utilizaremos una muy popular llamada Beautiful Soap. Como siempre, te recomiendo tener instalado el ambiente de desarrollo con Anaconda (se explica cómo instalar en este artículo) que ya trae incluida la librería. Si no, lo puedes instalar a mano, desde línea de comandos con

pip install BeautifulSoup4
pip install requests

Si bien utilizaremos una Jupyter Notebook para el código Python 3, podríamos ejecutar un archivo de texto plano “.py” desde nuestra Terminal.

Conocimientos básicos de HTML y CSS

Daré por sentados conocimientos de html y css. ¿Por qué? Las páginas webs están hechas con HTML y deberemos indicarle a nuestro “bot-spider” de qué etiquetas ó campos, deseamos extraer el contenido.

Repaso -MUY- mínimo de HTML es:

    
 Soy un parrafo
    
Soy un texto en un DIV
    
soy una celda dentro de una tabla
    

Aqui Vemos las etiquetas básicas de HTML, es decir las de inicio y cierre y dentro de body el contenido de la página. Como ejemplo vemos un párrafo “p”, un “div” y una tabla.

¿Y porqué CSS? en realidad no necesitamos estrictamente saber CSS, pero sí sus selectores, puesto que nos pueden ser de mucha ayuda. Lo básico para comprender selectores, usando este bloque de ejemplo es:

    /head>
    
    

        

        Bienvenido a mi web
        
    
    

Para poder seleccionar el texto “Bienvenido a mi web“, tenemos diversas formas:

• la más directa será si la etiqueta tiene un atributo id que es único en el ejemplo “123”
• Podríamos buscar los nodos de tipo div, pero podría haber muchos y deberemos filtrarlos.
• Podemos filtrar un div con el atributo name = “bloque_bienvenida”.
• Podemos buscar por clase CSS, en el ejemplo “verde”.
• Muchas veces se combinan selectores, por ejemplo: dentro de la clase “contenedor”, la clase “verde”. O decir: “traer un div con la clase verde”

La librería de Beautiful Soap nos permite buscar dentro de los nodos del árbol de la página web, también conocido como DOM. Al final del artículo veremos como obtener el texto “Bienvenido a mi web” con diversos selectores (y en la Jupyter Notebook de Github).

Inspección Manual de la web

Para el ejemplo inspeccionaremos la web de la Bolsa de Madrid. ¿Qué es eso de inspeccionar? Bueno, los navegadores web “modernos” (Safari, Firefox, Chrome) cuentan con una opción que nos permite ver el código html completo de la página que estamos viendo.

Además existe una opción de “inspección del código” que nos permite ver el HTML, Javascript, CSS y la web al mismo tiempo. Con ello buscaremos la manera de extraer el texto que nos interesa, si buscamos por id, por algún atributo, clase ó nodos.

Por lo general podemos inspeccionar haciendo click con el botón derecho del mouse sobre el área que nos interesa. Veamos cómo hacerlo con un gif animado

En nuestro caso nos interesa obtener el valor de la fila con nombre IBEX35® y el valor de la columna “último”.

Código Python – Arranquemos!

Veamos en código cómo haremos para acceder a esa porción de texto.

Primero importamos las librerías Python que utilizaremos:

import requests
from bs4 import BeautifulSoup
import csv
from datetime import datetime

Indicamos la ruta de la web que deseamos acceder:

# indicar la ruta
url_page = 'http://www.bolsamadrid.es/esp/aspx/Indices/Resumen.aspx'

Y ahora haremos el request a esa ruta y procesaremos el HTML mediante un objeto de tipo BeautifulSoap:

# tarda 480 milisegundos
page = requests.get(url_page).text 
soup = BeautifulSoup(page, "lxml")

Bien, ahora toca pensar la estrategia para acceder al valor. En nuestro caso nos interesa primero acceder a la tabla, y de allí a sus celdas. Por suerte la tabla tiene un id único!

# Obtenemos la tabla por un ID específico
tabla = soup.find('table', attrs={'id': 'ctl00_Contenido_tblÍndices'})
tabla

Bien, ahora dentro de la tabla y siendo que en este caso no tenemos un acceso directo a las celdas por ids únicos ni por clases, sólo nos queda iterar… Entonces, accederemos a la primer fila y obtendremos de las celdas el nombre del índice y su valor:

NOTA: realmente es la segunda fila, pues hay un encabezado, por eso usamos el índice 1 y no el cero.

name=""
price=""
nroFila=0
for fila in tabla.find_all("tr"):
    if nroFila==1:
        nroCelda=0
        for celda in fila.find_all('td'):
            if nroCelda==0:
                name=celda.text
                print("Indice:", name)
            if nroCelda==2:
                price=celda.text
                print("Valor:", price)
            nroCelda=nroCelda+1
    nroFila=nroFila+1

Veremos cómo salida:

Indice: IBEX 35® 
Valor: 9.185,20

Ya sólo nos queda guardar los datos para usar en el futuro.

Guardar CSV y ver en Excel

Vamos a suponer que ejecutaremos este script una vez al día, entonces lo que haremos es ir escribiendo una nueva línea al final del archivo cada vez.

# Abrimos el csv con append para que pueda agregar contenidos al final del archivo
with open('bolsa_ibex35.csv', 'a') as csv_file:
    writer = csv.writer(csv_file)
    writer.writerow([name, price, datetime.now()])

Finalmente obtenemos el archivo llamado “bolsa_ibex35.csv” listo para ser usado en nuestro proyecto

Otros ejemplos útiles de Webscaping:

Veamos otros ejemplos de uso de BeatifulSoap para extraer contenidos con python.

Usemos el bloque de ejemplo que usé antes e intentemos extraer el texto “Bienvenido a mi web” de diversas maneras:

#Obtener por ID:
elTexto = soup.find('div', attrs={'id': '123'}).getText()
print(elTexto)
#Obtener por Clase CSS:
elTexto = soup.find('div', attrs={'class': 'verde'}).getText()
print(elTexto)
#Obtener dentro de otra etiqueta anidado:
elTexto = next(soup.div.children).getText() #con next obtiene primer "hijo"
print(elTexto)

Obtener los enlaces de una página web

Otro caso práctico que nos suele ocurrir es querer colectar los enlaces de una página web. Para ello, obtenemos las etiquetas “A” e iteramos obteniendo el atributo HREF que es donde se encuentran las “nuevas rutas”, con posibilidad de hacer un nuevo request a cada una y extraer sus contenidos.

url_page = 'https://www.lifeder.com/cientificos-famosos/'
page = requests.get(url_page).text 
soup = BeautifulSoup(page, "lxml")
contenido = soup.find('div', attrs={'class': 'td-post-content'})
items = contenido.find_all('a')
for item in items:
    print(item['href'])

En el archivo Jupyter Notebook de mi cuenta de Github se ven estos ejemplos (y alguno más).

Conclusiones, repaso y código

Ahora sabemos cómo afrontar el proceso de obtener información de cualquier página web. Resumiendo el procedimiento básico que seguimos es:

1. Cargar la página en el navegador
2. Inspeccionar e investigar el HTML
3. En Python: importar las librerías
4. Obtener la página, parsear el contenido con BeautifulSoap
5. Obtner el “trozo” de contenido que buscamos
   • Mediante ID
   • Mediante Etiqueta
   • Mediante Clases CSS
   • Otros Atributos
6. Guardamos los datos en csv

Repasando, cuando ya tenemos el contenido en un objeto “soap”, solemos utilizar los métodos find() ó para múltiples etiquetas el find_all().

Si combinamos un script para webscraping, como en el ejemplo para capturar valores de la bolsa con el cron del sistema (ó con algún tipo de “repetidor de tareas del sistema”) que nos permita ejecutar nuestro código cada “x” tiempo, podremos generar un valioso archivo de información muy a medida de lo que necesitamos.

Otro ejemplo “clásico” es el de la obtención automática de los resultados de partidos de fútbol y en el código de este ejemplo en Github, encontrarás cómo hacerlo.

Obtener el Jupyter Notebook con código Python con este y más ejemplos de WebScaping

Si bien este artículo no es estrictamente sobre Machine Learning, me pareció bueno comentarlo pues he utilizado técnicas de Webscraping en ejercicios anteriores (como en el de Procesamiento del Lenguaje Natural) pasando por alto la explicación de esta porción del código. Además es un recurso utilizado frecuentemente para trabajar y para hacer pequeños experimentos con datos.

Ya estás listo para la Fase EDA!!!

Suscripción al Blog

Recibe los próximos artículos sobre Redes Neuronales y Deep Learning, Herramientas para Big Data y Data Science y ejercicios en código Python cada 15 días en tu bandeja de entrada.

The post Ejemplo Web Scraping en Python: IBEX35® la Bolsa de Madrid first appeared on Aprende Machine Learning.