No hace mucho tiempo, en una galaxia bastante distante, en un planeta provincial había descendientes famosos de monos que eran tan vagos que decidieron inventar inteligencia artificial. "Bueno, ¿qué?" Ellos pensaron. Es bueno tener en los asesores de la Overmind un "cerebro" que pensará por ti cuando sea necesario, tus problemas se pueden resolver rápidamente, y es incluso mejor de lo que una criatura viviente puede hacer ... Y, sin pensar en las consecuencias, comenzaron sus monos. Los cerebros inversos y el proceso cognitivo en los bloques de construcción se desmontan. Pensaron, pensaron y pensaron, no lo creerán: un modelo de neurona, un algoritmo de aprendizaje matemático y luego redes neuronales con diferentes topologías desplegadas. Por supuesto, esto no funcionó para decirlo muy bien. Hubo muchas deficiencias, en comparación con la inteligencia natural, pero una cierta gama de problemas, estos modelos nos permitieron resolver con una precisión razonable. Y lentamente, las habilidades digitalizadas y serializadas comenzaron a aparecer en forma de modelos de redes neuronales. Hoy, queridos amantes de la historia del universo, tocaremos la organización e implementación de varias habilidades de inteligencia artificial.


Sobre la creación y capacitación de modelos de redes neuronales (habilidades) en Habré se escribe mucho, por lo tanto, no hablaremos de eso hoy. Habiendo entrenado o recibido habilidades de IA serializadas, esperamos usarlas en nuestros sistemas de información objetivo, y aquí surge un problema. Lo que funciona en el stand de laboratorio no puede transferirse a la producción en su forma original, es necesario implementar toda la pila de tecnología asociada e incluso realizar modificaciones significativas en la plataforma objetivo (por supuesto, hay excepciones en la forma de CoreML, pero este es un caso especial y solo para equipos Apple). Además, existen muchas herramientas para desarrollar y serializar modelos, ¿es realmente necesario que todos desarrollen una solución de integración separada? Además, incluso en el laboratorio, a menudo es necesario obtener una conclusión rápida del modelo, sin esperar la carga de toda la pila de desarrollo asociada.
Como sugerencia para resolver estos problemas, me gustaría contarles acerca de una herramienta de código abierto relativamente nueva, que, tal vez, será útil para ustedes al desarrollar proyectos relacionados con la IA.

0Mind (leer ZeroMind) es un servidor de habilidades gratuito. La solución es un servidor de aplicaciones modular, universal y fácilmente extensible con elementos de un marco para servir modelos de aprendizaje automático heterogéneos (salida altamente accesible). El servidor es feo en Python 3 y usa Tornado para el procesamiento de solicitudes asíncronas. Independientemente del marco de aprendizaje automático que se utilizó para preparar y serializar el modelo, 0Mind facilita el uso de una habilidad o grupo de habilidades utilizando la API REST universal. De hecho, la solución es un servidor web asíncrono con una API REST, unificada para trabajar con modelos de habilidades de IA y un conjunto de adaptadores para varios marcos de aprendizaje automático. Es posible que haya trabajado con el servicio de tensorflow: esta es una solución similar, pero 0Mind no está apilado y puede servir varios modelos de diferentes marcos en el mismo puerto. Por lo tanto, en lugar de implementar toda la pila de tecnología para derivar modelos de IA en el sistema de información de destino, puede usar la API REST simple y familiar para la habilidad de interés, además, el modelo preparado permanece en el servidor y no termina en la distribución de software. Para no confundir una vez más con términos complejos, pasemos a ejemplos de uso y comencemos a lanzar hechizos de consola.

Instalación

Aquí todo es simple:

git clone git@github.com:MisteryX/0Mind.git 0Mind 

Ahora tenemos una instancia de servidor en funcionamiento. Instalar las dependencias:

 cd 0Mind pip3 install -r requirements.txt 

O si usas Conda:

 conda install --yes --file requirements.txt 

Una advertencia importante es que el servidor admite varios marcos de aprendizaje automático y, para no agregarlos todos y no instalarlos, usted mismo decide qué marcos de marcos cargará en el host con la instancia de 0Mind, instale y configure estas herramientas de forma independiente.

Personalización

El punto de entrada o el ejecutable del servidor principal es model_pool.py .
Las posibles opciones de inicio son -c o --config_file con la ruta al archivo de configuración. De manera predeterminada, 0Mind usa el archivo configs / model_pool_config.json como archivo de configuración. El servidor también usa el archivo config / logger.json para controlar el registro estándar del módulo de registro de Python.

Con el fin de demostrar las capacidades, podemos dejar intacto el archivo de configuración predeterminado. Lea más sobre la configuración en la documentación oficial .

La configuración principal del servidor es: id, host, puerto, tareas.

id : (número) identificador único del grupo de modelos (utilizado para equilibrar y direccionar en una red distribuida de grupos)
host - (cadena) dirección de red o nombre de dominio de este host
puerto : (número) en qué puerto desea alojar el servicio 0Mind (debe estar libre en este host)
tareas : (lista de objetos) una lista de tareas cargadas con el servicio (puede estar vacía). En la configuración predeterminada, se carga el modelo de demostración CNN_MNIST preparado por Keras, y lo usaremos para demostrar las capacidades.

Parámetros de configuración adicionales (opcionales):

model_types : (lista de cadenas) puede limitar los tipos de modelos cargados a este grupo al especificarlos en esta lista. Si la lista está vacía, entonces no hay restricciones.

debug : (tipo booleano) es responsable de habilitar o deshabilitar el modo de depuración de Tornado. En modo de depuración, en caso de errores, la información de error extendida se devuelve a stdout, lo cual es útil cuando se desarrollan extensiones.

Las posibilidades

Lo principal en 0Mind es la lista de marcos compatibles y las características de la API REST .

Las solicitudes a la API REST se pueden realizar utilizando un navegador o utilidades http. En esta guía, así como en la documentación del servidor, utilizaremos cURL como la herramienta más simple y asequible para sistemas abiertos.

Actualmente, 0Mind API tiene un total de 10 solicitudes:

1. http: // $ HOST: $ PORT / info - información general sobre la instancia de 0Mind
2. http: // $ HOST: $ PORT / info / system: información del sistema sobre el host en el que se ejecuta 0Mind
3. http: // $ HOST: $ PORT / info / task: información sobre la tarea especificada
4. http: // $ HOST: $ PORT / info / tareas - lista de tareas de instancia 0Mind
5. http: // $ HOST: $ PORT / model / list: una lista de identificadores de modelos cargados en el grupo
6. http: // $ HOST: $ PORT / model / info - muestra información de la interfaz sobre el modelo
7. http: // $ HOST: $ PORT / model / load: carga un nuevo modelo en el grupo
8. http: // $ HOST: $ PORT / model / drop: descarga un modelo cargado previamente del grupo
9. http: // $ HOST: $ PORT / model / predict - solicita salida del modelo
10.http: // $ HOST: $ PORT / command / stop - detiene el servicio 0Mind y finaliza su proceso

Informacion

Puede iniciar una instancia de servidor, por ejemplo, así:

 python3 model_pool.py 

Por ejemplo, obtendremos información general sobre una instancia de servidor en ejecución:

 curl http://127.0.0.1:5885/info 

 {"service": "ModelPool", "id": 1, "options": {"debug": false}, "version": [1, 1, 4]} 

Ok, ahora descubrimos qué modelos están cargados en el grupo:

 curl http://127.0.0.1:5885/model/list 

 {"id": 1, "check_sum": "4d8a15e3cc35750f016ce15a43937620", "models": ["1"]} 

Ahora aclaremos la interfaz del modelo cargado con el identificador "1":

 curl http://127.0.0.1:5885/model/info?id=1 

 {"inputs": {"0": {"name": "conv2d_1_input:0", "type": "float32", "shape": [null, 28, 28, 1]}}, "outputs": {"0": {"name": "dense_2/Softmax:0", "type": "float32", "shape": [null, 10]}}, "tool": "keras"} 

Queda por averiguar con qué filtros se carga el modelo. Para hacer esto, aclaramos los detalles de la tarea de cargar el modelo con el identificador "1":

 curl http://127.0.0.1:5885/info/task?id=1 

 {"id": "1", "model_file": "ML/models/mnist_cnn_model.keras", "model_type": "keras", "input_filters": {"conv2d_1_input:0": ["i_img_file_to_ns_arr.ImageFileToNormAndScaledNPArrayFilter"]}, "output_filters": {}} 

Como puede ver, nuestro modelo tiene un filtro de entrada: i_img_file_to_ns_arr.ImageFileToNormAndScaledNPArrayFilter y filtra la entrada con el nombre - conv2d_1_input: 0. Este filtro simplemente convierte el archivo de imagen especificado en un tensor y lo escala de acuerdo con la entrada del modelo. Los filtros son otra gran herramienta generalizada de 0Mind. Dado que el procesamiento previo y posterior del procesamiento de datos para los modelos es el mismo, simplemente puede acumular estos filtros para un uso rápido en el trabajo posterior con otros modelos, indicando la tarea deseada como un atributo para cargar el modelo.

Salida de datos del modelo (inferencia)

Bueno, ahora que tenemos toda la información necesaria para la inferencia, podemos sacar una conclusión del modelo. Como entrada, usamos la imagen del conjunto de pruebas incluido en la distribución 0Mind samples / image5.png :

 curl -d '{"conv2d_1_input:0": [{"image_file": "samples/image5.png"}]}' -H "Content-Type:application/json" -X POST http://127.0.0.1:5885/model/predict?id=1 

La única entrada del modelo conv2d_1_input: 0 con el filtro i_img_file_to_ns_arr.ImageFileToNormAndScaledNPArrayFilter son los datos en el formato aceptado por el filtro - [{"image_file": "samples / image5.png"}]. En respuesta de 0Mind, obtenemos la salida del modelo:

 {"result": {"dense_2/Softmax:0": [[2.190017217283827e-21, 1.6761866200587505e-11, 2.2447325167271673e-14, 0.00011080023978138342, 1.881280855367115e-17, 0.9998891353607178, 1.6690393796396863e-16, 9.67975005705668e-12, 1.1265206161566871e-13, 2.086113400079359e-13]]}, "model_time": 0.002135753631591797} 

Entonces, la única salida del modelo "dense_2 / Softmax: 0" (ver información sobre el modelo anterior) nos dio el vector de confianza del modelo en la clasificación de esta imagen. Como puede ver, la probabilidad más alta es 0.99 para una clase con un índice de 6 (las clases son números 0-9), que corresponde al número 5 . Por lo tanto, el modelo hizo frente con éxito al reconocimiento del manuscrito y dio una conclusión con gran confianza. El tiempo de inferencia del modelo en el host 0Mind fue 0.002135753631591797 segundos, porque la salida estaba en una CPU x86 normal.

Carga y descarga dinámica de modelos.

Ahora descargue nuestro modelo del grupo:

 curl http://127.0.0.1:5885/model/drop?id=1 

 {"result": true, "unload_time": 0.000152587890625, "memory_released": 0, "model_id": "1"} 

Volvemos a cargar el mismo modelo, pero ahora con un identificador diferente ("nuevo") y un filtro de salida del modelo io_argmax.ArgMaxFilter, que probablemente derivará el índice del vector de confianza del modelo. Tendremos que cambiar los índices de las entradas y salidas del modelo, esto se debe a las características de Keras:

 curl -d '{"id": "new", "output_filters": {"dense_2_1/Softmax:0": ["io_argmax.ArgMaxFilter"]}, "model_file": "ML/models/mnist_cnn_model.keras", "input_filters": {"conv2d_1_input_1:0": ["i_img_file_to_ns_arr.ImageFileToNormAndScaledNPArrayFilter"]}, "model_type": "keras"}' -H "Content-Type:application/json" -X POST http://127.0.0.1:5885/model/load 

 {"result": true, "load_time": 0.45618462562561035, "memory_consumed": 16183296, "model_id": "new"} 

Y ahora le pedimos al modelo que reconozca para nosotros dos imágenes a la vez en una solicitud samples / image5.png y samples / image1.png :

 curl -d '{"conv2d_1_input:0": [{"image_file": "samples/image5.png"}, {"image_file": "samples/image1.png"}]}' -H "Content-Type:application/json" -X POST http://127.0.0.1:5885/model/predict?id=new 

 {"result": {"dense_2_1/Softmax:0": [5, 1]}, "model_time": 0.003907206535339355} 

El modelo de demostración no volvió a confundirse.

Extensión

Ampliar las capacidades de 0Mind no es difícil, gracias a su arquitectura modular, el uso de herramientas populares y buenas convenciones de código en el proyecto. Los principales vectores de extensión pueden ser:

1. Los adaptadores son clases entre capas para trabajar con nuevos marcos de redes neuronales y aprendizaje automático.
2. Los filtros son manejadores de datos para entrar y salir de modelos de habilidades.
3. Controladores de solicitud : le permiten agregar nueva funcionalidad a las solicitudes y respuestas de la API 0Mind.