Não faz muito tempo, em uma galáxia bastante distante, em um planeta provincial, havia descendentes famosos de macacos que eram tão preguiçosos que decidiram inventar inteligência artificial. "Bem o que?" Eles pensaram. É bom ter nos conselheiros o Overmind um "cérebro" que pensará em você quando necessário, seus problemas podem ser resolvidos rapidamente e é ainda melhor do que uma criatura viva pode fazer ... E, sem pensar nas consequências, eles começaram seus macacos O cérebro reverso e o processo cognitivo dos blocos de construção desmontam. Eles pensaram, pensaram e pensaram: você não acredita: um modelo de neurônio, um algoritmo de aprendizado matemático e, em seguida, redes neurais com diferentes topologias. Obviamente, isso não funcionou para dizer muito bem. Havia muitas deficiências, em comparação com a inteligência natural, mas, com uma certa gama de problemas, esses modelos nos permitiram resolver com razoável precisão. E lentamente, habilidades digitalizadas e serializadas começaram a aparecer na forma de modelos de redes neurais. Hoje, queridos amantes da história do universo, abordaremos a organização e implementação de várias habilidades de inteligência artificial.


Sobre a criação e o treinamento de modelos de redes neurais (habilidades) em Habré está escrito muito, portanto, não falaremos sobre isso hoje. Tendo treinado ou recebido habilidades de IA serializadas, esperamos usá-las em nossos sistemas de informações de destino, e aqui surge um problema. O que funciona no suporte de laboratório não pode ser transferido para a produção em sua forma original, é necessário implementar toda a pilha de tecnologia associada e até fazer modificações significativas na plataforma de destino (é claro que há exceções na forma de CoreML, mas esse é um caso especial e apenas para equipamentos da Apple). Além disso, existem muitas ferramentas para o desenvolvimento e serialização de modelos. É realmente necessário que todos desenvolvam uma solução de integração separada? Além disso, mesmo no laboratório, muitas vezes é necessário obter uma conclusão rápida do modelo, sem esperar o carregamento de toda a pilha de desenvolvimento associada.
Como sugestão para resolver esses problemas, gostaria de falar sobre uma ferramenta de código-fonte relativamente nova, que talvez seja útil para você ao desenvolver projetos relacionados à IA.

0Mind (leia ZeroMind) é um servidor de habilidades gratuito. A solução é um servidor de aplicativos modular, universal e facilmente extensível, com elementos de estrutura para atender a modelos heterogêneos de aprendizado de máquina (saída altamente acessível). O servidor é feio no Python 3 e usa o Tornado para processamento de solicitações assíncronas. Independentemente de qual estrutura de aprendizado de máquina foi usada para preparar e serializar o modelo, o 0Mind facilita o uso de uma habilidade ou grupo de habilidades usando a API REST universal. De fato, a solução é um servidor da Web assíncrono com uma API REST, unificada para trabalhar com modelos de habilidades de IA e um conjunto de adaptadores para várias estruturas de aprendizado de máquina. Você pode ter trabalhado com a veiculação do tensorflow - essa é uma solução semelhante, mas o 0Mind não está empilhado e pode atender a vários modelos de estruturas diferentes na mesma porta. Assim, em vez de implementar toda a pilha de tecnologia para derivar modelos de IA no sistema de informações de destino, você pode usar a API REST simples e familiar para a habilidade de seu interesse; além disso, o modelo preparado permanece no servidor e não acaba na distribuição de software. Para não confundir mais uma vez com termos complexos, vamos passar a exemplos de uso e começar a lançar feitiços no console.

Instalação

Tudo é simples aqui:

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

Agora temos uma instância de servidor em funcionamento. Instale as dependências:

 cd 0Mind pip3 install -r requirements.txt 

Ou se você usa o Conda:

 conda install --yes --file requirements.txt 

Uma ressalva importante é que o servidor suporta várias estruturas de aprendizado de máquina e, para não adicionar todas elas às dependências e não instalá-las, você decide quais estruturas de estrutura fará o download no host com a instância 0Mind, instale e configure essas ferramentas independentemente.

Personalização

O ponto de entrada ou o servidor principal executável é model_pool.py .
As opções de inicialização possíveis são -c ou --config_file com o caminho para o arquivo de configuração. Por padrão, 0Mind usa o arquivo configs / model_pool_config.json como o arquivo de configuração. O servidor também usa o arquivo config / logger.json para controlar o registro padrão do módulo de registro Python.

Com o objetivo de demonstrar os recursos, podemos deixar intacto o arquivo de configuração padrão. Leia mais sobre a configuração na documentação oficial .

As principais configurações do servidor são: id, host, porta, tarefas.

id - identificador exclusivo (número) do pool de modelos (usado para balancear e endereçar em uma rede distribuída de pools)
host - endereço de rede (string) ou nome de domínio desse host
port - (número) em qual porta você deseja hospedar o serviço 0Mind (deve ser gratuito neste host)
tarefas - (lista de objetos) uma lista de tarefas carregadas com o serviço (pode estar vazia). Na configuração padrão, o modelo de demonstração CNN_MNIST preparado por Keras é carregado, que usaremos para demonstrar os recursos.

Parâmetros de configuração adicionais (opcionais):

model_types - (lista de cadeias), você pode limitar os tipos de modelos carregados para esse pool, especificando-os nesta lista. Se a lista estiver vazia, não haverá restrições.

debug - (tipo booleano) é responsável por ativar ou desativar o modo de depuração do Tornado. No modo de depuração, no caso de erros, as informações de erro estendidas são retornadas ao stdout, o que é útil ao desenvolver extensões.

As possibilidades

O principal no 0Mind é a lista de estruturas suportadas e os recursos da API REST .

Solicitações para a API REST podem ser executadas usando um navegador ou utilitários http. Neste guia, assim como na documentação do servidor, usaremos o cURL como a ferramenta mais simples e acessível para sistemas abertos.

Atualmente, a API 0Mind tem um total de 10 solicitações:

1. http: // $ HOST: $ PORT / info - informações gerais sobre a instância 0Mind
2. http: // $ HOST: $ PORT / info / system - informações do sistema sobre o host no qual o 0Mind está sendo executado
3. http: // $ HOST: $ PORT / info / task - informações sobre a tarefa especificada
4. http: // $ HOST: $ PORT / info / tasks - lista de tarefas da instância 0Mind
5. http: // $ HOST: $ PORT / model / list - uma lista de identificadores de modelos carregados no pool
6. http: // $ HOST: $ PORT / model / info - exibe informações da interface sobre o modelo
7. http: // $ HOST: $ PORT / model / load - carrega um novo modelo no pool
8. http: // $ HOST: $ PORT / model / drop - descarrega um modelo carregado anteriormente do pool
9. http: // $ HOST: $ PORT / model / predict - solicita saída do modelo
10.http: // $ HOST: $ PORT / command / stop - interrompe o serviço 0Mind e finaliza seu processo

Informação

Você pode iniciar uma instância do servidor, por exemplo, assim:

 python3 model_pool.py 

Por exemplo, obteremos informações gerais sobre uma instância do servidor em execução:

 curl http://127.0.0.1:5885/info 

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

Ok, agora descobrimos quais modelos são carregados no pool:

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

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

Agora vamos esclarecer a interface do modelo carregado com o 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"} 

Resta descobrir com quais filtros o modelo é carregado. Para isso, esclarecemos os detalhes da tarefa de carregar o modelo com o 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 você pode ver, nosso modelo possui um filtro de entrada - i_img_file_to_ns_arr.ImageFileToNormAndScaledNPArrayFilter e filtra a entrada com o nome - conv2d_1_input: 0. Esse filtro simplesmente converte o arquivo de imagem especificado em um tensor e o dimensiona de acordo com a entrada do modelo. Os filtros são outra ótima ferramenta generalizada do 0Mind. Como o pré-processamento e o pós-processamento de dados para modelos são os mesmos, você pode simplesmente acumular esses filtros para uso rápido em trabalhos futuros com outros modelos, indicando a tarefa desejada como um atributo para carregar o modelo.

Saída de dados do modelo (inferência)

Bem, agora que temos todas as informações necessárias para a inferência, podemos obter uma conclusão do modelo. Como entrada, usamos a imagem do conjunto de testes incluído na distribuição 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 

A única entrada do modelo conv2d_1_input: 0 com o filtro i_img_file_to_ns_arr.ImageFileToNormAndScaledNPArrayFilter são os dados no formato aceito pelo filtro - [{"image_file": "samples / image5.png"}]. Em resposta ao 0Mind, obtemos a saída do 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} 

Portanto, a única saída do modelo “dense_2 / Softmax: 0” (consulte as informações sobre o modelo acima) nos deu o vetor de confiança do modelo na classificação desta imagem. Como você pode ver, a probabilidade mais alta é de 0,99 para uma classe com um índice de 6 (as classes são os números de 0 a 9), o que corresponde ao número 5 . Assim, o modelo lidou com sucesso com o reconhecimento do manuscrito e deu uma conclusão com alta confiança. O tempo de inferência do modelo no host 0Mind foi de 0,002135753631591797 segundos, porque a saída estava em uma CPU x86 comum.

Carga e descarga dinâmica de modelos

Agora descarregue o nosso modelo da piscina:

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

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

Carregamos o mesmo modelo novamente, mas agora com um identificador diferente ("novo") e um filtro de saída do modelo io_argmax.ArgMaxFilter, que provavelmente derivará o índice do vetor de confiança do modelo. Teremos que alterar os índices das entradas e saídas do modelo - isso se deve aos recursos do 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"} 

E agora pedimos ao modelo que reconheça para nós duas imagens de uma só vez em uma solicitação samples / image5.png e 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} 

O modelo de demonstração não se enganou novamente.

Extensão

Expandir os recursos do 0Mind não é difícil, graças à sua arquitetura modular, ao uso de ferramentas populares e às boas convenções de código no projeto. Os principais vetores de extensão podem ser:

1. Adaptadores são classes entre camadas para trabalhar com novas estruturas de aprendizado de máquina e redes neurais.
2. Os filtros são manipuladores de dados para entrada e saída de modelos de habilidades.
3. Manipuladores de solicitação - permitem adicionar novas funcionalidades às solicitações e respostas da API 0Mind.