<?xml version="1.0" encoding="UTF-8"?><rss xmlns:dc="http://purl.org/dc/elements/1.1/" xmlns:content="http://purl.org/rss/1.0/modules/content/" xmlns:atom="http://www.w3.org/2005/Atom" version="2.0" xmlns:cc="http://cyber.law.harvard.edu/rss/creativeCommonsRssModule.html">
    <channel>
        <title><![CDATA[Stories by Christian Tutivén Gálvez on Medium]]></title>
        <description><![CDATA[Stories by Christian Tutivén Gálvez on Medium]]></description>
        <link>https://medium.com/@christian_tutiven?source=rss-631fff797e3a------2</link>
        <image>
            <url>https://cdn-images-1.medium.com/fit/c/150/150/1*0hNbVqDWiDc9xWSTZcXDNg.jpeg</url>
            <title>Stories by Christian Tutivén Gálvez on Medium</title>
            <link>https://medium.com/@christian_tutiven?source=rss-631fff797e3a------2</link>
        </image>
        <generator>Medium</generator>
        <lastBuildDate>Fri, 20 Nov 2026 18:53:16 GMT</lastBuildDate>
        <atom:link href="https://medium.com/@christian_tutiven/feed" rel="self" type="application/rss+xml"/>
        <webMaster><![CDATA[yourfriends@medium.com]]></webMaster>
        <atom:link href="http://medium.superfeedr.com/" rel="hub"/>
        <item>
            <title><![CDATA[Detector de COVID-19 usando imágenes de Rayos X]]></title>
            <link>https://medium.com/saturdays-ai/detector-de-covid-19-usando-im%C3%A1genes-de-rayos-x-eaa146efa26?source=rss-631fff797e3a------2</link>
            <guid isPermaLink="false">https://medium.com/p/eaa146efa26</guid>
            <dc:creator><![CDATA[Christian Tutivén Gálvez]]></dc:creator>
            <pubDate>Wed, 25 Mar 2020 20:34:46 GMT</pubDate>
            <atom:updated>2020-12-16T12:09:18.529Z</atom:updated>
            <content:encoded><![CDATA[<figure><img alt="COVID-D Detection" src="https://cdn-images-1.medium.com/max/500/1*C1plA3DIyTiC78L7Nvoxrw.jpeg" /><figcaption>COVID-D Detection</figcaption></figure><p>Entre profesores, investigadores y estudiantes creamos un grupo de trabajo con la finalidad de ayudar al sistema de salud pública del Ecuador, ahora que estamos viviendo esta pandemia del coronavirus (COVID-19) alrededor del mundo. Uno de los problemas que hemos evidenciado en este tiempo es la falta de mecanismos alternativos y eficaces -aparte del test médico vigente- para la detección de COVID-19. Por esto, es que queremos compartir un trabajo que puede ser útil, como apoyo para los médicos al momento de detectar este virus, evitando congestionar los hospitales, clínicas, centros de salud, etc.</p><p>En concreto, compartimos cómo fue el desarrollo de nuestro clasificador de COVID-19 usando radiografías, para que cualquier persona interesada en seguir investigando o que desee colaborar, lo pueda hacer. Además, hemos desarrollado una aplicación web que contiene el modelo entrenado, el cual deseamos compartir con el <a href="https://www.salud.gob.ec/"><strong>Ministerio de Salud Pública</strong></a> (MSP). Así que te invitamos a compartir y difundir esta información. Juntos podemos lograr que se salven más vidas, pues la tarea es de todos.</p><p>Este trabajo lo realizamos en conjunto con <a href="https://www.linkedin.com/in/%C3%A1ngel-encalada-d%C3%A1vila-17707319a/">Ángel Encalada</a> y <a href="https://www.linkedin.com/in/jamil-andres-torres-brunes-0b20631a5/">Andrés Torres</a>. Y agradecimientos a Xavier Guerrero y a todas las personas que nos han ayudado con imágenes para validar nuestro modelo.</p><p><strong><em>Descargo de responsabilidad:</em></strong><em> Este </em><strong><em>no</em></strong><em> es un estudio científicamente riguroso, ni será publicado en una revista. Es una versión beta que puede mejorarse de muchas maneras. El dataset de imágenes debe agrandarse y etiquetarse por profesionales de la salud.</em> <em>Este artículo es para lectores que estén interesados ​​en (1) Visión por computadora / Aprendizaje profundo y quieran aprender a través de métodos prácticos y (2) que sea una herramienta de apoyo para los doctores y para todo el sistema sanitario, más no un reemplazo a su trabajo.</em></p><h3>Problemática</h3><p>Debido al incremento de casos de COVID-19 positivos, casos no confirmados e incertidumbre, encontramos los siguientes problemas:</p><p>1- Los centros de salud públicos no pueden realizar pruebas para detección del COVID-19 a tantas personas (número que cada día incrementa).</p><p>2- Los call center están congestionados.</p><p>3- Los laboratorios privados cobran entre los 200 a 300 dólares por una prueba de detección.</p><h3>Objetivos del proyecto final</h3><p>En este proyecto, entrenaremos un clasificador de imágenes para identificar si un persona tiene COVID-19 o no, usando radiografías, las cuales tienen un costo entre $15 a $25 . Puedes imaginarte usar algo como esto en una aplicación de teléfono o en tu pc. En la práctica, se entrena a este clasificador y luego lo se lo exporta para usarlo en una aplicación. En este artículo les mostraremos como utilizamos FASTAI para completar el proyecto.</p><p>A continuación puedes ver algunos ejemplos de las imágenes a clasificar.</p><figure><img alt="Uso de radiografías para detectar el COVID" src="https://cdn-images-1.medium.com/max/407/1*nWd4iYX2VJlClkuoIuLYmw.png" /><figcaption>Distintas radiografías que se usaron para entrenar el modelo.</figcaption></figure><p>Para alguien que no es experto en imágenes médicas va ser muy difícil detectar a simple vista si es un caso positivo de COVID-19 o no.</p><p><strong>Observación</strong>: queremos destacar que el objetivo es que sea una herramienta de APOYO para los doctores (no para tener una decisión final).</p><h3>Herramientas usadas</h3><p>Haremos una introducción a dos herramientas que usamos para crear nuestro modelo:</p><p>1- <a href="https://www.fast.ai/">Fastai</a></p><p>2- <a href="https://colab.research.google.com/notebooks/intro.ipynb#recent=true">Google Colab</a></p><h3><strong>Fastai, una biblioteca de python que busca simplificar la Inteligencia Artificial (IA)</strong></h3><figure><img alt="Fastai, una biblioteca de python que busca simplificar la Inteligencia Artificial" src="https://cdn-images-1.medium.com/max/365/1*H5cbdK9eCb1GcPagSyR1Yg.png" /><figcaption>fast.ai startup</figcaption></figure><p>Una startup llamada <a href="https://www.fast.ai/">Fast.ai</a> tiene como objetivo ayudar a los desarrolladores a llevar a cabo tareas relacionadas con IA usando su biblioteca de aprendizaje profundo para Python (<a href="https://docs.fast.ai/">fastai</a>).</p><p>Fast.ai fue cofundado por dos empleados de la Universidad de San Francisco. Rachel Thomas es profesora en la universidad, mientras que Jeremy Howard es científico investigador.</p><p>Python se ha convertido casi en sinónimo de desarrollo de inteligencia artificial debido a que es rápido, robusto, portátil y escalable. Algunos de los marcos de inteligencia artificial más populares del mundo, como Pytorch, TensorFlow y Keras, están diseñados para Python.</p><p>Hay una gran curva de aprendizaje cuando se trata de hacer uso de los marcos existentes que pueden ser a la vez desalentadores y frustrantes. Fast.ai quiere reducir el tiempo que le toma a un desarrollador comenzar con la IA.</p><p>Por todo esto, decidimos usar esta librería para entrenar nuestro modelo y que sea sencillo de entender y así doctores e investigadores puedan seguir colaborando en este trabajo.</p><h3>¿Qué es Google Colab?</h3><figure><img alt="Google Colab" src="https://cdn-images-1.medium.com/max/255/1*edSxOSz-VbtPwZR8zVbsIw.jpeg" /><figcaption>Google Colab</figcaption></figure><p>Esta herramienta de Google ofrece el uso de un portátil tipo jupyter. El portátil tiene la misma extensión (.ipynb) y funciona de la misma manera que en Jupyter. Se puede usar como un cuaderno de jupyter un entorno local instalado en la máquina personal de uno (esto no se tratará en este artículo), no obstante, para poder aprovechar toda su potencia, se podría utilizar mejor una GPU disponible (en Google Colab) e instalar los paquetes necesarios (es muy fácil, no te asustes).</p><p>Para los que se mueren de hambre por más detalles, Google tiene un cuaderno “Te damos la bienvenida a Colaboratory” que tiene como objetivo dar una introducción detallada a la herramienta.</p><p><a href="https://colab.research.google.com/notebooks/welcome.ipynb"><em>https://colab.research.google.com/notebooks/welcome.ipynb</em></a></p><figure><img alt="" src="https://cdn-images-1.medium.com/max/179/1*8nOpjPij3R3FrV8pg1YK_A.jpeg" /></figure><h3>El Proyecto</h3><p>El proyecto se divide en varios pasos:</p><p>* Cargar y pre-procesar el conjunto de datos de la imagen.<br>* Entrena el clasificador de imágenes en tu conjunto de datos.<br>* Usa el clasificador entrenado para predecir el contenido de la imagen.</p><p>Esta guía te ayudará a desarrollar cada paso y como implementarlo en fastai usando el entorno de Google Colab.</p><h3>Empezando con Google Colab</h3><p>Google Colab ofrece una GPU Tesla K80. Se puede seguir trabajando con la instancia de GPU continuamente hasta 12 horas! Una vez que hayan consumido las 12 horas, simplemente cierra el cuaderno y vuelve a abrirlo. Ahora, ¡a trabajar!</p><p>Para configurar Google Colab puedes leer mi articulo en este <a href="https://medium.com/@christian_tutiven/empezando-a-usar-google-colab-con-pytorch-4efb53933624">link</a> (no leer la parte de pytorch ya que usaremos fastai).</p><h3>Dataset</h3><p>El conjunto de datos de imágenes de rayos X COVID-19 que usaremos para este tutorial fue recogido por el <a href="https://josephpcohen.com/w/">Dr. Joseph Cohen</a>, becario postdoctoral en la Universidad de Montreal.</p><p>Hace unas semana, el Dr. Cohen comenzó a recopilar imágenes de rayos X de los casos de COVID-19 y a publicarlas en el <a href="https://github.com/ieee8023/covid-chestxray-dataset">siguiente repositorio de GitHub</a>.</p><p>Dentro del repositorio encontrarás ejemplos de casos de COVID-19, y otros también como MERS, SARS y ARDS.</p><p>Lo primero que hicimos fue descargar el repositorio <a href="https://github.com/ieee8023/covid-chestxray-dataset">GitHub</a>. Puedes descargarlo manualmente o usar el comando (en caso que sepas usarlo)</p><pre>!wget <a href="https://github.com/ieee8023/covid-chestxray-dataset">https://github.com/ieee8023/covid-chestxray-dataset</a></pre><p>Al revisar los archivos, encontramos que existe una carpeta llamada images que contiene todas las imágenes y un archivo metadata.csv que contiene información tabular de cada unas de las imágenes, como por ejemplo las etiquetas que nos indican que enfermedad se le detecto (COVID-19, SARS, ARDS, Pneumocystis, etc.), tipo de imagen (X-ray o CT), view que nos da el tipo de toma de la radiografía (PA, L, Axial, AP, etc.), entre otras. Recomendamos que revises este archivo y quizás encuentres información importante que no fue tomada en cuenta en este trabajo.</p><p>La estructura de archivos que vamos a necesitar para entrenar el modelo es:</p><pre>path/<br> /train/covid<br> /train/nocovid/ <br> /validation/covid/<br> /validation/nocovid/<br> /valid/nocovid<br> /test/</pre><p>Como se puede observar para las imágenes de entrenamiento y validación tenemos dos carpetas (covid y nocovid). Como la finalidad del trabajo es detectar COVID-19 necesitamos guardar en las subcarpetas covid todas las imágenes etiquetadas como tal y en las subcarpetas nocovid cualquier otro tipo de virus (SARS, ARDS, Pneumocystis, etc). Además, no se hizo distinción del tipo de toma ( columna view en el archivo metadata.csv) de la radiografía, es decir, queremos que sea cual sea la toma (PA, AP, L, etc) aprenda a detectar si es COVID-19 o no.</p><p>Puedes ver que la carpeta test no tiene subcarpetas. Esto se debe a que estas son las imágenes que el modelo nunca ha visto y vamos a probar para saber que etiqueta les pone. Por esto ahí van imágenes COVID-19 positivo y negativo.</p><p>Para crear el conjunto de datos de imágenes de rayos X COVID-19 para este tutorial, se realizaron las distintas tareas:</p><p>1- Se revisó el archivo metadata.csv</p><p>2- Se realizo un <a href="https://drive.google.com/drive/folders/19e-lpRlg-INGmQk0416GKkif_db-E0QG?usp=sharing">script</a> (se puede descargar pero debes realizar modificaciones de ruta según tu ordenador) que lea el archivo metadata.csv y usando las columnas finding, view y modality para poder crear nuestros dataset de entrenamiento, validación y testeo y, además, las divida en las subcarpetas covid y nocovid. En las carpetas train usamos el 70% del total de imágenes, en validation el 15% y en test el 15% restante.</p><p>2.1- Guardamos en una carpeta llamada CT las imágenes etiquetadas como modality ct (tomografía computarizadas), ya que solo usaremos radiografías (Ray-X). Las de tipo ct no las usaremos pero deseamos guardarlas para alguna otra investigación. Puedes haber escuchado o leído que las tomografías son más eficientes a la hora de ayudar a detectar COVID-19 pero son más difíciles de conseguir y nuestra misión y evitar que el sistema sanitario colapse.</p><p>Nos dimos cuenta que no existían imágenes de pacientes sanos ni con neumonía así que tomamos una muy buena idea del artículo de <a href="https://www.pyimagesearch.com/author/adrian/">Adrian Rosebrok</a> (<a href="https://www.pyimagesearch.com/2020/03/16/detecting-covid-19-in-x-ray-images-with-keras-tensorflow-and-deep-learning/">link del articulo</a>) y descargamos el conjunto de datos de imágenes de rayos X del tórax de Kaggle (<a href="https://www.kaggle.com/paultimothymooney/chest-xray-pneumonia">Kaggle’s Chest X-Ray Images (Pneumonia) dataset</a>). Escogimos 40 radiografías al azar de saludable y 40 de neumonía y las agregamos a las subcarpeta nocovid de la carpeta train. Hicimos lo mismo con 40 imágenes distintas de cada clase pero ahora para la carpeta validación y 20 de cada clase para la carpeta test.</p><p>Después de reunir mi conjunto de datos, me quedaron 315 <strong>imágenes en total</strong> . El dataset de entrenamiento conformado por 77 imágenes de rayos X positivos para COVID-19 y 76 imágenes de rayos X de pacientes sin COVID-19.</p><p><strong>He incluido mi conjunto de datos el siguiente link <em>“</em></strong><a href="https://drive.google.com/drive/folders/19e-lpRlg-INGmQk0416GKkif_db-E0QG?usp=sharing"><strong><em>Descargas datasets</em></strong></a><strong><em>”</em>, por lo que no tienes que volver a crearlo.</strong></p><p>Además, he incluido mis scripts Python utilizados para generar el conjunto de datos en este <a href="https://drive.google.com/drive/folders/19e-lpRlg-INGmQk0416GKkif_db-E0QG?usp=sharing">link</a>, pero estos scripts no serán revisados ​​en este tutorial ya que están fuera del alcance de la publicación.</p><h3><strong>Implementación de nuestro script de clasificación COVID-19 o no, usando Fastai</strong></h3><p>Pues empecemos. Lo primero es abrir un portatil Jupyter en Colab y escribir</p><pre>!curl -s <a href="https://course.fast.ai/setup/colab">https://course.fast.ai/setup/colab</a> | bash</pre><p>para actualizar la librearía fastai.</p><p>Como estamos usando google Colab y no deseamos que cada vez que se reinicie la máquina que nos da google tengamos que volver a subir nuestro dataset, lo ideal es subir las imágenes a google drive y establecer una conexión, ejecutando el siguiente comando</p><pre>from google.colab import drive</pre><pre>drive.mount(‘/content/gdrive’, force_remount=True)</pre><p>Aparecerá un link al cual debes ingresar y dar autorización de acceso a tu espacio en Google Drive. Obtendrás un código que debes copiarlo y pegarlo en</p><figure><img alt="" src="https://cdn-images-1.medium.com/max/1024/1*kAf7MnLbPtnzLodQdKP2GQ.png" /><figcaption>link para acceso a tu espacio en google drive</figcaption></figure><h3>Importar librerías</h3><p>Ahora debes importar las librerías que vas a usar</p><pre>from fastai import *<br>from fastai.vision import *<br>from fastai.metrics import error_rate</pre><p>El símbolo * significa que estamos importando todo de las librerías fastai y fastai.vision.</p><h3><strong>Definir objetos</strong></h3><p>Ahora definimos la ruta donde está nuestro dataset.</p><pre>path = Path(&#39;gdrive/My Drive/Proyectos/2020/covid19/covid/covid2/dataset_fastai/&#39;)</pre><p>En tu caso puede ser otra ruta pero la puedes encontrar, dándole click a la carpeta que aparece del lado izquierdo de google colab, y encontrarás la carpeta gdrive y explorando un poco busca donde están tus imágenes. Copia la ruta y úsala.</p><p>Para asegurarnos que seleccionamos correctamente la ruta, veamos que tenemos adentro</p><pre>path.ls()</pre><p>Se mostraran las carpetas que tenemos adentro</p><pre>[PosixPath(&#39;gdrive/My Drive/Proyectos/2020/covid19/covid/covid2/dataset_fastai/pneumonia&#39;),<br> PosixPath(&#39;gdrive/My Drive/Proyectos/2020/covid19/covid/covid2/dataset_fastai/normal&#39;),<br> PosixPath(&#39;gdrive/My Drive/Proyectos/2020/covid19/covid/covid2/dataset_fastai/train&#39;),<br> PosixPath(&#39;gdrive/My Drive/Proyectos/2020/covid19/covid/covid2/dataset_fastai/validation&#39;),<br> PosixPath(&#39;gdrive/My Drive/Proyectos/2020/covid19/covid/covid2/dataset_fastai/test&#39;),<br> PosixPath(&#39;gdrive/My Drive/Proyectos/2020/covid19/covid/covid2/dataset_fastai/models&#39;)]</pre><p>Algunas de estas carpetas son nuestras por lo que a ti no te aparecerán. Lo que si debes ver son las carpetas train, validation y test que son donde están nuestras imágenes con las que trabajaremos.</p><p>También podemos visualizar una de las imágenes escribiendo lo siguiente (tomar en cuenta la ruta y el nombre de la imagen).</p><pre>img = open_image(path/&#39;train/covid/1-s2.0-S1684118220300682-main.pdf-002-a2.png&#39;)<br>print(img.data.shape)<br>img.show()</pre><p>El resultado sera la siguiente imagen7</p><figure><img alt="" src="https://cdn-images-1.medium.com/max/181/1*GxPm-7zNmTmkJ7D6mJ_CpQ.png" /><figcaption>Imagen de prueba</figcaption></figure><p>Recordemos que el split fue aleatorio así que quizás esta imagen se encuentre en otra de las carpetas y no en train.</p><p>Ahora seleccionamos el tamaño de nuestro batch (uno de los hyper parámetros de nuestro modelo). No entraremos en detalles técnicos pero batch son la cantidad de imágenes por grupo que pasaremos a nuestra red.</p><pre>bs = 16</pre><p>Seleccionamos una semilla (seed) para tener los mismos resultados.</p><pre>np.random.seed(7)</pre><p>Creamos un objeto de tipo get_transforms que nos permitirá aumentar nuestro dataset con imágenes que se crean a partir de las imágenes de nuestro dataset de entrenamiento pero con modificaciones. Por ejemplo, tendremos imágenes con máximo de rotación de 25 grados y giro horizontal. Esto nos ayuda a reducir el sobre entrenamiento (overfitting), ya que aunque sean modificaciones de las imágenes iniciales son distintas a las mismas. Si eres un experto en imágenes medicas quizás sugieras realizar otras transformaciones por lo que te doy el <a href="https://docs.fast.ai/vision.transform.html#get_transforms">link</a> con información de las transformaciones posibles.</p><pre>tfms = get_transforms(do_flip=True,flip_vert=False, max_rotate=25)</pre><p>Ahora cargaremos nuestras imágenes en un objeto de tipo ImageDataBunch. Este objeto de fastai nos permite cargar directamente las imágenes desde una carpeta (en este caso), definir el número de imágenes por batch, identificar cuales son para entrenamiento, validación y testeo, realizar las transformaciones definidas previamente, hacer que todas las imágenes tengan el mismo tamaño, etc. Para mayor información visita el <a href="https://docs.fast.ai/vision.data.html#ImageDataBunch">link</a>.</p><pre>data = ImageDataBunch.from_folder(path, train=&quot;train&quot;, valid=&#39;validation&#39;, test=&#39;test&#39;, ds_tfms=tfms, size=224, bs=bs, num_workers=4).normalize(imagenet_stats)</pre><p>Ahora podemos visualizar ejemplos de imágenes usando la función show_batch al cual le debemos pasar la cantidad de filas y columnas que deseamos mostrar y el tamaño (juega con estos valores para que veas como cambian). Recordar que cada vez que ejecutes esta función mostrará imágenes aleatorias.</p><pre>data.show_batch(3, figsize=(6,6))</pre><p>En nuestro caso decidimos que muestre 3 filas y 3 columnas</p><figure><img alt="" src="https://cdn-images-1.medium.com/max/407/1*R-_W2LQVXTyR_b28WDuURQ.png" /><figcaption>show_batch</figcaption></figure><p>Ahora veamos como se crearon nuestros datasets.</p><pre>data.c, len(data.train_ds), len(data.valid_ds), len(data.test_ds), len(data.classes)</pre><p>de resultado obtendremos</p><pre>(2, 153, 79, 83, 2)</pre><p>que significa que tenemos dos clases y tenemos 153 imágenes para entrenar, 79 para validar y 83 de test.</p><h3>Construyendo y entrenando el clasificador</h3><p>Ahora que los datos están listos, es hora de construir y entrenar al clasificador. Como de costumbre, usaremos uno de los modelos pre-entrenados para obtener las características de la imagen.</p><p>En los últimos años, se han creado varios modelos para reutilizarlos en problemas de visión de computadora. El uso de estos modelos pre-entrenados se conoce como aprendizaje por transferencia. Fastai hace que sea fácil cargar modelos pre-entrenados y construir sobre ellos, que es lo que haremos en este proyecto.</p><p>Algunos de los modelos pre-entrenados más populares incluyen VGGNet, DenseNet, ResNet y AlexNet, todos los cuales son modelos pre-entrenados del Challenge de ImageNet. Estos modelos pre-entrenados permiten que otros obtengan rápidamente resultados de vanguardia en visión por computadora sin necesidad de grandes cantidades de poder de cómputo, tiempo y paciencia para encontrar la técnica de entrenamiento adecuada para optimizar los pesos.</p><p>Decidimos usar la arquitectura Resnet34, sin embargo, otros modelos podrían haberse utilizado fácilmente con una configuración muy similar (<a href="https://docs.fast.ai/vision.learner.html#cnn_learner">información</a>).</p><pre>learn = cnn_learner(data, models.resnet34, metrics=error_rate)</pre><p>En general, lo que se está haciendo es crear un objeto llamado learn de tipo cnn_learner (una red convolucional), se le está pasando el objeto data, se le dice que use el modelo pre-entrenado resnet34 y que use la métrica error_rate con el dataset de validación. Existen otras métricas que podrías usar así que revisa la <a href="https://docs.fast.ai/metrics.html">información</a>.</p><p>Debes ver que se descarga el modelo.</p><p>Ahora sí lo interesante. Vamos a entrenar nuestro modelo</p><pre>learn.fit_one_cycle(4)</pre><p>Se usó el método llamado fit_one_cycle (<a href="https://arxiv.org/abs/1803.09820">paper</a>). El valor que se le está pasando es la cantidad de épocas que deseamos que entrenar. En general épocas son las cantidades de veces que toda nuestra data pasa por la red en sentido foward y backward (actualización de pesos). Muchas épocas puede provocar sobre entrenamiento (overfit), ya que ve las mismas imágenes muchas veces y solo aprende a reconocer esas imágenes pero no aprender a generalizar con imágenes nuevas.</p><figure><img alt="" src="https://cdn-images-1.medium.com/max/414/1*YEPKM5P8F2TcARVl3N7UXQ.png" /><figcaption>Resultados del entrenamiento (modelo 1)</figcaption></figure><p>Podemos ver que obtuvimos un modelo con un error rate de 10% en tan solo 1 minuto 21 segundos de entrenamiento. En conclusión con un entrenamiento de tan poco tiempo logramos acertar correctamente aproximadamente 90% del tiempo. Además, podemos observar que tan solo hemos ejecutado aproximadamente 10 lineas de código y ya tenemos un buen modelo. Esto es lo que hace genial a Pytorch y a fastai.</p><p>Ahora deseamos guardar nuestro modelo para poder usarlo más adelante. Para esto creamos un directorio donde guardar el modelo (puedes definir la ruta que desees).</p><pre>dest=Path(base_dir + “models/covidnocovid/”)<br>try:<br>dest.mkdir(parents=True, exist_ok=False)<br>except FileExistsError:<br>print (‘File Already Exists’)</pre><p>Y guardamos el modelo en un archivo .pth</p><pre>learn.save(dest/’covidnocovid_stage-1’)</pre><p><strong>Pero, ¿qué significan estos resultados?</strong></p><p>Para ver los resultados de mejor manera fastai nos lo facilita. Para esto, creamos un objeto de tipo ClassificationInterpretation de nuestro objeto learn.</p><pre>interp = ClassificationInterpretation.from_learner(learn)</pre><p>Una de las cosas más utiles de es llamado plot_top_losses que nos indica que tan buena fue nuestra predicción.</p><pre>interp.plot_top_losses(9, figsize=(15,11))</pre><figure><img alt="" src="https://cdn-images-1.medium.com/max/781/1*YBhKZrycFN4fabdj_nZrJg.png" /><figcaption>Top_losses (modelo 1)</figcaption></figure><p>Si tomamos como ejemplo la imagen de la primera columna y tercera fila, nos imprime cuatro cosas predicción/actual/loss/probabilidad de clase actual (<a href="https://docs.fast.ai/vision.learner.html#_cl_int_plot_top_losses">mayor información</a>).</p><p>Estas herramientas nos sirven para verificar en que hemos fallado comúnmente.</p><p>También podemos visualizar la matriz de confusión</p><figure><img alt="" src="https://cdn-images-1.medium.com/max/713/1*VYMyMDZc0nhF8nJf7L1l_A.png" /><figcaption>Matriz de confusión (modelo 1)</figcaption></figure><p>La diagonal nos indica en cuantos ejemplos hemos acertado.</p><h3>Mejorando nuestro modelo</h3><p>Pues hemos obtenido un buen modelo pero, ¿cómo podemos mejorarlo? quizás haciendo un mejor tuneo de los parámetros.</p><p>Nuestro modelo anterior fue entrenado en 4 épocas y de manera muy rápida. ¿Por qué paso esto? Porque usamos un pequeño truco llamado transferencia de aprendizaje.</p><p>Estos modelos de aprendizaje profundo tienen muchas capas.</p><p><strong>¿Qué hicimos?</strong><br>Agregamos algunas capas adicionales al final de la arquitectura y solo entrenamos esas. Dejamos la mayoría de las primeras capas como estaban. Esto se llama capas congeladas, es decir, los pesos de esas capas no se modificaron. Entonces por eso fue rápido.</p><p>Si queremos construir un modelo bastante similar al modelo pre entrenado original, en este caso, similar a los datos de Imagenet (dataset con el que fue entrenado) que funcionan bastante bien debemos entrenar todas las capas.</p><p><strong>¿Qué queremos hacer?</strong><br>Volver atrás y entrenar a todo el modelo. Por eso es que siempre usamos este proceso de 2 estados:</p><p>1- cuando llamamos a fit o fit_one_cycle() en create_cnn, afinará estas capas adicionales al final y se ejecutará muy rápido.</p><p>2- Nunca se sobreajustará, pero para hacerlo bien, debemos llamar a</p><pre>learn.unfreeze()</pre><p>para descongelar los pesos de todas las capas y poder actualizarlos con el entrenamiento.</p><p>Ahora usaremos una función muy útil que nos recomendara que taza de aprendizaje (learning rate) usar</p><pre>learn.lr_find()<br>learn.recorder.plot()<br>plt.title(&quot;Loss Vs Learning Rate&quot;)<br>plt.show()</pre><figure><img alt="" src="https://cdn-images-1.medium.com/max/664/1*uv8Em-dNd9YmLTrWF5S8Tw.png" /><figcaption>LR Finder</figcaption></figure><p>Esto trazará el resultado de nuestro LR finder y lo que esto muestra es el parámetro clave llamado tasa de aprendizaje. La tasa de aprendizaje indica qué tan rápido estamos actualizando los parámetros en nuestro modelo. El eje x aquí me muestra lo que sucede a medida que aumenta la tasa de aprendizaje. El eje y muestra cuál es la pérdida. Como puedes ver, una vez que la tasa de aprendizaje pasa de 10e-4, nuestra pérdida empeora.</p><p>La taza de aprendizaje predeterminada es de 0.003 = 10e–3 y fue la usada cuando entrenamos nuestro modelo. Debido a que estamos tratando de ajustar las cosas ahora, no podemos usar una tasa de aprendizaje tan alta. Entonces, según el LR finder, tratamos de elegir algo bien antes de que empeorara. Entonces decidimos usar 1e-6 (tiene pendiente negativa, es decir reduce el loss). Pero no tiene sentido entrenar todas las capas a ese ritmo porque sabemos que las capas posteriores funcionaron bien antes, cuando entrenamos mucho más rápido. Entonces, lo que podemos hacer es pasar un rango de tasas de aprendizaje a learn.fit_one_cycle. Y lo hacemos así:</p><pre>learn.unfreeze()<br>learn.fit_one_cycle(10, max_lr=slice(1e-6, 1e-4))</pre><p>Utilizamos la palabra clave en Python llamada slice y así podemos tomar un valor inicial y un valor final y, básicamente, lo que dice es entrenar las primeras capas a una velocidad de aprendizaje de 1e-6, y las últimas capas a una velocidad de 1e- 4, y distribuya todas las otras capas entre esos dos valores por igual. Y al hacer eso obtenemos</p><figure><img alt="" src="https://cdn-images-1.medium.com/max/439/1*LaWl9Rh54p7VCdDPhnC6eA.png" /><figcaption>Resultados del entrenamiento (modelo 2)</figcaption></figure><p>Como podemos observar en 10 épocas hemos obtenido un error rate del 3%, es decir, que acertaremos en la clase correcta el 97% de las veces. Osea, tuvimos una mejora del 7%.</p><pre>interp = ClassificationInterpretation.from_learner(learn)</pre><pre>interp.plot_top_losses(9, figsize=(15,11))</pre><p>Ahora guardaremos nuestro nuevo modelo</p><pre>learn.save(dest/’covidnocovid_stage-2’)</pre><p>Y visualizaremos los mismos resultados como lo hicimos con nuestro primer modelo</p><pre>interp.plot_confusion_matrix(figsize=(12,12), dpi=60)<br>interp.plot_top_losses(9, figsize=(15,11))</pre><figure><img alt="" src="https://cdn-images-1.medium.com/max/783/1*tlZ6wt2oSbnZX8hAgHOylw.png" /><figcaption>Top losses (modelo 2)</figcaption></figure><pre>interp.plot_confusion_matrix(figsize=(12,12), dpi=60)</pre><figure><img alt="" src="https://cdn-images-1.medium.com/max/713/1*dIzl8UwKViOYv3-UOGCg6A.png" /><figcaption>Matriz de confusión (modelo 2)</figcaption></figure><p>Se puede evidenciar la mejora en la clasificación de covid y nocovid.</p><h3>Modelo en producción</h3><p>Ahora deseamos verificar que nuestro modelo funcione con imágenes que nunca ha visto. Para esto, cargamos una imagen de nuestro dataset de testeo y la mostramos (previamente revisamos que etiqueta debería tener y era nocovid)</p><pre>img = learn.data.test_ds[54][0]<br>img</pre><figure><img alt="" src="https://cdn-images-1.medium.com/max/224/1*QcFMVnd0htCdcYFlJ-gXCA.png" /><figcaption>Imagén de testeo</figcaption></figure><p>Ahora vamos a predecir qué clase es esta imagen</p><pre>learn.predict(img)</pre><p>y el resultado nos da</p><pre>(Category noCovid, tensor(1), tensor([1.9421e-05, 9.9998e-01]))</pre><p>Aquí, nuestro modelo predijo que esta imagen es de clase noCovid que corresponde a la etiqueta 1. Y las probabilidades que encontró para cada una de las clases fue de 1.9421e-05 y 9.9998e-01 respectivamente.</p><p>Te adjuntamos el link de descarga del <a href="https://drive.google.com/drive/folders/19e-lpRlg-INGmQk0416GKkif_db-E0QG?usp=sharing">script</a>.</p><h3>Comentarios</h3><p>Finalmente, hemos desarrollado una app que contiene el modelo y al cargar una radiografía dará un resultado de COVID-19 positivo o negativo. Esta aplicación la deseamos compartir con el sistema sanitario del Ecuador (ministerio de salud) para que conjuntamente podamos validar los resultados, dar un apoyo a los doctores, conseguir más imágenes y poder realizar investigaciones que nos ayuden a mejorar este sistema.</p><p>Les compartimos unas fotos de la aplicación.</p><figure><img alt="" src="https://cdn-images-1.medium.com/max/590/1*3EovmcYLoTDWSAnSxe3T6w.png" /><figcaption>Ingreso de datos e imagen</figcaption></figure><figure><img alt="" src="https://cdn-images-1.medium.com/max/1024/1*TgaCBcdE1Nh-qc3kKmVTGg.png" /><figcaption>Resultado</figcaption></figure><h3>Conclusiones</h3><p>Gracias a fastai y a Google Colab para entrenar un detector de COVID-19 automático en un conjunto de imágenes de rayos X, en poco tiempo y con pocas líneas de código.</p><p>Las imágenes usadas fueron descargadas del dataset <a href="https://github.com/ieee8023/covid-chestxray-dataset">Joseph Cohen’s GitHub repo of open-source X-ray images</a>. Nuestra misión es poder colaborar con el ministerio de salud y centros médicos que puedan ayudarnos a aumentar los datos de entrenamiento y así mejorar el modelo.</p><p>Usamos una red pre entrenada para reducir los tiempos de entrenamiento y en un primer modelo obtuvimos un accuracy del 90%. Y al ajustar la taza de aprendizaje pudimos mejorar nuestro modelo al 97%.</p><p>La red pre entrenada que se usó fue la Resnet34 pero también obtuvimos buenos resultados con la Resnet50 pero el tiempo de entrenamiento es mayor y el tamaño del archivo del modelo. Existen muchos tipos de redes pre entrenadas que puedes probar y los invitamos a hacerlo.</p><p>Las radiografías usadas son de personas de otros países y no de Ecuador. No podemos opinar si esto afecta o no al modelo porque esto requiere una mayor investigación y no es nuestro campo. Esta parte se la dejamos a los expertos en salud y aclaramos que nuestra intención es el de poder colabaorar y combinar su experiencia con este tipo de herramientas. Queremos mostrar que se puede realizar algo similar y trabajar en conjunto con el MSP para seguir investigando con radiofrafías de personas de nuestro país.</p><p>Para aumentar nuestro dataset usamos algunas transformaciones pero un experto en imágenes médicas podrían recomendar realizar transformaciones adicionales y hasta preferir no realizar las que nosotros usamos. Así también pueden existir otras métricas distintas a la usada (error rate) para medir la eficiencia del modelo y tener distintos resultados.</p><p>No somos expertos en imágenes médicas por lo que solo dejamos que el algoritmo aprenda a encontrar información espacial en las radiografías que permita distinguir una clase de otra.</p><p><strong>Tenga en cuenta que el detector COVID-19 cubierto en este tutorial <em>no es un estudio cientícamente riguroso, ni será publicado en una revista. </em></strong>Nuestro objetivo es inspirar a los profesionales de aprendizaje profundo, investigadores y expertos en imágenes médicas a ver cómo el aprendizaje profundo y la visión por computadora pueden ser un apoyo.</p><p>Espero que hayan disfrutado esta publicación.</p><img src="https://medium.com/_/stat?event=post.clientViewed&referrerSource=full_rss&postId=eaa146efa26" width="1" height="1" alt=""><hr><p><a href="https://medium.com/saturdays-ai/detector-de-covid-19-usando-im%C3%A1genes-de-rayos-x-eaa146efa26">Detector de COVID-19 usando imágenes de Rayos X</a> was originally published in <a href="https://medium.com/saturdays-ai">Saturdays.AI</a> on Medium, where people are continuing the conversation by highlighting and responding to this story.</p>]]></content:encoded>
        </item>
        <item>
            <title><![CDATA[FastAI Machine Learning (Lección 5-segunda parte)]]></title>
            <link>https://medium.com/saturdays-ai/fastai-machine-learning-lecci%C3%B3n-5-segunda-parte-4b2cb15d92e8?source=rss-631fff797e3a------2</link>
            <guid isPermaLink="false">https://medium.com/p/4b2cb15d92e8</guid>
            <category><![CDATA[machine-learning]]></category>
            <category><![CDATA[random-forest]]></category>
            <category><![CDATA[ai-saturdays]]></category>
            <category><![CDATA[fastai]]></category>
            <category><![CDATA[prédiction]]></category>
            <dc:creator><![CDATA[Christian Tutivén Gálvez]]></dc:creator>
            <pubDate>Thu, 02 May 2019 04:14:33 GMT</pubDate>
            <atom:updated>2019-05-02T04:21:28.526Z</atom:updated>
            <content:encoded><![CDATA[<p>En este articulo aprenderemos como interpretar las predicciones de nuestros árboles, como saber si nuestro dataset es aleatorio o temporal y obtendremos nuestro modelo final. Este resultado nos pondría en el primer puesto del concurso de Kaggle.</p><h3>Interpretes de árboles</h3><p>¿Qué hace el intérprete de árboles y cómo lo hace? Comencemos con la salida del intérprete de árbol. Aquí hay un solo árbol:</p><figure><img alt="" src="https://cdn-images-1.medium.com/proxy/1*J2PsfxvM-FatWtVTPn10ww.png" /></figure><p>La raíz del árbol es antes de que haya alguna división. Entonces 10.189 es el logaritmo del precio promedio de registro de todas las opciones en nuestro conjunto de capacitación. Luego, si voy a Coupler_System ≤ 0.5, obtenemos un promedio de 10.345 (para el subconjunto de 16815 ejemplos). Fuera de las personas con Coupler_System ≤0.5, tomamos el subconjunto donde Enclosure ≤ 2.0 y el logaritmo del precio de registro promedio es 9.955. Luego el paso final es ModelID ≤ 4573.0 y eso nos da 10.226.</p><p>Si pasamos estos datos a una tabla de excel, y calculamos el cambio de cada uno de los valores del logaritmo de precios promedios, obtenemos la siguiente figura.</p><figure><img alt="" src="https://cdn-images-1.medium.com/proxy/1*9Y5L0q2vSzI6ZE8S5IS9YA.png" /></figure><p>Entonces podemos calcular el cambio en el precio promedio de registro por cada criterio adicional. Podemos dibujar eso como lo que se llama waterfall plot. Waterfall plots son uno de los gráficos más útiles que se conocen y, por extraño que parezca, no hay nada en Python para hacerlos. Esta es una de esas cosas donde existe esa desconexión entre el mundo de la consultoría de gestión y los negocios donde todo el mundo usa waterfall plots todo el tiempo y la academia que no tiene idea de qué son estas cosas. Cada vez que se tiene un punto de partida, una serie de cambios y un punto de finalización, los gráficos en cascada son casi siempre la mejor manera de mostrarlos.</p><figure><img alt="" src="https://cdn-images-1.medium.com/proxy/1*Ft7pCDIdupo2GkqIxkOAiw.png" /></figure><p>Con Excel 2016, está incorporado. Simplemente has clic en Insertar gráfico de cascada y ahí está. Si quieres ser un héroe, crea un paquete de gráficos en cascada para matplotlib, ponlo en pip y todos te amaran. Estos son realmente muy fáciles de construir. Básicamente, haces un gráfico de columnas apiladas donde la parte inferior es todo blanco. Puedes hacerlo, pero si puedes envolver eso, coloca los puntos en los lugares correctos y coloréalos muy bien, eso sería totalmente increíble. Creo que todos tienen las habilidades para hacerlo y serían una gran cosa para su cartera, te animas??.</p><p>Entonces, si solo estuviéramos haciendo un árbol de decisiones y alguien pregunta “¿por qué la predicción de esta subasta en particular fue este precio en particular?”, Así es como puede responder: “porque estas tres cosas tuvieron estos tres impactos”. Para un bosque aleatorio, podríamos hacer eso en todos los árboles.</p><pre><strong>from</strong> <strong>treeinterpreter</strong> <strong>import</strong> treeinterpreter <strong>as</strong> ti</pre><pre>df_train, df_valid = split_vals(df_raw[df_keep.columns], n_trn)</pre><pre>row = X_valid.values[<strong>None</strong>,0]; row</pre><pre><em>array([[4364751, 2300944, 665, 172, 1.0, 1999, 3726.0, 3, 3232, 1111, 0, 63, 0, 5, 17, 35, 4, 4, 0, 1, 0, 0,<br>        0, 0, 0, 0, 0, 0, 0, 0, 12, 0, 0, 0, 0, 0, 3, 0, 0, 0, 2, 19, 29, 3, 2, 1, 0, 0, 0, 0, 0, 2010, 9, 37,<br>        16, 3, 259, False, False, False, False, False, False, 7912, False, False]], dtype=object)</em></pre><pre>prediction, bias, contributions = ti.predict(m, row)</pre><p>Entonces, cuando uses treeinterpreter.predict (como en el ejemplo mostrado arriba) con un modelo de bosque aleatorio para un ejemplo especifico de precio de la subasta (en este caso es la fila de índice cero), te dice:</p><ul><li>prediction: igual a la predicción de bosque aleatorio.</li><li>bias: esto va a ser siempre el mismo: es el precio de venta promedio para cada una de las muestras aleatorias en el árbol</li><li>contributions: el total de todas las contribuciones para cada vez que vemos que esa columna específica aparece en un árbol.</li></ul><pre>prediction[0], bias[0]</pre><pre><em>(9.1909688098736275, 10.10606580677884)</em></pre><p>El valor de la <em>contribución</em> de cada entidad en el conjunto de datos para esta primera fila:</p><pre>idxs = np.argsort(contributions[0])</pre><pre>[o for o in zip(df_keep.columns[idxs], df_valid.iloc[0][idxs], contributions[0][idxs])]</pre><pre>[(&#39;ProductSize&#39;, &#39;Mini&#39;, -0.54680742853695008),<br>(&#39;age&#39;, 11, -0.12507089451852943),<br>(&#39;fiProductClassDesc&#39;,<br> &#39;Hydraulic Excavator, Track - 3.0 to 4.0 Metric Tons&#39;,<br> -0.11143111128570773),<br>(&#39;fiModelDesc&#39;, &#39;KX1212&#39;, -0.065155113754146801),<br>(&#39;fiSecondaryDesc&#39;, nan, -0.055237427792181749),<br>(&#39;Enclosure&#39;, &#39;EROPS&#39;, -0.050467175593900217),<br>(&#39;fiModelDescriptor&#39;, nan, -0.042354676935508852),<br>(&#39;saleElapsed&#39;, 7912, -0.019642242073500914),<br>(&#39;saleDay&#39;, 16, -0.012812993479652724),<br>(&#39;Tire_Size&#39;, nan, -0.0029687660942271598),<br>(&#39;SalesID&#39;, 4364751, -0.0010443985823001434),<br>(&#39;saleDayofyear&#39;, 259, -0.00086540581130196688),<br>(&#39;Drive_System&#39;, nan, 0.0015385818526195915),<br>(&#39;Hydraulics&#39;, &#39;Standard&#39;, 0.0022411701338458821),<br>(&#39;state&#39;, &#39;Ohio&#39;, 0.0037587658190299409),<br>(&#39;ProductGroupDesc&#39;, &#39;Track Excavators&#39;, 0.0067688906745931197),<br>(&#39;ProductGroup&#39;, &#39;TEX&#39;, 0.014654732626326661),<br>(&#39;MachineID&#39;, 2300944, 0.015578052196894499),<br>(&#39;Hydraulics_Flow&#39;, nan, 0.028973749866174004),<br>(&#39;ModelID&#39;, 665, 0.038307429579276284),<br>(&#39;Coupler_System&#39;, nan, 0.052509808150765114),<br>(&#39;YearMade&#39;, 1999, 0.071829996446492878)]</pre><p>Así que una pequeña pieza de equipo industrial (ProductSize Mini) significaba que era menos costoso. Si se lo hizo hace poco (YearMade) significaba que era más caro, si era antiguo (age) lo hace más económico. Así que esto no te ayudará mucho con Kaggle, donde solo necesitas predicciones. Pero te va a ayudar mucho en un entorno de producción o incluso en la preproducción. Entonces, algo que un buen administrador debería hacer si le dices que aquí hay un modelo de aprendizaje automático que creo que deberíamos usar, es tomar un ejemplo de clientes reales o subastas reales y verificar si tu modelo parece intuitivo. Por ejemplo, si dices que mi predicción es que mucha gente realmente va a disfrutar de una mala película, y es como “wow, esa fue una película muy mala”, entonces volverán a ti y te dirán “explica por qué tu modelo me está diciendo que me va a gustar esta película porque odio esa película ”. Luego puedes volver atrás y decir bien, es porque te gusta esta película y porque tienes este rango de edad y género, y en promedio, a la gente le gustó esa película.</p><p>Esta es una técnica casi totalmente desconocida y esta biblioteca en particular también es casi totalmente desconocida. Así que es una gran oportunidad para mostrar algo que muchas personas no saben. Es totalmente crítico en mi opinión, pero rara vez se hace.</p><h3>Extrapolation</h3><p>El último paso que vamos a hacer antes de intentar construir nuestro propio bosque aleatorio es lidiar con este complicado problema de extrapolación. Entonces, en este caso, si observamos la precisión de nuestros árboles recientes, todavía tenemos una gran diferencia entre nuestro puntaje de validación y nuestro puntaje de entrenamiento.</p><figure><img alt="" src="https://cdn-images-1.medium.com/proxy/1*Tu28k2nmQq7SNqHPurMqMw.png" /></figure><p>Además, en este caso, la diferencia entre el OOB (0.89420) y la validación (0.89319) es bastante cercana. Aquí está el modelo más reciente:</p><figure><img alt="" src="https://cdn-images-1.medium.com/proxy/1*gtNHvpXOlgTmgPv4Chi1Zg.png" /></figure><p>Muy a menudo verás que hay una gran diferencia entre tu puntuación de validación y tu puntuación OOB, y quiero mostrarte cómo enfrentarías eso en particular porque sabemos que la puntuación OOB debería ser un poco peor porque usa menos árboles. Así que me da la sensación de que deberíamos hacerlo un poco mejor. La forma en que deberíamos poder hacerlo un poco mejor es manejar el componente de tiempo un poco mejor.</p><p>Aquí está el problema con los bosques aleatorios cuando se trata de extrapolación. Cuando tienes un conjunto de datos con cuatro años de datos de ventas, creas tu árbol y dice que está en alguna tienda en particular y en algún artículo en particular, este es el precio promedio. Y en realidad nos dice el precio promedio de todo el conjunto de entrenamiento que podría ser bastante antiguo. Entonces, cuando quieras dar un paso adelante hacia lo que será el precio el próximo mes, nunca se verá el próximo mes. En cualquier otro lugar con un modelo lineal, puedes encontrar una relación entre el tiempo y el precio donde, a pesar de que contamos con mucha información, cuando vaya y prediga algo en el futuro, puede extrapolar eso. Pero un bosque aleatorio no puede hacer eso. Así que hay algunas maneras de lidiar con esto, pero una manera simple es tratar de evitar el uso de variables de tiempo como predictores, si es que hay algo más que podríamos usar que nos de una mejor y fuerte relación de cómo en realidad funcionaria en el futuro.</p><p>Entonces, en este caso, lo que se debe hacer es averiguar cuál es la diferencia entre nuestro conjunto de validación y nuestro conjunto de entrenamiento. Si comprendo la diferencia entre nuestro conjunto de validación y nuestro conjunto de entrenamiento, eso me dice cuáles son los predictores que tienen un fuerte componente temporal y, por lo tanto, pueden ser irrelevantes cuando llegue al período de tiempo futuro.</p><p>Para averiguar qué variables dependen del tiempo, crearemos un modelo de bosque aleatorio que intente predecir si una fila en particular está en el conjunto de validación o no. Luego veremos qué variable tiene la mayor contribución para hacer una predicción exitosa.</p><p>Definiendo la variable objetivo “is valid”:</p><pre>df_ext = df_keep.copy()<br>df_ext[&#39;is_valid&#39;] = 1<br>df_ext.is_valid[:n_trn] = 0<br>x, y, nas = proc_df(df_ext, &#39;is_valid&#39;)<br><br>m = RandomForestClassifier(n_estimators=40, min_samples_leaf=3, max_features=0.5, n_jobs=-1, oob_score=<strong>True</strong>)<br>m.fit(x, y);<br>m.oob_score_</pre><pre>0.99998753505765037</pre><p>Este es un gran truco en Kaggle porque a menudo no te dirán si el conjunto de pruebas es una muestra aleatoria o no. Así que puedes poner el conjunto de prueba y el conjunto de entrenamiento, crear una nueva columna llamada is_test y ver si puedes predecirlo. Si puede, no tiene una muestra aleatoria, lo que significa que debe averiguar cómo crear un conjunto de validación a partir de ella.</p><p>El modelo es capaz de separar los conjuntos de entrenamiento y de validación con un valor de R² 0.99998, por lo que no tengo una muestra aleatoria.</p><p>Calculamos las variables más importante</p><pre>fi = rf_feat_importance(m, x)<br>fi[:10]</pre><figure><img alt="" src="https://cdn-images-1.medium.com/max/199/0*BDogWBbhTBE7DsNY.png" /></figure><p>Entonces, si observo la importancia de las características, lo más importante es SalesID. Así que esto es realmente interesante. Nos dice muy claramente que SalesID no es un identificador aleatorio, pero probablemente es algo que se configura consecutivamente a medida que pasa el tiempo. SaleElapsed fue el número de días desde la primera fecha en nuestro conjunto de datos, así que no es sorprendente que también sea un buen predictor. Es interesante MachineID: claramente, cada máquina está siendo etiquetada con algún identificador consecutivo también, y luego hay una gran disminución de importancia, por lo que nos detendremos aquí.</p><p>Tomemos ahora los tres primeros y luego podemos ver sus valores tanto desde el conjunto de entrenamiento como desde el conjunto de validación.</p><pre>feats=[&#39;SalesID&#39;, &#39;saleElapsed&#39;, &#39;MachineID&#39;]<br>(X_train[feats]/1000).describe()</pre><figure><img alt="" src="https://cdn-images-1.medium.com/max/300/0*wW7xcptx-sJa4iVa.png" /></figure><pre>(X_valid[feats]/1000).describe()</pre><figure><img alt="" src="https://cdn-images-1.medium.com/max/300/0*9qn6L7jxF9NtIVvb.png" /></figure><p>Podemos ver, por ejemplo, que SalesID en promedio es de 1,8 millones en el conjunto de capacitación y 5,8 millones en el conjunto de validación (observa que el valor está dividido por 1000). Así que puedes confirmar que son muy diferentes.</p><p>Así que vamos a eliminarlos.</p><pre>x.drop(feats, axis=1, inplace=<strong>True</strong>)</pre><pre>m = RandomForestClassifier(n_estimators=40, min_samples_leaf=3, max_features=0.5, n_jobs=-1, oob_score=<strong>True</strong>)<br>m.fit(x, y);<br>m.oob_score_</pre><pre><em>0.9789018385789966</em></pre><p>Entonces, después de eliminarlos, veamos si puedo predecir si algo es del conjunto de validación. Todavía puedo con R² de 0,978.</p><pre>fi = rf_feat_importance(m, x)<br>fi[:10]</pre><figure><img alt="" src="https://cdn-images-1.medium.com/max/217/0*s3ucqGnOAz1QaHQv.png" /></figure><p>Aunque estas variables son obviamente dependientes del tiempo, también pueden ser importantes para hacer las predicciones. Antes de eliminar estas variables, debemos comprobar cómo afectan la puntuación OOB. La puntuación inicial OOB en una muestra se calcula para la comparación:</p><pre>set_rf_samples(50000)<br>feats=[&#39;SalesID&#39;, &#39;saleElapsed&#39;, &#39;MachineID&#39;, &#39;age&#39;, &#39;YearMade&#39;, &#39;saleDayofyear&#39;]<br>X_train, X_valid = split_vals(df_keep, n_trn)<br>m = RandomForestRegressor(n_estimators=40, min_samples_leaf=3, max_features=0.5, n_jobs=-1, oob_score=True)<br>m.fit(X_train, y_train)<br>print_score(m)</pre><pre>[0.21136509778791376, 0.2493668921196425, 0.90909393040946562, 0.88894821098056087, 0.89255408392415925]</pre><p>Eliminando cada una de las variables de una en una:</p><pre>for f in feats:<br><br>  df_subs = df_keep.drop(f, axis=1)<br>  X_train, X_valid = split_vals(df_subs, n_trn)<br>  m = RandomForestRegressor(n_estimators=40, min_samples_leaf=3, max_features=0.5, n_jobs=-1, oob_score=True)<br>  m.fit(X_train, y_train)<br>  print(f)<br>  print_score(m)</pre><pre>SalesID<br>0.20918653475938534, 0.2459966629213187, 0.9053273181678706, 0.89192968797265737, 0.89245205174299469]<br><br>saleElapsed<br>[0.2194124612957369, 0.2546442621643524, 0.90358104739129086, 0.8841980790762114, 0.88681881032219145]<br><br>MachineID<br>[0.206612984511148, 0.24446409479358033, 0.90312476862123559, 0.89327205732490311, 0.89501553584754967]<br><br>age<br>[0.21317740718919814, 0.2471719147150774, 0.90260198977488226, 0.89089460707372525, 0.89185129799503315]<br><br>YearMade<br>[0.21305398932040326, 0.2534570148977216, 0.90555219348567462, 0.88527538596974953, 0.89158854973045432]<br><br>saleDayofyear<br>[0.21320711524847227, 0.24629839782893828, 0.90881970943169987, 0.89166441133215968, 0.89272793857941679]</pre><p>Y se puede ver que cuando elimino SalesID, mi puntuación aumenta. Esto es lo que esperábamos. Hemos eliminado una variable dependiente del tiempo, hubo otras variables que podrían encontrar relaciones similares sin la dependencia del tiempo. Así que eliminarlo causó que nuestra validación subiera. Ahora OOB no subió, porque esto es realmente un predictor estadísticamente útil, pero es dependiente del tiempo y tenemos un conjunto de validación dependiente del tiempo. Así que esto es realmente sutil pero puede ser realmente importante. Está tratando de encontrar las cosas que le dan una predicción generalizable a través del tiempo y aquí es cómo puedes verlo.</p><p>Debemos eliminar SalesID con seguridad, pero saleElapsed no mejoró, por lo que no queremos eliminarlo. MachineID mejoró: de 0.888 a 0.893, por lo que es un poco mejor. La edad mejoró un poco. YearMade empeoró, saleDayofyear un poco mejor.</p><pre>reset_rf_samples()<br>df_subs = df_keep.drop([&#39;SalesID&#39;, &#39;MachineID&#39;, &#39;saleDayofyear&#39;],axis=1)<br>X_train, X_valid = split_vals(df_subs, n_trn)<br>m = RandomForestRegressor(n_estimators=40, min_samples_leaf=3, max_features=0.5, n_jobs=-1, oob_score=<strong>True</strong>)<br>m.fit(X_train, y_train)<br>print_score(m)</pre><pre>[0.1418970082803121, 0.21779153679471935, 0.96040441863389681, 0.91529091848161925, 0.90918594039522138]</pre><p>Después de eliminar las variables dependientes del tiempo, la puntuación de validación (0.915) ahora es mejor que la puntuación OOB (0.909).</p><p>Ese fue un enfoque muy exitoso allí, y ahora podemos verificar la importancia de las características.</p><pre>plot_fi(rf_feat_importance(m, X_train));</pre><figure><img alt="" src="https://cdn-images-1.medium.com/proxy/1*aUryUuD3FN20P2THP1pfow.png" /></figure><p>Ahora podemos jugar con otros parámetros como n_estimator en max_features. Para crear el modelo final, podemos aumentar el número de árboles a 160 y aquí están los resultados:</p><pre>m = RandomForestRegressor(n_estimators=160, max_features=0.5, n_jobs=-1, oob_score=<strong>True</strong>)<br>%time m.fit(X_train, y_train)<br>print_score(m)</pre><pre>CPU times: user 6min 3s, sys: 2.75 s, total: 6min 6s<br>Wall time: 16.7 s<br>[0.08104912951128229, 0.2109679613161783, 0.9865755186304942, 0.92051576728916762, 0.9143700001430598]</pre><p>Como puedes ver, hicimos todas nuestras interpretaciones, todos nuestros ajustes, básicamente con modelos / subconjuntos más pequeños y al final, ejecutamos todo el proceso. Y en realidad solo tomó 16 segundos y ahora el puntaje de validación es de 0.92 mientras que el RMSE mejora a 0.21. Ahora podemos comprobar eso contra Kaggle. Desafortunadamente, esta es una competencia más antigua y ya no se nos permite entrar para ver cómo habríamos ido. Entonces, lo mejor que podemos hacer es verificar si parece que podríamos haberlo hecho bien en función de su conjunto de validación, por lo que debería estar en el área correcta. Basado en eso, habríamos quedado primeros.</p><figure><img alt="" src="https://cdn-images-1.medium.com/max/1024/1*RHqb7i0LdicwgXPI_bH6uw.png" /></figure><p>Creo que esta es una interesante serie de pasos. Así que puedes seguir la misma serie de pasos en tus proyectos Kaggle y, lo que es más importante, tus proyectos del mundo real. Uno de los desafíos es que una vez que abandones este entorno de aprendizaje, de repente te encuentres rodeado de personas que nunca tienen suficiente tiempo, siempre quieren que tengas prisa, siempre te dicen que hagas esto y luego que hagas eso. Debes encontrar el tiempo para alejarte y regresar, ya que este es un proceso de modelado real que puedes usar. Y da resultados de clase mundial, lo digo en serio. El chico que ganó esto, Leustagos, lamentablemente falleció, pero es el mejor competidor de Kaggle de todos los tiempos. Ganó, creo que docenas de competiciones, así que si podemos obtener un puntaje incluso mejor que él, entonces lo estamos haciendo muy bien.</p><p>Con esto concluimos nuestro modelo de Random Forest usando FastAI y podemos ver que con pocas líneas de código podemos tener un buen modelo en producción.</p><p>Espero que te haya gustado y sea de utilidad. Puedes dejar tus aplausos y recuerda, puedes dejar hasta 50 =)</p><img src="https://medium.com/_/stat?event=post.clientViewed&referrerSource=full_rss&postId=4b2cb15d92e8" width="1" height="1" alt=""><hr><p><a href="https://medium.com/saturdays-ai/fastai-machine-learning-lecci%C3%B3n-5-segunda-parte-4b2cb15d92e8">FastAI Machine Learning (Lección 5-segunda parte)</a> was originally published in <a href="https://medium.com/saturdays-ai">Saturdays.AI</a> on Medium, where people are continuing the conversation by highlighting and responding to this story.</p>]]></content:encoded>
        </item>
        <item>
            <title><![CDATA[FastAI Machine Learning (Lección 5-Primera parte)]]></title>
            <link>https://medium.com/saturdays-ai/fastai-machine-learning-lecci%C3%B3n-5-primera-parte-889a5761ce2f?source=rss-631fff797e3a------2</link>
            <guid isPermaLink="false">https://medium.com/p/889a5761ce2f</guid>
            <category><![CDATA[machine-learning]]></category>
            <category><![CDATA[ai-saturdays]]></category>
            <category><![CDATA[fastai]]></category>
            <category><![CDATA[predictions]]></category>
            <category><![CDATA[crossvalidation]]></category>
            <dc:creator><![CDATA[Christian Tutivén Gálvez]]></dc:creator>
            <pubDate>Sat, 02 Mar 2019 18:49:12 GMT</pubDate>
            <atom:updated>2019-03-03T05:44:05.294Z</atom:updated>
            <content:encoded><![CDATA[<p>Ahora ya entendemos que es un bosque aleatorio (Random Forest) y sabemos como usarlo para analizar nuestros datos. En la lección # 5, nos centraremos en cómo identificar si el modelo se está generalizando bien o no. Jeremy Howard también habla acerca de los intérpretes de árboles, la contribución y la comprensión de los mismos usando un cuadro de cascada (que ya hemos cubierto en la lección anterior, por lo que no explicaremos más sobre esto). El enfoque principal del vídeo es sobre la extrapolación y la comprensión de cómo podemos construir un algoritmo de bosque aleatorio desde cero.</p><h3>El objetivo de Machine Learning es generalizar</h3><p>Tenemos un conjunto de datos con un montón de filas y tenemos algunas variables dependientes. ¿Cuál es la diferencia entre el aprendizaje automático y cualquier otro tipo de trabajo? La diferencia es que, en el aprendizaje automático, lo que nos importa es la precisión de la generalización o el error de la generalización. Además, en casi todo lo demás, lo único que nos importa es qué tan bien podemos mapear las observaciones. Así que esta cosa sobre la generalización es la pieza clave única de aprendizaje automático. Y si queremos saber si estamos haciendo un buen trabajo de aprendizaje automático, necesitamos saber si estamos haciendo un buen trabajo de generalización. Si no lo sabemos, no sabemos nada.</p><h3>Escalabilidad vs Generalizar</h3><p>Escalar es una cosa importante en muchas áreas. Es como si tenemos algo que funciona en mi computadora con 10,000 artículos, ahora necesito hacer que funcione con 10,000 artículos por segundo. Por lo tanto, la escalabilidad es importante, pero no solo para el aprendizaje automático, sino para casi todo lo que ponemos en producción.</p><p>Para entender la generalización veamos el siguiente ejemplo. He visto cinco fotos de gatos y cinco fotos de perros, y he construido un modelo que es perfecto. Luego miro a un grupo diferente de cinco gatos y perros, y los clasifico a todos mal. Entonces, en ese caso, lo que aprendió no fue la diferencia entre un gato y un perro, sino que aprendió cómo se veían esos cinco gatos exactos y cómo se veían esos cinco perros exactos. O construí un modelo para predecir las ventas de comestibles para un producto en particular, por ejemplo para los rollos de papel higiénico en Nueva Jersey el mes pasado, luego voy y lo pongo en producción y la escalabilidad es excelente (en otras palabras, una gran latencia, sin una gran carga de CPU) pero no predice nada más que rollos de papel higiénico en Nueva Jersey. También resulta que solo lo hizo bien el mes pasado, no el mes siguiente. Así que ambas son fallas de generalización.</p><p>La forma más común en que las personas verifican la capacidad de generalizar es crear una muestra aleatoria. Así que se tomarán unas cuantas filas al azar y lo pondrán en un conjunto de prueba. Luego, construirán todos sus modelos en el resto de las filas y cuando terminen, comprobarán la precisión que obtuvieron en el conjunto de pruebas (el resto de filas se denomina conjunto de entrenamiento). En otras palabras, al final de su proceso de modelado en el conjunto de entrenamiento, obtuvieron una precisión del 99% al identificar gatos en un conjunto que tiene también perros y lo comparan con un conjunto de prueba para asegurarse de que el modelo realmente se generalice.</p><p>Ahora el problema es, ¿y si no lo hace? Bueno, podría volver atrás y cambiar algunos hyper-parámetros, hacer un aumento de datos, cualquier otra cosa que intente crear un modelo más generalizable. Y luego volveré otra vez después de hacer todo eso, y comprobaré que todavía no es bueno. Seguiré haciendo esto una y otra vez hasta que finalmente, después de cincuenta intentos, se generalice. ¿Pero realmente se generaliza? Porque tal vez todo lo que he hecho es encontrar accidentalmente este que funciona solo para ese conjunto de pruebas porque he probado cincuenta cosas diferentes. Entonces, lo que generalmente hacemos es dejar de lado un segundo conjunto de datos (conjunto de validación). Entonces todo lo que no está en la validación o prueba ahora se está entrenando. Lo que hacemos es entrenar un modelo, verificarlo con la validación para ver si se generaliza, hacer eso unas cuantas veces. Luego, cuando finalmente obtengamos algo que creemos que se generalizará correctamente en función del conjunto de validación (al final del proyecto), lo comparamos con el conjunto de prueba.</p><h3>OOB</h3><p>Otro truco que hemos aprendido para el bosque aleatorio es una forma de no necesitar un conjunto de validación. Y la forma en que aprendimos fue utilizar, la puntuación OOB. Esta idea se basa en que para tener aleatoriedad cada árbol fue entrenado con filas de manera aleatoria, por lo que quedan filas que no fueron usadas en todos los árboles (solo en algunos) y, por lo tanto, al promediar los árboles que no usaron esa fila para su entrenamiento obtenemos el OOB. Entonces, el puntaje OOB nos da algo que es bastante similar al puntaje de validación, pero en promedio es un poco menos bueno. ¿Por qué? Debido a que cada fila usará un subconjunto de los árboles para hacer su predicción, y con menos árboles, sabemos que obtenemos una predicción menos precisa. De todos modos, generalmente están lo suficientemente cerca. Entonces, ¿por qué tener un conjunto de validación cuando está utilizando bosques aleatorios? Si se trata de un conjunto de validación elegido al azar, no es estrictamente necesario, pero puedes realizar pruebas en el OOB. Cuando funciona bien, puede realizar pruebas en el conjunto de validación, y con suerte en el momento en que compruebes el conjunto de pruebas, no habrá sorpresas, por lo que será una buena razón.</p><figure><img alt="" src="https://cdn-images-1.medium.com/max/915/1*0AksvyOqLWriT9OwAiljAQ.png" /></figure><p>Lo que hace Kaggle es algo inteligente. Lo que Kaggle hace es dividir el conjunto de pruebas en dos partes: una pública y otra privada. Y no te dicen cuál es cuál. Entonces, envías tus predicciones a Kaggle y luego un 30% aleatorio de ellas se usa para decirte el puntaje de la tabla de clasificación. Pero al final de la competencia, eso se desecha y usan el otro 70% para calcular tu puntaje real. Entonces, lo que está haciendo es asegurarse de que no estás utilizando continuamente los comentarios de la tabla de clasificación para descubrir un conjunto de hyper-parámetros que funcionan bien y que en realidad no se generalizan. Así que es una gran prueba. Esta es una de las razones por las que es una buena práctica usar Kaggle, porque al final de una competencia, en algún momento esto te sucederá, y bajaras cien lugares en la tabla de clasificación el último día de la competencia. Ahí es cuando veras lo que es estar sobre-entrenado y es mucho mejor practicar y tener ese sentido allí que hacerlo en una compañía donde hay cientos de millones de dólares en juego.</p><h3>Por qué hay casos en que usar muestra aleatorios para validar va mal?</h3><p>Si predecimos quién va a comprar papel higiénico en Nueva Jersey y tardamos dos semanas en ponerlo en producción y lo hicimos utilizando datos de los últimos dos años y para ese entonces, las cosas pueden parecer muy diferentes. Y, en particular, nuestro conjunto de validación, si lo probamos al azar, y fue de un período de cuatro años, la gran mayoría de los datos tendrá más de un año de diferencia. Y puede ser que los hábitos de compra de papel higiénico de la gente en Nueva Jersey hayan cambiado drásticamente. Tal vez ahora existe una recesión terrible y ya no pueden pagar un papel higiénico de alta calidad. O tal vez saben que su industria de fabricación de papel se ha disparado y de repente están comprando mucho más papel higiénico porque es muy barato. Entonces, el mundo cambia y, por lo tanto, si usas una muestra aleatoria para tu conjunto de validación, ¿realmente estás comprobando qué tan bueno es tu modelo para predecir cosas que están totalmente obsoletas ahora? ¿Qué tan bueno eres para predecir cosas que sucedieron hace cuatro años? Eso no es interesante. Entonces, lo que queremos hacer en la práctica, cada vez que hay una parte temporal es decir, suponiendo que lo hayamos ordenado por tiempo, usaremos la última parte como nuestro conjunto de validación. Supongo, en realidad hacerlo correctamente:</p><figure><img alt="" src="https://cdn-images-1.medium.com/proxy/1*Ka6WNHrQDnoD1WfvYxKl_w.png" /></figure><p>Podemos ver nuestro conjunto de validación, y nuestro conjunto de prueba. Así que el resto es nuestro conjunto de entrenamiento y lo usamos, tratando de modelar que aún funcione en cosas que son más tarde que cualquier otra cosa en la que se construyó el modelo. Por lo tanto, no solo estamos probando la generalización en algún tipo de sentido abstracto, sino en un sentido del tiempo muy específico que generaliza el futuro.</p><h3>¿Cómo se hace el compromiso entre la cantidad de datos frente a la actualidad de los datos?</h3><p>Lo que Jeremy tiende a hacer es, cuando existe este tipo de problema temporal, que es probablemente la mayoría del tiempo, una vez que se tiene algo que funciona bien en el conjunto de validación, no iría y solo usaría ese modelo en el conjunto de prueba, porque el conjunto de pruebas está mucho más lejos en el futuro en comparación con el conjunto de entrenamiento. Entonces volvería a replicar la construcción de ese modelo, pero esta vez combinaría los conjuntos de entrenamiento y validación y volvería a entrenar el modelo. En ese momento, no hay forma de probar un conjunto de validación, por lo que se debe asegurar tener un script o cuaderno reproducible que realice exactamente los mismos pasos de la misma manera porque si se equivoca en algo, entonces, vamos a encontrar en el conjunto de prueba, que tienes un problema.</p><h3>Cómo saber si mi conjunto de validación realmente representa mi conjunto de prueba?</h3><p>En la práctica se necesita saber si mi conjunto de validación es realmente representativo del conjunto de pruebas. Entonces, lo que se hace es construir cinco modelos en el conjunto de entrenamiento, y tratar de que varíen en lo buenos que creo que son. Luego calificamos los cinco modelos en el conjunto de validación y también los calificamos en el conjunto de prueba. Por lo tanto, no estamos haciendo trampa, ya que no utilizamos ninguna observación del conjunto de pruebas para cambiar los hyper-parámetros, solo lo usamos para esta única cosa que es verificar el conjunto de validación. Así que obtenemos cinco puntajes del conjunto de validación y del conjunto de pruebas y luego verificamos que crean una línea.</p><figure><img alt="" src="https://cdn-images-1.medium.com/max/831/1*KBCFWOiD8h40cboJ10xfLA.png" /></figure><p>Si no lo hacen, entonces no obtendremos suficiente información del conjunto de validación. Así que hay que seguir haciendo ese proceso hasta que obtengamos una línea y eso puede ser bastante complicado.</p><p>Tratar de crear algo que sea lo más parecido posible al resultado del mundo real es difícil. Y en el mundo real, lo mismo ocurre con la creación del conjunto de prueba: el conjunto de prueba debe ser lo más cercano posible a la producción. Entonces, ¿cuál es la mezcla real de clientes que van a usar esto, cuánto tiempo realmente habrá entre cuando construyes el modelo y cuando lo pones en producción? ¿Con qué frecuencia vas a poder actualizar el modelo? Estas son todas las cosas en que pensar cuando construyes ese conjunto de pruebas.</p><p>Entonces, si comienzas con un conjunto de validación de muestras aleatorias de todo tu set y no obtienes una línea, te das cuenta de que deberías haber elegido los últimos dos meses. Luego escoges los últimos dos meses y todavía los puntos están en todas partes y te das cuenta de que deberías haberlo elegido para que también sea desde el primero del mes hasta el quince del mes, y sigues cambiando el conjunto de validación hasta que encuentres un conjunto que es indicativo de los resultados de tu conjunto de prueba. Lo que se desea es tener una idea de qué pasa si mi conjunto de validación no se generaliza temporalmente, y si no se generaliza estadísticamente.</p><figure><img alt="" src="https://cdn-images-1.medium.com/max/395/1*5AJ2Kv2EO6HIdEijWyEa6w.png" /></figure><p>Ejemplos de sets de validación que se pueden usar (si deseamos predecir del 15 de agosto al 30 de agosto):</p><ul><li>Muestra aleatoria (4 años)</li><li>Último mes de datos (15 de julio al 15 de agosto)</li><li>Últimas 2 semanas (1 al 15 de agosto)</li><li>Rango el mismo día un mes antes (15–30 de julio)</li></ul><p>En cada uno de los cinco modelos, calculo la puntuación de validación. Luego vuelvo a entrenar el modelo en todo el conjunto (entrenamiento y validación) y calculo lo mismo en el conjunto de prueba. Entonces, cada uno de estos puntos ahora me dice qué tan bien fue en el conjunto de validación y qué tan bien fue en el conjunto de prueba. Si el conjunto de validación es útil, diríamos que cada vez que el conjunto de puntuación de validación mejore, el puntaje de prueba también debería mejorar.</p><p>Reconocer que el set de prueba refleja el mundo real es el paso más importante de un proyecto de Machine Learning. ¿Por qué es el paso más importante? Porque si arruinas todo lo demás, sabrás que fue lo que lo causo. Si tienes un buen conjunto de pruebas, entonces sabrás que todo salio mal porque cambiaste algo, lo probaste y no funcionó. Está bien, no vas a destruir la empresa. Si arruinaste la creación del conjunto de prueba, sería horrible. Porque entonces no sabes si has cometido un error. Intentas construir un modelo, lo pruebas en el conjunto de pruebas y se ve bien. Pero el conjunto de pruebas no era indicativo del entorno del mundo real. Así que no sabes realmente si vas a destruir la compañía.</p><p>El conjunto de pruebas, es algo de lo que todo el mundo habla un poco en las clases de aprendizaje automático, pero a menudo se detiene en el punto en el que aprendiste que hay una cosa en sklearn (librería de machine learning) llamada train_test_split y devuelve estas cosas y listo, o la función de validación cruzada. El hecho de que estas cosas siempre te den muestras aleatorias te dice que, la mayoría de las veces no deberías usarlas. El hecho de que un bosque aleatorio te dé un OOB gratis, es útil pero solo te dice que esto se generaliza en un sentido estadístico, no en un sentido práctico.</p><h3>Cross validation (validación cruzada)</h3><p>La validación cruzada dice que no solo extraigamos un conjunto de validación, sino que extraigamos cinco, por ejemplo. Así que supongamos que primero vamos a barajar aleatoriamente los datos. Esto es crítico.</p><ul><li>Mezclar aleatoriamente los datos.</li><li>Dividirlo en cinco grupos</li><li>Para el modelo №1, llamaremos al primer conjunto para la validación y los cuatro últimos al para el entrenamiento.</li><li>Entrenaremos y verificaremos la validación y obtendremos RMSE, R², etc.</li><li>Lo repetiremos cinco veces, y tomamos el promedio de RMSE, R², etc., y eso es una precisión promedio de validación cruzada.</li></ul><figure><img alt="" src="https://cdn-images-1.medium.com/max/713/1*1F87nNoLiIWJy4QjYSj7yA.png" /></figure><p>¿Cuál es el beneficio de usar la validación cruzada? Puedes utilizar todos los datos. No tienes que poner nada a un lado. Y también obtienes un pequeño beneficio, ya que ahora tienes cinco modelos que puedes armar juntos, cada uno utiliza el 80% de los datos. Así que a veces ese conjunto puede ser útil.</p><p>¿Cuáles podrían ser algunas razones por las que no debes utilizar la validación cruzada? Para grandes conjuntos de datos, tomará mucho tiempo. Tenemos que ajustar cinco modelos en lugar de uno, por lo que el tiempo es un inconveniente clave. Si estamos haciendo un aprendizaje profundo y demora un día en ejecutarse, de repente demoran cinco días o necesitamos 5 GPU.</p><p>¿Qué pasa con mis problemas anteriores sobre conjuntos de validación? Nuestras preocupaciones anteriores acerca de por qué los conjuntos aleatorios de validación son un problema son totalmente relevantes aquí. Estos conjuntos de validación son aleatorios, por lo que si un conjunto de validación aleatorio no es adecuado para tu problema, probablemente porque tu problema es temporal, ninguno de estos cinco conjuntos de validación es bueno. Todos son aleatorios. Entonces, si tienes datos temporales como lo hicimos antes, no hay manera de hacer validación cruzada o no hay una buena manera de hacerlo. Deseas que tu conjunto de validación sea lo más cercano posible al conjunto de prueba, y no puedes hacer eso mediante el muestreo aleatorio de diferentes cosas. Es posible que no necesites realizar una validación cruzada os de validación al azar no son adecuados para nuestro problema.</p><h3>Conclusión</h3><p>Espero que esta guía te haya ayudado a entender la importancia de crear un buen conjunto de validación y de pruebas. Continuaremos con la parte práctica de esta lección en la siguiente guía.</p><img src="https://medium.com/_/stat?event=post.clientViewed&referrerSource=full_rss&postId=889a5761ce2f" width="1" height="1" alt=""><hr><p><a href="https://medium.com/saturdays-ai/fastai-machine-learning-lecci%C3%B3n-5-primera-parte-889a5761ce2f">FastAI Machine Learning (Lección 5-Primera parte)</a> was originally published in <a href="https://medium.com/saturdays-ai">Saturdays.AI</a> on Medium, where people are continuing the conversation by highlighting and responding to this story.</p>]]></content:encoded>
        </item>
        <item>
            <title><![CDATA[FastAI Machine Learning (Lección 4)]]></title>
            <link>https://medium.com/saturdays-ai/fastai-machine-learning-lecci%C3%B3n-4-200a2d37f910?source=rss-631fff797e3a------2</link>
            <guid isPermaLink="false">https://medium.com/p/200a2d37f910</guid>
            <category><![CDATA[data-analysis]]></category>
            <category><![CDATA[machine-learning]]></category>
            <category><![CDATA[ai-saturdays]]></category>
            <category><![CDATA[fastai]]></category>
            <category><![CDATA[random-forest]]></category>
            <dc:creator><![CDATA[Christian Tutivén Gálvez]]></dc:creator>
            <pubDate>Mon, 25 Feb 2019 18:53:35 GMT</pubDate>
            <atom:updated>2019-02-25T18:53:35.483Z</atom:updated>
            <content:encoded><![CDATA[<p>Continuamos analizando nuestros datos usando el modelo de predicción Random Forest. Puedes leer la lección 3 <a href="https://medium.com/saturdays-ai/fastai-machine-learning-lecci%C3%B3n-3-aecf329e963d?source=friends_link&amp;sk=04340a9e8d67100906252481f18c4928">aquí</a>.</p><h3>Codificación One-Hot</h3><p>Recordemos la lección 1 de FastAI Machine Learning, donde nos encontramos con el problema de que teníamos muchas variables categóricas, las cuales muchos modelos no aceptan. Usando <em>proc_df</em> , convertimos las variables categóricas en columnas numéricas. Por ejemplo, tenemos una variable <em>UsageBand</em> , que tiene tres niveles: “Alto”, “Bajo” y “Medio”. Reemplazamos estas categorías con números 0, 1 y 2.</p><p>Si UsageBand tuviera filas con un valor llamado unknow, con qué número se podría reemplazar, respetando el orden?. ¿Seguramente debe haber otra forma de manejar esto?</p><p>En lugar de convertir estas categorías en números, podemos crear columnas separadas para cada categoría. La columna <em>UsageBand</em> se puede reemplazar con tres columnas:</p><ul><li><em>UsoBand_low</em></li><li><em>UsoBand_medium</em></li><li><em>UsoBand_high</em></li></ul><p>Cada uno de estos tiene 1s y 0s como los valores. Esto se llama una codificación one-hot.</p><p>¿Qué pasa cuando hay más de 3 categorías? ¿Qué pasa si tenemos más de 10? Tomemos un ejemplo para entender esto.</p><p>Supongamos que tenemos una columna ‘ <em>zip_code</em> ‘ en el conjunto de datos que tiene un valor único para cada fila. El uso de la codificación one-hot aquí no será beneficioso para el modelo y terminará aumentando el tiempo de ejecución (un escenario de pérdida-pérdida).</p><p>Usando <em>proc_df</em> en fastai, podemos realizar una codificación <em>instantánea</em> pasando un parámetro <em>max_n_cat</em> . Aquí, hemos establecido el <em>max_n_cat = 7</em> , lo que significa que las variables que tienen niveles más de 7 (como el zip_code) no se codificarán, mientras que todas las demás variables se codificarán en un solo lugar.</p><pre>df_trn2, y_trn, nas = proc_df(df_raw, &#39;SalePrice&#39;, max_n_cat=7)<br>X_train, X_valid = split_vals(df_trn2, n_trn)</pre><pre>m = RandomForestRegressor(n_estimators=40, min_samples_leaf=3, max_features=0.6, n_jobs=-1, oob_score=True)<br>m.fit(X_train, y_train)<br>print_score(m)</pre><figure><img alt="" src="https://cdn-images-1.medium.com/max/727/1*PfoceWxQa6DcctY_pOtlnA.png" /></figure><p>Esto puede ser útil para determinar si un nivel particular en una columna particular es importante o no. Ya que hemos separado cada nivel para las variables categóricas, podremos verlas también en el gráfico de características importantes. De nuevo FastAI nos facilita la vida y tiene una función a la medida.</p><pre>fi = rf_feat_importance(m, df_trn2)<br>plot_fi(fi[:25]);</pre><figure><img alt="" src="https://cdn-images-1.medium.com/max/844/1*OD_p4Ow7SfM4ovnShdntMg.png" /></figure><p>Anteriormente, <em>YearMade</em> era la función más importante en el conjunto de datos, pero Enclosure_<em>EROPS w AC</em> tiene una importancia más importante en esta nueva tabla. Interesante verdad?</p><h3>Eliminar características redundantes</h3><p>Hasta ahora, hemos entendido que tener una gran cantidad de características puede afectar el rendimiento del modelo y también dificultar la interpretación de los resultados. En esta sección, veremos cómo podemos identificar las características redundantes y eliminarlas de los datos.</p><p>Usaremos de clustering jerárquico (dendrograma), para identificar variables similares. En esta técnica, observamos cada objeto e identificamos cuál de ellos es el más cercano en términos de características. Estas variables son reemplazadas por su punto medio. Para entenderlo mejor, echemos un vistazo al diagrama de cluster de nuestro conjunto de datos.</p><p>Primero importamos</p><pre>from scipy.cluster import hierarchy as hc</pre><pre>corr = np.round(scipy.stats.spearmanr(df_keep).correlation, 4)<br>corr_condensed = hc.distance.squareform(1-corr)<br>z = hc.linkage(corr_condensed, method=’average’)<br>fig = plt.figure(figsize=(16,10))<br>dendrogram = hc.dendrogram(z, labels=df_keep.columns, orientation=’left’, leaf_font_size=16)<br>plt.show()</pre><figure><img alt="" src="https://cdn-images-1.medium.com/max/1024/1*ndPynKv7AszPhjognGTP7A.png" /></figure><p>Podemos ver que las variables <em>SaleYear</em> y <em>SaleElapsed</em> son muy similares entre sí y tienden a representar lo mismo. De manera similar, <em>Grouser_Tracks</em> , <em>Hydraulics_Flow</em> y <em>Coupler_System</em> están altamente correlacionados. Lo mismo sucede con <em>ProductGroup</em> y <em>ProductGroupDesc y finalmente fiBaseModel</em> con <em>fiModelDesc</em> . Eliminaremos cada una de estas funciones una por una y veremos cómo afecta el rendimiento del modelo.</p><p>Primero, definimos una función para calcular la puntuación de fuera de bolsa (OOB) (para evitar repetir las mismas líneas de código):</p><pre>def get_oob(df):<br> m = RandomForestRegressor(n_estimators=30, min_samples_leaf=5, max_features=0.6, n_jobs=-1, oob_score=True)<br> x, _ = split_vals(df, n_trn)<br> m.fit(x, y_train)<br> return m.oob_score_</pre><p>A continuación se muestra el puntaje original de OOB antes de eliminar cualquier función:</p><pre>get_oob(df_keep)<br>0.89019425494301454</pre><p>Ahora eliminamos una variable a la vez y calcularemos la puntuación:</p><pre>for c in (‘saleYear’, ‘saleElapsed’, ‘fiModelDesc’, ‘fiBaseModel’, ‘Grouser_Tracks’, ‘Coupler_System’):<br> print(c, get_oob(df_keep.drop(c, axis=1)))</pre><figure><img alt="" src="https://cdn-images-1.medium.com/max/251/1*aC0czBLPdwlyGryhQ7_H5g.png" /></figure><p>Esto no ha afectado en gran medida la puntuación OOB, lo que quiere decir que eliminar una de estas variables redundantes no afecta en mucho a nuestro modelo. Ahora eliminemos una variable de cada par y verifiquemos la puntuación general:</p><pre>to_drop = [‘saleYear’, ‘fiBaseModel’, ‘Grouser_Tracks’]<br>get_oob(df_keep.drop(to_drop, axis=1))<br>0.8886129948554602</pre><p>La puntuación ha cambiado de 0.8901 a 0.8885. Utilizaremos estas características seleccionadas en el conjunto de datos completo y veremos cómo funciona nuestro modelo:</p><pre>df_keep.drop(to_drop, axis=1, inplace=True)<br>X_train, X_valid = split_vals(df_keep, n_trn)</pre><pre>reset_rf_samples()</pre><pre>m = RandomForestRegressor(n_estimators=40, min_samples_leaf=3, max_features=0.5, n_jobs=-1, oob_score=True)<br>m.fit(X_train, y_train)<br>print_score(m)</pre><p>Obtenemos</p><pre>[0.12615142089579687, 0.22781819082173235, 0.96677727309424211, 0.90731173105384466, 0.9084359846323049]</pre><p>Una vez que estas variables se eliminan del marco de datos original, el puntaje del modelo resulta ser 0.907 en el conjunto de validación, con un modelo más pequeño y simple.</p><h3>Dependencia parcial</h3><p>Existe otra técnica que tiene el potencial de ayudarnos a comprender mejor los datos. Esta técnica se llama Dependencia parcial y se usa para averiguar cómo se relacionan las características con la variable objetivo.</p><pre>from pdpbox import pdp<br>from plotnine import *</pre><pre>set_rf_samples(50000)</pre><pre>df_trn2, y_trn, nas = proc_df(df_raw, &#39;SalePrice&#39;, max_n_cat=7)<br>X_train, X_valid = split_vals(df_trn2, n_trn)</pre><pre>m = RandomForestRegressor(n_estimators=40, min_samples_leaf=3, max_features=0.6, n_jobs=-1)<br>m.fit(X_train, y_train);</pre><pre>plot_fi(rf_feat_importance(m, df_trn2)[:10]);</pre><figure><img alt="" src="https://cdn-images-1.medium.com/max/846/1*_CF8gkO3CKSDre2vYJBE4A.png" /></figure><p>Comparemos <em>YearMade</em> y <em>SalePrice</em> . Si creas un diagrama de dispersión para <em>YearMade</em> y <em>SaleElapsed</em> , <em>notarías</em> que algunos vehículos fueron creados en el año 1000, lo cual no es prácticamente posible.</p><pre>df_raw.plot(‘YearMade’, ‘saleElapsed’, ‘scatter’, alpha=0.01, figsize=(10,8));</pre><figure><img alt="" src="https://cdn-images-1.medium.com/max/571/1*1RG4b14J0cFGDXpjFNXPwA.png" /></figure><p>Estos podrían ser los valores que inicialmente faltaban y se han reemplazado con 1,000. Para mantener las cosas prácticas, nos centraremos en los valores superiores a 1930 para la variable <em>YearMade.</em></p><pre>x_all = get_sample(df_raw[df_raw.YearMade&gt;1930], 500)</pre><p>Creamos un gráfico utilizando el popular paquete <em>ggplot</em> .</p><pre>import skmisc<br>ggplot(x_all, aes(‘YearMade’, ‘SalePrice’))+stat_smooth(se=True, method=’loess’)</pre><figure><img alt="" src="https://cdn-images-1.medium.com/max/582/0*KuEYv8fyqCjsPJe3.png" /></figure><p>Esta gráfica muestra que el precio de venta es mayor para los vehículos fabricados más recientemente, excepto por una caída entre 1991 y 1997. Podría haber varias razones para esta caída: la recesión, los vehículos preferidos por los clientes de menor precio o algún otro factor externo. Para entender esto, crearemos una gráfica que muestre la relación entre <em>YearMade</em> y <em>SalePrice</em> , dado que todos los demás valores de características son los mismos, es decir que si vendemos algo en 1990 versus 1980 y fue vendido exactamente lo mismo, la misma persona fue la que lo compro, la misma opción, etc. , entonces cuál sería la diferencia en precios. Para esto usamos el gráfico de dependencia parcial.</p><pre>x = get_sample(X_train[X_train.YearMade&gt;1930], 500)<br><br>def plot_pdp(feat, clusters=None, feat_name=None):<br>    feat_name = feat_name or feat<br>    p = pdp.pdp_isolate(m, x, x.columns, feat)<br>    return pdp.pdp_plot(p, feat_name, plot_lines=True,<br>                        cluster=clusters is not None,<br>                        n_cluster_centers=clusters)<br>plot_pdp (&#39;YearMade&#39;)</pre><figure><img alt="" src="https://cdn-images-1.medium.com/max/943/0*PGTTck4h7bUkU6nC.png" /></figure><p>Esta trama se obtiene al fijar el <em>Año Hecho</em> para cada fila en 1960, luego en 1961, y así sucesivamente. En palabras simples, tomamos un conjunto de filas y calculamos el <em>Precio</em> de <em>Venta</em> para cada fila cuando <em>YearMade</em> es 1960. Luego, tomamos todo el conjunto de nuevo y calculamos el <em>Precio</em> de <em>Venta</em> al establecer <em>YearMade</em> en 1962. Repetimos esto varias veces, lo que resulta en las múltiples líneas azules Lo vemos en la trama anterior. La línea negra oscura representa el promedio. <strong>Esto confirma nuestra hipótesis de que el precio de venta aumenta para los vehículos fabricados más recientemente.</strong></p><p>Ahora podemos hacer un análisis de cluster, para ver los cinco más omunes comportamientos que tenemos.</p><pre>plot_pdp(‘YearMade’, clusters=5)</pre><figure><img alt="" src="https://cdn-images-1.medium.com/max/890/1*MKfufHgZaWP3MEW0GYNNfA.png" /></figure><p>Podemos que algunos tipos de vehículos llegan a un tiempo que los precios son más planos a lo largo del tiempo, otros que exactamente lo opuesto, etc. Quizás esta información no nos ayude a mejorar el modelo pero si nos sirve para entender el comportamiento real de los datos. Muchas veces queremos predecir cosas pero también es importante entender que podemos cambiar en la forma de que hacemos negocios, marketing, logística, etc. y ahí es que es importante entender como están relacionadas nuestras variables unas con otras.</p><p>Podemos hacer lo mismo en un gráfico de dependencia parcial (PDP Interaction Plot). Lo que deseamos ver es como saleElapsed y YearMade juntas impactan al precio.</p><pre>## Line added to draw pdp_interact properly<br>!sed -i ‘251s/.* / inter_ax.clabel(c2, /g’ /usr/local/lib/python3.6/dist-packages/pdpbox/pdp_plot_utils.py</pre><pre>feats = [‘saleElapsed’, ‘YearMade’]<br>p = pdp.pdp_interact(m, x, x.columns, feats)<br>pdp.pdp_interact_plot(p, feats)</pre><figure><img alt="" src="https://cdn-images-1.medium.com/max/524/1*t23RntVx8wEBFJHGqZRBxA.png" /></figure><p>Podemos ver que los precios más altos son en los mas recientes YearMade y el menor SaleElapsed.</p><p>Realizando el mismo paso para las categorías en <em>Enclosure</em> (dado que <em>Enclosure_EROPS w AC</em> demostró ser una de las características más importantes), el gráfico resultante se ve así:</p><pre>plot_pdp([‘Enclosure_EROPS w AC’, ‘Enclosure_EROPS’, ‘Enclosure_OROPS’], 5, ‘Enclosure’)</pre><figure><img alt="" src="https://cdn-images-1.medium.com/max/891/1*UeX9c_x7jgEZUpN0QzB6OA.png" /></figure><p><em>Enclosure_EROPS w AC</em> parece tener un precio de venta más alto en comparación con las otras dos variables (que tienen valores casi iguales). Entonces, ¿qué en el mundo es EROPS? Es una estructura protectora antivuelco cerrada que puede ser con o sin AC. Y, obviamente, EROPS con un AC tendrá un precio de venta más alto.</p><p>Otro ejemplo:</p><pre>df_raw.YearMade[df_raw.YearMade&lt;1950] = 1950<br>df_keep[‘age’] = df_raw[‘age’] = df_raw.saleYear-df_raw.YearMade</pre><pre>X_train, X_valid = split_vals(df_keep, n_trn)<br>m = RandomForestRegressor(n_estimators=40, min_samples_leaf=3, max_features=0.6, n_jobs=-1)<br>m.fit(X_train, y_train)<br>plot_fi(rf_feat_importance(m, df_keep));</pre><figure><img alt="" src="https://cdn-images-1.medium.com/max/813/1*ZoDVV4oc9IIxZFo4tyqlwQ.png" /></figure><p>Podemos ver que con estas condiciones los años del equipo son la variable con mayor peso. No podemos asumir que esto nos ayudara a obtener un mejor modelo, tan solo es para explorar los datos.</p><h3>Intérprete de árboles</h3><p>Intérprete de árbol en otra técnica interesante que analiza cada fila individual en el conjunto de datos. Hemos visto hasta ahora cómo interpretar un modelo, y cómo cada característica (y los niveles en cada característica categórica) afectan las predicciones del modelo. Ahora usaremos este concepto de intérprete de árbol y visualizaremos las predicciones para una fila en particular.</p><p>Importemos la biblioteca del intérprete de árbol y evaluemos los resultados de la primera fila en el conjunto de validación.</p><pre>from treeinterpreter import treeinterpreter as ti</pre><pre>df_train, df_valid = split_vals(df_raw[df_keep.columns], n_trn)</pre><pre>row = X_valid.values[None,0]; row</pre><p>Obteniendo</p><pre>array([[ 1999, 5, 0, 17, 665, 1284595200, 0, 1, <br>         3232, 4364751, 0, 2300944, 0, 4, 4, 0, <br>            0, 16, 35, 259, 12, 11]])</pre><p>Estos son los valores originales para la primera fila (y cada columna) en el conjunto de validación. Usando el intérprete de árbol, haremos predicciones para el mismo usando un modelo de bosque aleatorio. El intérprete de árboles da tres resultados: predicción, sesgo y contribución.</p><ul><li>Las predicciones son los valores predichos por el modelo de bosque aleatorio</li><li>El sesgo es el valor promedio de la variable objetivo para el conjunto de datos completo</li><li>Las contribuciones son la cantidad en la cual el valor predicho fue cambiado por cada columna</li></ul><figure><img alt="" src="https://cdn-images-1.medium.com/max/1024/0*pHew-j9Si-lOjvx1.png" /></figure><p><strong>El valor de <em>Coupler_System</em> &lt;0.5 aumentó el valor de 10.189 a 10.345 y Enclosure menos de 0.2 redujo el valor de 10.345 a 9.955, y así sucesivamente. </strong>Así que las contribuciones representarán este cambio en los valores predichos.</p><p>Imprimiendo la predicción y el sesgo de la primera fila en nuestro conjunto de validación</p><pre>prediction[0], bias[0]</pre><pre>(9.1909688098736275, 10.10606580677884)</pre><p>El valor de la <em>contribución</em> de cada entidad en el conjunto de datos para esta primera fila:</p><pre>[o for o in zip(df_keep.columns[idxs], df_valid.iloc[0][idxs], contributions[0][idxs])]</pre><pre>[(&#39;ProductSize&#39;, &#39;Mini&#39;, -0.54680742853695008),<br>(&#39;age&#39;, 11, -0.12507089451852943),<br>(&#39;fiProductClassDesc&#39;,<br> &#39;Hydraulic Excavator, Track - 3.0 to 4.0 Metric Tons&#39;,<br> -0.11143111128570773),<br>(&#39;fiModelDesc&#39;, &#39;KX1212&#39;, -0.065155113754146801),<br>(&#39;fiSecondaryDesc&#39;, nan, -0.055237427792181749),<br>(&#39;Enclosure&#39;, &#39;EROPS&#39;, -0.050467175593900217),<br>(&#39;fiModelDescriptor&#39;, nan, -0.042354676935508852),<br>(&#39;saleElapsed&#39;, 7912, -0.019642242073500914),<br>(&#39;saleDay&#39;, 16, -0.012812993479652724),<br>(&#39;Tire_Size&#39;, nan, -0.0029687660942271598),<br>(&#39;SalesID&#39;, 4364751, -0.0010443985823001434),<br>(&#39;saleDayofyear&#39;, 259, -0.00086540581130196688),<br>(&#39;Drive_System&#39;, nan, 0.0015385818526195915),<br>(&#39;Hydraulics&#39;, &#39;Standard&#39;, 0.0022411701338458821),<br>(&#39;state&#39;, &#39;Ohio&#39;, 0.0037587658190299409),<br>(&#39;ProductGroupDesc&#39;, &#39;Track Excavators&#39;, 0.0067688906745931197),<br>(&#39;ProductGroup&#39;, &#39;TEX&#39;, 0.014654732626326661),<br>(&#39;MachineID&#39;, 2300944, 0.015578052196894499),<br>(&#39;Hydraulics_Flow&#39;, nan, 0.028973749866174004),<br>(&#39;ModelID&#39;, 665, 0.038307429579276284),<br>(&#39;Coupler_System&#39;, nan, 0.052509808150765114),<br>(&#39;YearMade&#39;, 1999, 0.071829996446492878)]</pre><p>Por ahora terminamos este análisis, pero recuerden que seguiremos con el resto de lecciones del curso de Machine Learning de FastAI. Espero les haya sido de gran ayuda.</p><img src="https://medium.com/_/stat?event=post.clientViewed&referrerSource=full_rss&postId=200a2d37f910" width="1" height="1" alt=""><hr><p><a href="https://medium.com/saturdays-ai/fastai-machine-learning-lecci%C3%B3n-4-200a2d37f910">FastAI Machine Learning (Lección 4)</a> was originally published in <a href="https://medium.com/saturdays-ai">Saturdays.AI</a> on Medium, where people are continuing the conversation by highlighting and responding to this story.</p>]]></content:encoded>
        </item>
        <item>
            <title><![CDATA[FastAI Machine Learning (Lección 3)]]></title>
            <link>https://medium.com/saturdays-ai/fastai-machine-learning-lecci%C3%B3n-3-aecf329e963d?source=rss-631fff797e3a------2</link>
            <guid isPermaLink="false">https://medium.com/p/aecf329e963d</guid>
            <category><![CDATA[ai-saturdays]]></category>
            <category><![CDATA[random-forest]]></category>
            <category><![CDATA[fastai]]></category>
            <category><![CDATA[predictions]]></category>
            <category><![CDATA[machine-learning]]></category>
            <dc:creator><![CDATA[Christian Tutivén Gálvez]]></dc:creator>
            <pubDate>Thu, 21 Feb 2019 21:23:23 GMT</pubDate>
            <atom:updated>2019-02-22T04:58:33.121Z</atom:updated>
            <content:encoded><![CDATA[<figure><img alt="" src="https://cdn-images-1.medium.com/proxy/1*bTYyiZ3ynOZj9G_SCfubdw.png" /></figure><p>En las lecciones anteriores pudimos construir un modelo que es muy bueno prediciendo precios (usando la técnica Random Forest), pero algo más importante que haber construido este modelo es el saber interpretarlo para así entender que nos dice acerca de nuestros datos, es decir entender mejor los datos usando machine learning. Con esta lección se pretende demostrar que técnicas como Random Forest no son cajas negras y que de hecho la verdad es que Random Forest nos permite entender de manera más profunda nuestros datos y más rápida que los métodos tradicionales.</p><h3>Obteniendo los datos</h3><p>Esta lección la ejecutaremos en Google Colab por lo debemos instalar las distintas librerías que usaremos y descargar los set de datos que usaremos.</p><pre>print (“ Installing FastAI libraries…”)<br>!pip install fastai==0.7.0 &gt; /dev/null<br>print (“\n Installing required libraries…”)<br>!pip install feather &gt; /dev/null<br>!pip install scikit-misc==0.1.0 &gt; /dev/null<br>!pip install pdpbox==0.2.0 &gt; /dev/null<br>!pip install treeinterpreter==0.2.2 &gt; /dev/null<br>print (“\n Downloading train dataset…”)<br>!wget <a href="https://raw.githubusercontent.com/Giffy/Personal_dataset_repository/master/train.tar.gz">https://raw.githubusercontent.com/Giffy/Personal_dataset_repository/master/train.tar.gz</a><br>!tar xvf train.tar.gz &gt; /dev/null<br>print (“\n Downloading dataframe processed …”)<br>!wget <a href="https://raw.githubusercontent.com/Giffy/Personal_dataset_repository/master/df_raw.tar.gz">https://raw.githubusercontent.com/Giffy/Personal_dataset_repository/master/df_raw.tar.gz</a><br>!tar xvf df_raw.tar.gz &gt; /dev/null</pre><p>Importamos las librerías</p><pre>%matplotlib inline</pre><pre>from fastai.imports import *<br>from fastai.structured import *<br>from pandas_summary import DataFrameSummary<br>from sklearn.ensemble import RandomForestRegressor, RandomForestClassifier<br>from IPython.display import display<br>from sklearn import metrics</pre><p>Cargamos automáticamente los módulos antes de ingresar a la ejecución</p><pre>%load_ext autoreload<br>%autoreload 2</pre><p>Cargamos nuestro archivo guardado de la lección anterior y ejecutamos proc_df, para convertir todo en enteros, cambiar los missing values por el valor medio, etc.</p><pre>PATH = “/content/data/bulldozers/” </pre><pre>import feather # Import feather library<br>df_raw=feather.read_dataframe(‘tmp/bulldozers-raw’) <br>df_trn, y_trn, nas = proc_df(df_raw, ‘SalePrice’)</pre><p>Creamos nuestro set de validación</p><pre>def split_vals(a,n): return a[:n], a[n:]<br>n_valid = 12000<br>n_trn = len(df_trn)-n_valid<br>X_train, X_valid = split_vals(df_trn, n_trn)<br>y_train, y_valid = split_vals(y_trn, n_trn)<br>raw_train, raw_valid = split_vals(df_raw, n_trn)</pre><p>Creamos nuestra función para poder trabajar con la métrica RMSLE</p><pre>def rmse(x,y): return math.sqrt(((x-y)**2).mean())</pre><pre>def print_score(m):<br> res = [rmse(m.predict(X_train), y_train), rmse(m.predict(X_valid), y_valid),<br> m.score(X_train, y_train), m.score(X_valid, y_valid)]<br> if hasattr(m, ‘oob_score_’): res.append(m.oob_score_)<br> print(res)</pre><p>Ahora sabemos como predecir un valor de una fila pero a veces lo que deseamos saber es que tan confiable es la predicción de esa fila. Qué tal si en lugar de tomar la media de cada uno de los arboles tomamos la desviación estándar de las predicciones de los arboles?. Si la desviación estándar de la predicción de los arboles es alta significa que cada árbol nos esta dando estimaciones muy distintas de la predicción de esa fila. Es decir, la desviación estándar nos indica que tan confiable es una predicción.</p><p>Seleccionamos 50000 ejemplos para entrenar. Se define este valor porque no queremos un modelo tan exacto en este caso, sino que deseamos entender la naturaleza de las relaciones y esta cantidad es suficiente alta para interpretar el modelo (si ejecuto esta línea varias veces me dan resultados similares).</p><pre>set_rf_samples(50000)</pre><p>Ajusto los datos al modelo de Random Forest</p><pre>m = RandomForestRegressor(n_estimators=40, min_samples_leaf=3, max_features=0.5, n_jobs=-1, oob_score=True)<br>m.fit(X_train, y_train)<br>print_score(m)</pre><figure><img alt="" src="https://cdn-images-1.medium.com/max/817/1*mHQYEDtloF7x9W518M_f_Q.png" /></figure><p>Creamos una lista de todas las predicciones de cada uno de los arboles. Obtendremos predicciones de cada uno de los 40 árboles. Además, np.stack se utilizará para concatenar las predicciones una sobre la otra. Y calculamos la media del primer ejemplo y su desviación estándar. Hacemos predicciones en paralelo.</p><pre>def get_preds(t): return t.predict(X_valid)<br>%time preds = np.stack(parallel_trees(m, get_preds))<br>np.mean(preds[:,0]), np.std(preds[:,0])</pre><figure><img alt="" src="https://cdn-images-1.medium.com/max/808/1*PZgyIFAU5PgeFaamkidrTQ.png" /></figure><p>Podemos ver que diferentes árboles están dando diferentes estimaciones en esta subasta. Para ver cómo varía la confianza en la predicción, podemos agregar esto a nuestro conjunto de datos.</p><p>Creamos una copia de nuestros datos y creamos una columna adicional con la desviación estándar de las predicciones y además creamos una columna con el valor promedio.</p><p>Ahora, tomemos una variable del conjunto de datos y visualicemos su distribución y entendamos lo que realmente representa. Comenzaremos con la variable <em>Enclosure</em> .</p><p>1- Averiguamos el valor del conteo de cada categoría presente en la variable <em>Enclosure:</em></p><pre>x = raw_valid.copy()<br>x[‘pred_std’] = np.std(preds, axis=0)<br>x[‘pred’] = np.mean(preds, axis=0)<br>x.Enclosure.value_counts().plot.barh();</pre><figure><img alt="" src="https://cdn-images-1.medium.com/max/505/1*YvAiDjyEpAo-NRUGKodf6A.png" /></figure><p>Viendo el gráfico podemos decidir descartar las tres primeras categorías.</p><p>2- Para cada categoría, a continuación se muestran los valores medios de <em>saleprice</em> , predicción y desviación estándar.</p><pre>flds = [‘Enclosure’, ‘SalePrice’, ‘pred’, ‘pred_std’]<br>enc_summ = x[flds].groupby(‘Enclosure’, as_index=False).mean()<br>enc_summ</pre><figure><img alt="" src="https://cdn-images-1.medium.com/max/733/1*d1ppUNxRLzbhWHimOOB8tQ.png" /></figure><p>El precio de venta real y los valores de predicción son casi similares en tres categorías: ‘EROPS’, ‘EROPS w AC’, ‘OROPS’ (el resto tiene valores nulos). Dado que estas columnas de valor nulo no agregan ninguna información adicional, las eliminaremos y visualizaremos los gráficos para el precio de <em>venta</em> y la predicción:</p><pre>enc_summ = enc_summ[~pd.isnull(enc_summ.SalePrice)]<br>enc_summ.plot(‘Enclosure’, ‘SalePrice’, ‘barh’, xlim=(0,11));</pre><figure><img alt="" src="https://cdn-images-1.medium.com/max/480/1*gQLwadB7kFCE5dXh8uRN1g.png" /></figure><pre>enc_summ.plot(‘Enclosure’, ‘pred’, ‘barh’, xerr=’pred_std’, alpha=0.6, xlim=(0,11));</pre><figure><img alt="" src="https://cdn-images-1.medium.com/max/496/1*GjLVJkl5tb0w1EKgt2LfQA.png" /></figure><p>Tenga en cuenta que las barras negras pequeñas representan la desviación estándar. De la misma manera, veamos otra variable: <em>ProductSize</em> .</p><pre>raw_valid.ProductSize.value_counts().plot.barh();</pre><figure><img alt="" src="https://cdn-images-1.medium.com/max/480/1*CrEy7A3rv98y9LyNKVs1hA.png" /></figure><pre>#categoría significa el precio de venta, la predicción y la desviación estándar<br>flds = [&#39;ProductSize&#39;, &#39;SalePrice&#39;, &#39;pred&#39;, &#39;pred_std&#39;]<br>summ = x[flds].groupby(flds[0]).mean()<br>summ</pre><figure><img alt="" src="https://cdn-images-1.medium.com/max/381/1*mo6evFXDwN3HoqMNR4h5Kw.png" /></figure><p>Tomaremos una proporción de los valores de desviación estándar y la suma de las predicciones para comparar qué categoría tiene una desviación más alta.</p><pre>(summ.pred_std/summ.pred).sort_values(ascending=False)</pre><figure><img alt="" src="https://cdn-images-1.medium.com/max/273/1*FxWoyLi7tb22Dlyz4m-A3A.png" /></figure><p>La desviación estándar es mayor para las categorías ‘Grande’ y ‘Compacto’. ¿Por qué haces eso? Tómese un momento para reflexionar sobre la respuesta antes de seguir leyendo.</p><p>Eche un vistazo a la gráfica de barras de valores para cada categoría en <em>ProductSize. </em>¿Encontraste la razón? Tenemos un número menor de filas para estas dos categorías. Por lo tanto, el modelo está dando una precisión de predicción relativamente pobre para estas variables.</p><p>Con esta información, podemos decir que confiamos más en las predicciones para el tamaño de producto mini, mediano y mediano / grande y menos confiados en los pequeños, compactos y grandes.</p><h3>Importancia de la característica</h3><p>La importancia de las características es uno de los aspectos clave de un modelo de aprendizaje automático. Entender qué variable es la que más contribuye a un modelo es fundamental para interpretar los resultados. Esto es lo que luchan los científicos de datos cuando construyen modelos que necesitan ser explicados a partes interesadas no técnicas.</p><p>Nuestro conjunto de datos tiene múltiples características y, a menudo, es difícil entender qué característica es dominante. Aquí es donde la función de importancia de la característica del bosque aleatorio es tan útil. Veamos las 10 características más importantes de nuestro modelo actual (incluida la visualización por su importancia):</p><pre>fi = rf_feat_importance(m, df_trn); fi[:10]</pre><figure><img alt="" src="https://cdn-images-1.medium.com/max/265/1*GSRD_AvOWd1ufWVKouf3sg.png" /></figure><pre>fi.plot(‘cols’, ‘imp’, figsize=(10,6), legend=False);</pre><figure><img alt="" src="https://cdn-images-1.medium.com/max/620/1*tPNmW11TJb63-hPpCin34Q.png" /></figure><p>Esto nos dice que hay ciertas columnas que son realmente importantes y la mayoría en realidad no nos interesan.</p><p>Esa es una trama bastante intuitiva. Aquí hay una visualización de diagrama de barras de las 30 características principales:</p><figure><img alt="" src="https://cdn-images-1.medium.com/max/822/1*bTYyiZ3ynOZj9G_SCfubdw.png" /></figure><p>Claramente, <em>YearMade</em> es la característica más importante, seguida por <em>Coupler_System. </em>La mayoría de las características parece tener poca importancia en el modelo final. Verifiquemos esta declaración eliminando estas características y verificando si esto afecta el rendimiento del modelo.</p><p>Por lo tanto, construiremos un modelo de bosque aleatorio usando solo las características que tienen una importancia de característica mayor que 0.005:</p><pre>to_keep = fi[fi.imp&gt;0.005].cols; len(to_keep)</pre><pre>24</pre><p>Tenemos 24 características con una importancia mayor a 0.005. Creamos una copia del dataframe original solo con estas características.</p><pre>df_keep = df_trn[to_keep].copy()<br>X_train, X_valid = split_vals(df_keep, n_trn)</pre><p>Ajustamos los nuevos datos a nuestro modelo</p><pre>m = RandomForestRegressor(n_estimators=40, min_samples_leaf=3, max_features=0.5,<br> n_jobs=-1, oob_score=True)<br>m.fit(X_train, y_train)<br>print_score(m)</pre><figure><img alt="" src="https://cdn-images-1.medium.com/max/804/1*CPxmeGFgtlnVJdZkGSOclA.png" /></figure><p>Cuando piensas en ello, eliminar columnas redundantes no debería disminuir la puntuación del modelo, ¿verdad? Y en este caso, el rendimiento del modelo ha mejorado ligeramente. Algunas de las características que descartamos anteriormente podrían haber sido altamente colineales con otras, por lo que eliminarlas no afectó negativamente al modelo. Revisemos la importancia de la característica nuevamente para verificar nuestra hipótesis:</p><pre>fi = rf_feat_importance(m, df_keep)<br>plot_fi(fi);</pre><figure><img alt="" src="https://cdn-images-1.medium.com/max/824/1*LR3mDYV7bHrHHbYjfk48Dw.png" /></figure><p>La diferencia entre la importancia de la característica de las <em>variables YearMade</em> y C <em>oupler_System</em> es más significativa. De la lista de características eliminadas, algunas características fueron altamente colineales a <em>YearMade, lo que</em> resultó en la distribución de la importancia de las características entre ellas.</p><p>Al eliminar estas características, podemos ver que la diferencia entre la importancia de <em>YearMade</em> y <em>CouplerSystem</em> ha aumentado con respecto al gráfico anterior. Aquí hay una explicación detallada de cómo se calcula la importancia de la característica:</p><ul><li><strong>Calcula R² considerando todas las columnas:</strong> suponga que en este caso resulta ser 0,89</li><li>Ahora <strong>mezcla aleatoriamente los valores para cualquier columna</strong> , digamos <em>YearMade. Esta</em> columna no tiene relación con la variable objetivo.</li><li><strong>Calcula de nuevo R²: R²</strong> ha bajado a 0,8. Esto muestra que la variable <em>YearMade</em> es una característica importante</li><li><strong>Toma otra variable</strong> , por ejemplo <em>Enclosure,</em> y <strong>baraja aleatoriamente</strong></li><li><strong>Calcula R²:</strong> Ahora digamos que <strong>R²</strong> llegará a ser 0.84. Esto indica que la variable es importante pero comparativamente menos que la variable <em>YearMade</em></li></ul><p>¡Y eso concluye la implementación de la lección # 3! Los animo a probar estos códigos y experimentar con ellos en su propia máquina para comprender realmente cómo funciona cada aspecto de un modelo de bosque aleatorio.</p><img src="https://medium.com/_/stat?event=post.clientViewed&referrerSource=full_rss&postId=aecf329e963d" width="1" height="1" alt=""><hr><p><a href="https://medium.com/saturdays-ai/fastai-machine-learning-lecci%C3%B3n-3-aecf329e963d">FastAI Machine Learning (Lección 3)</a> was originally published in <a href="https://medium.com/saturdays-ai">Saturdays.AI</a> on Medium, where people are continuing the conversation by highlighting and responding to this story.</p>]]></content:encoded>
        </item>
        <item>
            <title><![CDATA[FastAI Machine Learning (Leccion 2)]]></title>
            <link>https://medium.com/saturdays-ai/fastai-machine-learning-leccion-2-e359d76b7286?source=rss-631fff797e3a------2</link>
            <guid isPermaLink="false">https://medium.com/p/e359d76b7286</guid>
            <category><![CDATA[predictions]]></category>
            <category><![CDATA[ai-saturdays]]></category>
            <category><![CDATA[fastai]]></category>
            <category><![CDATA[machine-learning]]></category>
            <category><![CDATA[random-forest]]></category>
            <dc:creator><![CDATA[Christian Tutivén Gálvez]]></dc:creator>
            <pubDate>Fri, 08 Feb 2019 02:22:24 GMT</pubDate>
            <atom:updated>2019-02-22T05:34:00.491Z</atom:updated>
            <content:encoded><![CDATA[<h3>FastAI Machine Learning (Lección 2)</h3><p>Ahora que sabemos cómo crear un modelo de bosque aleatorio (Random Forest) en un Jupyter Notebook usando FastAI, es igualmente importante comprender cómo funciona realmente este código. Hemos visto que Random Forest para ciertos DataSets funciona muy bien, sin muchos problemas pero aún no sabemos como realmente funciona, que podemos hacer si no funciona adecuadamente, sus ventajas y desventajas y qué parámetros podemos modificar, por lo que en esta lección veremos todo esto y luego como interpretar los resultados del modelo de Random Forest, no solo para obtener predicciones sino que para profundizar el conocimiento de nuestros datos.</p><h3>Analizando R²</h3><p>Primero analicemos el score que usamos para medir si nuestro modelo es bueno o no.</p><figure><img alt="" src="https://cdn-images-1.medium.com/max/300/0*enoQPc7BYvtO9pHG.png" /></figure><p>SSregression, es la suma de los cuadrados de (valor real — predicción).<br>SStotal, es la suma de los cuadrados de (valor real — promedio)<br>El valor de R² puede ser cualquier valor menor que 1. Si el cuadrado R² es negativo, significa que su modelo es peor que la predicción de la media.</p><p>Observamos en la primera lección que el modelo funciona extremadamente bien con los datos de entrenamiento (los puntos con los que se entreno) pero cae cuando se prueba en el conjunto de validación (el conjunto con el cual no fue entrenado el modelo). Ahora, entendamos cómo creamos el conjunto de validación y por qué es tan crucial.</p><h3>Creando un conjunto de validación (Repaso de lección 1)</h3><p>Crear un buen conjunto de validación es una de las tareas más importantes en el aprendizaje automático. El puntaje de validación es representativo de cómo se desempeña nuestro modelo en datos del mundo real o en los datos de prueba.</p><p>Hay que tener en cuenta que si hay un componente de tiempo involucrado, entonces las filas más recientes deben incluirse en el conjunto de validación. Esto es debido a que en el concurso se desea predecir precios en el futuro, no precios en determinados meses. Por lo tanto, nuestro conjunto de validación debe tener las mismas propiedades que el conjunto de prueba. El conjunto de prueba del concurso tiene 12,000 filas por lo que nuestro conjunto de validación será del mismo tamaño (las últimas 12,000 filas de los datos de entrenamiento).</p><pre>def split_vals(a,n): return a[:n].copy(), a[n:].copy()<br><br>n_valid = 12000  <br>n_trn = len(df)-n_valid<br>raw_train, raw_valid = split_vals(df_raw, n_trn)<br>X_train, X_valid = split_vals(df, n_trn)<br>y_train, y_valid = split_vals(y, n_trn)</pre><p>Los puntos de datos de 0 a (longitud — 12000) se almacenan como el conjunto de entrenamiento (x_train, y_train).</p><p>Para ver las dimensiones de nuestro conjuntos ejecutamos</p><pre>X_train.shape, y_train.shape, X_valid.shape</pre><p>Se muestra</p><pre>((389125, 66), (389125,), (12000,66))</pre><p>Creamos nuestra función para poder trabajar con la métrica RMSLE</p><pre>def rmse(x,y): return math.sqrt(((x-y)**2).mean())</pre><pre>def print_score(m):<br>    res = [rmse(m.predict(X_train), y_train),        <br>                rmse(m.predict(X_valid), y_valid),<br>                m.score(X_train, y_train), m.score(X_valid,   <br>                y_valid)]<br>    if hasattr(m, &#39;oob_score_&#39;): res.append(m.oob_score_)<br>    print(res)</pre><p>El modelo se construye utilizando el conjunto de entrenamiento y su rendimiento se mide tanto en el conjunto de entrenamiento como en los conjuntos de validación. Volvemos a ejecutar el entrenamiento con Random Forest.</p><pre>m = RandomForestRegressor(n_jobs=-1)<br>%time m.fit(X_train, y_train)<br>print_score(m)</pre><p>Obteniendo la siguiente salida:</p><pre>CPU times: user 1min 3s, sys: 356 ms, total: 1min 3s <br>Wall time: 8.46 s <br>[0.09044244804386327, 0.2508166961122146, 0.98290459302099709, 0.86765316048270615]</pre><p>Del código anterior, obtenemos los resultados:</p><ul><li>RMSE en el conjunto de entrenamiento</li><li>RMSE en el conjunto de validación</li><li>R² en el conjunto de entrenamiento</li><li>R² en el conjunto de validación</li></ul><p>Está claro que el modelo esta demasiado ajustado al conjunto de datos de entrenamiento. Aun así obtenemos un 0.2508 en el RMSE en el conjunto de validación, lo que nos pone en el top-25% del concurso de Kaggle.</p><p>Además se puede observar que nos tomo 8.46 segundos para entrenar el modelo. Como estamos usando varias CPUs en esta computadora, se muestra que el tiempo total es de 1min 3s. ¿Podemos reducir el tiempo de entrenamiento? ¡Si podemos!.</p><h3>Lección 2</h3><p>Desde aquí en adelante, todo es nuevo en la lección 2.</p><h3>Acelerando las cosas</h3><p>Una manera de acelerar el proceso es pasarle a la función “proc_df” el parámetro “subset”. Esto creara una muestra aleatoria de los datos.</p><pre>df_trn, y_trn, nas = proc_df(df_raw, &#39;SalePrice&#39;, subset=30000, na_dict=nas)<br>X_train, _ = split_vals(df_trn, 20000)<br>y_train, _ = split_vals(y_trn, 20000)</pre><p>Se ha creado un subconjunto de 30,000 muestras, de las cuales tomamos 20,000 para entrenar el modelo de Random Forest.</p><p>Entrenamos nuestro nuevo modelo</p><pre>m = RandomForestRegressor(n_jobs=-1)<br>%time m.fit(X_train, y_train)<br>print_score(m)</pre><p>obteniendo</p><pre>CPU times: user 3.89 s, sys: 16 ms, total: 3.88 s <br>Wall time: 621 ms <br>[0.11794430422595521, 0.28881319691543633, 0.970812018265333525, 0.8510357543674435]</pre><p>Se puede observar que el tiempo se redujo a 621 ms. Muy bien verdad!!</p><h3>Construyendo un árbol sencillo</h3><p>Bosque aleatorio es un grupo de árboles que se llaman estimadores. El número de árboles en un modelo de bosque aleatorio está definido por el parámetro n_estimator. Primero veremos un solo árbol (n_estimator = 1) con una profundidad máxima de 3 (max_depth=3).</p><pre>m = RandomForestRegressor(<strong>n_estimators=1</strong>, max_depth=3, bootstrap=<strong>False</strong>, n_jobs=-1)<br>m.fit(X_train, y_train)<br>print_score(m)</pre><p>Pasando estos parámetros creamos un pequeño árbol, obteniendo los siguientes resultados:</p><pre>[0.5214347423221267, 0.5813295482070254, 0.41033418186185866, 0.3964784664823804]</pre><p>Podemos observar que nuestros R² empeoro, por lo que este no es un buen modelo, pero es un modelo que podemos dibujar.</p><p>Dibujando el árbol:</p><pre>draw_tree(m.estimators_[0], df_trn, precision=3)</pre><figure><img alt="" src="https://cdn-images-1.medium.com/max/1024/1*DvvFFhCqHrM8FonORFbDqQ.png" /></figure><p>Un árbol consiste de una secuencia de decisiones binarias, como se puede ver en la figura. Cada bloque consta del número de ejemplos usados, el promedio del logaritmo de los precios y si construimos un modelo donde usamos el valor promedio todo el tiempo, cuanto sería el Error cuadrático medio (MSE). Es decir, muestra el modelo más básico que puede predecir el promedio.</p><p>Mirando la primera casilla, la primera división es en el valor de Coupler_Systems menor o igual a 0.5 o mayor a 0.5. Del mismo modo, la siguiente división es en el valor de Yearmade.</p><figure><img alt="" src="https://cdn-images-1.medium.com/max/468/1*cypftO3QqrF_OKbOgud5tA.png" /></figure><p>Para el primer cuadro (Coupler_Systems), se crea un modelo utilizando solo el valor promedio (10.189). Esto significa que todas las filas tienen un valor predicho de 10.189 y el MSE para estas predicciones es 0.459. En cambio, si hacemos una división y separamos las filas basadas en coupler_system &lt;0.5, el MSE se reduce a 0.414 para muestras que satisfacen la condición (verdadero) y 0.109 para las muestras restantes.</p><p>Entonces, ¿cómo decidimos en qué variable dividir? La idea es dividir los datos en dos grupos que sean tan diferentes entre sí como sea posible. Esto se puede hacer al verificar cada posible punto de división para cada variable, y luego averiguar cuál da el MSE más bajo. Para hacer esto, podemos tomar un promedio ponderado de los dos valores de MSE después de la separación. La división se detiene cuando alcanza el valor max_depth preespecificado o cuando cada nodo hoja solo tiene un valor.</p><p>Vamos a ver qué pasa si creamos un árbol más grande.</p><pre>m = RandomForestRegressor(n_estimators=1, bootstrap=False, n_jobs=-1)<br>m.fit(X_train, y_train)<br>print_score(m)</pre><p>Obteniendo</p><pre>[6.526751786450488e-17, 0.5277160421601815, 1.0, 0.5026655229333343]</pre><p>¡El resultado del set de entrenamiento se ve genial! Pero el conjunto de validación es peor que nuestro modelo original. Esta es la razón por la que necesitamos utilizar la acumulación de varios árboles para obtener resultados más generalizables.</p><p>Tenemos un modelo básico, un solo árbol, pero este no es un muy buen modelo. Necesitamos algo un poco más complejo que se construya sobre esta estructura. Para crear un bosque, utilizaremos una técnica estadística llamada bagging.</p><h3>Bagging</h3><p>En la técnica de bagging, creamos múltiples modelos, cada uno con predicciones que no están correlacionadas con la otra. Luego promediamos las predicciones de estos modelos. Random Forest es una técnica de bagging.</p><p>Si todos los árboles creados son similares entre sí y dan predicciones similares, entonces promediar estas predicciones no mejorará el rendimiento del modelo. En su lugar, podemos crear múltiples árboles en un subconjunto diferente de datos, de modo que incluso si estos árboles se adaptan, lo harán en un conjunto diferente de puntos. Estas muestras se toman con reemplazo.</p><p>En palabras simples, creamos múltiples modelos (con datos aleatorios) de bajo rendimiento y los promediamos para crear un buen modelo. Los modelos individuales deben ser lo más predictivos posible, pero juntos no deben estar correlacionados.</p><p>Ahora aumentaremos el número de estimadores en nuestro bosque aleatorio y veremos los resultados.</p><pre>m = RandomForestRegressor(n_jobs=-1)<br>m.fit(X_train, y_train)<br>print_score(m)</pre><p>Si no le damos un valor al parámetro n_estimator, se toma como 10 por defecto. Luego de ejecutar Random Forest, cada árbol se almacenó en el atributo “m.estimators_”.</p><pre>preds = np.stack([t.predict(X_valid) for t in m.estimators_])</pre><p>Lo que se creo fue una lista de todas las predicciones de cada uno de los arboles. Obtendremos predicciones de cada uno de los 10 árboles. Además, np.stack se utilizará para concatenar las predicciones una sobre la otra.</p><p>Para ver las dimensiones de nuestras predicciones</p><pre>preds.shape</pre><p>Podemos ver que las dimensiones de las predicciones son (10, 12000). Esto significa que tenemos 10 predicciones para cada fila en el conjunto de validación.</p><p>Ahora, para comparar los resultados de nuestro modelo con el conjunto de validación, aquí está la fila de predicciones, la media de las predicciones y el valor real del conjunto de validación.</p><pre>preds[:,0], np.mean(preds[:,0]), y_valid[0]</pre><p>El valor real es 9.10 pero ninguna de nuestras predicciones se acerca a este valor. Al tomar el promedio de todas nuestras predicciones obtenemos 9.07, que es una mejor predicción que cualquiera de los árboles individuales.</p><pre>(array([ 9.21034,  8.9872 , 8.9872 , 8.9872 ,  8.9872 , 9.21034, 8.92266, 9.21034,  9.21034, 8.9872 ]),<br>9.0700003890739005,<br>9.1049798563183568)</pre><p>Siempre es una buena idea visualizar tu modelo lo más posible. Aquí hay una gráfica que muestra la variación en el valor de R² a medida que aumenta el número de árboles.</p><pre>plt.plot([metrics.r2_score(y_valid, np.mean(preds[:i+1], axis=0)) for i in range(10)]);</pre><figure><img alt="" src="https://cdn-images-1.medium.com/max/381/0*0nY2c4q1Biicamvf.png" /></figure><p>Como se esperaba, R² mejora a medida que aumenta el número de árboles. Puede experimentar con el valor n_estimator y ver cómo cambia el valor R² con cada iteración. Notarás que después de un cierto número de árboles, el valor de R² es plano.</p><h3>Puntuación de fuera de bolsa (OOB)</h3><p>Crear un conjunto de validación separado para un conjunto de datos pequeño puede ser potencialmente un problema, ya que resultará en un conjunto de entrenamiento aún más pequeño. En tales casos, podemos usar los puntos de datos (o muestras) en los que no se entrenó el árbol.</p><p>Para esto, establecemos el parámetro oob_score = True.</p><pre>m = RandomForestRegressor(n_estimators=40, n_jobs=-1, oob_score=True)<br>m.fit(X_train, y_train)<br>print_score(m)<br><br>[0.10198464613020647, 0.2714485881623037, 0.9786192457999483, 0.86840992079038759, 0.84831537630038534]</pre><p>Se puede observar que tenemos un nuevo valor al final, el cual es el oob_score. El oob_score es 0.84, que es similar al del conjunto de validación.</p><p>Veamos algunas otras técnicas interesantes mediante las cuales podemos mejorar nuestro modelo.</p><h3>Submuestreo</h3><p>Anteriormente, creamos un subconjunto de 30,000 filas y el conjunto de entrenamiento fue elegido al azar de este subconjunto. Como alternativa, por qué no usar el conjunto completo de entrenamiento y crear un subconjunto diferente cada vez para que el modelo sea entrenado en una gran parte de los datos. Suena lógico, verdad?</p><pre>df_trn, y_trn, nas = proc_df(df_raw, &#39;SalePrice&#39;)<br>X_train, X_valid = split_vals(df_trn, n_trn)<br>y_train, y_valid = split_vals(y_trn, n_trn)</pre><pre>set_rf_samples(20000)</pre><p>Usamos set_rf_sample para especificar el tamaño de la muestra. Vamos a comprobar si el rendimiento del modelo ha mejorado o no.</p><pre>m = RandomForestRegressor(n_estimators=40, n_jobs=-1, oob_score=True)<br>m.fit(X_train, y_train)<br>print_score(m)<br><br>[0.2317315086850927, 0.26334275954117264, 0.89225792718146846, 0.87615150359885019, 0.88097587673696554]</pre><p>Obtenemos una puntuación de validación de 0,876. Hasta ahora, hemos trabajado en un subconjunto de una muestra. Podemos ajustar este modelo en todo el conjunto de datos (¡pero llevará mucho tiempo ejecutarlo dependiendo de qué tan buenos sean sus recursos computacionales!).</p><h3>Otros Hyper-parámetros para experimentar y sintonizar</h3><h3>Hoja de muestra mínima</h3><p>Esto puede ser tratado como el criterio de parada para el árbol. El árbol deja de crecer (o dividirse) cuando el número de muestras en el nodo de hoja es menor que el especificado.</p><pre>m = RandomForestRegressor(n_estimators=40, min_samples_leaf=3,n_jobs=-1, oob_score=True)<br>m.fit(X_train, y_train)<br>print_score(m)<br><br>[0.11595869956476182, 0.23427349924625201, 0.97209195463880227, 0.90198460308551043, 0.90843297242839738]</pre><p>Aquí hemos especificado min_sample_leaf como 3. Esto significa que el número mínimo de muestras en el nodo debe ser 3 para cada división. Vemos que el R² ha mejorado para el conjunto de validación y se ha reducido en el conjunto de prueba, concluyendo que el modelo no se adapta demasiado a los datos de entrenamiento.</p><h3>Característica máxima</h3><p>Otro parámetro importante en el bosque aleatorio es max_features. Hemos discutido previamente que los árboles individuales deben estar lo menos correlacionados posible. Para el mismo, el bosque aleatorio utiliza un subconjunto de filas para entrenar cada árbol. Además, también podemos usar un subconjunto de columnas (características) en lugar de usar todas las características. Esto se logra ajustando el parámetro max_features.</p><pre>m = RandomForestRegressor(n_estimators=40, min_samples_leaf=3, max_features=0.5, n_jobs=-1, oob_score=True) <br>m.fit(X_train, y_train)<br>print_score(m)<br><br>[0.11926975747908228, 0.22869111042050522, 0.97026995966445684, 0.9066000722129437, 0.91144914977164715]</pre><p>La configuración de max_features ha mejorado ligeramente la puntuación de validación. Aquí, max_features se establece en 0.5, lo que significa que se utiliza el 50% de las variables para cada división.</p><p>Pues ahora tenemos otra mejora a 0.906 en nuestro conjunto de validación y un R² de 0.22.</p><p>Los documentos de sklearn muestran un ejemplo de diferentes métodos de max_features con un número creciente de árboles; como puedes ver, usar un subconjunto de funciones en cada división requiere usar más árboles, pero resulta en mejores modelos:</p><figure><img alt="" src="https://cdn-images-1.medium.com/max/640/0*C6a8Ezl0SZXqIKMY.png" /></figure><h3>Conclusiones</h3><p>No podemos comparar nuestros resultados directamente con la competencia Kaggle, ya que usó un conjunto de validación diferente (y no podemos enviarnos a esta competencia ya que esta cerrada), pero al menos podemos ver que estamos obteniendo resultados similares a los ganadores basados en el conjunto de datos que tenemos.</p><img src="https://medium.com/_/stat?event=post.clientViewed&referrerSource=full_rss&postId=e359d76b7286" width="1" height="1" alt=""><hr><p><a href="https://medium.com/saturdays-ai/fastai-machine-learning-leccion-2-e359d76b7286">FastAI Machine Learning (Leccion 2)</a> was originally published in <a href="https://medium.com/saturdays-ai">Saturdays.AI</a> on Medium, where people are continuing the conversation by highlighting and responding to this story.</p>]]></content:encoded>
        </item>
        <item>
            <title><![CDATA[FastAI Machine Learning (Lección 1)]]></title>
            <link>https://medium.com/saturdays-ai/fastai-machine-learning-lecci%C3%B3n-1-73aa6ee8d2a5?source=rss-631fff797e3a------2</link>
            <guid isPermaLink="false">https://medium.com/p/73aa6ee8d2a5</guid>
            <category><![CDATA[machine-learning]]></category>
            <category><![CDATA[ai-saturdays]]></category>
            <category><![CDATA[fastai]]></category>
            <category><![CDATA[random-forest]]></category>
            <category><![CDATA[artificial-intelligence]]></category>
            <dc:creator><![CDATA[Christian Tutivén Gálvez]]></dc:creator>
            <pubDate>Sun, 03 Feb 2019 17:31:07 GMT</pubDate>
            <atom:updated>2019-06-18T03:09:16.143Z</atom:updated>
            <content:encoded><![CDATA[<figure><img alt="" src="https://cdn-images-1.medium.com/max/365/1*vmltuWapn0QY5eMEOzhT_g.png" /><figcaption><a href="https://www.fast.ai/">https://www.fast.ai/</a></figcaption></figure><figure><img alt="" src="https://cdn-images-1.medium.com/max/213/1*9mLtMTdsJ_ezvyg49Akhdw.png" /></figure><p>Uno de los cursos que se dan en AI Saturdays Guayaquil, como también en los capítulos de otras ciudades alrededor del mundo, es el mooc de <a href="http://course18.fast.ai/ml">“Introduction to Machine Learning for Coders”</a> de <a href="https://www.fast.ai/">FastAI</a>. Este curso es gratuito y cualquiera lo puede seguir. Para ayudar a cualquier persona a seguir este curso a solucionar cualquiera de los problemas que se pueden encontrar y aclarar dudas, decidí escribir mis notas acerca de los vídeos de la primera Lección “Introducción a Random Forest”.</p><p>La Lección 1 te mostrará cómo crear un “bosque aleatorio” (Random Forest), quizás el modelo de aprendizaje automático más aplicable, para crear una solución para la competencia Kaggle de “Bull Book for Bulldozers”, que te llevará al 25% superior en la tabla de líderes. Aprenderás cómo usar un cuaderno Jupyter para crear y analizar modelos, cómo descargar datos y otras habilidades básicas que necesita para comenzar a practicar el aprendizaje automático en la práctica.</p><h3>Paso 1: Configurar el entorno con las bibliotecas requeridas</h3><p>Hay varias opciones de plataformas para poder seguir este curso, entre las que están:</p><ul><li>Google Colab (gratuita).</li><li>Jupyter Notebook en tu propio ordenador (gratuito).</li><li>Crestle (GPU $0.59/hora).</li><li>Paperspace (GPU $0.51/hora).</li><li>Etc.</li></ul><p>Les mostrare como ejecutar la lección 1 en las dos plataformas gratuitas (Google Colab y Jupyter Notebook).</p><h3>Configuración de Jupyer Notebook (en tu propio ordenador)</h3><p>Si bien Windows no es oficialmente compatible con Fastai o con las lecciones en esta etapa, parece que está funcionando ahora. Aquí les dejo instrucciones para comenzar a correr las leciones en una GPU y en una CPU en Windows:</p><p><strong>GPU</strong></p><p>1- Debes tener una GPU de Nvidia y haber instalado los controladores de Nvidia más recientes.</p><p>2- Instala Anaconda (Python 3.7) utilizando el <a href="https://www.anaconda.com/download/?lang=en-us#download">instalador gráfico de 64 bits</a>. Elije la opción de instalación para “solo este usuario”. Te puede ser útil la guía <a href="https://medium.com/@christian_tutiven/empezando-a-usar-jupyter-notebook-para-python-parte-1-instalaci%C3%B3n-94e97b4c5f37">“Empezando a usar Jupyter Notebook para Python (Parte 1 — Instalación)”</a>.</p><p>3- Instala <a href="https://gitforwindows.org/">Git para windows</a>.</p><p>4- Ejecuta el “Anaconda Prompt” desde el menú de inicio y escribe:</p><pre>git clone https://github.com/fastai/fastai.git</pre><p>Este comando te clonara el repositorio del curso de Fastai en tu ordenador.</p><p>5- Cuando el repositorio este clonado, estas listo para configurar Fastai:</p><pre>cd fastai<br>conda env update</pre><p>5- Activa tu nuevo entorno (debes ejecutar este comando siempre que vayas a trabajar con Fastai).</p><pre>activate fastai</pre><p>6- Instala widgets ipython en jupyter:</p><pre>jupyter nbextension enable --py widgetsnbextension --sys-prefix</pre><p>7- Reemplaza el enlace simbólico de Linux por uno de Windows (ten en cuenta que esto requiere un símbolo de sistema ejecutado como administrador si no tienes una versión completamente actualizada de Windows 10):</p><pre>cd courses\ml1<br>del fastai<br>mklink /d fastai ..\..\old\fastai<br>cd ..\..</pre><p>8- ¡Eso es! Debería estar listo para escribir</p><pre>jupyter notebook</pre><p>Se abrirá el entorno de Jupyter. Busca la carpeta de los cursos y abre el cuaderno “lesson1-rf”.</p><p><strong>CPU</strong></p><p>1- Repite los pasos de configuración para GPU hasta el paso 4 (Ejecuta el “Anaconda Prompt” desde el menú de inicio y escribe:).</p><p>2- Cuando el repositorio este clonado, estas listo para configurar Fastai:</p><pre>conda env update -f environment-cpu.yml</pre><p>Importante: usamos el archivo environment-cpu.yml, porque vamos a usar una CPU, no una GPU.</p><p>3- Activa tu nuevo entorno (debes ejecutar este comando siempre que vayas a trabajar con Fastai).</p><pre>conda activate fastai-cpu</pre><p>4- Instala widgets ipython en jupyter:</p><pre>jupyter nbextension enable --py widgetsnbextension --sys-prefix</pre><p>5- Reemplaza el enlace simbólico de Linux por uno de Windows (ten en cuenta que esto requiere un símbolo de sistema ejecutado como administrador si no tienes una versión completamente actualizada de Windows 10):</p><pre>cd courses\ml1<br>del fastai<br>mklink /d fastai ..\..\old\fastai<br>cd ..\..</pre><p>6- ¡Eso es! Debería estar listo para escribir</p><pre>jupyter notebook</pre><p>Se abrirá el entorno de Jupyter. Busca la carpeta de los cursos y abre el cuaderno “lesson1-rf”.</p><h3>Configuración usando Google Colab</h3><p><strong>Paso 1: Acceder a Colab</strong></p><p>1- En primer lugar, debe iniciar sesión en tu cuenta de Google si no has iniciado sesión de forma predeterminada. Debe realizar este paso antes de abrir Colab, de lo contrario, los cuadernos no funcionarán. Puedes iniciar sesión <a href="https://accounts.google.com/signin/v2/identifier?hl=en-gb&amp;flowName=GlifWebSignIn&amp;flowEntry=ServiceLogin">aquí</a>.</p><p>2- A continuación, dirígete a la página de <a href="https://colab.research.google.com/notebooks/welcome.ipynb#recent=true">bienvenida de Colab</a> y has clic en “Github”. En el ‘Ingresa una URL de GitHub o busca por organización o usuario’ ingresa ‘fastai/’. En repositorio selecciona fastai/fastai y veras los cuadernos de los cursos de ml1, dl1 y dl2. Selecciona la lección “lesson1-rf.ipynb”.</p><figure><img alt="" src="https://cdn-images-1.medium.com/max/849/1*c20slctV5V7smXYynMNkQw.png" /></figure><p>Deberías ver tu cuaderno ahora. Antes de ejecutar cualquier cosa, debe decirle a Colab que estas interesado en utilizar una GPU. Puedes hacerlo haciendo clic en la pestaña “Tiempo de ejecución” y seleccionando “Cambiar tipo de tiempo de ejecución”. Se abrirá una ventana emergente con un menú desplegable. Seleccione ‘GPU’ en el menú y has clic en ‘Guardar’.</p><figure><img alt="" src="https://cdn-images-1.medium.com/max/595/1*GYFBnWKYA9Txjy-kuOXluQ.png" /></figure><figure><img alt="" src="https://cdn-images-1.medium.com/max/880/1*afQ2vSBZmNzxsUbIS7ZvMQ.png" /></figure><p><strong>Paso 2: Guarda tu trabajo</strong></p><p>Si abriste una libreta de Github, deberás guardar tu trabajo en Google Drive. Puedes hacer esto haciendo clic en “Archivo” y luego en “Guardar”. Deberías ver una ventana emergente con el siguiente mensaje:</p><figure><img alt="" src="https://cdn-images-1.medium.com/max/690/1*qTxmmFZrybPYfmK4LosUSA.png" /></figure><p><strong>Paso 3: Configurar tu instancia</strong></p><p>Antes de comenzar a utilizar tu cuaderno, debes instalar los paquetes necesarios. Puedes hacer esto creando una celda de código y ejecutando:</p><pre>!pip install fastai==0.7.0</pre><h3>Lección 1 (Blue Book for Bulldozers)</h3><figure><img alt="" src="https://cdn-images-1.medium.com/max/964/1*7Hpit3wHgAXCFsILU1NBGQ.png" /><figcaption><a href="https://www.kaggle.com/c/bluebook-for-bulldozers">https://www.kaggle.com/c/bluebook-for-bulldozers</a></figcaption></figure><p>Este es el primer <a href="https://www.kaggle.com/c/bluebook-for-bulldozers">proyecto de Kaggle</a> que Jeremy analizó en la serie “<a href="http://course18.fast.ai/ml">Introduction to Machine Learning for Coders</a>”. El objetivo de este proyecto es predecir el “precio de venta”, que es la variable dependiente del valor continuo. Este proyecto tiene datos que se han recopilado durante muchos años. El algoritmo que se utiliza en la tarea es “Random Forest”. Jeremy enseguida salta al punto en que “<a href="https://en.wikipedia.org/wiki/Random_forest">Random Forest</a>” puede usarse para desarrollar un modelo predictivo exitoso.</p><p><strong>Random Forest</strong> también conocidos en castellano como ‘“Bosques Aleatorios”’ es una combinación de árboles predictores tal que cada árbol depende de los valores de un vector aleatorio probado independientemente y con la misma distribución para cada uno de estos. Es una modificación sustancial de bagging que construye una larga colección de árboles no correlacionados y luego los promedia.</p><p>Aquí hay una breve introducción de las palabras de Jeremy Howard:</p><ul><li>El bosque aleatorio es un tipo de técnica de aprendizaje automático universal.</li><li>Se puede utilizar para problemas de regresión (el objetivo es una variable continua) o la clasificación (el objetivo es una variable categórica).</li><li>También funciona con columnas de cualquier tipo, como valores de píxeles, códigos postales, ingresos, etc.</li><li>En general, el bosque aleatorio no se sobre ajusta (overfit)(es muy fácil evitar que se sobre ajuste demasiado).</li><li>No necesita un conjunto de validación separado en general. Puede indicarle qué tan bien se generaliza incluso si solo tiene un conjunto de datos.</li><li>Tiene pocas (si alguna) suposiciones estadísticas (no asume que los datos se distribuyen normalmente, los datos son lineales o que necesita especificar las interacciones).</li><li>Requiere muy pocas características tácticas de ingeniería, por lo que es un excelente lugar para comenzar.</li></ul><p>Suena como una técnica Fascinante, ¿verdad?</p><p><strong>Pues empecemos.</strong></p><h3>Importar librerías</h3><p>Vas encontrar la siguiente celda:</p><pre>%load_ext autoreload<br>%autoreload 2</pre><pre>%matplotlib inline</pre><p>El comando “autoreload” te ayuda a cargar automáticamente los módulos antes de ingresar a la ejecución, “autoreload 2” recarga todos los módulos (excepto los excluidos por %aimport) cada vez antes de ejecutar el código Python escrito (más información <a href="https://ipython.org/ipython-doc/3/config/extensions/autoreload.html">aquí</a>) y “matplotlib” es un paquete de trazado que ayuda a visualizar tus datos de la manera más fácil posible.</p><p>Ahora debes importar las librerías:</p><pre>from fastai.imports import *<br>from fastai.structured import *</pre><pre>from pandas_summary import DataFrameSummary<br>from sklearn.ensemble import RandomForestRegressor, RandomForestClassifier<br>from IPython.display import display</pre><pre>from sklearn import metrics</pre><p>Si estas usando un cuaderno de Jupyter en tu ordenador puede que necesites instalar ciertas librerías que necesita Fastai y no las tienes en tu entorno. Posibles problemas y soluciones, <a href="https://medium.com/@GuruAtWork/fast-ai-lesson-1-7fc38e978d37">aquí</a>.</p><h3>Obteniendo los datos</h3><p>Kaggle: Problemas del mundo real publicados por una empresa / instituto.<br>Estos están realmente cerca de los problemas del mundo real, te permite medirte contra otros competidores y es perfecto para comprobar tus habilidades.</p><p>Jeremy: “He aprendido más de las competiciones Kaggle que cualquier otra cosa que haya hecho en toda mi vida”</p><figure><img alt="" src="https://cdn-images-1.medium.com/max/964/1*Dz_nbVrDtVkzOe7eZ3QZRQ.png" /></figure><p>Para descargar los datos de entrenamiento desde <a href="https://kaggle.com/">Kaggle</a> debes tener creada una cuenta. Ingresar a la página de la competición de <a href="https://www.kaggle.com/c/bluebook-for-bulldozers">Blue Book for Bulldozers</a> y aceptar los términos y condiciones.</p><p>Para descargar los datos de entrenamiento tienes tres maneras de hacerlo y va depender de si estas usando Colab o tu ordenador (Jupyter Notebook).</p><p>1- Google Colab: Debes instalar el paquete kaggle-cli (parece que dejo de funcionar), creando una línea de código y escribiendo:</p><pre>!pip install kaggle-cli<br># always use ! to run bash commands from Notebook</pre><p>Y obtienes los datos escribiendo:</p><pre>!kg download -u <a href="/service/mailto:venkateshrajagopalan86@gmail.com">&lt;</a>&lt;Kaggle UserName&gt;&gt; -p &lt;&lt;Kaggle Password&gt;&gt; -c bluebook-for-bulldozers -f Train.zip</pre><p>Una vez que hayamos descargado los datos, vamos a extraer y organizar los datos para el trabajo.</p><pre>!mkdir -p data/bulldozers/<br>!mv Train.zip data/bulldozers/<br>!unzip data/bulldozers/Train.zip -d data/bulldozers/</pre><p>2-Google Colab: Usamos !wget para descargar el archivo desde un repositorio y !tar para descomprimirlo (usa este método hasta que vuelva a funcionar la librería kaggle-cli).</p><pre>!wget <a href="https://raw.githubusercontent.com/Giffy/Personal_dataset_repository/master/train.tar.gz">https://raw.githubusercontent.com/Giffy/Personal_dataset_repository/master/train.tar.gz</a><br>!tar xvf train.tar.gz</pre><p>3- Jupyter Notebook: y en la pestaña de datos (en el concurso de Kaggle)descargar el archivo Train.zip. Descomprime este archivo en una carpeta llamada “data/bulldozers/” (debes crearla).</p><h3>Veamos los datos</h3><p>a) Primero ponemos los datos en la memoria:</p><p>Se establece la ruta en nuestro código:</p><pre>PATH = “data/bulldozers/”</pre><p>Leemos el archivo de datos utilizando Pandas para permitirnos analizar y procesar previamente los datos. Pandas es la mejor librería para trabajar con datos tabulares y te permite leer archivos CSV.</p><pre>df_raw = pd.read_csv(f&#39;{PATH}Train.csv&#39;, low_memory=False, <br>                     parse_dates=[&quot;saledate&quot;])</pre><p>low_memory=False (permite cargar más detalles a la memoria).</p><p>b) Revisamos los datos y obtenemos información de alto nivel para tener una idea de lo que estamos tratando.</p><pre>df_raw.info()</pre><p>La salida es la siguiente:</p><pre>&lt;class &#39;pandas.core.frame.DataFrame&#39;&gt;<br>RangeIndex: 401125 entries, 0 to 401124<br>Data columns (total 53 columns):<br>SalesID                     401125 non-null int64<br>SalePrice                   401125 non-null int64<br>MachineID                   401125 non-null int64<br>ModelID                     401125 non-null int64<br>datasource                  401125 non-null int64<br>auctioneerID                380989 non-null float64<br>YearMade                    401125 non-null int64<br>MachineHoursCurrentMeter    142765 non-null float64<br>UsageBand                   69639 non-null object<br>saledate                    401125 non-null datetime64[ns]<br>fiModelDesc                 401125 non-null object<br>fiBaseModel                 401125 non-null object<br>fiSecondaryDesc             263934 non-null object<br>fiModelSeries               56908 non-null object<br>fiModelDescriptor           71919 non-null object<br>ProductSize                 190350 non-null object<br>fiProductClassDesc          401125 non-null object<br>state                       401125 non-null object<br>ProductGroup                401125 non-null object<br>ProductGroupDesc            401125 non-null object<br>Drive_System                104361 non-null object<br>Enclosure                   400800 non-null object<br>Forks                       192077 non-null object<br>Pad_Type                    79134 non-null object<br>Ride_Control                148606 non-null object<br>Stick                       79134 non-null object<br>Transmission                183230 non-null object<br>Turbocharged                79134 non-null object<br>Blade_Extension             25219 non-null object<br>Blade_Width                 25219 non-null object<br>Enclosure_Type              25219 non-null object<br>Engine_Horsepower           25219 non-null object<br>Hydraulics                  320570 non-null object<br>Pushblock                   25219 non-null object<br>Ripper                      104137 non-null object<br>Scarifier                   25230 non-null object<br>Tip_Control                 25219 non-null object<br>Tire_Size                   94718 non-null object<br>Coupler                     213952 non-null object<br>Coupler_System              43458 non-null object<br>Grouser_Tracks              43362 non-null object<br>Hydraulics_Flow             43362 non-null object<br>Track_Type                  99153 non-null object<br>Undercarriage_Pad_Width     99872 non-null object<br>Stick_Length                99218 non-null object<br>Thumb                       99288 non-null object<br>Pattern_Changer             99218 non-null object<br>Grouser_Type                99153 non-null object<br>Backhoe_Mounting            78672 non-null object<br>Blade_Type                  79833 non-null object<br>Travel_Controls             79834 non-null object<br>Differential_Type           69411 non-null object<br>Steering_Controls           69369 non-null object<br>dtypes: datetime64[ns](1), float64(2), int64(6), object(44)<br>memory usage: 162.2+ MB</pre><p>Podemos ver que tenemos 401125 elementos de datos con información distribuida en 53 columnas y tipos de datos divididos: datetime64[ns](1), float64(2), int64(6), object(44).</p><h3>Pre-procesamiento de los datos</h3><p>a) <strong>Convertir la variable dependiente usando la métrica RMSLE</strong></p><p>Es importante tener en cuenta qué métrica se está utilizando para un proyecto. En general, la selección de la métrica (s) es una parte importante de la configuración del proyecto. Sin embargo, en este caso, Kaggle nos dice qué métrica usar: RMSLE (Error logarítmico medio cuadrático) entre los precios de subasta reales y previstos. Por lo tanto, tomamos el registro de los precios para que RMSE nos brinde lo que necesitamos.</p><pre>df_raw.SalePrice = np.log(df_raw.SalePrice)</pre><p><strong>b) Extraer información adicional del campo de fecha</strong></p><p>Antes de realizar cualquier manipulación / procesamiento de datos, debemos comprender la declaración del problema. De la descripción dada en Kaggle, entendemos que nuestro modelo debe aprender sobre los precios del historial de ventas y predecir el precio de venta futuro. Por lo tanto, cualquier fecha / período de ventas de la información podría ser uno de los factores importantes y deberíamos intentar extraer la mayor cantidad de información posible a partir de la fecha.</p><p>Fastai tiene una función incorporada que extrae información de la fecha como día de la semana, día del año, fin de mes, inicio de mes, fin de año, fin de año, etc. La función add_datepart de Fastai toma un campo de fecha como entrada y extrae esta información variada de eso.</p><pre>add_datepart(df_raw, &#39;saledate&#39;)</pre><p>Podemos observar las nuevas columnas creadas escribiendo</p><pre>df_raw.columns</pre><p><strong>c) Trabajar con Strings</strong></p><p>Random Forest espera datos numéricos. Así que necesitamos convertir datos de objetos, etc. a números. Pandas y Scikit disponen de varios métodos para preprocesar los datos, pero aquí usaremos Fastai, que proporciona algunos métodos de envoltura sorprendentes para realizar el preprocesamiento que cubre la mayoría de las acciones de preprocesamiento de forma predeterminada.</p><pre>train_cats(df_raw)</pre><p>Esta función toma campos no numéricos (/ no datetime) y los transforma al tipo de datos Categoría. Como se ve a continuación, todos los campos de objetos se transformaron en datos categóricos.</p><p><strong>d) Ordenar las categorías</strong></p><p>Al ejecutar</p><pre>df_raw.UsageBand.cat.categories</pre><p>veremos la salida</p><pre>Index([&#39;High&#39;, &#39;Low&#39;, &#39;Medium&#39;], dtype=&#39;object&#39;)</pre><p>Y podemos observar que la organización de las categorías no es la adecuada por lo que podemos re ordenarla escribiendo</p><pre>df_raw.UsageBand.cat.set_categories([&#39;High&#39;, &#39;Medium&#39;, &#39;Low&#39;], ordered=True, inplace=True)</pre><p>inplace=True, modifica el DataFrame actual en lugar de crear uno nuevo.</p><p><strong>e) Reparando los datos faltantes “missing values (valores continuos) y convirtiendo todos los datos de tipo de categoría a tipo de datos numéricos</strong></p><p>Usamos la función proc_df de Fastai para dividir los datos en datos de la variable dependiente (y) y los datos transformados a totalmente numéricos (x).</p><p>Primero corrige los datos faltantes al actualizarlos por la mediana de los campos numéricos y luego reemplazar los datos categóricos por sus códigos numéricos. Ten en cuenta que no tomamos ninguna medida para que falten datos categóricos, ya que cuando convertimos los datos de Categoría a su código, los datos que faltan se reemplazan por -1.</p><p>Aquí proporcionamos 2 entradas para proc_df. Primero, el marco de datos de entrada cuyos datos se cambiarán a numérico y se cargarán en df_processed y segundo el nombre del campo de destino que se dividirá del marco de datos y se guardará por separado (df_target).</p><pre>df, y, nas = proc_df(df_raw, &#39;SalePrice&#39;)</pre><h3>Construimos el modelo</h3><p>Con los datos modificados para poder usados por los algoritmos de ML, ajustamos los datos para Random Forest en este caso como un Regresor, ya que necesitamos predecir el precio (variable continua).</p><pre>m = RandomForestRegressor(n_jobs=-1)<br>m.fit(df, y)<br>m.score(df,y)</pre><p>Aquí ejecutamos el entrenamiento en procesos separaos para todos los núcleos de CPU disponibles definiendo n_jobs = -1.</p><p>Podemos observar que obtenemos un resultado del</p><pre>0.9830970922936578</pre><p><strong>WOOOOOOOOWW un 98% sin hacer mucho(1 es el mejor y 0 el peor)!!</strong></p><h3>Revisar Modelo</h3><p>Pues sí, pero ahora debemos de ver si nuestro modelo no esta sobre entrenado (overfitting), es decir que no generaliza a nuevos datos.</p><figure><img alt="" src="https://cdn-images-1.medium.com/max/781/1*3O5pvKZ95nzJsSYamsfDLA.png" /></figure><p>Para esto podemos crear un set de validación ordenado por fecha. Las 12000 fechas más recientes serán el conjunto de validación.</p><pre>def split_vals(a,n): return a[:n].copy(), a[n:].copy()</pre><pre>n_valid = 12000  # same as Kaggle&#39;s test set size<br>n_trn = len(df)-n_valid<br>raw_train, raw_valid = split_vals(df_raw, n_trn)<br>X_train, X_valid = split_vals(df, n_trn)<br>y_train, y_valid = split_vals(y, n_trn)</pre><pre>X_train.shape, y_train.shape, X_valid.shape</pre><h3>RESULTADO FINAL</h3><p>Probemos de nuevo nuestro modelo, esta vez con conjuntos de validación y entrenamiento separados.</p><p>Creamos nuestra función para poder trabajar con la métrica RMSLE</p><pre>def rmse(x,y): return math.sqrt(((x-y)**2).mean())</pre><pre>def print_score(m):<br>    res = [rmse(m.predict(X_train), y_train),        <br>                rmse(m.predict(X_valid), y_valid),<br>                m.score(X_train, y_train), m.score(X_valid,   <br>                y_valid)]<br>    if hasattr(m, &#39;oob_score_&#39;): res.append(m.oob_score_)<br>    print(res)</pre><p>Volvemos a ejecutar el entrenamiento con Random Forest</p><pre>m = RandomForestRegressor(n_jobs=-1)<br>%time m.fit(X_train, y_train)<br>print_score(m)</pre><p>Obteniendo</p><pre>[0.09044244804386327, 0.2508166961122146, 0.98290459302099709, 0.88765316048270615]</pre><p>El segundo valor mostrado es el RMSLE entre los datos de validación.</p><p>Con 0.25 nos coloca en el Top 25% del concurso de Kaggle.</p><figure><img alt="" src="https://cdn-images-1.medium.com/max/1024/1*8JoVZ2PB1HLfULqzF868Sg.png" /><figcaption>Tabla de lideres del concurso en Kaggle</figcaption></figure><p>Gracias a Fastai, ahora podemos configurar un entorno desde cero, procesar datos y entrenar un modelo de aprendizaje automático con resultados muy buenos con pocas líneas de código.</p><h3>Antes de la siguiente clase</h3><p>Por favor, repite este proceso para resolver la mayor cantidad posible de competiciones Kaggle. Lo que probablemente sucederá es que te sorprenderá muchísimo. Nos vemos en la siguiente lección…</p><img src="https://medium.com/_/stat?event=post.clientViewed&referrerSource=full_rss&postId=73aa6ee8d2a5" width="1" height="1" alt=""><hr><p><a href="https://medium.com/saturdays-ai/fastai-machine-learning-lecci%C3%B3n-1-73aa6ee8d2a5">FastAI Machine Learning (Lección 1)</a> was originally published in <a href="https://medium.com/saturdays-ai">Saturdays.AI</a> on Medium, where people are continuing the conversation by highlighting and responding to this story.</p>]]></content:encoded>
        </item>
        <item>
            <title><![CDATA[Empezando a usar Jupyter Notebook para Python (Parte 1- Instalación)]]></title>
            <link>https://medium.com/saturdays-ai/empezando-a-usar-jupyter-notebook-para-python-parte-1-instalaci%C3%B3n-94e97b4c5f37?source=rss-631fff797e3a------2</link>
            <guid isPermaLink="false">https://medium.com/p/94e97b4c5f37</guid>
            <category><![CDATA[jupyter-notebook]]></category>
            <category><![CDATA[anaconda]]></category>
            <category><![CDATA[ai-saturdays]]></category>
            <category><![CDATA[python]]></category>
            <category><![CDATA[machine-learning]]></category>
            <dc:creator><![CDATA[Christian Tutivén Gálvez]]></dc:creator>
            <pubDate>Wed, 23 Jan 2019 01:36:47 GMT</pubDate>
            <atom:updated>2019-01-23T01:36:47.668Z</atom:updated>
            <content:encoded><![CDATA[<p>El 2 de febrero de 2019, inicia una nueva edición de los cursos de Inteligencia Artificial (IA) de <a href="http://saturdays.ai/">AI Saturdays</a> (una Comunidad sin fines de lucro con el objetivo de capacitar a diversas personas para que aprendan Inteligencia Artificial de forma colaborativa y basada en proyectos, más allá del camino de la educación convencional) y nos expandimos a Guayaquil, Ecuador =). Es importante que todos nuestros fellows (estudiantes) y además de cualquier persona interesada en entrar en este mundo de la IA tengan material en español. Por eso decidí escribir este tutorial de como usar Jupyter Notebooks de una manera fácil para el desarrollo de tus proyectos.</p><figure><img alt="" src="https://cdn-images-1.medium.com/max/800/1*GzjddlYRSY-wvb-CJEJdxw.jpeg" /><figcaption>AI Saturdays Guayaquil</figcaption></figure><p>En el siguiente tutorial, se te guiará a través del proceso de instalación de Jupyter Notebook.</p><h3>Qué es Jupyter Notebook?</h3><figure><img alt="" src="https://cdn-images-1.medium.com/max/731/1*RQBY0LUv-ItFuhJujhjkUg.png" /><figcaption>El proyecto Jupyter existe para desarrollar software de código abierto, estándares abiertos y servicios para computación interactiva en docenas de lenguajes de programación.</figcaption></figure><p>Jupyter Notebook (anteriormente, IPython Notebook)es una aplicación web de código abierto que te permite crear y compartir documentos que contienen código en vivo, ecuaciones, visualizaciones y texto narrativo. Además, es una aplicación muy utilizada en el campo de la Ciencia de Datos (Data Science) para crear y compartir documentos que incluyen: limpieza y transformación de datos, simulación numérica, modelado estadístico, visualización de datos, aprendizaje automático y mucho más. Te permite editar y ejecutar documentos de notebook a través de cualquier navegador web de tu elección; y puede ejecutarse en un escritorio local que no requiere acceso a Internet o puede instalarse en un servidor remoto y acceder a través de Internet. También podemos ejecutar Jupyter Notebook sin ninguna instalación.</p><p>Jupyter Notebook es ideal para los siguientes casos de uso:</p><p>Aprende y prueba Python<br>Procesamiento / transformación de datos<br>Simulación numérica<br>Modelado estadístico<br>Aprendizaje automático</p><p><strong>Comencemos e instalemos Jupyter Notebook en tu computadora …</strong></p><h3>Configurando el cuaderno de Jupyter</h3><p>El primer paso es visitar el sitio web del proyecto en <a href="http://www.jupyter.org/">http://www.jupyter.org</a></p><figure><img alt="" src="https://cdn-images-1.medium.com/max/1024/1*2oEpPgPbAotYhf-asxmaxQ.jpeg" /><figcaption><a href="https://jupyter.org/">https://jupyter.org/</a></figcaption></figure><p>Aquí encontrarás dos opciones:</p><ul><li>Pruébalo en tu navegador (Try in your browser).</li><li>Instalar el cuaderno (Install the Notebook).</li></ul><p>Con la primera opción “Pruébalo en tu navegador”, puedes acceder a una versión alojada de Jupyter Notebook. Esto te dará acceso directo sin necesidad de instalarlo en tu computadora.</p><figure><img alt="" src="https://cdn-images-1.medium.com/max/897/1*H4c4fsTFoJo4Tb6ikm8Sxw.jpeg" /></figure><p>Tendrás varias opciones para trabajar:</p><ul><li>Jupyter con Python.</li><li>Jupyter con R.</li><li>Jupyter con C++.</li><li>Jupyter con Julia.</li><li>JupyterLab.</li><li>Etc.</li></ul><p>La segunda opción “Instalar el cuaderno” te llevará a otra página que te brinda instrucciones detalladas para la instalación. Hay dos maneras diferentes:</p><ul><li>Instalar Jupyter Notebook utilizando el pip del administrador de paquetes de Python (como usuario de Python existente o con experiencia, es posible que desees instalar Jupyter utilizando el administrador de paquetes de Python, pip, en lugar de Anaconda).</li><li>Si tienes Python 3 instalado (es recomendable):</li></ul><pre>python3 -m pip install --upgrade pip<br>python3 -m pip install jupyter</pre><p>Si tienes Python 2 instalado:</p><pre>python -m pip install --upgrade pip<br>python -m pip install jupyter</pre><p>Enhorabuena, has instalado Jupyter Notebook! Para ejecutar el notebook, ejecuta el siguiente comando en la Terminal (Mac / Linux) o en el Símbolo del sistema (Windows):</p><pre>jupyter notebook</pre><ul><li>La segunda opción, instalando Jupyter Notebook, instalando la distribución de Anaconda (recomendamos encarecidamente instalar Python y Jupyter utilizando Anaconda Distribution, que incluye Python, Jupyter Notebook y otros paquetes de uso común para la computación científica y la ciencia de los datos).</li></ul><figure><img alt="" src="https://cdn-images-1.medium.com/max/318/1*x03zXmCxq0W7Wv5RGdCzSg.png" /></figure><p>Especialmente si eres nuevo en Python y te gustaría configurar tu entorno de desarrollo desde cero utilizando la distribución de Anaconda (plataforma que permite hacer más rápido y fácil la ciencia de datos y aprendizaje automático con Python y R en Linux, Windows y Mac OS X. Es el estándar de la industria para desarrollar, probar y capacitar en una sola máquina.) es una excelente opción. Si sigues el enlace (<a href="https://www.anaconda.com/download/">https://www.anaconda.com/download/</a>) llegaras a la página de descarga de Anaconda. Puedes elegir entre los instaladores para Windows, macOS y Linux:</p><figure><img alt="" src="https://cdn-images-1.medium.com/max/960/1*6_wCnGzExhU8HrmuAL4vwQ.jpeg" /><figcaption><a href="https://www.anaconda.com/download/">https://www.anaconda.com/download/</a></figcaption></figure><p>Para este proceso, necesitamos conocer 2 datos importantes sobre el sistema operativo en nuestra computadora:&gt; Tipo (Windows / Macintosh / Linux) y&gt; Arquitectura (32/64 bit). Otra cosa importante a tener en cuenta es la variedad de paquetes disponibles:&gt; Anaconda 2 (descarga esto solo si deseas usar Python ≤ 2.7) y&gt; Anaconda para Python 3 (Recomendado | Permite la creación de entornos virtuales para usar Python 2, si es necesario) .</p><p>Descarga y ejecuta el instalador de tu elección. Una vez instalada la distribución de Anaconda, ahora podemos iniciar Jupyter Notebook.</p><h3>Usando Jupyter Notebook</h3><p>Hemos terminado con nuestra exitosa instalación de Anaconda, que ahora nos dará acceso fácil a algunas herramientas sorprendentes relacionadas con el desarrollo de Python. Una forma fácil de acceder a todas estas herramientas instaladas es mediante el uso de Anaconda Navigator, que es una interfaz gráfica de usuario (GUI) de escritorio incluida en la distribución de Anaconda® que nos permite iniciar aplicaciones y administrar fácilmente los paquetes, entornos y canales de Conda sin usar la interfaz de línea de comandos.</p><p>Para estar en un lado más seguro, reiniciaremos nuestra computadora en esta etapa. Ahora, usa la barra de búsqueda en tu computadora para iniciar esta consola y ten en cuenta que la primera vez que inicie, demora un poco, así que ten paciencia con ello. Un simple clic en el icono de Jupyter Notebook abrirá nuestra computadora portátil en el navegador web predeterminado (como Google Chrome, Mozilla Firefox, Safari y Windows IE / Edge) de nuestra computadora. Pero, si intentamos iniciar Jupyter Notebook para un entorno dentro de Anaconda Navigator, entonces usa el menú desplegable junto a Aplicaciones y selecciona ese entorno (no hablaremos de entornos en este tutorial) en particular antes de iniciar Notebook.</p><figure><img alt="" src="https://cdn-images-1.medium.com/max/622/1*84jnb98dXUPMF81nAk6tmg.png" /><figcaption>Interfaz gráfica de usuario de Anaconda Navigator para el botón ‘Iniciar’ (resaltado) de Jupyter Notebook</figcaption></figure><p>También lanzar el cuaderno Jupyter a través de la línea de comandos, y en realidad eso también implica un solo paso, es decir, escribir y ejecutar</p><pre>jupyter notebook </pre><p>en su símbolo del sistema o terminal de Windows. Esto imprimirá cierta información sobre el servidor de notebook en nuestro terminal, incluida la URL de la aplicación web (de forma predeterminada, <a href="http://localhost:8888):">http://localhost:8888</a>). Antes de ejecutar este comando de una línea, se recomienda que verifiquemos que nuestro directorio de Anaconda PATH se haya agregado correctamente a las Variables de entorno, y si no es así, debemos ubicar nuestra ruta de directorio / archivo de Anaconda y <a href="http://www.itprotoday.com/management-mobility/how-can-i-add-new-folder-my-system-path">agregarlo a las Variables de entorno</a>, o si no podrías obtener un error: “jupyter no se reconoce como un comando interno o externo”. Si el lanzamiento es exitoso, el indicador de comando se verá como la siguiente Imagen:</p><figure><img alt="" src="https://cdn-images-1.medium.com/max/800/1*08o_vcIHqkYradyYPaG5Aw.png" /><figcaption>Mensaje de Anaconda para lanzar el cuaderno de Jupyter</figcaption></figure><p>y se abrirá el cuaderno Jupyter.</p><figure><img alt="" src="https://cdn-images-1.medium.com/max/800/1*bmvXD7Y9F7oIzbpbqEvR-Q.png" /><figcaption>Jupyter Notebook Dashboard en el navegador web predeterminado</figcaption></figure><p>Si queremos saber dónde está instalado Jupyter en nuestra computadora, podemos ejecutar</p><pre>where jupyter</pre><p>en nuestro símbolo del sistema. Si deseamos saber qué versión de Python tenemos instalada, ejecute</p><pre>python -V</pre><p>Además, observaremos un botón llamado “New” que, al hacer clic, nos permite seleccionar un kernel de Python (las opciones dependen de lo que esté instalado en nuestro servidor local) del menú desplegable. Algunos núcleos en la captura de pantalla de abajo pueden no existir como una opción en nuestro caso.</p><figure><img alt="" src="https://cdn-images-1.medium.com/max/352/1*e8RdL_4smpH0aL4RnkCPSg.png" /><figcaption>Nuevo Kernel</figcaption></figure><p>Si le das click a Python 3 (recomendable) se abrirá nuestro nuevo cuaderno de Jupyter y se verá así:</p><figure><img alt="" src="https://cdn-images-1.medium.com/max/1024/1*LeBxUNEJwgB_pXWT2p8C0Q.png" /><figcaption>Jupyter Notebook</figcaption></figure><p>Pues ya tenemos creado nuestro Jupyter Notebook y podemos empezar a usarlo para nuestro curso de IA.</p><p>Espero te sea útil y puedas compartirlo con más personas.</p><img src="https://medium.com/_/stat?event=post.clientViewed&referrerSource=full_rss&postId=94e97b4c5f37" width="1" height="1" alt=""><hr><p><a href="https://medium.com/saturdays-ai/empezando-a-usar-jupyter-notebook-para-python-parte-1-instalaci%C3%B3n-94e97b4c5f37">Empezando a usar Jupyter Notebook para Python (Parte 1- Instalación)</a> was originally published in <a href="https://medium.com/saturdays-ai">Saturdays.AI</a> on Medium, where people are continuing the conversation by highlighting and responding to this story.</p>]]></content:encoded>
        </item>
        <item>
            <title><![CDATA[Deep Learning: Cómo clasificar imágenes usando PyTorch y Google Colab.]]></title>
            <link>https://medium.com/@christian_tutiven/deep-learning-c%C3%B3mo-clasificar-im%C3%A1genes-usando-pytorch-y-google-colab-f3c9129148f6?source=rss-631fff797e3a------2</link>
            <guid isPermaLink="false">https://medium.com/p/f3c9129148f6</guid>
            <category><![CDATA[tutorial]]></category>
            <category><![CDATA[google-colab]]></category>
            <category><![CDATA[neural-networks]]></category>
            <category><![CDATA[ai-saturdays]]></category>
            <category><![CDATA[pytorch]]></category>
            <dc:creator><![CDATA[Christian Tutivén Gálvez]]></dc:creator>
            <pubDate>Wed, 16 Jan 2019 20:13:08 GMT</pubDate>
            <atom:updated>2019-11-19T08:48:54.116Z</atom:updated>
            <content:encoded><![CDATA[<h3>Deep Learning: cómo clasificar imágenes usando PyTorch y Google Colab</h3><p>El pasado mes de octubre recibí un correo electrónico de <strong>Udacity</strong> indicándome que estaba aprobado como uno de los concursantes para el <strong>“Desafio de Becas de PyTorch de Facebook”</strong>. Feliz de saber que algunos amigos de nuestra comunidad <a href="https://www.saturdays.ai/"><strong>AI Saturdays</strong></a><strong> </strong>(una organización sin fines de lucro con el objetivo de capacitar a diversos individuos para que aprendan Inteligencia Artificial de forma colaborativa y basada en proyectos, más allá del camino de la educación convencional) también estaban concursando, nos pusimos manos a la obra con el proyecto final!!</p><figure><a href="http://chatbotchocolate.com/"><img alt="" src="https://cdn-images-1.medium.com/max/680/1*lB6KDoqrcbd_XSVLxIxIpw.png" /></a></figure><figure><img alt="" src="https://cdn-images-1.medium.com/max/1024/1*oDg9dvUITz5WU3sbgJebVg.png" /><figcaption>Desafio de Becas de PyTorch de Facebbok</figcaption></figure><h3>Objetivos del proyecto final</h3><p>En este proyecto, entrenaremos un clasificador de imágenes para identificar <a href="http://www.robots.ox.ac.uk/~vgg/data/flowers/102/index.html">102 tipos distintos de flores</a>. Puedes imaginarte usar algo como esto en una aplicación de teléfono que te diga el nombre de la flor que está mirando tu cámara. En la práctica, entrenaría a este clasificador y luego lo exportaría para usarlo en su aplicación. En este artículo les mostraré como utilicé PyTorch para completar el proyecto. A continuación puedes ver algunos ejemplos de las imágenes a clasificar.</p><figure><img alt="" src="https://cdn-images-1.medium.com/max/1024/1*M6c7DLkKiWvolgzJdhigAw.png" /></figure><p>Espero que este articulo pueda ayudarte a introducirte en el mundo de la Inteligencia Artificial usando PyTorch.</p><h3>Qué es PyTorch?</h3><p>Es un paquete basado en Python que sirve como reemplazo de Numpy para usar el poder de las GPUs y proporciona flexibilidad y velocidad como plataforma de desarrollo de aprendizaje profundo. Si estas interesado en aprender más de PyTorch, visita el siguiente <a href="https://www.udacity.com/course/deep-learning-pytorch--ud188">link</a>.</p><figure><img alt="" src="https://cdn-images-1.medium.com/max/1024/1*jcZLpgh3gppeFFgcpFSP0w.jpeg" /></figure><h3>Qué es Google Colab?</h3><p>Esta herramienta de Google ofrece el uso de un portátil tipo jupyter. El portátil tiene la misma extensión (.ipynb) y funciona de la misma manera que en Jupyter. Se puede usar como un cuaderno de jupyter un entorno local instalado en la máquina personal de uno (esto no se tratará en este artículo), no obstante, para poder aprovechar toda su potencia, se podría utilizar mejor una GPU disponible (en Google Colab) e instalar los paquetes necesarios (es muy fácil, no te asustes).</p><p>Para los que se mueren de hambre por más detalles, Google tiene un cuaderno “Te damos la bienvenida a Colaboratory” que tiene como objetivo dar una introducción detallada a la herramienta.</p><p><a href="https://colab.research.google.com/notebooks/welcome.ipynb"><em>https://colab.research.google.com/notebooks/welcome.ipynb</em></a></p><figure><img alt="" src="https://cdn-images-1.medium.com/max/179/1*dt3F0tyLlJRy1tz9hhDdGw.jpeg" /><figcaption>Google Colaboratory</figcaption></figure><h3>Desarrollando una aplicación de Inteligencia Artificial (IA)</h3><p>En el futuro, los algoritmos de IA se incorporarán a las aplicaciones más y más cotidianas. Por ejemplo, es posible que desees incluir un clasificador de imágenes en una aplicación de teléfono inteligente. Para hacer esto, usaría un modelo de aprendizaje profundo entrenado en cientos de miles de imágenes como parte de la arquitectura general de la aplicación. Una gran parte del desarrollo de software en el futuro será usar este tipo de modelos como partes comunes de las aplicaciones.</p><h3>El Proyecto</h3><p>El proyecto se divide en varios pasos:</p><p>* Cargar y preprocesar el conjunto de datos de la imagen.<br>* Entrena el clasificador de imágenes en tu conjunto de datos.<br>* Usa el clasificador entrenado para predecir el contenido de la imagen.</p><p>Esta guía te ayudara a desarrollar cada paso y como implementarlo en Python usando el entorno de Google Colab.</p><h3>Empezando con Google Colab</h3><p>Google Colab ofrece una GPU Tesla K80. Se puede seguir trabajando con la instancia de GPU continuamente hasta 12 horas! Una vez que hayan consumido las 12 horas, simplemente cierre el cuaderno y vuelva a abrirlo. Ahora, ¡A trabajar!</p><p>Para configurar Google Colab con PyTorch puedes leer mi articulo en este <a href="https://medium.com/@christian_tutiven/empezando-a-usar-google-colab-con-pytorch-4efb53933624">link</a>.</p><h3>Data set</h3><p>Como estamos usando Google Colab debes descargarte el data set de las imágenes de las flores que entrega Udacity (estas imagenes estarán instaladas por 12 horas).</p><p>Para esto debes ingresar el siguiente código.</p><pre>!wget <a href="https://s3.amazonaws.com/content.udacity-data.com/courses/nd188/flower_data.zip">https://s3.amazonaws.com/content.udacity-data.com/courses/nd188/flower_data.zip</a></pre><p>Si no han pasado las 12 horas y en caso de que deseas reiniciar el cuaderno de Colab, ya no debes volver a ejecutar el código anterior.</p><p>El archivo descargado esta en formato zip, por lo que, para descomprimirlo debes hacerlo con el siguiente código, donde indicas cual es el archivo que deseas descomprimir y donde lo deseas descomprimir.</p><pre>from zipfile import ZipFile<br>with ZipFile(&#39;flower_data.zip&#39;, &#39;r&#39;) as zf:<br>    zf.extractall(&#39;flower_data/&#39;)</pre><p>Al revisar el dataset, encontré que solo tiene una capeta de entrenamiento y otra de validación pero buscando y buscando encontré un enlace donde puedes descargarte el set de testeo. Para descargarte este set ingresa</p><pre>!wget -O flower_data_orginal_test.zip &quot;<a href="https://www.dropbox.com/s/da6ye9genbsdzbq/flower_data_original_test.zip?dl=1">https://www.dropbox.com/s/da6ye9genbsdzbq/flower_data_original_test.zip?dl=1</a>&quot;</pre><p>Igual que antes, viene comprimido así que debes descomprimirlo.</p><pre>from zipfile import ZipFile<br>with ZipFile(&#39;flower_data_orginal_test.zip&#39;, &#39;r&#39;) as zf:<br>    zf.extractall(&#39;flower_data/flower_data/test&#39;)</pre><p>Udacity te entrega un enlace al repositorio donde están los archivos del challenge. Para clonarlos, ingresa el siguiente código.</p><pre>!git clone <a href="https://github.com/udacity/pytorch_challenge.git">https://github.com/udacity/pytorch_challenge.git</a></pre><h3>Importar librerías</h3><p>Lo primero es importar los paquetes que necesitarás. Es una buena práctica mantener todas las importaciones al principio de su código. Cuando trabajes en este cuaderno y descubras que necesitas importar un paquete, asegúrate de agregar la importación al principio de tu cuaderno.</p><pre># Imports here<br>import torch<br>import torch.nn as nn<br>import torch.optim as optim<br>from torch.optim import lr_scheduler<br>import numpy as np<br>import time<br>import os<br>import argparse<br>from torchvision import datasets, models, transforms, utils<br>from torch.autograd import Variable<br>import torch.nn.functional as F<br>import copy<br>from PIL import Image<br>import matplotlib.pyplot as plt<br>import json<br>from collections import OrderedDict</pre><h3>Cargar los datos</h3><p>Aquí usarás <strong>torchvision</strong> para cargar los datos (<a href="http://pytorch.org/docs/0.3.0/torchvision/index.html">documentación</a>). Para la capacitación, querrás aplicar transformaciones, como la escala aleatoria, el recorte y el volteado. Esto ayudará a que la red se generalice conduciendo a un mejor rendimiento. Si utilizas una red pre-entrenada, también deberás asegurarte de que los datos de entrada se redimensionen a 224x224 píxeles como lo requieren las redes.</p><p>El conjunto de validación se utiliza para medir el rendimiento del modelo en datos que aún no se han visto. Para esto, no se desea ninguna transformación de escala o rotación, pero deberás cambiar el tamaño y luego recortar las imágenes al tamaño adecuado.</p><p>Las redes pre-entrenadas disponibles de torchvision fueron entrenadas en el conjunto de datos de <strong>ImageNet</strong> donde cada canal de color se normalizó por separado. Para ambos conjuntos, deberás normalizar los medios y las desviaciones estándar de las imágenes a lo que la red espera. Para las medias, es [0.485, 0.456, 0.406] y para las desviaciones estándar [0.229, 0.224, 0.225], calculadas a partir de las imágenes de ImageNet. Estos valores cambiarán cada canal de color para que se centre en 0 y oscile entre -1 y 1.</p><p>A continuación, es útil configurar las transformaciones de datos. Esencialmente, las transformaciones de datos en PyTorch nos permiten entrenar en muchas variaciones de las imágenes originales que se recortan de diferentes maneras o se rotan de diferentes maneras.</p><pre># TODO: Define your transforms for the training and validation sets<br>data_transforms = {<br>    &#39;train&#39;: transforms.Compose([<br>        transforms.RandomRotation(45),<br>        transforms.RandomResizedCrop(224),<br>        transforms.RandomHorizontalFlip(),<br>        transforms.ToTensor(),<br>        transforms.Normalize([0.485, 0.456, 0.406], <br>                             [0.229, 0.224, 0.225])<br>    ]),<br>    &#39;valid&#39;: transforms.Compose([<br>        transforms.Resize(256),<br>        transforms.CenterCrop(224),<br>        transforms.ToTensor(),<br>        transforms.Normalize([0.485, 0.456, 0.406], <br>                             [0.229, 0.224, 0.225])<br>    ]),<br>    &#39;test&#39;: transforms.Compose([<br>        transforms.Resize(256),<br>        transforms.CenterCrop(224),<br>        transforms.ToTensor(),<br>        transforms.Normalize([0.485, 0.456, 0.406], <br>                             [0.229, 0.224, 0.225])<br>    ]),<br>}</pre><pre># TODO: Load the datasets with ImageFolder<br># TODO: Using the image datasets and the trainforms, define the dataloaders<br>train_dir = &#39;flower_data/flower_data/train&#39;<br>valid_dir = &#39;flower_data/flower_data/valid&#39;<br>test_dir  = &#39;flower_data/flower_data/test&#39;<br>dirs = {&#39;train&#39;: train_dir, <br>        &#39;valid&#39;: valid_dir, <br>        &#39;test&#39; : test_dir}<br>image_datasets = {x: datasets.ImageFolder(dirs[x],   transform=data_transforms[x]) for x in [&#39;train&#39;, &#39;valid&#39;, &#39;test&#39;]}<br>dataloaders = {x: torch.utils.data.DataLoader(image_datasets[x], batch_size=32, shuffle=True) for x in [&#39;train&#39;, &#39;valid&#39;, &#39;test&#39;]}<br>dataset_sizes = {x: len(image_datasets[x]) <br>                              for x in [&#39;train&#39;, &#39;valid&#39;, &#39;test&#39;]}<br>class_names = image_datasets[&#39;train&#39;].classes<br>class_to_idx = image_datasets[&#39;train&#39;].class_to_idx</pre><p>Ahora podemos mostrar el tamaño de cada uno de los data sets, el número de clases , las clases que tenemos y cuantos data sets existen.</p><pre>print (&quot;Dasaset Size: &quot;+ str(dataset_sizes) + &quot;\n&quot;)<br>n_class = len(class_names)<br>print (&quot;Number of classes: &quot;+ str(n_class) + &quot;\n&quot;)<br>print (&quot;Classes: &quot;+ str(class_names) + &quot;\n&quot;)</pre><pre>print (len(dataloaders))</pre><p>La salida será así:</p><p>Dasaset Size: {‘train’: 6552, ‘valid’: 818, ‘test’: 819}</p><p>Number of classes: 102</p><p>Classes: [‘1’, ‘10’, ‘100’, ‘101’, ‘102’, ‘11’, ‘12’, ‘13’, ‘14’, ‘15’, ‘16’, ‘17’, ‘18’, ‘19’, ‘2’, ‘20’, ‘21’, ‘22’, ‘23’, ‘24’, ‘25’, ‘26’, ‘27’, ‘28’, ‘29’, ‘3’, ‘30’, ‘31’, ‘32’, ‘33’, ‘34’, ‘35’, ‘36’, ‘37’, ‘38’, ‘39’, ‘4’, ‘40’, ‘41’, ‘42’, ‘43’, ‘44’, ‘45’, ‘46’, ‘47’, ‘48’, ‘49’, ‘5’, ‘50’, ‘51’, ‘52’, ‘53’, ‘54’, ‘55’, ‘56’, ‘57’, ‘58’, ‘59’, ‘6’, ‘60’, ‘61’, ‘62’, ‘63’, ‘64’, ‘65’, ‘66’, ‘67’, ‘68’, ‘69’, ‘7’, ‘70’, ‘71’, ‘72’, ‘73’, ‘74’, ‘75’, ‘76’, ‘77’, ‘78’, ‘79’, ‘8’, ‘80’, ‘81’, ‘82’, ‘83’, ‘84’, ‘85’, ‘86’, ‘87’, ‘88’, ‘89’, ‘9’, ‘90’, ‘91’, ‘92’, ‘93’, ‘94’, ‘95’, ‘96’, ‘97’, ‘98’, ‘99’]</p><p>3</p><p>Además podemos mostrar un ejemplo de una de las imágenes</p><pre>images, labels = next(iter(dataloaders[&quot;train&quot;]))<br>print(len(images[0,2]))<br>plt.imshow(images[0,0])</pre><figure><img alt="" src="https://cdn-images-1.medium.com/max/337/1*LAAxX_yCD0cDDeEoROz8OQ.png" /></figure><h3>Mapeo de etiquetas</h3><p>También deberás cargar una asignación de etiqueta de categoría a nombre de categoría. Puedes encontrar esto en el archivo cat_to_name.json dentro de la carpeta pytorch_challenge. Es un objeto JSON que se puede leer con el módulo json. Esto te dará un diccionario que asigna las categorías codificadas con enteros a los nombres reales de las flores.</p><pre>with open(&#39;pytorch_challenge/cat_to_name.json&#39;, &#39;r&#39;) as f:<br>    cat_to_name = json.load(f)</pre><h3>Construyendo y entrenando el clasificador</h3><p>Ahora que los datos están listos, es hora de construir y entrenar al clasificador. Como de costumbre, se debe usar uno de los modelos pre-entrenados de torchvision.models para obtener las características de la imagen.</p><p>En los últimos años, se han creado varios modelos para reutilizarlos en problemas de visión de computadora. El uso de estos modelos pre-entrenados se conoce como aprendizaje por transferencia. PyTorch hace que sea fácil cargar modelos pre-entrenados y construir sobre ellos, que es lo que haremos en este proyecto.</p><p>Algunos de los modelos pre-entrenados más populares incluyen VGGNet, DenseNet, ResNet y AlexNet, todos los cuales son modelos pre-entrenados del Challenge de ImageNet. Estos modelos pre-entrenados permiten que otros obtengan rápidamente resultados de vanguardia en visión por computadora sin necesidad de grandes cantidades de poder de cómputo, tiempo y paciencia para encontrar la técnica de entrenamiento adecuada para optimizar los pesos.</p><p>Decidí usar la arquitectura DenseNet121, que podemos obtener de la biblioteca torchvision. Sin embargo, otros modelos podrían haberse utilizado fácilmente con una configuración muy similar.</p><pre>model = models.densenet121(pretrained=True)</pre><p>Puedes ver la arquitectura del modelo ejecutano la siguiente celda:</p><pre>print(model)</pre><p>Si te desplazas por la arquitectura del modelo, notará que tiene varias capas convolucionales. A continuación puedes ver la capa fina de la red.</p><p>(classifier): Linear(in_features=1024, out_features=1000) )</p><p>Hay dos partes del clasificador que deben ser consistentes</p><ol><li>El número de entidades de entrada con un valor de 1024 también debe ser el mismo que nuestro primer nivel de entrada.</li><li>El número de características de salida, que actualmente es de 1000 características, debe ser igual al número de clases que tenemos en nuestro conjunto de datos. En nuestro caso, vamos a querer predecir las 102 clases de flores.</li></ol><p>Luego, para garantizar que no actualizaremos los pesos del modelo pre-entrenado se define “param.requires_grad= False”. Además se define una nueva estructura de las capas finales del modelo re-definiendo el “classifier” previamente mostrado y para esto se usa un diccionario ordenado.</p><pre># TODO: Build and train your network<br>def build_model(hidden_layers, class_to_idx):<br>    model = models.densenet121(pretrained=True)<br>    for param in model.parameters():<br>        param.requires_grad = False<br>    <br>    classifier_input_size = model.classifier.in_features<br>    print(&quot;Input size: &quot;, classifier_input_size)<br>    output_size = 102</pre><pre>    from collections import OrderedDict<br>    classifier = nn.Sequential(OrderedDict([<br>        (&#39;fc1&#39;, nn.Linear(classifier_input_size, hidden_layers)),<br>        (&#39;relu&#39;, nn.ReLU()),<br>        (&#39;drpot&#39;, nn.Dropout(p=0.2)),<br>        (&#39;fc2&#39;, nn.Linear(hidden_layers, output_size)),<br>        (&#39;output&#39;, nn.LogSoftmax(dim=1))<br>    ]))<br>    <br>    model.classifier = classifier<br>    model.class_to_idx = class_to_idx<br>    return model# TODO: Build and train your network</pre><p>Se puede observar que esta función define nuestro nuevo classifier con dos fully connected layers, una función ReLu luego de la primera fully connected layer, un Dropout (0.20) y una salida de 102 características.</p><p>Se crea el nuevo modelo de la red donde se define que el hidden_layers tendrá 512 neuronas</p><pre>hidden_layers = 512<br>model = build_model(hidden_layers, class_to_idx)</pre><p>Y para ver la nueva arquitectura del modelo</p><pre>print(model)</pre><p>Se puede observar que el classifier cambio a:</p><p>(classifier): Sequential(</p><p>(fc1): Linear(in_features=1024, out_features=512)</p><p>(relu): ReLU()</p><p>(drpot): Dropout(p=0.2)</p><p>(fc2): Linear(in_features=512, out_features=102)</p><p>(output): LogSoftmax() ) )</p><p>Se definen las funciones de entrenamiento</p><pre>def train(model, epochs, learning_rate, criterion, optimizer, training_loader, validation_loader):<br>    <br>    model.train()<br>    print_every = 40<br>    steps = 0<br>    use_gpu = False<br>    <br>    if torch.cuda.is_available():<br>        use_gpu = True<br>        model.cuda()<br>    else:<br>        model.cpu()</pre><pre>    for epoch in range(epochs):<br>        running_loss = 0<br>        for inputs, labels in iter(training_loader):<br>            steps += 1</pre><pre>            if use_gpu:<br>                inputs = Variable(inputs.float().cuda())<br>                labels = Variable(labels.long().cuda()) <br>            else:<br>                inputs = Variable(inputs)<br>                labels = Variable(labels)</pre><pre>            optimizer.zero_grad()<br>            output = model.forward(inputs)<br>            loss = criterion(output, labels)<br>            loss.backward()<br>            optimizer.step()<br>            running_loss += loss.data[0]</pre><pre>            if steps % print_every == 0:<br>                validation_loss, accuracy = validate(model, <br>                criterion, validation_loader)</pre><pre>                print(&quot;Epoch: {}/{} &quot;.format(epoch+1, epochs),<br>                        &quot;Training Loss: {:.3f}    <br>                        &quot;.format(running_loss/print_every),<br>                        &quot;Validation Loss: {:.3f} <br>                        &quot;.format(validation_loss),<br>                        &quot;Validation Accuracy:   <br>                        {:.3f}&quot;.format(accuracy))</pre><pre>def validate(model, criterion, data_loader):<br>    model.eval()<br>    accuracy = 0<br>    test_loss = 0<br>    <br>    for inputs, labels in iter(data_loader):<br>        if torch.cuda.is_available():<br>            inputs = Variable(inputs.float().cuda(), volatile=True)<br>            labels = Variable(labels.long().cuda(), volatile=True) <br>        else:<br>            inputs = Variable(inputs, volatile=True)<br>            labels = Variable(labels, volatile=True)</pre><pre>        output = model.forward(inputs)<br>        test_loss += criterion(output, labels).data[0]<br>        ps = torch.exp(output).data <br>        equality = (labels.data == ps.max(1)[1])<br>        accuracy += equality.type_as(torch.FloatTensor()).mean()</pre><pre>    return test_loss/len(data_loader), accuracy/len(data_loader)</pre><p>Vamos a configurar las entradas necesarias para esta función. Hay seis entradas al modelo:</p><ol><li>El argumento “model” es el modelo, que es solo el modelo que creamos en la parte anterior.</li><li>El argumento “criterion” es el método utilizado para evaluar el ajuste del modelo.</li><li>El optimizador “optimizer” es la técnica de optimización utilizada para actualizar los pesos.</li><li>Las épocas “epoch”, es una ejecución completa de feedforward y backpropagation a través de la red. Si deseas reducir el tiempo de entrenamiento puedes reducir los epoch.</li><li>El learning_rate o tasa de aprendizaje, es un hiper-parámetro que controla cuánto estamos ajustando los pesos de nuestra red con respecto al gradiente de pérdida. Si la tasa de aprendizaje es baja, entonces la capacitación es más confiable (para no perder ningún mínimo local), pero la optimización tomará mucho tiempo porque los pasos hacia el mínimo de la función de pérdida son muy pequeños. Si la tasa de aprendizaje es alta, entonces el entrenamiento puede no converger o incluso divergir. Los cambios de peso pueden ser tan grandes que el optimizador sobrepasa el mínimo y empeora la pérdida.</li></ol><figure><img alt="" src="https://cdn-images-1.medium.com/max/800/1*n79s9gvd0E8ALe9dLUEKAw.png" /><figcaption>Gradient descent with small (top) and large (bottom) learning rates. Source: Andrew Ng’s Machine Learning course on Coursera</figcaption></figure><p>Para entrenar mi modelo, establezco lo anterior a los siguientes valores:</p><pre>epochs = 20<br>learning_rate = 0.001<br>criterion = nn.NLLLoss()<br>optimizer = optim.Adam(model.classifier.parameters(), lr=learning_rate)</pre><p>Se entrena el modelo ejecutando la siguiente celda</p><pre>train(model, epochs, learning_rate, criterion, optimizer, dataloaders[&#39;train&#39;], dataloaders[&#39;valid&#39;])</pre><p>Si todo está configurado correctamente, debería ver algo como lo siguiente:</p><figure><img alt="" src="https://cdn-images-1.medium.com/max/739/1*3jnaX4GP0SqTwX0GF-RsvQ.png" /></figure><figure><img alt="" src="https://cdn-images-1.medium.com/max/683/1*2DmAxkeV9z15REK_Erf7zQ.png" /><figcaption><a href="http://www.aprendemachinelearning.com/que-es-overfitting-y-underfitting-y-como-solucionarlo/">http://www.aprendemachinelearning.com/que-es-overfitting-y-underfitting-y-como-solucionarlo/</a></figcaption></figure><p>En la imagen puedes ver que tenemos un “training loss” y un “validation loss”, que nos permitirán ver si nuestro modelo esta “overfitting” es decir sobre-entrenado o tiene sobreajuste (el modelo no es esta generalizando porque el modelo tiene exactamente los mismos valores de las muestras de entrenamiento), si esta “underfitting” es decir tiene subajuste (tiene falta de entrenamiento) o nos dirá si esta correctamente entrenado.</p><h3>Test de tu modelo</h3><p>Es una buena práctica probar tu modelo capacitado en datos de prueba, imágenes que la red nunca ha visto, ya sea en entrenamiento o validación. Esto le dará una buena estimación del rendimiento del modelo en imágenes completamente nuevas. Debería poder alcanzar aproximadamente el 70% de precisión en el conjunto de pruebas si el modelo ha sido bien entrenado.</p><pre><em># TODO: Do validation on the test set</em><br>test_loss, accuracy = validate(model, criterion, dataloaders[&#39;testing&#39;])<br>print(&quot;Val. Accuracy: <strong>{:.3f}</strong>&quot;.format(accuracy))<br>print(&quot;Val. Loss: <strong>{:.3f}</strong>&quot;.format(test_loss))</pre><h3>Guardar el punto de control</h3><p>Ahora que tu modelo está entrenado, es hora de guardarlo para poder cargarlo más tarde y hacer predicciones. Probablemente desees guardar otras cosas, como la asignación de clases a los índices que obtiene de uno de los conjuntos de datos de imagen: image_datasets [‘train’]. class_to_idx. Puede adjuntar esto al modelo como un atributo que facilita la inferencia más adelante.</p><p>model.class_to_idx = image_datasets [‘train’]. class_to_idx</p><p>Recuerde que querrá reconstruir completamente el modelo más adelante para poder usarlo como inferencia. Asegúrese de incluir cualquier información que necesite en el punto de control. Si desea cargar el modelo y seguir entrenando, querrá guardar el número de épocas y el estado del optimizador, optimizer.state_dict. Es probable que desee utilizar este modelo capacitado en la siguiente parte del proyecto, por lo que es mejor guardarlo ahora.</p><pre># TODO: Save the checkpoint <br>model.class_to_idx = image_datasets[&#39;train&#39;].class_to_idx<br>model.cpu()<br>torch.save({&#39;arch&#39;: &#39;densenet121&#39;,<br>            &#39;state_dict&#39;: model.state_dict(), <br>            &#39;class_to_idx&#39;: model.class_to_idx}, <br>            &#39;densenet121.pth&#39;)</pre><h3>Cargando el modelo</h3><p>En este punto, es bueno escribir una función que pueda cargar un punto de control y reconstruir el modelo. De esa manera, puedes volver a este proyecto y seguir trabajando en él sin tener que volver a entrenar la red.</p><pre># TODO: Write a function that loads a checkpoint and rebuilds the model<br>def load_checkpoint(filepath):<br>    checkpoint = torch.load(filepath)<br>    model = models.densenet121()<br>    <br>    classifier = nn.Sequential(OrderedDict([<br>        (&#39;fc1&#39;, nn.Linear(1024, hidden_layers)),<br>        (&#39;relu&#39;, nn.ReLU()),<br>        (&#39;drpot&#39;, nn.Dropout(p=0.2)),<br>        (&#39;fc2&#39;, nn.Linear(hidden_layers, 102)),<br>        (&#39;output&#39;, nn.LogSoftmax(dim=1))<br>    ]))<br>    <br>    model.classifier = classifier<br>    model.load_state_dict(checkpoint[&#39;state_dict&#39;])<br>    <br>    return model, checkpoint[&#39;class_to_idx&#39;]</pre><pre># get index to class mapping<br>loaded_model, class_to_idx = load_checkpoint(&#39;densenet121.pth&#39;)<br>idx_to_class = { v : k for k,v in class_to_idx.items()}</pre><h3>Inferencia para clasificación</h3><p>Ahora hay que escribir una función para usar un modelo entrenado para la inferencia. Es decir, pasar una imagen al modelo y predecir la clase de la flor en la imagen.</p><h3>Preprocesamiento de imágenes</h3><p>Hay que escribir una función que preprocese la imagen para que pueda usarse como entrada para el modelo. Esta función debe procesar las imágenes de la misma manera utilizada para el entrenamiento. Primero, se cambia el tamaño de las imágenes donde el lado más corto es de 256 píxeles, manteniendo la relación de aspecto. Esto se puede hacer con los métodos de miniatura o cambio de tamaño. Luego deberá recortar la parte central de 224x224 de la imagen.</p><pre>def process_image(image):<br>    &#39;&#39;&#39; Scales, crops, and normalizes a PIL image for a PyTorch    <br>    model, returns an Numpy array &#39;&#39;&#39;<br>    <br>    # TODO: Process a PIL image for use in a PyTorch model</pre><pre>    size = 256, 256<br>    image.thumbnail(size, Image.ANTIALIAS)<br>    image = image.crop((128 - 112, 128 - 112, 128 + 112, 128 + 112))<br>    npImage = np.array(image)<br>    npImage = npImage/255.<br>        <br>    imgA = npImage[:,:,0]<br>    imgB = npImage[:,:,1]<br>    imgC = npImage[:,:,2]<br>    <br>    imgA = (imgA - 0.485)/(0.229) <br>    imgB = (imgB - 0.456)/(0.224)<br>    imgC = (imgC - 0.406)/(0.225)<br>        <br>    npImage[:,:,0] = imgA<br>    npImage[:,:,1] = imgB<br>    npImage[:,:,2] = imgC<br>    <br>    npImage = np.transpose(npImage, (2,0,1))<br>    <br>    return npImag</pre><p>Para verificar el trabajo, la siguiente función convierte un tensor de PyTorch y lo muestra en el cuaderno. Si tu función process_image funciona, al ejecutar la salida a través de esta función debería devolver la imagen original (excepto las partes recortadas).</p><pre>def imshow(image, ax=None, title=None):<br>    &quot;&quot;&quot;Imshow for Tensor.&quot;&quot;&quot;<br>    if ax is None:<br>        fig, ax = plt.subplots()<br>    <br>    # PyTorch tensors assume the color channel is the first       <br>    dimension<br>    # but matplotlib assumes is the third dimension<br>    image = image.numpy().transpose((1, 2, 0))<br>    <br>    # Undo preprocessing<br>    mean = np.array([0.485, 0.456, 0.406])<br>    std = np.array([0.229, 0.224, 0.225])<br>    image = std * image + mean<br>    <br>    # Image needs to be clipped between 0 and 1 or it looks like <br>    noise when displayed<br>    image = np.clip(image, 0, 1)<br>    <br>    ax.imshow(image)<br>    <br>    return ax</pre><h3>Predicción de clase</h3><p>Una vez que puede obtener imágenes en el formato correcto, es el momento de escribir una función para hacer predicciones con el modelo. Una práctica común es predecir la mayoría de las 5 clases más probables (generalmente llamadas top-<em>K</em> ).</p><p>Nuevamente, este método debe tomar una ruta hacia una imagen y un punto de control del modelo, luego devolver las probabilidades y las clases.</p><pre>def predict(image_path, model, topk=5):<br>    &#39;&#39;&#39; Predict the class (or classes) of an image using a trained <br>    deep learning model.&#39;&#39;&#39;<br>    <br>    # TODO: Implement the code to predict the class from an image  <br>    file<br>    <br>    image =  <br>    torch.FloatTensor([process_image(Image.open(image_path))])<br>    model.eval()<br>    output = model.forward(Variable(image))<br>    pobabilities = torch.exp(output).data.numpy()[0]</pre><pre>    top_idx = np.argsort(pobabilities)[-topk:][::-1] <br>    top_class = [idx_to_class[x] for x in top_idx]<br>    top_probability = pobabilities[top_idx]</pre><pre>    return top_probability, top_class</pre><pre>print (predict(&#39;flower_data/flower_data/test/1/image_06743.jpg&#39;, loaded_model))</pre><h3>Comprobación</h3><p>Ahora que se puede usar el modelo entrenado para las predicciones, hay que verificar que tenga sentido. Incluso si la precisión de las pruebas es alta, siempre es bueno verificar que no haya errores obvios.</p><pre># TODO: Display an image along with the top 5 classes<br>def view_classify(img, probabilities, classes, mapper):<br>    &#39;&#39;&#39; Function for viewing an image and it&#39;s predicted classes.<br>    &#39;&#39;&#39;<br>    img_filename = img.split(&#39;/&#39;)[-2]<br>    img = Image.open(img)</pre><pre>    fig, (ax1, ax2) = plt.subplots(figsize=(6,10), ncols=1, nrows=2)<br>    flower_name = mapper[img_filename]<br>    <br>    ax1.set_title(flower_name)<br>    ax1.imshow(img)<br>    ax1.axis(&#39;off&#39;)<br>    <br>    y_pos = np.arange(len(probabilities))<br>    ax2.barh(y_pos, probabilities)<br>    ax2.set_yticks(y_pos)<br>    ax2.set_yticklabels([mapper[x] for x in classes])<br>    ax2.invert_yaxis()</pre><pre>img = &#39;flower_data/flower_data/test/24/image_06815.jpg&#39;<br>p, c = predict(img, loaded_model)<br>view_classify(img, p, c, cat_to_name)</pre><p>Obteniendo como salida la siguiente comprobación:</p><figure><img alt="" src="https://cdn-images-1.medium.com/max/400/1*0s0MVRB5zNydVu_qeNuyxg.png" /></figure><h3>Conclusiones</h3><p>Como podemos ver, las redes pre-entrenadas son increíblemente beneficiosas, ya que nos permiten enfocarnos en los aspectos específicos de nuestro caso de uso, mientras reutilizamos genéricos conocidos para el preprocesamiento de imágenes en el ejemplo.</p><p>También hemos aprendido que el tamaño de la salida de nuestro clasificador debe ser el mismo que el número de tipos diferentes que queremos poder identificar.</p><p>Finalmente, hemos visto que la salida de las capas de entidades y la entrada de nuestro clasificador personalizado también deben coincidir en tamaño.</p><p>Espero que este artículo te ayude a entender de una manera fácil como usar PyTorch y Google Colab para mediante redes neuronales pre-entrenadas clasificar imágenes.</p><iframe src="https://cdn.embedly.com/widgets/media.html?src=https%3A%2F%2Fupscri.be%2Ff%2F68bc97%3Fas_embed%3Dtrue&amp;dntp=1&amp;display_name=Upscribe&amp;url=https%3A%2F%2Fupscri.be%2F68bc97%2F&amp;key=a19fcc184b9711e1b4764040d3dc5c07&amp;type=text%2Fhtml&amp;schema=upscri" width="800" height="400" frameborder="0" scrolling="no"><a href="https://medium.com/media/d8021540cbf50434828deb5439e1cf04/href">https://medium.com/media/d8021540cbf50434828deb5439e1cf04/href</a></iframe><figure><a href="http://bit.ly/2BDa2xQ"><img alt="" src="https://cdn-images-1.medium.com/max/1024/1*Axmr4bMScpjBU_WcOm263A.png" /></a></figure><figure><img alt="" src="https://cdn-images-1.medium.com/max/788/1*u6pz8xzjblHCXLMQUQGF3Q.gif" /></figure><figure><a href="https://twitter.com/planetaChatbot"><img alt="" src="https://cdn-images-1.medium.com/max/788/1*qQxzn3vV9Xu4lYMpuc5OOw.png" /></a></figure><img src="https://medium.com/_/stat?event=post.clientViewed&referrerSource=full_rss&postId=f3c9129148f6" width="1" height="1" alt="">]]></content:encoded>
        </item>
        <item>
            <title><![CDATA[Empezando a usar Google Colab con Pytorch!!]]></title>
            <link>https://medium.com/saturdays-ai/empezando-a-usar-google-colab-con-pytorch-4efb53933624?source=rss-631fff797e3a------2</link>
            <guid isPermaLink="false">https://medium.com/p/4efb53933624</guid>
            <category><![CDATA[inteligencia-artificial]]></category>
            <category><![CDATA[colab]]></category>
            <category><![CDATA[pytorch]]></category>
            <category><![CDATA[ai-saturdays]]></category>
            <category><![CDATA[google]]></category>
            <dc:creator><![CDATA[Christian Tutivén Gálvez]]></dc:creator>
            <pubDate>Mon, 14 Jan 2019 15:01:00 GMT</pubDate>
            <atom:updated>2019-01-14T19:00:35.077Z</atom:updated>
            <content:encoded><![CDATA[<h3>Empezando a usar Google Colab con PyTorch!!</h3><p>Como embajador de <a href="https://www.saturdays.ai/"><strong>AI Saturdays</strong></a><strong> </strong>(una organización sin fines de lucro con el objetivo de capacitar a diversos individuos para que aprendan Inteligencia Artificial de forma colaborativa y basada en proyectos, más allá del camino de la educación convencional) quería compartir mi experiencia en el mundo de la Inteligencia Artificial (IA) y empezaba a escribir mi primer artículo de como desarrollar un clasificador de imágenes usando PyTorch y mientras escribía tuve que decidir que herramienta usar para entrenar mis modelos. Como deseaba que todos puedan replicar lo hecho por mí, decidí primero escribir esta guía de como configurar Google Colab (herramienta gratuita) para poder trabajar con PyTorch.</p><figure><img alt="" src="https://cdn-images-1.medium.com/max/1024/1*uUaKscsKUBwCAHFQ5446EA.png" /></figure><h3>Qué es Google Colab?</h3><p>Esta herramienta de Google ofrece el uso de un cuaderno tipo J<a href="https://jupyter.org/">upyter</a>. El cuaderno tiene la misma extensión (.ipynb) y funciona de la misma manera que en Jupyter. Ya que se puede usar como un cuaderno Jupyter con un entorno local instalado en la máquina personal de uno (esto no se tratará en este artículo). No obstante, para poder aprovechar toda su potencia, uno podría utilizar mejor una <strong>GPU gratuita</strong> e instalar los paquetes necesarios (es muy fácil, no te asustes).</p><p>Para los que se mueren de hambre por más detalles, Google tiene un cuaderno llamado “Te damos la bienvenida a Colaboratory” que tiene como objetivo dar una introducción detallada a la herramienta.</p><p><a href="https://colab.research.google.com/notebooks/welcome.ipynb"><em>https://colab.research.google.com/notebooks/welcome.ipynb</em></a></p><h3>Empezando con Google Colab</h3><p>Google Colab ofrece una GPU Tesla K80. Se puede seguir trabajando con la instancia de GPU continuamente hasta 12 horas! Una vez que hayan consumido las 12 horas, simplemente cierre el cuaderno y vuelva a abrirlo. Ahora, ¡A trabajar!</p><p>1- Conéctate a tu cuenta de gmail en el navegador y acceda a Google Drive. Una vez que accedas a tu Google Drive, veras algo parecido a esto.</p><figure><img alt="" src="https://cdn-images-1.medium.com/max/273/1*yncKD0fUXXmt-NUZuNxXbQ.png" /></figure><p>2- Google Colab es una aplicación como cualquier otra aplicación (Google Docs, Sheets, etc.) que desee utilizar en Google Drive. Para instalarlo, has clic en el botón + Nuevo -&gt; Más-&gt; Conectar más aplicaciones, como se muestra a continuación. En mi caso ya tengo instalado previamente Google Colab, por eso vas a ver el icono en la figura.</p><figure><img alt="" src="https://cdn-images-1.medium.com/max/642/1*KftUMtvOq3h3QCIhjD7NLQ.png" /></figure><p>A partir de ahí, se abrirá una ventana. Todo lo que debes hacer es escribir en la pestaña dela esquina superior derecha “Colaboratory” y aparecerá la aplicación.</p><figure><img alt="" src="https://cdn-images-1.medium.com/max/743/1*rHBnyUa4z2F1zSS5h5ZcZw.png" /></figure><p>Ahora, has clic en el botón azul de conectar. Una vez instalada, aparecerá un mensaje indicando si permite que la aplicación abra archivos que puede abrir, has clic en Sí.<br>Una vez que este paso se haya completado con éxito, debería verse el logotipo de Google Colab con un visto verde.</p><figure><img alt="" src="https://cdn-images-1.medium.com/max/736/1*s7G5kCc_IIpIRaY53Z2YCA.png" /></figure><p>Ahora, has clic en el botón + Nuevo -&gt; Colaboratory</p><figure><img alt="" src="https://cdn-images-1.medium.com/max/662/1*PsSi0Gb_AZNmE2lULxRBFw.png" /></figure><p>Esto creará un cuaderno en tu unidad de Google Drivey abrirá una nueva pestaña para el cuaderno.</p><h3>Configurando Google Colab</h3><p>Ahora, Colab te ofrece un par de opciones interesantes: trabajar con Python2 o Python3 o trabajar con o sin GPU. La configuración predeterminada es Python2 sin GPU. Cambiar esto solo necesita un par de clics del mouse. Una vez dentro de tu nuevo cuaderno, vas a Editar-&gt; Configuración del cuaderno.</p><figure><img alt="" src="https://cdn-images-1.medium.com/max/480/1*knM0JyiD6R_u94HMI9qRRg.png" /></figure><p>Continua y cambia el tipo de tiempo de ejecución a Python 3 (si lo deseas. ¡No hay ningún problema!) Y el acelerador de hardware a GPU.</p><figure><img alt="" src="https://cdn-images-1.medium.com/max/470/1*vyfWrVpu_3dKRQR50cP2sw.png" /></figure><h3>Instalando PyTorch</h3><p>Para instalar pytorch ingresa las siguientes lineas de código.</p><pre>!pip3 install <a href="http://download.pytorch.org/whl/cu80/torch-0.3.0.post4-cp36-cp36m-linux_x86_64.whl">http://download.pytorch.org/whl/cu80/torch-0.3.0.post4-cp36-cp36m-linux_x86_64.whl</a></pre><pre>!pip3 install torchvision</pre><p>La salida se mostrará así:</p><figure><img alt="" src="https://cdn-images-1.medium.com/max/1024/1*EbEco_ia-HHkBZFbwEvqRw.png" /></figure><h3>LISTO, YA TIENES CONFIGURADO GOOGLE COLAB PARA PODER USAR PYTORCH.</h3><img src="https://medium.com/_/stat?event=post.clientViewed&referrerSource=full_rss&postId=4efb53933624" width="1" height="1" alt=""><hr><p><a href="https://medium.com/saturdays-ai/empezando-a-usar-google-colab-con-pytorch-4efb53933624">Empezando a usar Google Colab con Pytorch!!</a> was originally published in <a href="https://medium.com/saturdays-ai">Saturdays.AI</a> on Medium, where people are continuing the conversation by highlighting and responding to this story.</p>]]></content:encoded>
        </item>
    </channel>
</rss>