Este artigo é sobre como usar Python no contexto de um sistema de aprendizado de máquina ou inteligência artificial (AI) para fazer previsões em tempo real, com uma API REST Flask. A arquitetura exposta aqui pode ser vista como uma maneira de ir da prova de conceito (PoC) para o produto mínimo viável (MVP) para aplicativos de aprendizado de máquina.

Pitão não é a primeira escolha em que se pode pensar ao projetar uma solução em tempo real. Mas como Tensorflow e Scikit-Learn são algumas das bibliotecas de aprendizado de máquina mais usadas suportadas pelo Python, ele é usado convenientemente em muitos PoCs do Jupyter Notebook .

O que torna essa solução viável é o fato de que o treinamento leva muito tempo em comparação com a previsão. Se você pensa no treinamento como o processo de assistir a um filme e prever as respostas às perguntas sobre ele, então parece bastante eficiente não ter que assistir novamente ao filme após cada nova pergunta.

O treinamento é uma espécie de visualização comprimida desse “filme” e a previsão é a recuperação de informações da visualização comprimida. Deve ser muito rápido, seja o filme complexo ou longo.

Vamos implementar isso com um exemplo rápido de [Flask] em Python!

Arquitetura Genérica de Aprendizado de Máquina

Vamos começar delineando um fluxo genérico de arquitetura de treinamento e predição:

Primeiro, um pipeline de treinamento é criado para aprender sobre os dados anteriores de acordo com uma função objetivo.

Isso deve resultar em dois elementos principais:

1. Funções de engenharia de recursos : as transformações usadas na hora do treinamento devem ser reutilizadas na hora da previsão.
2. Parâmetros de modelo : o algoritmo e os hiperparâmetros finalmente selecionados devem ser salvos, para que possam ser reutilizados no momento da previsão

Observe que a engenharia de recursos feita durante o tempo de treinamento deve ser cuidadosamente salva para ser aplicável à previsão. Um problema comum entre muitos outros que podem surgir ao longo do caminho é dimensionamento de recursos o que é necessário para muitos algoritmos.

Se o recurso X1 for escalado do valor 1 a 1000 e for redimensionado para o intervalo [0,1] com uma função f(x) = x/max(X1), o que aconteceria se o conjunto de predições tivesse um valor de 2000?

Alguns ajustes cuidadosos devem ser pensados ​​com antecedência para que a função de mapeamento retorne resultados consistentes que serão calculados corretamente no momento da previsão.

Treinamento de aprendizado de máquina vs previsão

Há uma questão importante a ser abordada aqui. Por que estamos separando treinamento e previsão para começar?

É absolutamente verdade que, no contexto de exemplos de aprendizado de máquina e cursos, onde todos os dados são conhecidos com antecedência (incluindo os dados a serem previstos), uma maneira muito simples de construir o preditor é empilhar dados de treinamento e previsão (geralmente chamado de conjunto de teste).

Então, é necessário treinar no 'conjunto de treinamento' e prever no 'conjunto de teste' para obter os resultados, enquanto ao mesmo tempo faz a engenharia de recursos nos dados de treinamento e teste, treinando e prevendo no mesmo pipeline único .

No entanto, em sistemas da vida real, geralmente você tem dados de treinamento, e os dados a serem previstos chegam exatamente quando estão sendo processados. Em outras palavras, você assiste ao filme uma vez e tem algumas perguntas sobre ele mais tarde, o que significa que as respostas devem ser fáceis e rápidas.

Além disso, geralmente não é necessário treinar novamente todo o modelo cada vez que novos dados chegam, uma vez que o treinamento leva tempo (pode levar semanas para alguns conjuntos de imagens) e deve ser estável o suficiente ao longo do tempo.

É por isso que o treinamento e a previsão podem ser, ou mesmo deveriam ser, claramente separados em muitos sistemas, e isso também reflete melhor como um sistema inteligente (artificial ou não) aprende.

A conexão com overfitting

A separação do treinamento e da previsão também é uma boa maneira de resolver o problema de overfitting.

Em estatística, overfitting é “a produção de uma análise que corresponde muito próxima ou exatamente a um determinado conjunto de dados e pode, portanto, não ajustar dados adicionais ou prever observações futuras de forma confiável”.

A linha verde representa um modelo superaquecido e a linha preta representa um modelo regularizado. Embora a linha verde siga melhor os dados de treinamento, ela é muito dependente desses dados e é provável que tenha uma taxa de erro maior em novos dados não vistos, em comparação com a linha preta._

O overfitting é particularmente visto em conjuntos de dados com muitos recursos ou com conjuntos de dados com dados de treinamento limitados. Em ambos os casos, os dados contêm muitas informações em comparação com o que pode ser validado pelo preditor, e alguns deles podem nem mesmo estar vinculados à variável prevista. Nesse caso, o próprio ruído pode ser interpretado como um sinal.

Uma boa maneira de controlar o overfitting é treinar em parte dos dados e prever em outra parte sobre a qual temos a verdade básica. Portanto, o erro esperado em novos dados é aproximadamente o erro medido naquele conjunto de dados, desde que os dados que treinamos sejam representativos da realidade do sistema e de seus estados futuros.

Portanto, se projetarmos um pipeline de treinamento e predição adequado, juntamente com uma divisão correta de dados, não apenas abordaremos o problema de overfitting, mas também poderemos reutilizar essa arquitetura para prever novos dados.

A última etapa seria controlar se o erro nos novos dados é o mesmo esperado. Sempre há uma mudança (o erro real está sempre abaixo do esperado), e deve-se determinar o que é uma mudança aceitável - mas esse não é o tópico deste artigo.

Uma API REST para previsão

É aí que separar claramente o treinamento e a previsão se torna útil. Se salvamos nossos métodos de engenharia de recursos e nossos parâmetros de modelo, podemos construir uma API REST simples com esses elementos.

A chave aqui é carregar o modelo e os parâmetros no lançamento da API. Depois de iniciada e armazenada na memória, cada chamada de API aciona o cálculo de engenharia de recursos e o método de 'previsão' do algoritmo de ML. Ambos são geralmente rápidos o suficiente para garantir uma resposta em tempo real.

A API pode ser projetada para aceitar um único exemplo a ser previsto ou vários exemplos diferentes (previsões em lote).

Aqui está o código Python / Flask mínimo que implementa este princípio, com JSON dentro e JSON fora (pergunta dentro, resposta fora):

app = Flask(__name__) @app.route('/api/makecalc/', methods=['POST']) def makecalc(): ''' Function run at each API call No need to re-load the model ''' # reads the received json jsonfile = request.get_json() res = dict() for key in jsonfile.keys(): # calculates and predicts res[key] = model.predict(doTheCalculation(key)) # returns a json file return jsonify(res) if __name__ == '__main__': # Model is loaded when the API is launched model = pickle.load(open('modelfile', 'rb')) app.run(debug=True)

Observe que a API pode ser usada para prever a partir de novos dados, mas não recomendo usá-la para treinar o modelo. Ele poderia ser usado, mas isso complexifica o código de treinamento do modelo e pode ser mais exigente em termos de recursos de memória.

Exemplo de implementação - compartilhamento de bicicletas

Vejamos um conjunto de dados Kaggle, compartilhamento de bicicletas, como exemplo. Digamos que sejamos uma empresa de compartilhamento de bicicletas que deseja prever o número de aluguéis de bicicletas a cada dia, a fim de gerenciar melhor a manutenção, logística e outros aspectos do negócio.

Os aluguéis dependem principalmente das condições climáticas, então com a previsão do tempo essa empresa pode ter uma ideia melhor quando os aluguéis vão atingir o pico, e tentar evitar a manutenção nesses dias.

Primeiro, treinamos um modelo e o salvamos como um objeto pickle que pode ser visto no Caderno Jupyter .

O treinamento e o desempenho do modelo não são tratados aqui, é apenas um exemplo para a compreensão de todo o processo.

Em seguida, escrevemos a transformação de dados que será feita em cada chamada de API:

import numpy as np import pandas as pd from datetime import date def doTheCalculation(data): data['dayofyear']=(data['dteday']- data['dteday'].apply(lambda x: date(x.year,1,1)) .astype('datetime64[ns]')).apply(lambda x: x.days) X = np.array(data[['instant','season','yr','holiday','weekday','workingday', 'weathersit','temp','atemp','hum','windspeed','dayofyear']]) return X

Este é apenas um cálculo de uma variável (dia do ano) para incluir o mês e o dia preciso. Há também uma seleção de colunas e sua respectiva ordem a serem mantidas.

Precisamos, então, escrever a API REST com Flask:

from flask import Flask, request, redirect, url_for, flash, jsonify from features_calculation import doTheCalculation import json, pickle import pandas as pd import numpy as np app = Flask(__name__) @app.route('/api/makecalc/', methods=['POST']) def makecalc(): ''' Function run at each API call ''' jsonfile = request.get_json() data = pd.read_json(json.dumps(jsonfile),orient='index',convert_dates=['dteday']) print(data) res = dict() ypred = model.predict(doTheCalculation(data)) for i in range(len(ypred)): res[i] = ypred[i] return jsonify(res) if __name__ == '__main__': modelfile = 'modelfile.pickle' model = pickle.load(open(modelfile, 'rb')) print('loaded OK') app.run(debug=True)

Execute este programa, ele servirá a API na porta 5000 por padrão.

Se testarmos uma solicitação localmente, ainda com Python:

import requests, json url = '[http://127.0.0.1:5000/api/makecalc/](http://127.0.0.1:5000/api/makecalc/)' text = json.dumps({'0':{'instant':1,'dteday':'2011-01-01T00:00:00.000Z','season':1,'yr':0,'mnth':1,'holiday':0,'weekday':6,'workingday':0,'weathersit':2,'temp':0.344167,'atemp':0.363625,'hum':0.805833,'windspeed':0.160446}, '1':{'instant':2,'dteday':'2011-01-02T00:00:00.000Z','season':1,'yr':0,'mnth':1,'holiday':0,'weekday':3,'workingday':0,'weathersit':2,'temp':0.363478,'atemp':0.353739,'hum':0.696087,'windspeed':0.248539}, '2':{'instant':3,'dteday':'2011-01-03T00:00:00.000Z','season':1,'yr':0,'mnth':1,'holiday':0,'weekday':1,'workingday':1,'weathersit':1,'temp':0.196364,'atemp':0.189405,'hum':0.437273,'windspeed':0.248309}})

A solicitação contém todas as informações que foram fornecidas ao modelo. Portanto, nosso modelo responderá com uma previsão de aluguel de bicicletas para as datas especificadas (aqui temos três delas).

headers = {'content-type': 'application/json', 'Accept-Charset': 'UTF-8'} r = requests.post(url, data=text, headers=headers) print(r,r.text) { '0': 1063, '1': 1028, '2': 1399 }

É isso aí! Este serviço pode ser usado facilmente em qualquer aplicativo da empresa, para planejamento de manutenção ou para que os usuários estejam cientes do tráfego de bicicletas, da demanda e da disponibilidade de aluguel de bicicletas.

Juntando tudo

A principal falha de muitos sistemas de aprendizado de máquina, e especialmente PoCs, é misturar treinamento e previsão.

Se eles forem separados cuidadosamente, as previsões em tempo real podem ser realizadas facilmente para um MVP, com um custo de desenvolvimento e esforço bastante baixos com Python / Flask, especialmente se, para muitos PoCs, ele foi inicialmente desenvolvido com Scikit-learn, Tensorflow ou qualquer outra biblioteca de aprendizado de máquina Python.

No entanto, isso pode não ser viável para todos os aplicativos, especialmente aqueles em que a engenharia de recursos é pesada ou aplicativos que recuperam a correspondência mais próxima que precisam ter os dados mais recentes disponíveis em cada chamada.

Em qualquer caso, você precisa assistir filmes continuamente para responder a perguntas sobre eles? A mesma regra se aplica ao aprendizado de máquina!

Compreender o básico

O que é uma API REST?

No contexto dos serviços web, as APIs RESTful são definidas com os seguintes aspectos: uma URL, um tipo de mídia e um método HTTP (GET, POST, etc.). Eles podem ser usados ​​como uma forma unificada de troca de informações entre aplicativos.

O que é aprendizado de máquina?

O aprendizado de máquina é um subconjunto da inteligência artificial no campo da ciência da computação que costuma usar técnicas estatísticas para dar aos computadores a capacidade de 'aprender' (ou seja, melhorar progressivamente o desempenho em uma tarefa específica) com dados, sem serem programados explicitamente.

O que é Tensorflow?

TensorFlow é uma biblioteca de software de código aberto para programação de fluxo de dados em uma variedade de tarefas. É uma biblioteca matemática simbólica e também é usada para aplicativos de aprendizado de máquina, como redes neurais.

O que é Scikit-Learn?

Scikit-learn, também sklearn, é uma biblioteca de aprendizado de máquina de software livre para a linguagem de programação Python.

O que é engenharia de recursos?

Engenharia de recursos é o processo de usar o conhecimento de domínio dos dados para criar recursos que fazem os algoritmos de aprendizado de máquina funcionarem. Ele aumenta os dados disponíveis com informações adicionais relevantes para o alvo previsto.

O que é Jupyter?

Jupyter Notebook (anteriormente IPython Notebooks) é um ambiente computacional interativo baseado na web que oferece suporte à linguagem de programação Python.

O que é um PoC?

Um PoC, ou prova de conceito, é um primeiro estágio do programa que demonstra a viabilidade de um projeto.