Más

Usando Python, ¿la salida del proyecto por lotes no caerá en el conjunto de datos de características?

Usando Python, ¿la salida del proyecto por lotes no caerá en el conjunto de datos de características?


Cuando intento realizar un proyecto por lotes en ArcGIS 9.3 o 10 (usando arcpy o arcgisscripting), no puedo hacer que los resultados de mi geoprocesamiento caigan en el dataset de entidades que especifico. En cambio, los resultados se colocan en la raíz de la geodatabase (* .mdb).

Aquí hay una versión abreviada de lo que tengo hasta ahora:

import arcgisscripting, os gp = arcgisscripting.create (9.3) #set date dmy = datetime.now () currentDate = str (dmy.month) + "-" + str (dmy.day) + "-" + str (dmy. year) outputfolder = gp.getparameterastext (0) #donde vamos a colocar gdb citydata = gp.getparameterastext (1) gp.workspace = outputfolder carpetaproyectada = os.path.join (carpeta de salida, "proyectada") gp.CreateFolder_management (* os.path.split (carpetaproyectada)) gdb = "Projected_Data_" + currentDate + ".mdb" #set sistema de coordenadas outputCS = gp.CreateObject ("SpatialReference") outputCS.createFromFile (os.path.join (gp.getinstallinfo () ['InstallDir'], "Sistemas de coordenadas  Sistemas de coordenadas geográficas  Norteamérica  NAD 1983.prj")) transformación = "" gp.AddMessage ("Creando un conjunto de datos de entidades de la ciudad") gp.CreateFeatureDataset (os. path.join (projectedfolder, gdb), "City", outputCS) gp.AddMessage ("Cargando en clases de entidad de la ciudad") arcpy.BatchProject_management (citydata, os.path.join (projectedfolder, gdb, "City"), outputCS, "", transformación)

Obviamente, la parte con la que tengo problemas es la ruta de salida en la última línea. También he codificado de forma rígida la ruta al conjunto de datos de la función "Ciudad", pero aún lo coloco en la raíz. ¿Algunas ideas?

(Publicación cruzada en los foros de ESRI aquí)


Mucha gente ha preguntado sobre esto. Se ha rechazado al menos una solicitud (NIM013677) con el estado "según lo diseñado". La razón dada es:

Porque cuando se usa la versión de secuencia de comandos, la herramienta no puede saber si el objetivo es un conjunto de datos o una clase de entidad. Está diseñado para no admitir un conjunto de datos de características.

Descargo de responsabilidad estándar: trabajo en Esri, pero no en el equipo de geoprocesamiento (que tomó esta decisión).


Esto se corrige en ArcGIS 10.1: http://forums.arcgis.com/threads/39448-Using-Python-can-t-get-Batch-Project-outputs-to-save-in-a-feature-dataset?p = 244841 & viewfull = 1 # post244841

Lo probé en la ventana de Python en ArcMap 10.1, funciona :-)


A lo largo de la documentación asumimos que está utilizando virtualenv para administrar sus entornos Python. Esta configuración es la utilizada y recomendada por los autores del proyecto y es la forma más fácil de asegurarse de que no se encontrará con problemas ambientales. Si está usando Anaconda, Miniconda o Mamba, primero lea las instrucciones en Capacitación desde un entorno Anaconda o miniconda y luego continúe desde el paso de instalación a continuación.

Al crear un entorno virtual, creará un directorio que contiene un binario de python3 y todo lo necesario para ejecutar deeppeech. Puede utilizar el directorio que desee. A los efectos de la documentación, nos basaremos en $ HOME / tmp / deepspeech-train-venv. Puedes crearlo usando este comando:

Una vez que este comando se complete con éxito, el entorno estará listo para ser activado.


Introducción

Para aquellos que se inician en el entorno de reconocimiento óptico de caracteres (OCR), me parece interesante aportar un breve contexto.

Según [1], los sistemas OCR tienen dos categorías: en línea, en el que la información de entrada se obtiene a través de sensores de escritura en tiempo real y desconectado, en el que la información de entrada se obtiene a través de información estática (imágenes). Dentro de desconectado categoría, existe el reconocimiento de texto mecanografiado y manuscrito (Figura 1).

Entonces, el reconocimiento de texto escrito a mano (HTR) tiene el propósito de transcribir texto cursivo al medio digital (ASCII, Unicode) [2].

Durante muchos años, los sistemas HTR han utilizado los modelos ocultos de Markov (HMM) para la tarea de transcripción [3] - [5], pero recientemente, a través del aprendizaje profundo, se ha utilizado el enfoque de redes neuronales recurrentes convolucionales (CRNN) para superar algunas limitaciones de HMM [6], [7]. Para ejemplificar un modelo CRNN, traigo el modelo [8] (Figura 2).

El flujo de trabajo se puede dividir en 3 pasos. Paso 1: la imagen de entrada se alimenta a las capas de CNN para extraer entidades. La salida es un mapa de características. Paso 2: a través de la implementación de Long Short-Term Memory (LSTM), el RNN puede propagar información a distancias más largas y proporcionar funciones más sólidas para el entrenamiento. Paso 3: con la matriz de salida RNN, la Clasificación temporal conexionista (CTC) [9] calcula el valor de pérdida y también descodifica en el texto final.

Para obtener más detalles sobre este proceso, recomiendo leer Cree un sistema de reconocimiento de texto escrito a mano con TensorFlow por Harald Scheidl (2018).

Finalmente, es muy importante explicar que para este post, el paso 3 (CTC) es el mismo para todas las arquitecturas presentadas, luego se utiliza el método Vanilla Beam Search [10], ya que no requiere diccionario para su aplicación, a diferencia de otros métodos conocidos como Token Passing [11] y Búsqueda por haz de palabras [8]. Por lo tanto, las arquitecturas presentadas en las siguientes secciones solo actúan en los pasos 1 y 2.

además, el juego de caracteres para codificar texto también es el mismo para todos los conjuntos de datos. Por lo tanto, la lista utilizada consta de 95 caracteres imprimibles de la tabla ASCII (Figura 3) de forma predeterminada y no contiene letras acentuadas.

Ahora puede que se pregunte por qué utilizar el mismo CTC y juego de caracteres para las arquitecturas y los conjuntos de datos. Bueno, para este experimento a propósito, quería traer un enfoque más uniforme entre los modelos y las bases de datos. Dado que el uso de diccionarios y conjuntos de caracteres específicos puede traer mejores resultados en algunos escenarios, pero no tanto en otros. Por ejemplo, un juego de caracteres con solo 60 caracteres es “más fácil de acertar” (1/60) que otro con 125 (1/125). De hecho, el enfoque aquí se vuelve más difícil para el reconocimiento de texto por parte de los modelos.


Definir la función de puntuación de anomalía

A continuación, necesitamos definir una función que calcule qué tan anómala es cada transacción. Cuanto más anómala sea la transacción, es más probable que sea fraudulenta, asumiendo que el fraude es poco común y se ve algo diferente a la mayoría de las transacciones, que son normales.

Como comentamos en el capítulo anterior, los algoritmos de reducción de dimensionalidad reducen la dimensionalidad de los datos mientras intentan minimizar el error de reconstrucción. En otras palabras, estos algoritmos intentan capturar la información más destacada de las características originales de tal manera que puedan reconstruir el conjunto de características original a partir del conjunto de características reducido lo mejor posible. Sin embargo, estos algoritmos de reducción de dimensionalidad no pueden capturar toda la información de las características originales a medida que se mueven a un espacio dimensional más bajo, por lo tanto, habrá algún error a medida que estos algoritmos reconstruyan el conjunto de características reducidas al número original de dimensiones.

En el contexto de nuestro conjunto de datos de transacciones de tarjetas de crédito, los algoritmos tendrán el mayor error de reconstrucción en aquellas transacciones que son más difíciles de modelar; en otras palabras, aquellas que ocurren con menos frecuencia y son las más anómalas. Dado que el fraude es poco común y presumiblemente diferente a las transacciones normales, las transacciones fraudulentas deben presentar el mayor error de reconstrucción. Así que definamos la puntuación de anomalía como el error de reconstrucción. El error de reconstrucción para cada transacción es la suma de las diferencias al cuadrado entre la matriz de características original y la matriz reconstruida utilizando el algoritmo de reducción de dimensionalidad. Escalaremos la suma de las diferencias al cuadrado por el rango máximo-mínimo de la suma de las diferencias al cuadrado para todo el conjunto de datos, de modo que todos los errores de reconstrucción estén dentro de un rango de cero a uno.

Las transacciones que tengan la mayor suma de diferencias al cuadrado tendrán un error cercano a uno, mientras que aquellas que tengan la menor suma de diferencias al cuadrado tendrán un error cercano a cero.

Esto debería resultarle familiar. Al igual que la solución de detección de fraude supervisada que creamos en el Capítulo 2, el algoritmo de reducción de dimensionalidad asignará efectivamente a cada transacción una puntuación de anomalía entre cero y uno. Cero es normal y uno es anómalo (y lo más probable es que sea fraudulento).


Usando Python, ¿la salida del proyecto por lotes no caerá en el conjunto de datos de características? - Sistemas de Información Geográfica

Ingeniería de funciones automatizada y puntuación de modelos con IBM Watson Studio Local

El objetivo de este patrón de código es demostrar cómo los científicos de datos pueden aprovechar Watson Studio Local de IBM para automatizar:

Extracción periódica de características (utilizadas para entrenar el modelo de aprendizaje automático) de conjuntos de datos distribuidos.

Puntuación por lotes de las características extraídas en el modelo implementado.

Para ilustrar esto, en este patrón de código se utiliza un flujo de trabajo de ciencia de datos de ejemplo que clasifica 3 categorías de vinos diferentes a partir de las propiedades químicas de esos vinos.

Para la extracción de características, el análisis de componentes principales (PCA) se aplica al conjunto de datos de clasificación del vino y se extraen dos componentes principales.

Para el modelo de clasificación, se aplica la regresión logística (un modelo de aprendizaje automático popular) en los componentes extraídos para predecir las categorías de vino.

¿Qué es PCA? El análisis de componentes principales (PCA) es una técnica de reducción de dimensionalidad popular que se utiliza para reducir un número N de variables numéricas en unos pocos componentes principales que se utilizan como características en el modelo de aprendizaje automático. Estos componentes principales capturan un porcentaje importante del efecto de varianza combinado de todas las variables.

¿Qué es IBM Watson Studio Local? Watson Studio Local es una solución local para científicos e ingenieros de datos. Ofrece un conjunto de herramientas de ciencia de datos que se integran con las tecnologías de portátiles RStudio, Spark, Jupyter y Zeppelin.

¿Qué es IBM Watson Machine Learning? Watson Machine Learning es una herramienta de Watson Studio Local que brinda a los usuarios la capacidad de crear y entrenar modelos de aprendizaje automático. Los usuarios también pueden implementar sus modelos para que estén disponibles para una audiencia más amplia.

Este repositorio contiene dos cuadernos de Jupyter que ilustran cómo extraer características y construir un modelo en el conjunto de datos de clasificación de vinos. Los datos contienen una lista de vinos con sus características químicas asociadas y clasificación de vino asignada. Hay tres scripts en el repositorio para automatizar la extracción de características, puntuar las características extraídas y combinar los dos pasos como un contenedor, respectivamente.

El primer portátil utiliza técnicas de ingeniería de funciones como PCA y escalado estándar para extraer las funciones para el desarrollo del modelo de un conjunto de datos de vino.

El segundo cuaderno entrena, construye y guarda un modelo que se puede puntuar. Luego, el modelo se puede implementar y acceder de forma remota.

El primer script es simplemente una réplica del primer cuaderno como el script .py que se puede programar para extraer las funciones periódicamente y guardarlas con los números de versión.

El segundo script se usa para calificar el conjunto de características extraídas en el modelo implementado y guardar los resultados con control de versiones.

El tercer script es simplemente un script contenedor que ejecuta los dos scripts anteriores uno tras otro y se utiliza para automatizar la extracción de características y la puntuación del modelo en una ejecución.

Con la función Watson Machine Learning en Watson Studio, los tres scripts se implementan como un servicio para automatizar la extracción y puntuación de funciones en producción.

Cuando haya completado este patrón de código, comprenderá cómo:

  • Utilice Watson Studio Local y extraiga funciones utilizando PCA y otras técnicas.
  • Cree, entrene y guarde un modelo a partir de las características extraídas utilizando Watson Studio Local.
  • Utilice la función Watson Machine Learning para implementar y acceder a su modelo en modo por lotes y API
  • Automatice la extracción de características y la puntuación del modelo utilizando los scripts que se implementan como un servicio en modo por lotes y API.

  1. El conjunto de datos de clasificación de vinos se carga en Watson Studio Local como un activo.
  2. El usuario interactúa con Watson Studio Local para acceder a activos como cuadernos de Jupyter, scripts de Python y conjuntos de datos.
  3. Los cuadernos de Jupyter usan operaciones Spark DataFrame para limpiar el conjunto de datos y usan Spark MLlib para entrenar un modelo de clasificación de PCA.
  4. El modelo y los scripts que lo acompañan se implementan y ejecutan desde Watson Machine Learning.
    : Una solución local lista para usar para científicos e ingenieros de datos. Ofrece un conjunto de herramientas de ciencia de datos que se integran con las tecnologías de portátiles RStudio, Spark, Jupyter y Zeppelin. : Un sistema de computación en clúster de código abierto, rápido y de propósito general. : Una aplicación web de código abierto que le permite crear y compartir documentos que contienen código en vivo, ecuaciones, visualizaciones y texto explicativo.
    : La inteligencia artificial se puede aplicar a espacios de soluciones dispares para ofrecer tecnologías disruptivas. : Python es un lenguaje de programación que le permite trabajar más rápidamente e integrar sus sistemas de manera más efectiva.

Instalar Watson Studio Local

Watson Studio Local proporciona un conjunto de herramientas de ciencia de datos, como los cuadernos Spark y Jupyter, que se necesitan para completar este patrón de código. Lea la Guía de instalación para instalar y configurar su instancia local de Watson Studio.

Siga estos pasos para configurar el entorno adecuado para ejecutar nuestros portátiles de forma local.

2. Cree un proyecto en IBM Watson Studio Local

En Watson Studio Local, usamos proyectos como contenedor para todos nuestros activos relacionados. Para crear un proyecto:

Una vez creado, puede ver todos los activos del proyecto seleccionando la pestaña Activos en la página de inicio del proyecto.

Para nuestro proyecto, necesitamos agregar nuestros cuadernos y scripts. Para agregar nuestros cuadernos:

Seleccione Notebooks en la lista de Activos del proyecto, luego presione el botón Add Notebook.

Ingrese un nombre de cuaderno único y use la opción Desde URL para cargar el cuaderno desde el repositorio de github.

Seleccione el entorno que se ejecuta en Python v3.1 o superior.

NOTA: Para que sea más fácil seguir las instrucciones restantes, se recomienda que configure Nombre para que coincida con el nombre del cuaderno en el archivo cargado.

  • Haga clic en la pestaña Desde archivo y luego use la opción Arrastrar y soltar para cargar el archivo de script desde su repositorio local. El nombre de la secuencia de comandos se completará previamente con el nombre del archivo cargado. Seleccione Python versión 3.

En la pestaña Archivo local, haga clic en el botón Seleccionar de su sistema de archivos local para seleccionar el archivo /data/Wine.csv de su repositorio local.

4. Ejecute los cuadernos para crear nuestro modelo.

Para ver nuestros cuadernos, seleccione Cuadernos en la lista de Activos del proyecto.

Primero, algunos antecedentes sobre cómo ejecutar un cuaderno:

  • Un espacio en blanco indica que la celda nunca se ha ejecutado.
  • Un número, este número representa el orden relativo en que se ejecutó este paso de código.
  • Un *, que indica que la celda se está ejecutando actualmente.
  • Una celda a la vez.
    • Seleccione la celda y luego presione el botón Reproducir en la barra de herramientas.
    • Desde la barra de menú Celda, hay varias opciones disponibles. Por ejemplo, puede Ejecutar todas las celdas en su cuaderno, o puede Ejecutar todo a continuación, que comenzará a ejecutarse desde la primera celda debajo de la celda actualmente seleccionada, y luego continuará ejecutando todas las celdas siguientes.
    • Presione el botón Programar ubicado en la sección superior derecha del panel de su computadora portátil. Aquí puede programar su cuaderno para que se ejecute una vez en el futuro, o repetidamente en el intervalo especificado.

    Para ejecutar un cuaderno, simplemente haga clic en el nombre del cuaderno de la lista de Cuadernos.

    Ejecute primero el cuaderno pca-features. Lee y transforma el conjunto de datos del vino. También crea archivos de datos que serán requeridos por el próximo cuaderno. Estos archivos de datos csv se pueden ver seleccionando Conjuntos de datos en la lista de Activos del proyecto.

    Ejecute el cuaderno de modelado pca, que genera y guarda nuestro modelo de datos.

    Una vez creado el modelo, puede verlo seleccionando Modelos en la lista de Activos del proyecto. Tenga en cuenta que se le asigna un número de versión predeterminado.

    Nota: Después de ejecutar los cuadernos, es posible que se pregunte por qué no combinamos todo el código en un solo cuaderno. La razón es simplemente separar los pasos de procesamiento de datos de los pasos de creación del modelo. Esto nos permite procesar cualquier dato nuevo en el futuro sin afectar nuestro modelo actual. De hecho, esto es exactamente lo que se debe hacer con cualquier dato nuevo: primero califíquelo con el modelo actual para determinar si los resultados aún son aceptables. Si no es así, podemos ejecutar el segundo cuaderno para generar un nuevo modelo.

    Como verá más adelante, la ejecución del primer cuaderno se realizará ejecutando un script en nuestro proyecto (scripts / feature_engineering.py). Este script se creó inicialmente cargando el cuaderno pca-features en Jupyter, luego exportando las celdas del cuaderno a un script de Python (use las opciones de menú Archivo - & gt Descargar como - & gt Python (.py)). Solo tuvimos que modificar ligeramente el script para incluir algo de código para manejar el control de versiones de datos.

    5. Confirmar cambios en el repositorio principal local de Watson Studio

    Después de realizar cambios en su proyecto, se le recordará ocasionalmente que confirme y envíe sus cambios al repositorio principal local de Watson Studio.

    Ahora que hemos agregado nuestros cuadernos y scripts, y generado nuestro modelo, sigamos adelante y hagamos eso. Confirme e impulse todos nuestros nuevos activos y configure la etiqueta de versión en v1.0.

    6. Cree un proyecto de lanzamiento en IBM Watson Machine Learning

    IBM Watson Machine Learning proporciona el mecanismo para implementar nuestro modelo como un servicio web. Gestiona los lanzamientos de proyectos, que ahora crearemos.

    • Inicie la herramienta IBM Watson Machine Learning seleccionándola en el menú desplegable principal de la página de inicio de Watson Studio Local.

    • Seleccione nuestro proyecto previamente comprometido de la lista desplegable Proyecto de origen y seleccione la etiqueta de versión que asignó al proyecto. Dale al lanzamiento un Nombre y una Ruta (que puede ser cualquier cadena aleatoria), y presiona Crear.

    7. Implementar nuestro modelo como servicio web

    • Seleccione el modelo de la lista de Activos asociados a nuestro proyecto. Desde el panel de detalles del modelo, presione el botón de servicio web.

    • En la pantalla de implementación del modelo, proporcione un nombre único, reserve algunas CPU y memoria, luego presione Crear.

    8. Implementar nuestros scripts como trabajo

    • En la pantalla de implementación de la secuencia de comandos, proporcione un nombre de trabajo, establezca el tipo en Ejecución de secuencia de comandos, agregue v1 como un argumento de línea de comando y luego presione Crear.

    Repita estos pasos para los 2 scripts restantes.

    9. Ponga las implementaciones en línea

    Si selecciona la pestaña Implementaciones de la página del proyecto, notará que todas las implementaciones se enumeran como deshabilitadas.

    Para poner las implementaciones en línea, presione el ícono del botón Iniciar, que es el ícono más a la izquierda que se encuentra en la parte superior de la página. Una vez que complete la acción, debería ver lo siguiente.

    Nota: es posible que deba habilitar manualmente la implementación del modelo mediante las opciones de menú que se enumeran en el lado derecho de la fila del modelo en la tabla de implementaciones.

    10. Recopile datos de puntos finales de API para usarlos en scripts

    Algunos de nuestros scripts necesitarán acceso a nuestro modelo implementado y, en algunos casos, a los otros scripts implementados.

    Aquí hay una descripción general rápida de lo que hacen y requieren nuestros scripts:

    feature_engineering.py - este script realiza la misma función que nuestro cuaderno pca-features. Lee los datos del conjunto de datos del vino y luego aplica técnicas de aprendizaje automático para transformar los datos. La salida serán dos archivos de datos: características y destino. Tenga en cuenta que estos archivos de datos tendrán una etiqueta de versión adjunta para que su contenido no se sobrescriba cada vez que se ejecute este script. Este script no requiere acceso a nuestro modelo u otros scripts.

    model_scoring.py - este script es un procesador por lotes. Lee el archivo de datos de características y puntúa cada característica, una a la vez, ejecutándolas a través de nuestro modelo. La salida será un archivo de datos scoring_output. Tenga en cuenta que el archivo de datos tendrá una etiqueta de versión adjunta para que su contenido no se sobrescriba cada vez que se ejecuta este script. Este script requiere acceso a nuestro modelo implementado.

    extract_and_score.py - esta secuencia de comandos se creó por conveniencia y se puede utilizar en lugar de ejecutar las secuencias de comandos anteriores por separado. Primero invoca la secuencia de comandos feature_engineering, luego, cuando se completa, invoca la secuencia de comandos model_scoring. Este script requiere acceso a los otros scripts implementados.

    Para acceder al modelo o scripts implementados, necesitamos recopilar los puntos finales de API asociados y un token de autorización. Todos estos valores están disponibles en las páginas de implementación para cada uno de los objetos. Los puntos finales adoptarán el siguiente formato:

    • los puntos finales del modelo terminarán en / score.
    • los puntos finales del script terminarán en / trigger, / status o / cancel (que corresponde a las acciones: inicio, estado y parada).

    Para obtener el punto final de nuestro modelo implementado, haga clic en el modelo en la pestaña Activos de la página del proyecto.

    El punto final aparece en la parte superior de la página. Tanto el punto final como el token de implementación se pueden guardar en el portapapeles haciendo clic en sus respectivos iconos.

    Repita este paso para recuperar los puntos finales de los scripts feature_engineering y model_scoring.

    Nota: solo necesitará obtener una copia del token de implementación. Será igual para todas las implementaciones dentro de este proyecto.

    11. Modifique los scripts en Watson Studio Local.

    Una vez que hayamos reunido nuestros puntos finales de implementación y el token de implementación, debemos volver al modo local de Watson Studio para poder modificar y probar nuestros scripts.

    Vaya a la lista Activos del proyecto y seleccione Scripts. Haga clic en un archivo de secuencia de comandos para abrirlo en modo de edición.

    Los scripts que modificaremos son aquellos que hacen referencia a objetos de implementación. Estos son:

    • Para la secuencia de comandos model_scoring, sustituya los valores de token y punto final, luego guarde la nueva versión de la secuencia de comandos.

    Para el script extract_and_score, sustituya los valores del token y del punto final. Los valores de punto final son para los scripts de implementación feature_engineering y model_scoring.

    Importante: los puntos finales terminarán con la cadena / activador. Elimine esa parte de la URL, ya que el script agregará / trigger o / status a los puntos finales, según sea necesario.

    Para terminar, guarde la nueva versión del script haciendo clic en el icono Guardar ubicado en la parte superior derecha de la página.

    12. Ejecute scripts localmente para probar

    Para evitar tener que ir y venir entre Watson Studio Local y Watson Machine Learning (que incluye volver a implementar y crear nuevas versiones de lanzamiento), asegúrese de que los scripts se ejecuten localmente en Watson Studio Local primero.

    Las secuencias de comandos se pueden ejecutar desde el panel de detalles de la secuencia de comandos o desde el editor de secuencias de comandos.

    Ejecutar como trabajo desde el panel de detalles del script:

    Comience con el script feature_engineering. Utilice la barra de menú en el lado derecho de la fila de la secuencia de comandos para Crear trabajo y ejecutar la secuencia de comandos.

    En el panel de ejecución Crear trabajo, proporcione un nombre exclusivo y asegúrese de utilizar las siguientes opciones:

    • Tipo: ejecución de secuencia de comandos
    • Trabajador: Python 3
    • Activo fuente: /scripts/feature_engineering.py
    • Argumentos de la línea de comando: v1
    • Programado para ejecutarse: a pedido

    Después de presionar el botón Crear, verá el panel de ejecución.

    Si se desplaza un poco hacia abajo, verá un botón Ejecutar ahora. Haga clic en él para iniciar la secuencia de comandos. Nuevamente, se le presentará un cuadro de diálogo que requiere que le dé un nombre de ejecución. El resto de los valores se establecerán de forma predeterminada en los valores que ya estableció, por lo que no es necesario modificarlos. Haga clic en el botón Ejecutar para ejecutar el script.

    Será transferido de nuevo al panel de ejecución, donde podrá ver el estado (que aparece en Duración) y una cola del archivo de registro. Una vez que se haya completado correctamente, debería ver 2 archivos nuevos enumerados en Conjuntos de datos en la lista de Activos.

    NOTA: Los archivos de datos creados (destino y funciones) tendrán una etiqueta de versión adjunta a su nombre. Esto coincide con el argumento de la línea de comandos que pasamos al script.

    Ejecutar de forma interactiva desde el editor de secuencias de comandos

    • desde la página del proyecto, haga clic en Scripts en la lista de Activos, luego haga clic en el script feature_engineering en la lista. Esto abrirá el editor de secuencias de comandos.

    Haga clic en el botón Ejecutar configuración en la barra de herramientas y luego agregue v1 como argumento de línea de comando.

    Arrastre el icono de tamaño ubicado en el lado derecho del panel para abrir el registro de la consola. Luego inicie el script haciendo clic en el botón Ejecutar - & gt Ejecutar como trabajo en la barra de herramientas.

    La secuencia de comandos comenzará a ejecutarse y mostrará la salida en el registro de la consola.

    Con cualquiera de los métodos, repita este proceso para ejecutar el script model_scoring y luego el script extract_and_score.

    NOTA: La secuencia de comandos extract_and_score fallará cuando intente verificar el estado de la secuencia de comandos model_scoring. Recuerde, invoca los otros scripts llamando a sus puntos finales que están implementados en Watson Machine Learning. El problema es que esos scripts implementados aún no tienen la información de punto final actualizada y no la tendrán hasta que enviemos nuestros cambios al modelo de lanzamiento de Watson Machine Learning (lo que haremos a continuación).

    Una vez que haya verificado los scripts, confirme y envíe los cambios al repositorio principal de Watson Studio, como se describe anteriormente en el paso 5. Asegúrese de marcar el número de versión.

    13. Gestione su modelo con IBM Watson Machine Learning

    Inicie IBM Watson Machine Learning seleccionándolo en el menú desplegable principal de la página de inicio de Watson Studio Local.

    Primero, debemos actualizar nuestro proyecto de lanzamiento para obtener todas las últimas versiones de nuestros scripts.

    Desde la página de inicio de Watson Machine Learning, haga clic en el mosaico de nuestro proyecto.

    De la fila de íconos enumerados en el banner de la página, haga clic en el ícono Actualizar.

    Desde la pantalla de actualización, use el menú desplegable Proyecto de origen para seleccionar nuestro proyecto Watson Studio Local. Luego, seleccione la etiqueta de versión asociada con nuestra última confirmación.

    Ahora que todos nuestros activos están actualizados, podemos administrar nuestro modelo mediante el seguimiento de su uso y rendimiento.

    Para empezar a rodar, comencemos ejecutando nuestro script extract_and_score. Como se explicó anteriormente, esto se leerá en el archivo csv de vino actual y lo transformará, luego calificará cada vino contra nuestro modelo.

    • En la página Activo, seleccione el script extract_and_score. Desde la página de detalles, haga clic en el nombre del script para abrir la página de inicio del script. Luego haga clic en la pestaña API.

    Tenga en cuenta que el valor de los argumentos de la línea de comandos se establece en v1. Puede configurarlo como desee, pero se agregará a los nombres de archivo generados por este script. Así es como se evita anular los datos de ejecuciones anteriores de este script.

    Para ejecutar el script, haga clic en la pestaña Descripción general y desplácese hacia abajo hasta la sección Ejecuciones de la página. Luego haga clic en el botón Ejecutar ahora.

    Desde el diálogo de inicio, ingrese un nombre, modifique el argumento de la línea de comando si es necesario, luego haga clic en el botón Ejecutar.

    Puede ver el estado del trabajo desde el mismo panel. Para ver el archivo de registro asociado, haga clic en la opción de menú Ver registros ubicada en el lado derecho de la fila del trabajo.

    Desde el panel principal, también puede ver que la secuencia de comandos se completó correctamente y también observar que, en el caso de la secuencia de comandos de extracción y puntuación, se iniciaron tres trabajos separados (la secuencia de comandos principal y las dos secuencias de comandos invocadas).

    Si la secuencia de comandos se completa con éxito, debe haber tres archivos de datos con versiones que se deben agregar como activos de conjuntos de datos en el proyecto. El archivo scoring_output-v1 contiene las puntuaciones finales de clasificación de vinos.

    Aquí hay enlaces a cada uno de los cuadernos con salida de ejemplo:

    • Patrones de código de análisis de datos: ¿Disfrutaste de este patrón de código? Consulte nuestros otros patrones de código de análisis de datos
    • Lista de reproducción de patrones de código de datos e IA: Marque nuestra lista de reproducción con todos nuestros videos de patrones de código
    • Estudio Watson: Domine el arte de la ciencia de datos con Watson Studio de IBM
    • Spark en IBM Cloud: ¿Necesita un clúster Spark? Cree hasta 30 ejecutores Spark en IBM Cloud con nuestro servicio Spark

    Este patrón de código tiene la licencia de Apache Software License, Versión 2. Los objetos de código de terceros independientes invocados dentro de este patrón de código tienen licencia de sus respectivos proveedores de conformidad con sus propias licencias independientes. Las contribuciones están sujetas al Certificado de origen de desarrollador, versión 1.1 (DCO) y la licencia de software Apache, versión 2.


    ImageDataGenerator de Keras y aumento de datos

    2020-06-04 Actualización: ¡Esta publicación de blog ahora es compatible con TensorFlow 2+!

    Comenzaremos este tutorial con una discusión sobre el aumento de datos y por qué lo usamos.

    Luego, cubriré los tres tipos de aumento de datos que verá al entrenar redes neuronales profundas:

    1. Generación de conjuntos de datos y expansión de datos a través del aumento de datos (menos común)
    2. Aumento de datos in situ / sobre la marcha (más común)
    3. Combinando la generación de conjuntos de datos y el aumento in situ

    A partir de ahí, le enseñaré cómo aplicar el aumento de datos a sus propios conjuntos de datos (usando los tres métodos) usando la clase ImageDataGenerator de Keras.

    ¿Qué es el aumento de datos?

    El aumento de datos abarca una amplia gama de técnicas utilizadas para generar "nuevas" muestras de entrenamiento a partir de las originales aplicando fluctuaciones y perturbaciones aleatorias (pero al mismo tiempo asegurando que las etiquetas de clase de los datos no se modifiquen).

    Nuestro objetivo al aplicar el aumento de datos es aumentar la generalización del modelo.

    Dado que nuestra red ve constantemente versiones nuevas y ligeramente modificadas de los datos de entrada, la red puede aprender características más sólidas.

    En el momento de la prueba, no aplicamos el aumento de datos y simplemente evaluamos nuestra red capacitada en los datos de prueba no modificados & # 8212 en la mayoría de los casos, verá un aumento en la precisión de las pruebas, quizás a expensas de una ligera caída en la precisión del entrenamiento.

    Un ejemplo simple de aumento de datos

    Figura 2: Izquierda: Una muestra de 250 puntos de datos que siguen exactamente una distribución normal. Derecha: Añadiendo una pequeña cantidad de "jitter" aleatorio a la distribución. Este tipo de aumento de datos aumenta la generalización de nuestras redes.

    Consideremos Figura 2 (izquierda) de una distribución normal con media cero y varianza unitaria.

    El entrenamiento de un modelo de aprendizaje automático con estos datos puede resultar en que modelemos la distribución exactamente & # 8212 sin embargo, en aplicaciones del mundo real, los datos rara vez siguen una distribución tan agradable y ordenada.

    En cambio, para aumentar la generalización de nuestro clasificador, primero podemos alterar aleatoriamente los puntos a lo largo de la distribución agregando algunos valores aleatorios extraído de una distribución aleatoria (derecho).

    Nuestra trama todavía sigue un aproximadamente distribución normal, pero no es una Perfecto distribución como a la izquierda.

    Es más probable que un modelo entrenado en estos datos aumentados modificados se generalice a puntos de datos de ejemplo no incluidos en el conjunto de entrenamiento.

    Visión por computadora y aumento de datos

    Figura 3: En visión artificial, el aumento de datos realiza manipulaciones aleatorias en imágenes. Por lo general, se aplica en tres escenarios discutidos en esta publicación de blog.

    En el contexto de la visión por computadora, el aumento de datos se presta naturalmente.

    Por ejemplo, podemos obtener datos aumentados de las imágenes originales aplicando transformaciones geométricas simples, como aleatoria:

    1. Traducciones
    2. Rotaciones
    3. Cambios de escala
    4. Cizallamiento
    5. Volteretas horizontales (y en algunos casos, verticales)

    La aplicación de una (pequeña) cantidad de transformaciones a una imagen de entrada cambiará ligeramente su apariencia, pero no es cambie la etiqueta de la clase & # 8212, lo que hace que el aumento de datos sea un método muy natural y fácil de aplicar para tareas de visión por computadora.

    Tres tipos de aumento de datos

    Hay tres tipos de aumento de datos que probablemente encontrará al aplicar el aprendizaje profundo en el contexto de las aplicaciones de visión por computadora.

    Exactamente qué definición de aumento de datos es "correcta" es totalmente dependiente en el contexto de su proyecto / conjunto de experimentos.

    Tómese el tiempo para leer esta sección con cuidado as I see many deep learning practitioners confuse what data augmentation does and does not do.

    Type #1: Dataset generation and expanding an existing dataset (less common)

    Figure 4: Type #1 of data augmentation consists of dataset generation/dataset expansion. This is a less common form of data augmentation.

    The first type of data augmentation is what I call dataset generation o dataset expansion.

    As you know machine learning models, and especially neural networks, can require quite a bit of training data — but what if you don’t have very much training data in the first place?

    Let’s examine the most trivial case where you only have one image and you want to apply data augmentation to create an entire dataset of images, all based on that one image.

    To accomplish this task, you would:

    1. Load the original input image from disk.
    2. Randomly transform the original image via a series of random translations, rotations, etc.
    3. Take the transformed image and write it back out to disk.
    4. Repeat steps 2 and 3 a total of N times.

    After performing this process you would have a directory full of randomly transformed “new” images that you could use for training, all based on that single input image.

    This is, of course, an incredibly simplified example.

    You more than likely have more than a single image — you probably have 10s or 100s of images and now your goal is to turn that smaller set into 1000s of images for training.

    In those situations, dataset expansion and dataset generation may be worth exploring.

    But there’s a problem with this approach — we haven’t exactly increased the ability of our model to generalize.

    Yes, we have increased our training data by generating additional examples, but all of these examples are based on a super small dataset.

    Keep in mind that our neural network is only as good as the data it was trained on.

    We cannot expect to train a NN on a small amount of data and then expect it to generalize to data it was never trained on and has never seen before.

    If you find yourself seriously considering dataset generation and dataset expansion, you should take a step back and instead invest your time gathering additional data or looking into methods of behavioral cloning (and then applying the type of data augmentation covered in the “Combining dataset generation and in-place augmentation” section below).

    Type #2: In-place/on-the-fly data augmentation (most common)

    Figure 5: Type #2 of data augmentation consists of on-the-fly image batch manipulations. This is the most common form of data augmentation with Keras.

    The second type of data augmentation is called in-place data augmentation o on-the-fly data augmentation. This type of data augmentation is what Keras’ ImageDataGenerator class implements.

    Using this type of data augmentation we want to ensure that our network, when trained, sees new variations of our data at each and every epoch.

    Figure 5 demonstrates the process of applying in-place data augmentation:

    1. Step #1: An input batch of images is presented to the ImageDataGenerator .
    2. Step #2: The ImageDataGenerator transforms each image in the batch by a series of random translations, rotations, etc.
    3. Step #3: The randomly transformed batch is then returned to the calling function.

    There are two important points that I want to draw your attention to:

    1. The ImageDataGenerator is no returning both the original data and the transformed data — the class only returns the randomly transformed data.
    2. We call this “in-place” and “on-the-fly” data augmentation because this augmentation is done at training time (i.e., we are not generating these examples ahead of time/prior to training).

    When our model is being trained, we can think of our ImageDataGenerator class as “intercepting” the original data, randomly transforming it, and then returning it to the neural network for training, all the while the NN has no idea the data was modified!

    I’ve written previous tutorials on the PyImageSearch blog where readers think that Keras’ ImageDateGenerator class is an “additive operation”, similar to the following (incorrect) figure:

    Figure 6: How Keras data augmentation does no work.

    In the above illustration the ImageDataGenerator accepts an input batch of images, randomly transforms the batch, and then returns both the original batch and modified data — again, this is no what the Keras ImageDataGenerator does. Instead, the ImageDataGenerator class will return just the randomly transformed data.

    When I explain this concept to readers the next question is often:

    But Adrian, what about the original training data? Why is it not used? Isn’t the original training data still useful for training?

    Keep in mind that the entire point of the data augmentation technique described in this section is to ensure that the network sees “new” images that it has never “seen” before at each and every epoch.

    If we included the original training data along with the augmented data in each batch, then the network would “see” the original training data multiple times, effectively defeating the purpose. Secondly, recall that the overall goal of data augmentation is to increase the generalizability of the model.

    To accomplish this goal we “replace” the training data with randomly transformed, augmented data.

    In practice, this leads to a model that performs better on our validation/testing data but perhaps performs slightly worse on our training data (to due to the variations in data caused by the random transforms).

    You’ll learn how to use the Keras ImageDataGenerator class later in this tutorial.

    Type #3: Combining dataset generation and in-place augmentation

    The final type of data augmentation seeks to combine both dataset generation and in-place augmentation — you may see this type of data augmentation when performing behavioral cloning.

    A great example of behavioral cloning can be seen in self-driving car applications.

    Creating self-driving car datasets can be extremely time consuming and expensive — a way around the issue is to instead use video games and car driving simulators.

    Video game graphics have become so life-like that it’s now possible to use them as training data.

    Therefore, instead of driving an actual vehicle, you can instead:

    • Play a video game
    • Write a program to play a video game
    • Use the underlying rendering engine of the video game

    …all to generate actual data that can be used for training.

    Once you have your training data you can go back and apply Type #2 data augmentation (i.e., in-place/on-the-fly data augmentation) to the data you gathered via your simulation.

    Configuring your development environment

    To configure your system for this tutorial, I first recommend following either of these tutorials:

    Either tutorial will help you configure you system with all the necessary software for this blog post in a convenient Python virtual environment.

    Project structure

    Before we dive into the code let’s first review our directory structure for the project:

    First, there are two dataset directories which are not to be confused:

    • dogs_vs_cats_small/ : A subset of the popular Kaggle Dogs vs. Cats competition dataset. In my curated subset, only 2,000 images (1,000 per class) are present (as opposed to the 25,000 images for the challenge).
    • generated_dataset/ : We’ll create this generated dataset using the cat.jpg and dog.jpg images which are in the parent directory. We’ll utilize data augmentation Type #1 to generate this dataset automatically and fill this directory with images.

    Next, we have our pyimagesearch module which contains our implementation of the ResNet CNN classifier.

    Today, we’ll review two Python scripts:

    • train.py : Used to train models for both Type #1 y Type #2 (and optionally Type #3 if the user so wishes) data augmentation techniques. We’ll perform three training experiments resulting in each of the three plot*.png files in the project folder.
    • generate_images.py : Used to generate a dataset from a single image using Type #1.

    Implementing our training script

    In the remainder of this tutorial we’ll be performing three experiments:

    1. Experiment #1: Generate a dataset via dataset expansion and train a CNN on it.
    2. Experiment #2: Use a subset of the Kaggle Dogs vs. Cats dataset and train a CNN sin data augmentation.
    3. Experiment #3: Repeat the second experiment, but this time con data augmentation.

    All of these experiments will be accomplished using the same Python script.

    Open up the train.py script and let’s get started:

    On Lines 2-18 our necessary packages are imported. Line 10 is our ImageDataGenerator import from the Keras library — a class for data augmentation.

    Our script accepts three command line arguments via the terminal:

    • --dataset : The path to the input dataset.
    • --augment : Whether “on-the-fly” data augmentation should be used (refer to type #2 above). By default, this method is no performed.
    • --plot : The path to the output training history plot.

    Let’s proceed to initialize hyperparameters and load our image data:

    Training hyperparameters, including initial learning rate, batch size, and number of epochs to train for, are initialized on Lines 32-34.

    From there Lines 39-53 grab imagePaths , load images, and populate our data and labels lists. The only image preprocessing we perform at this point is to resize each image to 64吼px.

    Next, let’s finish preprocessing, encode our labels, and partition our data:

    On Line 57, we convert data to a NumPy array as well as scale all pixel intensities to the range [0, 1]. This completes our preprocessing.

    From there we perform “one-hot encoding” of our labels (Lines 61-63). This method of encoding our labels results in an array that may look like this:

    For this sample of data, there are two cats ( [1., 0.] ) and five dogs ( [0., 1] ) where the label corresponding to the image is marked as “hot”.

    From there we partition our data into training and testing splits marking 75% of our data for training and the remaining 25% for testing (Lines 67 and 68).

    Now, we are ready to initialize our data augmentation object:

    Line 71 initializes our empty data augmentation object (i.e., no augmentation will be performed). This is the default operation of this script.

    Let’s check if we’re going to override the default with the --augment command line argument:

    Line 75 checks to see if we are performing data augmentation. If so, we re-initialize the data augmentation object with random transformation parameters (Lines 77-84). As the parameters indicate, random rotations, zooms, shifts, shears, and flips will be performed during in-place/on-the-fly data augmentation.

    Let’s compile and train our model:

    2020-06-04 Update: Formerly, TensorFlow/Keras required use of a method called .fit_generator in order to accomplish data augmentation. Now, the .fit method can handle data augmentation as well, making for more-consistent code. This also applies to the migration from .predict_generator to .predict . Be sure to check out my other article fit and fit_generator after you’re done reading this tutorial.

    Lines 88-92 construct our ResNet model using Stochastic Gradient Descent optimization and learning rate decay. We use "binary_crossentropy" loss for this 2-class problem. If you have more than two classes, be sure to use "categorial_crossentropy" .

    Lines 96-100 then train our model. The aug object handles data augmentation in batches (although be sure to recall that the aug object will only perform data augmentation if the --augment command line argument was set).

    Finally, we’ll evaluate our model, print statistics, and generate a training history plot:

    2020-06-04 Update: In order for this plotting snippet to be TensorFlow 2+ compatible the H.history dictionary keys are updated to fully spell out “accuracy” sans “acc” (i.e., H.history["val_accuracy"] and H.history["accuracy"] ). It is semi-confusing that “val” is not spelled out as “validation” we have to learn to love and live with the API and always remember that it is a work in progress that many developers around the world contribute to.

    Line 104 makes predictions on the test set for evaluation purposes. A classification report is printed via Lines 105 and 106.

    From there, Lines 109-120 generate and save an accuracy/loss training plot.

    Generating a dataset/dataset expansion with data augmentation and Keras

    In our first experiment, we will perform dataset expansion via data augmentation with Keras.

    Our dataset will contain 2 classes and initially, the dataset will trivially contain only 1 image per class:

    We’ll utilize Type #1 data augmentation (see the “Type #1: Dataset generation and expanding an existing dataset” section above) to generate a new dataset with 100 images per class:

    Again, this meant to be an example — in a real-world application you would have 100s of example images, but we’re keeping it simple here so you can learn the concept.

    Generating the example dataset

    Before we can train our CNN we first need to generate an example dataset.

    From our “Project Structure” section above you know that we have two example images in our root directory: cat.jpg and dog.jpg . We will use these example images to generate 100 new training images per class (200 images in total).

    To see how we can use data augmentation to generate new examples, open up the generate_images.py file and follow along:

    Lines 2-6 import our necessary packages. Our ImageDataGenerator is imported on Line 2 and will handle our data augmentation with Keras.

    From there, we’ll parse three command line arguments:

    • --image : The path to the input image. We’ll generate additional random, mutated versions of this image.
    • --output : The path to the output directory to store the data augmentation examples.
    • --total : The number of sample images to generate.

    Let’s go ahead and load our image and initialize our data augmentation object:

    Our image is loaded and prepared for data augmentation via Lines 21-23. Image loading and processing is handled via Keras functionality (i.e. we aren’t using OpenCV).

    From there, we initialize the ImageDataGenerator object. This object will facilitate performing random rotations, zooms, shifts, shears, and flips on our input image.

    Next, we’ll construct a Python generator and put it to work until all of our images have been produced:

    We will use the imageGen to randomly transform the input image (Lines 39 and 40). This generator saves images as .jpg files to the specified output directory contained within args["output"] .

    Finally, we’ll loop over examples from our image data generator and count them until we’ve reached the required total number of images.

    To run the generate_examples.py script make sure you have used the “Downloads” section of the tutorial to download the source code and example images.

    From there open up a terminal and execute the following command:

    Check the output of the generated_dataset/cats directory you will now see 100 images:

    Let’s do the same now for the “dogs” class:

    And now check for the dog images:

    A visualization of the dataset generation via data augmentation can be seen in Figure 6 at the top of this section — notice how we have accepted a single input image (of me — not of a dog or cat) and then created 100 new training examples (48 of which are visualized) from that single image.

    Experiment #1: Dataset generation results

    We are now ready to perform our first experiment:

    Figure 8: Data augmentation with Keras Experiment #1 training accuracy/loss results.

    Our results show that we were able to obtain 100% accuracy with little effort.

    Of course, this is a trivial, contrived example. In practice, you would not be taking only a single image and then building a dataset of 100s or 1000s of images via data augmentation. Instead, you would have a dataset of 100s of images and then you would apply dataset generation to that dataset — but again, the point of this section was to demonstrate on a simple example so you could understand the process.

    Training a network with in-place data augmentation

    The more popular form of (image-based) data augmentation is called in-place data augmentation (see the “Type #2: In-place/on-the-fly data augmentation” section of this post for more details).

    When performing in-place augmentation our Keras ImageDataGenerator will:

    1. Accept a batch of input images.
    2. Randomly transform the input batch.
    3. Return the transformed batch to the network for training.

    We’ll explore how data augmentation can reduce overfitting and increase the ability of our model to generalize via two experiments.

    To accomplish this task we’ll be using a subset of the Kaggle Dogs vs. Cats dataset:

    We’ll then train a variation of ResNet, from scratch, on this dataset with and without data augmentation.

    Experiment #2: Obtaining a baseline (no data augmentation)

    In our first experiment we’ll perform no data augmentation:

    Looking at the raw classification report you’ll see that we’re obtaining 64% accuracybut there’s a problem!

    Take a look at the plot associated with our training:

    Figure 9: Para Experiment #2 we did not perform data augmentation. The result is a plot with strong indications of overfitting.

    There is dramatic overfitting occurring — at approximately epoch 15 we see our validation loss start to rise while training loss continues to fall. By epoch 20 the rise in validation loss is especially pronounced.

    This type of behavior is indicative of overfitting.

    The solution is to (1) reduce model capacity, and/or (2) perform regularization.

    Experiment #3: Improving our results (with data augmentation)

    Let’s now investigate how data augmentation can act as a form of regularization:

    We’re now up to 69% accuracy, an increase from our previous 64% accuracy.

    But more importantly, we are no longer overfitting:

    Figure 10: Para Experiment #3, we performed data augmentation with Keras on batches of images in-place. Our training plot shows no signs of overfitting with this form of regularization.

    Note how validation and training loss are falling together with little divergence. Similarly, classification accuracy for both the training and validation splits are growing together as well.

    By using data augmentation we were able to combat overfitting!

    In nearly all situations, unless you have very good reason not to, you should be performing data augmentation when training your own neural networks.

    What's next? I recommend PyImageSearch University.

    I strongly believe that if you had the right teacher you could master computer vision and deep learning.

    Do you think learning computer vision and deep learning has to be time-consuming, overwhelming, and complicated? Or has to involve complex mathematics and equations? Or requires a degree in computer science?

    All you need to master computer vision and deep learning is for someone to explain things to you in simple, intuitive terms. And that’s exactly what I do. My mission is to change education and how complex Artificial Intelligence topics are taught.

    If you're serious about learning computer vision, your next stop should be PyImageSearch University, the most comprehensive computer vision, deep learning, and OpenCV course online today. Here you’ll learn how to successfully y confidently apply computer vision to your work, research, and projects. Join me in computer vision mastery.

    Inside PyImageSearch University you'll find:

    • &check 23 courses on essential computer vision, deep learning, and OpenCV topics
    • &check 23 Certificates of Completion
    • &check 35h 14m on-demand video
    • &check Brand new courses released every month, ensuring you can keep up with state-of-the-art techniques
    • &check Pre-configured Jupyter Notebooks in Google Colab
    • &check Run all code examples in your web browser — works on Windows, macOS, and Linux (no dev environment configuration required!)
    • &check Access to centralized code repos for all 400+ tutorials on PyImageSearch
    • &check Easy one-click downloads for code, datasets, pre-trained models, etc.
    • &check Access on mobile, laptop, desktop, etc.

    How to Use a Learned Embedding for Categorical Data

    A learned embedding, or simply an “embedding,” is a distributed representation for categorical data.

    Each category is mapped to a distinct vector, and the properties of the vector are adapted or learned while training a neural network. The vector space provides a projection of the categories, allowing those categories that are close or related to cluster together naturally.

    This provides both the benefits of an ordinal relationship by allowing any such relationships to be learned from data, and a one hot encoding in providing a vector representation for each category. Unlike one hot encoding, the input vectors are not sparse (do not have lots of zeros). The downside is that it requires learning as part of the model and the creation of many more input variables (columns).

    The technique was originally developed to provide a distributed representation for words, e.g. allowing similar words to have similar vector representations. As such, the technique is often referred to as a word embedding, and in the case of text data, algorithms have been developed to learn a representation independent of a neural network. For more on this topic, see the post:

    An additional benefit of using an embedding is that the learned vectors that each category is mapped to can be fit in a model that has modest skill, but the vectors can be extracted and used generally as input for the category on a range of different models and applications. That is, they can be learned and reused.

    Embeddings can be used in Keras via the Embedding layer.

    For an example of learning word embeddings for text data in Keras, see the post:

    One embedding layer is required for each categorical variable, and the embedding expects the categories to be ordinal encoded, although no relationship between the categories is assumed.

    Each embedding also requires the number of dimensions to use for the distributed representation (vector space). It is common in natural language applications to use 50, 100, or 300 dimensions. For our small example, we will fix the number of dimensions at 10, but this is arbitrary you should experimenter with other values.

    First, we can prepare the input data using an ordinal encoding.

    The model we will develop will have one separate embedding for each input variable. Therefore, the model will take nine different input datasets. As such, we will split the input variables and ordinal encode (integer encoding) each separately using the LabelEncoder and return a list of separate prepared train and test input datasets.

    La prepare_inputs() function below implements this, enumerating over each input variable, integer encoding each correctly using best practices, and returning lists of encoded train and test variables (or one-variable datasets) that can be used as input for our model later.

    Now we can construct the model.

    We must construct the model differently in this case because we will have nine input layers, with nine embeddings the outputs of which (the nine different 10-element vectors) need to be concatenated into one long vector before being passed as input to the dense layers.

    We can achieve this using the functional Keras API. If you are new to the Keras functional API, see the post:

    First, we can enumerate each variable and construct an input layer and connect it to an embedding layer, and store both layers in lists. We need a reference to all of the input layers when defining the model, and we need a reference to each embedding layer to concentrate them with a merge layer.

    We can then merge all of the embedding layers, define the hidden layer and output layer, then define the model.

    When using a model with multiple inputs, we will need to specify a list that has one dataset for each input, e.g. a list of nine arrays each with one column in the case of our dataset. Thankfully, this is the format we returned from our prepare_inputs() function.

    Therefore, fitting and evaluating the model looks like it does in the previous section.

    Additionally, we will plot the model by calling the plot_model() function and save it to file. This requires that pygraphviz and pydot are installed, which can be a pain on some systems. If you have trouble, just comment out the import statement and call to plot_model().

    Tying this all together, the complete example of using a separate embedding for each categorical input variable in a multi-input layer model is listed below.

    Running the example prepares the data as described above, fits the model, and reports the performance.

    Note: Your results may vary given the stochastic nature of the algorithm or evaluation procedure, or differences in numerical precision. Consider running the example a few times and compare the average outcome.

    In this case, the model performs reasonably well, matching what we saw for the one hot encoding in the previous section.

    As the learned vectors were trained in a skilled model, it is possible to save them and use them as a general representation for these variables in other models that operate on the same data. A useful and compelling reason to explore this encoding.

    To confirm our understanding of the model, a plot is created and saved to the file embeddings.png in the current working directory.

    The plot shows the nine inputs each mapped to a 10 element vector, meaning that the actual input to the model is a 90 element vector.

    Note: Click to the image to see the large version.

    Plot of the Model Architecture With Separate Inputs and Embeddings for each Categorical Variable
    Click to Enlarge.


    X_train, y_train = train_generator.next() X_test, y_test = validation_generator.next()

    X_train, y_train = next(train_generator) X_test, y_test = next(validation_generator)

    As per the above answer, the below code just gives 1 batch of data.

    To extract full data from the train_generator use below code -

    y_train, y_test values will be based on the category folders you have in train_data_dir. Not values will be like 0,1,2,3. mapping to class names in Alphabetical Order.

    Otherwise, use below code to get indices map

    Make sure they both are the same.

    More of an indirect answer, but maybe helpful to some: Here is a script I use to sort test and train images into the respective (sub) folders to work with Keras and the data generator function (MS Windows).


    Resumen

    In this tutorial, you learned how to use the Keras deep learning library for regression.

    Specifically, we used Keras and regression to predict the price of houses based on four numerical and categorical attributes:

    • Number of bedrooms
    • Number of bathrooms
    • Area (i.e., square footage)
    • Zip code

    Overall our neural network obtained a mean absolute percentage error of 22.71%, implying that, on average, our house price predictions will be off by 22.71%.

    That raises the questions:

    • How can we better our house price prediction accuracy?
    • What if we leveraged images for each house? Would that improve accuracy?
    • Is there some way to combine both our categorical/numerical attributes with our image data?

    To answer these questions you’ll need to stay tuned for the remaining to tutorials in this Keras regression series.

    To download the source code to this post (and be notified when the next tutorial is published here on PyImageSearch), just enter your email address in the form below.

    Download the Source Code and FREE 17-page Resource Guide

    Enter your email address below to get a .zip of the code and a FREE 17-page Resource Guide on Computer Vision, OpenCV, and Deep Learning. Inside you'll find my hand-picked tutorials, books, courses, and libraries to help you master CV and DL!

    About the Author

    Hi there, I’m Adrian Rosebrock, PhD. All too often I see developers, students, and researchers wasting their time, studying the wrong things, and generally struggling to get started with Computer Vision, Deep Learning, and OpenCV. I created this website to show you what I believe is the best possible way to get your start.


    Making your model impactful

    Tada! We’ve now made our lead scoring model impactful by sending results directly into Intercom. To get a sense of how this might show up for a sales team member, here you can see each example lead now has a custom attribute listing whether or not they are likely to convert:

    With these labels easily available for each potential lead, a sales team member can start to prioritize their time and pick who they will reach out to first. This will hopefully lead to better efficiency, and more sales for your business! There are many ways to measure the success of these outcomes, but we’ll visit that at another time!


    Ver el vídeo: Identificación de Sistemas python