Julio de 2018

Volumen 33, número 7

Machine Learning: Machine Learning con dispositivos IoT en Edge

Por James McCaffrey

Imagine, en el futuro no muy lejano, usted es el Diseñador de una intersección de tráfico inteligente. La intersección inteligente tiene cuatro cámaras de vídeo conectadas a Internet del dispositivo de las cosas (IoT) con una CPU pequeño, similar a un Raspberry Pi. Las cámaras enviar fotogramas de vídeo en el dispositivo de IoT, donde está analizando mediante un modelo de machine learning (ML) reconocimiento de imágenes y las instrucciones de control, a continuación, se envían a las señales de tráfico. Uno de los pequeños dispositivos de IoT está conectado a Azure Cloud Services, donde se ha registrado y analizar sin conexión, información.

Este es un ejemplo de Machine Learning en un dispositivo de IoT en el perímetro. Uso el término dispositivo de edge para indicar que cualquier cosa conectado a la nube, donde en la nube se refiere a algo como Microsoft Azure o en servidores remotos de la empresa. En este artículo, explicaré dos maneras puede diseñar el aprendizaje automático en el borde. En concreto, describiré cómo escribir un modelo personalizado y una función de E/S para un dispositivo y cómo usar el conjunto de la biblioteca de aprendizaje incrustado (ELL) de Microsoft de herramientas para implementar un modelo de aprendizaje automático optimizado en un dispositivo en el perímetro. El enfoque de E/S personalizado es actualmente, mientras escribo este artículo, la manera más común para implementar un modelo de aprendizaje automático en un dispositivo de IoT. El enfoque de ELL es prevención.

Incluso si no está trabajando con aprendizaje automático en los dispositivos de IoT, hay al menos tres razones por qué desea leer este artículo. En primer lugar, los principios de diseño implicados generalización a otros escenarios de desarrollo de software. En segundo lugar, es bastante posible que trabajará con dispositivos IoT y aprendizaje automático relativamente pronto. En tercer lugar, es posible que solo encontrará las técnicas descritas aquí interesante en sí mismas.

¿Por qué ML debe estar en IoT edge? ¿Por qué no simplemente hacer todo el procesamiento en la nube? Dispositivos de IoT en el borde pueden ser muy económicos, pero a menudo tienen limitado limitado de funcionalidad y una fuente de alimentación limitado de procesamiento, memoria. En muchos escenarios, intentar realizar el aprendizaje automático de procesamiento en la nube tiene varias desventajas.

Latencia suele ser un gran problema. En el ejemplo de intersección tráfico inteligente, un retraso de más de una fracción de segundo podría tener consecuencias desastrosas. Los problemas adicionales al tratar de realizar el aprendizaje automático en la nube incluyen (una conexión de red normalmente es imposible predecir y difíciles de tratar con) de confiabilidad, disponibilidad de la red (por ejemplo, un buque en el mar puede tener conectividad solo cuando una licencia satélite es una sobrecarga) y la privacidad o seguridad (cuando, por ejemplo, está supervisando un paciente en un hospital.)

En este artículo no se supone tiene cualquier fondo concreta o aptitud establece pero suponga que tiene cierta experiencia de desarrollo de software general. La demostración programas descritos en este artículo (un programa de Python que usa la biblioteca de CNTK para crear un modelo de aprendizaje automático, un programa de C que simula el código de IoT y un programa de Python que usa un modelo ELL) son demasiado largos para presentarlo aquí, pero están disponibles en el archivo hacia abajo carga.

¿Qué es un modelo de aprendizaje automático?

Para comprender los problemas con la implementación de un modelo de aprendizaje automático en un dispositivo de IoT en el perímetro, debe comprender es exactamente de qué un modelo de aprendizaje automático. Muy términos generales, un modelo de aprendizaje automático es toda la información necesaria para aceptar datos de entrada, realizar una predicción y generar datos de salida. En lugar de intentar explicar en resumen, ilustraré las ideas con un ejemplo concreto.

Eche un vistazo a la captura de pantalla en figura 1 y el diagrama de figura 2. Las dos ilustraciones muestra una red neuronal con cuatro nodos de entrada, cinco nodos de procesamiento de la capa oculta y tres nodos de la capa de salida. Los valores de entrada son (6,1, 3.1, 5.1, 1.1) y los valores de salida son (0.0321, 0.6458, 0.3221). Figura 1 se muestra cómo se desarrolló y se entrena el modelo. Usé Visual Studio Code, pero existen muchas alternativas.

Figura 1 crear y entrenar un modelo de red neuronal

Figura 2 el mecanismo de entrada-salida de red neuronal

Este ejemplo concreto implica predecir las especies de una flor iris con valores de entrada que representan la longitud del sépalo (una estructura de tipo hoja) y el ancho y longitud del pétalo y ancho. Existen tres posibles especies de flor: setosa, versicolor, virginica. Los valores de salida se pueden interpretar como probabilidades (tenga en cuenta que suma 1,0) por lo tanto, dado que el segundo valor, 0.6458, es más grande, predicción del modelo es la segunda especie, versicolor.

En figura 2, cada línea que conecta un par de nodos representa una ponderación. Un peso es simplemente una constante numérica. Si los nodos son cero indizada, de arriba a abajo, la ponderación de input [0] a hidden [0] es 0.2680 y la ponderación de hidden [4] a [0] de la salida es 0.9381.

Cada nodo oculto y de salida tiene una pequeña flecha que apunta al nodo. Se denominan los sesgos. El sesgo de hidden [0] es 0.1164 y el sesgo de output [0] es-0.0466.

Se puede considerar una red neuronal como una función matemática compleja porque sólo acepta entradas numéricas y genera un resultado numérico. Un modelo de aprendizaje automático en un dispositivo de IoT necesita saber cómo calcular la salida. Para la red neuronal en figura 2, el primer paso consiste en calcular los valores de los nodos ocultos. El valor de cada nodo oculto es la función de tangente hiperbólica (tanh) aplicada a la suma de los productos de entradas y ponderaciones asociadas más el sesgo. De hidden [0] es el cálculo:

hidden[0] = tanh((6.1 * 0.2680) + (3.1 * 0.3954) +
                 (5.1 * -0.5503) + (1.1 * -0.3220) + 0.1164)
          = tanh(-0.1838)
          = -0.1817

Los nodos ocultos [1] a [4] se calculan de forma similar. La función tanh se denomina función de activación de capa oculta. Hay otras funciones de activación que se pueden usar, como logística sigmoide y de unidad lineal unidad, lo que daría a los valores distintos nodos ocultos.

Una vez se hayan calculado los valores de nodo oculto, el paso siguiente consiste en calcular los valores de nodo de salida preliminares. Un valor de nodo de salida preliminares es simplemente la suma de los productos de los nodos ocultos y ponderaciones de oculto a salida asociadas, además de la diferencia. En otras palabras, utiliza el mismo cálculo como para los nodos ocultos, pero sin la función de activación. Para el valor de salida [0] preliminar el cálculo es:

o_pre[0] = (-0.1817 * 0.7552) + (-0.0824 * -0.7297) +
           (-0.1190 * -0.6733) + (-0.9287 * 0.9367) +
           (-0.9081 * 0.9381) + (-0.0466)
         = -1.7654

Se calculan los valores de nodos de salida [1] y [2] de la misma manera. Una vez se hayan calculado los valores preliminares de los nodos de salida, se pueden convertir los valores de nodo de salida final en probabilidades mediante la función de activación softmax. La función softmax se explica mejor con un ejemplo. Los cálculos de los valores de salida final son:

sum = exp(o_pre[0]) + exp(o_pre[1]) + exp(o_pre[2])
    = 0.1711 + 3.4391 + 1.7153
    = 5.3255
output[0] = exp(o_pre[0]) / sum
          = 0.1711 / 5.3255 = 0.0321
output[1] = exp(o_pre[1]) / sum
          = 3.4391 / 5.3255 = 0.6458
output[2] = exp(o_pre[2]) / sum
          = 1.7153 / 5.3255 = 0.3221

Al igual que con los nodos ocultos, existen funciones de activación de nodo de salida alternativos, como la función identity.

En resumen, un modelo de aprendizaje automático es toda la información necesaria para aceptar datos de entrada y generar una predicción de salida. En el caso de una red neuronal, esta información está formada por el número de nodos ocultos, entrados y de salida, los valores de las ponderaciones y sesgos y los tipos de funciones de activación que se usa en los nodos ocultos y de salida de capa.

¿Bien, pero que sí los valores de las ponderaciones y los sesgos proceden? Están determinados por el entrenamiento del modelo. Aprendizaje está usando un conjunto de datos que se conocen los valores de entrada y conocido, corrija los valores de salida y aplicar un algoritmo de optimización, como la propagación inversa para minimizar la diferencia entre los valores de salida calculados y conocido, corregir los valores de salida.

Hay muchos otros tipos de modelos de aprendizaje automático, como árboles de decisión y Bayes naive, pero los principios generales son los mismos. Cuando se usa una biblioteca de código de la red neuronal, como Microsoft CNTK o Google Keras/TensorFlow, el programa que entrena un modelo de aprendizaje automático guardará el modelo en el disco. Por ejemplo, código CNTK y Keras es similar:

mp = ".\\Models\\iris_nn.model"
model.save(mp, format=C.ModelFormat.CNTKv2)  # CNTK
model.save(".\\Models\\iris_model.h5")  # Keras

Las bibliotecas de ML también tienen funciones para cargar un modelo guardado. Por ejemplo:

mp = ".\\Models\\iris_nn.model"
model = C.ops.functions.Function.load(mp)  # CNTK
model = load_model(".\\Models\\iris_model.h5")  # Keras

Las bibliotecas de red neuronales más tienen una manera de guardar simplemente un ponderaciones y sesgos los valores del modelo en el archivo (en lugar de todo el modelo).

Implementar un modelo de aprendizaje automático estándar en un dispositivo de IoT

La imagen en figura 1 muestra un ejemplo del aspecto de lo que entrenar un modelo de aprendizaje automático. He usado Visual Studio Code como el editor y la interfaz de API de lenguaje Python a la biblioteca CNTK v2.4. Creación de un modelo de aprendizaje automático entrenado puede tardar días o semanas de esfuerzo y normalmente requiere una gran cantidad de potencia de procesamiento y memoria. Por lo tanto, entrenamiento del modelo se realiza normalmente en máquinas eficaz, a menudo con una o varias GPU. Además, como aumenta el tamaño y la complejidad de una red neuronal, el número de ponderaciones y sesgos aumenta significativamente y, por lo que el tamaño del archivo de un modelo guardado también aumenta en gran medida.

Por ejemplo, el 4-5-3 modelo iris se describe en la sección anterior, solo tiene (4 * 5) + 5 + (5 * 3) + 3 = 43 ponderaciones y sesgos. Pero un modelo de clasificación de imágenes con millones de valores de entrada píxeles y cientos de nodos de procesamiento ocultos puede tener cientos de millones o incluso miles de millones, de ponderaciones y sesgos. Tenga en cuenta que se muestran los valores de todos los 43 ponderaciones y sesgos del ejemplo de iris en figura 1:

[[ 0.2680 -0.3782 -0.3828  0.1143  0.1269]
 [ 0.3954 -0.4367 -0.4332  0.3880  0.3814]
 [-0.5503  0.6453  0.6394 -0.6454 -0.6300]
 [-0.322   0.4035  0.4163 -0.3074 -0.3112]]
 [ 0.1164 -0.1567 -0.1604  0.0810  0.0822]
[[ 0.7552 -0.0001 -0.7706]
 [-0.7297 -0.2048  0.9301]
 [-0.6733 -0.2512  0.9167]
 [ 0.9367 -0.4276 -0.5134]
 [ 0.9381 -0.3728 -0.5667]]
 [-0.0466  0.4528 -0.4062]

Por lo tanto, suponga que tiene un modelo de aprendizaje automático entrenado. Desea implementar el modelo en un dispositivo de IoT débil, pequeño. La solución más sencilla consiste en instalar en el dispositivo de IoT en el mismo software de la biblioteca de red neuronal que usó para entrenar el modelo. A continuación, puede copiar el archivo de modelo entrenado guardado en el dispositivo de IoT y escribir código para cargar el modelo y realizar una predicción. ¡Fácil!

Desafortunadamente, este enfoque funcionará sólo en situaciones relativamente poco frecuentes donde el dispositivo de IoT es bastante eficaz, quizás a lo largo de las líneas de un PC de escritorio o portátil. Además, las bibliotecas de red neuronal, como CNTK y TensorFlow/Keras se diseñaron para entrenar modelos de forma rápida y eficaz, pero en general, no están necesariamente diseñados para optimizar el rendimiento al realizar la entrada y salida con un modelo entrenado. En resumen, una solución simple para implementar un modelo de aprendizaje automático entrenado en un dispositivo de IoT en el borde es factible con poca frecuencia.

La solución de código personalizado

Según mi experiencia y las conversaciones con sus colegas, la manera más común para implementar un modelo de aprendizaje automático entrenado en un dispositivo de IoT en el borde es escribir código personalizado de C o C++ en el dispositivo. La idea es que está casi totalmente disponible en dispositivos IoT C/C++ y C o C++ suele ser rápido y compacto. El programa de demostración de figura 3 se muestra el concepto.

Figura 3 simulación de código de C o C++ personalizado E/S en un dispositivo de IoT

El programa de demostración se inicia mediante la herramienta de C o C++ gcc para compilar el archivo test.c en un archivo ejecutable en el dispositivo de destino. En este caso, el dispositivo de destino es simplemente mi equipo de escritorio, pero existen compiladores de C o C++ para prácticamente cualquier tipo de dispositivo de IoT y CPU. Cuando se ejecuta, el programa de demostración muestra los valores de las ponderaciones y sesgos del ejemplo de flores de iris, a continuación, usa los valores de entrada de (6.1, 3.1, 5.1, 1.1) y calcula y muestra los valores de salida (0.0321, 0.6458, 0.3221). Si compara figura 3 con las figuras 1 y 2, verá las entradas, ponderaciones y sesgos, y las salidas son los mismos (sujeto a errores de redondeo).   

Test.c del programa de demostración implementa sólo el proceso de entrada y salida de red neuronal. El programa se inicia mediante la configuración de una estructura de datos de estructura para contener el número de nodos en cada capa, los valores para el texto oculto y nodos de la capa de salida y valores de las ponderaciones y sesgos:

#include <stdio.h>
#include <stdlib.h>
#include <math.h>  // Has tanh()
typedef struct {
  int ni, nh, no;
  float *h_nodes, *o_nodes;  // No i_nodes
  float **ih_wts, **ho_wts;
  float *h_biases, *o_biases;
} nn_t;

El programa define las siguientes funciones:

construct(): initialize the struct
free(): deallocate memory when done
set_weights(): assign values to weights and biases
softmax(): the softmax function
predict(): implements the NN IO mechanism
show_weights(): a display helper

Las líneas clave del código en la función principal del programa de demostración tiene el siguiente aspecto:

nn_t net;  // Neural net struct
construct(&net, 4, 5, 3);  // Instantiate the NN
float wts[43] = {  // specify the weights and biases
  0.2680, -0.3782, -0.3828, 0.1143, 0.1269,
. . .
 -0.0466, 0.4528, -0.4062 };
set_weights(&net, wts);  // Copy values into NN
float inpts[4] = { 6.1, 3.1, 5.1, 1.1 };  // Inputs
int shownodes = 0;  // Don’t show
float* probs = predict(net, inpts, shownodes);

El punto es que si sabe exactamente cómo funciona un modelo de aprendizaje automático de la red neuronal simple, el proceso de E/S no es mágico. Puede implementar E/S básica con bastante facilidad.

La principal ventaja de usar una función de C o C++ E/S personalizada es la simplicidad conceptual. Además, dado que el código se escribe en un nivel muy bajo (en realidad un nivel de abstracción por encima del lenguaje de ensamblado), el código ejecutable generado normalmente será muy pequeñas y ejecución muy rápida. Además, puesto que tiene control total sobre el código de E/S, puede usar todo tipo de trucos para acelerar el rendimiento o reducir la superficie de memoria. Por ejemplo, test.c programa usa el tipo float pero, según el escenario del problema, es posible que pueda usar un tipo de datos personalizados de punto flotante de 16 bits.

La principal desventaja de usar un enfoque de E/S de C o C++ personalizado es que la técnica es más difícil que la complejidad de los aumentos de modelo de aprendizaje automático entrenados. Por ejemplo, una función de E/S para una red neuronal única capa oculta con la activación tanh y softmax es muy fácil de implementar, teniendo sólo alrededor de un día en una semana de trabajo de desarrollo, dependiendo de muchos factores, por supuesto. Es un poco más fácil de tratar con una red neuronal profunda con varias capas ocultas, quizás una semana o dos de esfuerzo. Pero implementar la funcionalidad de E/S de una red neuronal convolucional (CNN) o un valor long, Red neuronal recurrente de a corto plazo (LSTM) de memoria es muy difícil y normalmente requeriría mucho más de cuatro semanas de esfuerzo de desarrollo.

Sospecho que como el uso de los aumentos de dispositivos de IoT, habrá esfuerzos para crear bibliotecas de C o C++ de código abierto que implementan la operación de E/S para los modelos de aprendizaje automático creados por las bibliotecas de red neuronal diferentes, como CNTK y TensorFlow/Keras. O bien, si no hay suficiente demanda, los desarrolladores de bibliotecas de red neuronal podrían crear las API de E/S de C o C++ para dispositivos de IoT a sí mismos. Si tenía una de estas bibliotecas, la escritura de E/S personalizado para un dispositivo IoT sería relativamente sencilla.

La biblioteca de aprendizaje incrustado de Microsoft

La biblioteca de aprendizaje incrustado de Microsoft (ELL) es un proyecto de código abierto ambicioso diseñado para facilitar el esfuerzo de desarrollo necesario para implementar un modelo de aprendizaje automático en un dispositivo de IoT en el perímetro (microsoft.github.io/ELL). La idea básica de la celda se muestra en el lado izquierdo de figura 4.

Figura 4 el proceso de flujo de trabajo ELL, Granular y de alto nivel

En palabras, el sistema ELL acepta un modelo de aprendizaje automático creado por una biblioteca compatible, como CNTK, o un formato de modelo admitidos, como exchange de la red neuronal abierta (ONNX). El sistema ELL usa el modelo de aprendizaje automático de entrada y genera un modelo como un archivo .ell intermedio. A continuación, el sistema ELL usa el archivo de modelo .ell intermedio para generar código ejecutable de algún tipo de dispositivo de destino compatibles. Dicho de otro modo, se puede considerar ELL como una especie de compilador cruzado para modelos de aprendizaje automático.

Para obtener una explicación más granular del funcionamiento de la celda se muestra en el lado derecho de figura 4, en el ejemplo de modelo de flor iris. El proceso comienza con un desarrollador de ML escribir un programa de Python denominado iris_nn.py para crear y guardar un modelo de predicción denominado iris_cntk.model, que se encuentra en un formato binario. Este proceso se muestra en figura 1.

El cntk_import.py de la herramienta de línea de comandos ELL, a continuación, se usa para crear un archivo intermedio iris_cntk.ell, que se almacena en formato JSON. A continuación, se usa el wrap.py de la herramienta de línea de comandos ELL para generar un host\build del directorio de archivos de código fuente de C o C++. Tenga en cuenta que el "host" significa que adoptar la configuración de la máquina actual, por lo que un escenario más común sería algo parecido a \pi3\build. A continuación, la herramienta de compilación del compilador de C o C++ cmake.exe se usa para generar un módulo de Python de código ejecutable, que contiene la lógica del modelo de aprendizaje automático original, denominada iris_cntk. El destino podría ser un archivo ejecutable de C o C++ o C# ejecutable o lo que es el más adecuado para el dispositivo de IoT de destino.

A continuación, se puede importar el módulo de Python iris_cntk por un programa de Python (use_iris_ell_model.py) en el dispositivo de destino (Mi PC de escritorio), como se muestra en figura 5. Tenga en cuenta que los valores de entrada (6.1, 3.1, 5.1, 1.1) y valores de salida generados por el modelo del sistema ELL (0.0321, 0.6457, 0.3221) son los mismos que los valores generados durante el desarrollo del modelo (figura 1) y los valores generados por el función personalizada de C o C++ IO (figura 3).

Figura 5 simulación de uso de un modelo de celda en un dispositivo de IoT

El interlineado "(py36)" antes de los símbolos en figura 5 indican que estoy trabajando en una configuración especial de Python llama a un entorno de Conda donde estoy usando versión 3.6, que era necesaria en el momento en que codifiqué mi demostración de la celda.

Se muestra el código de programa use_iris_ell_model.py en figura 6. El punto es que ELL ha generado un módulo o paquete de Python que se puede usar como cualquier otro paquete o módulo.

Figura 6 uso de un modelo de celda en un programa de Python

# use_iris_ell_model.py
# Python 3.6
import numpy as np
import tutorial_helpers   # used to find package
import iris_cntk as m     # the ELL module/package
print("\nBegin use ELL model demo \n")
unknown = np.array([[6.1, 3.1, 5.1, 1.1]],
  dtype=np.float32)
np.set_printoptions(precision=4, suppress=True)
print("Input to ELL model: ")
print(unknown)
predicted = m.predict(unknown)
print("\nPrediction probabilities: ")
print(predicted)
print("\nEnd ELL demo \n"

El sistema ELL está en las primeras fases de desarrollo, pero Basándome en mi experiencia, el sistema está listo para que pueda experimentar con y es lo suficientemente estable para escenarios de desarrollo de producción limitados.

Espero que su reacción al diagrama del proceso en ELL figura 4 y su explicación es algo como "Wow, que es una gran cantidad de pasos!" Al menos, eso fue todo mi reacción. Finalmente, espera que el sistema ELL avanza a un punto donde puede generar un modelo para su implementación en un dispositivo de IoT a lo largo de las líneas de:

source_model = ".\\iris_cntk.model"
target_model = ".\\iris_cortex_m4.model"
ell_generate(source_model, target_model)

Pero por ahora, si desea explorar ELL tendrá que trabajar con varios pasos. Por suerte, el tutorial ELL desde el sitio Web ELL en que gran parte de este artículo se basa es muy bueno. Debo señalar que empezar a trabajar con ELL debe instalar ELL en el equipo de escritorio y la instalación consta de la creación de código fuente de C o C++, no hay ningún instalador de .msi para ELL (todavía).

Una interesante característica de la celda que no sea obvia es que realice alguna optimización muy sofisticada en segundo plano. Por ejemplo, el equipo ELL ha explorado formas para comprimir grandes modelos de aprendizaje automático, incluidos sparsification y técnicas de eliminación y reemplazando la aritmética de punto flotante con las matemáticas de 1 bit. Los algoritmos que pueden usarse en lugar de las redes neuronales, incluidos los árboles de decisión mejorada y clasificadores de k DNF también está buscando el equipo de la celda.

Los tutoriales en el sitio Web de ELL están bastante buenos, pero dado que hay muchos pasos, son un poco largos. Permítanme brevemente esbozar el proceso, por lo que puede hacerse una idea de lo que son instalar y usar ELL como. Tenga en cuenta que Mis comandos no son sintácticamente correctos; está muy simplificadas para mantener las ideas principales claras.

Es similar instalar el sistema ELL:

x> (install several tools such as cmake and BLAS)
> git clone https://github.com/Microsoft/ELL.git
> cd ELL
> nuget.exe restore external/packages.config -PackagesDirectory external
> md build
> cd build
> cmake -G "Visual Studio 15 2017 Win64" ..
> cmake --build . --config Release
> cmake --build . --target _ELL_python --config Release

En palabras, debe tener bastantes instaladas antes de iniciar las herramientas y luego desplegar el código fuente de ELL desde GitHub y, a continuación, crear las herramientas de ejecutable ELL y enlace de Python con cmake.

Es similar crear un modelo de celda:

> python cntk_import.py iris_cntk.model
> python wrap.py iris_nn_cntk.ell --language python --target host
> cd host
> md build
> cd build
> cmake -G "Visual Studio 15 2017 Win64" .. && cmake --build . --config release

Es decir, ELL herramienta cntk_import.py usa para crear un archivo .ell desde un archivo de modelo CNTK. Use wrap.py para generar mucho de C o C++ específicas de un dispositivo de IoT de destino determinado. Y use cmake para generar archivos ejecutables que encapsulan el comportamiento original entrenado ML del modelo.

Resumen

En resumen, un modelo de aprendizaje automático es toda la información necesaria para que un sistema de software Aceptar la entrada y generar una predicción. Dado que los dispositivos de IoT en el borde a menudo requieren un rendimiento muy rápido y confiable, a veces es necesario calcular las predicciones de aprendizaje automático directamente en un dispositivo. Sin embargo, los dispositivos de IoT suelen ser pequeñas y débil, por lo que simplemente no se puede copiar un modelo que se desarrolló en un equipo de escritorio eficaces en el dispositivo. Un enfoque estándar consiste en escribir código personalizado de C o C++, pero este enfoque no se escala para los modelos de aprendizaje automático complejos. Un enfoque emergente es el uso de ML compiladores cruzados, por ejemplo, la biblioteca de aprendizaje de Microsoft Embedded.

Cuando maduro y lanzadas por completo, el sistema ELL es bastante probable que hará que desarrollar modelos de aprendizaje automático complejos para los dispositivos de IoT en el borde considerablemente más fácil de lo que es hoy en día.

El Dr. James McCaffrey trabaja para Microsoft Research en Redmond, Washington. Ha colaborado en el desarrollo de varios productos de Microsoft como, por ejemplo, Internet Explorer y Bing. Puede ponerse en contacto con el Dr. McCaffrey en jamccaff@microsoft.com.

Gracias a los siguientes expertos técnicos de Microsoft por revisar este artículo: Byron Changuion, Chuck Jacobs, Chris Lee y Ricky Loynd

Discuta sobre este artículo en el foro de MSDN Magazine