Deep Learning with Python

Chapter1.ipynb

{
 "cells": [
  {
   "cell_type": "markdown",
   "metadata": {},
   "source": [
    "Qué aprendizaje profundo se ha logrado hasta ahora\n",
    "\n",
    "Aunque el aprendizaje profundo es un subcampo bastante antiguo del aprendizaje automático, solo se elevó a\n",
    "prominencia a principios de 2010. En los pocos años desde entonces, ha logrado nada menos que\n",
    "una revolución en el campo, con resultados notables en problemas perceptivos como ver\n",
    "y problemas de audición que involucran habilidades que parecen naturales e intuitivas para los humanos\n",
    "pero durante mucho tiempo han sido elusivas para las máquinas.\n",
    "En particular, el aprendizaje profundo ha logrado los siguientes avances:\n",
    "- Clasificación de imágenes a nivel humano\n",
    "- Reconocimiento de voz a nivel humano\n",
    "- Transcripción de escritura a nivel humano\n",
    "- Traducción automática mejorada\n",
    "- Mejora de la conversión de texto a voz\n",
    "- Asistentes digitales como Google Now y Amazon Alexa\n",
    "- Conducción autónoma a nivel humano\n",
    "- Mejora de la orientación de anuncios, tal como la utilizan Google, Baidu y Bing.\n",
    "- Mejores resultados de búsqueda en la web\n",
    "- Capacidad para responder preguntas en lenguaje natural\n",
    "- Juego sobrehumano\n",
    "\n",
    "Decision trees, random forests, and gradient boosting machines\n",
    "\n",
    "Los árboles de decisión son estructuras tipo diagrama de flujo que le permiten clasificar puntos de datos de entrada o predecir valores de salida dadas entradas. Son fáciles de visualizar e interpretar.\n",
    "Los árboles de decisiones aprendidos a partir de los datos comenzaron a recibir un interés de investigación significativo en la década de 2000, y en 2010 a menudo se preferían a los métodos kernel.\n",
    "\n",
    "En particular, el algoritmo de Random Forest presentó una versión robusta y práctica de\n",
    "el aprendizaje del árbol de decisiones que implica la construcción de una gran cantidad de decisiones especializadas. Random Forest son aplicables a un amplio rango de problemas; se podría decir que casi siempre son el segundo mejor algoritmo para cualquier tarea superficial de aprendizaje automático. Cuando la popular competencia de aprendizaje de máquina del sitio web Kaggle (http://kaggle.com) comenzó en 2010, Random Forest rápidamente se convirtió en uno de los favoritos en la plataforma, hasta 2014, cuando GRADIENT BOOSTING MACHINES tomaron su lugar. Este es una técnica de aprendizaje automático basada en el conjunto de modelos de predicción débiles, generalmente árboles de decisión. Utiliza el aumento de gradiente, una forma de mejorar cualquier modelo de aprendizaje automático mediante el entrenamiento iterativo de nuevos modelos que se especializan en abordar los puntos débiles de los modelos anteriores.\n",
    "Aplicado a árboles de decisión, el uso de la técnica de aumento de gradiente da como resultado modelos\n",
    "que supera estrictamente a Random Forests la mayor parte del tiempo, al tiempo que tiene propiedades similares.\n",
    "Puede ser uno de los mejores, si no el mejor, algoritmo para tratar con datos no perceptuales al día de hoy. Junto con Deep Learning, es una de las técnicas más comúnmente utilizadas en la competiciones de Kaggle.\n",
    "\n",
    "Entonces, qué tipo de algoritmo está ganando competencias confiablemente? ¿Qué herramientas usan los principales participantes?\n",
    "\n",
    "En 2016 y 2017, Kaggle estuvo dominada por dos enfoques: gradient boosting machines and deep learning. Específicamente, gradient boosting se usa para problemas donde los datos estructurados están disponibles, mientras que el aprendizaje profundo se usa para problemas de percepción como la clasificación de imágenes. Los practicantes de la primera usan casi siempre la biblioteca XGBoost, que ofrece soporte para los dos idiomas más populares de\n",
    "ciencia de datos: Python y R. Mientras tanto, la mayoría de los participantes de Kaggle usan aprendizaje profundo\n",
    "utilice la biblioteca de Keras, debido a su facilidad de uso, flexibilidad y soporte de Python.\n",
    "Estas son las dos técnicas con las que debería estar más familiarizado para poder tener exito en el aprendizaje automático aplicado hoy en día: gradient boosting machines, para el aprendizaje superficial de problemas; y Deep Learning, para problemas de percepción. En términos técnicos, esto significa que tendrá que estar familiarizado con XGBoost y Keras.\n",
    "\n",
    "Antes de comenzar: conocimientos matemáticos de redes neuronales\n",
    "\n",
    "Comprender Deep Learning requiere familiarizarse con muchos conceptos de matemáticas simples: tensores, operaciones de tensor, diferenciación, descenso de gradiente, etc.\n",
    "Nuestro objetivo en este capítulo será construir su intuición sobre estas nociones sin ser demasiado técnico. En particular, nos alejaremos de la notación matemática que puede ser desalentador para aquellos sin bases matemáticas.\n",
    "Para agregar un contexto para los tensores y el descenso del gradiente, comenzaremos el capítulo\n",
    "con un ejemplo práctico de una red neuronal. Luego repasaremos cada nuevo concepto punto por punto."
   ]
  },
  {
   "cell_type": "markdown",
   "metadata": {},
   "source": [
    "## Una primera mirada a una red neuronal\n",
    "Veamos un ejemplo concreto de una red neuronal que usa la biblioteca Python Keras\n",
    "para aprender a clasificar los dígitos escritos a mano. El problema que estamos tratando de resolver aquí es clasificar las imágenes en escala de grises de los digitos manuscritos(28 × 28 píxeles) en sus 10 categorías(0 a 9). Usaremos el conjunto de datos de MNIST, un clásico en la comunidad de aprendizaje automático, que ha existido casi\n",
    "siempre. Es un conjunto de 60,000 entrenamientos imágenes, más 10,000 imágenes de prueba, ensambladas por el Instituto Nacional de Estándares y Tecnología (el NIST en MNIST) en la década de 1980. Puedes pensar en \"resolver\" a MNIST como el \"Hola mundo\" de aprendizaje profundo: es lo que haces para verificar que tus algoritmos están trabajando como esperas. A medida que se convierte en un practicante de aprendizaje automático, verá MNIST aparece una y otra vez, en artículos científicos, publicaciones en blogs, etc.\n"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 4,
   "metadata": {},
   "outputs": [
    {
     "name": "stdout",
     "output_type": "stream",
     "text": [
      "Downloading data from https://s3.amazonaws.com/img-datasets/mnist.npz\n",
      "11493376/11490434 [==============================] - 35s 3us/step\n"
     ]
    }
   ],
   "source": [
    "## Cargando el conjunto de datos MNIST en Keras\n",
    "from keras.datasets import mnist\n",
    "(train_images, train_labels), (test_images, test_labels) = mnist.load_data()"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 7,
   "metadata": {},
   "outputs": [],
   "source": [
    "## train_images y train_labels forman el conjunto de entrenamiento, \n",
    "## los datos de los que aprenderá el modelo. El modelo se probará en el conjunto de prueba, test_images y test_labels.\n",
    "## Las imagenes son codificadas como Numpy arrays y los campos son un array de digitos, en un rango de 0 a 9. Las imagenes\n",
    "## y los campos tienen una correspondencia de uno a uno"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 8,
   "metadata": {},
   "outputs": [
    {
     "data": {
      "text/plain": [
       "(60000, 28, 28)"
      ]
     },
     "execution_count": 8,
     "metadata": {},
     "output_type": "execute_result"
    }
   ],
   "source": [
    "train_images.shape"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 9,
   "metadata": {},
   "outputs": [
    {
     "data": {
      "text/plain": [
       "60000"
      ]
     },
     "execution_count": 9,
     "metadata": {},
     "output_type": "execute_result"
    }
   ],
   "source": [
    "len(train_labels)"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 10,
   "metadata": {},
   "outputs": [
    {
     "data": {
      "text/plain": [
       "array([5, 0, 4, ..., 5, 6, 8], dtype=uint8)"
      ]
     },
     "execution_count": 10,
     "metadata": {},
     "output_type": "execute_result"
    }
   ],
   "source": [
    "train_labels"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 11,
   "metadata": {},
   "outputs": [
    {
     "data": {
      "text/plain": [
       "(10000, 28, 28)"
      ]
     },
     "execution_count": 11,
     "metadata": {},
     "output_type": "execute_result"
    }
   ],
   "source": [
    "test_images.shape"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 12,
   "metadata": {},
   "outputs": [
    {
     "data": {
      "text/plain": [
       "10000"
      ]
     },
     "execution_count": 12,
     "metadata": {},
     "output_type": "execute_result"
    }
   ],
   "source": [
    "len(test_labels)"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 13,
   "metadata": {},
   "outputs": [
    {
     "data": {
      "text/plain": [
       "array([7, 2, 1, ..., 4, 5, 6], dtype=uint8)"
      ]
     },
     "execution_count": 13,
     "metadata": {},
     "output_type": "execute_result"
    }
   ],
   "source": [
    "test_labels"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": null,
   "metadata": {},
   "outputs": [],
   "source": []
  }
 ],
 "metadata": {
  "kernelspec": {
   "display_name": "Python 3",
   "language": "python",
   "name": "python3"
  },
  "language_info": {
   "codemirror_mode": {
    "name": "ipython",
    "version": 3
   },
   "file_extension": ".py",
   "mimetype": "text/x-python",
   "name": "python",
   "nbconvert_exporter": "python",
   "pygments_lexer": "ipython3",
   "version": "3.6.5"
  }
 },
 "nbformat": 4,
 "nbformat_minor": 2
}