[Aprenda Flask] - Modelo de linguagem natural em Flask

Desenvolva um modelo de Linguagem Natural e implemente com Flask, passo a passo

De longe, desenvolvemos muitos modelos de aprendizado de máquina, geramos previsões numéricas sobre os dados de teste e testamos os resultados. E fazemos tudo isso offline. 

Na realidade, gerar previsões é apenas parte de um projeto de aprendizado de máquina, embora seja a parte mais importante na minha opinião.

Considerando um sistema usando aprendizado de máquina para detectar mensagens de texto SMS de spam. Nosso fluxo de trabalho de sistemas ML é assim: Treine offline -> Torne o modelo disponível como um serviço -> Análise preditiva on-line.

• Um classificador é treinado offline com mensagens de spam e não spam.
• O modelo treinado é implantado como um serviço para atender aos usuários.

figura 1

Quando desenvolvemos um modelo de aprendizado de máquina, precisamos pensar em como implantá-lo, ou seja, como disponibilizar esse modelo para outros usuários.

Os bootcamps da Kaggle e Data Science são ótimos para aprender como construir e otimizar modelos, mas eles não ensinam os engenheiros a levá-los para a próxima etapa, onde há uma grande diferença entre construir um modelo e realmente prepará-lo para as pessoas usar em seus produtos e serviços.

Neste artigo, vamos nos concentrar em ambos: construir um modelo de aprendizado de máquina para classificação de mensagens SMS de spam e criar uma API para o modelo, usando o Flask, a microestrutura do Python para construir aplicativos da Web. Essa API nos permite utilizar os recursos preditivos através de solicitações HTTP. Vamos começar!

Construindo o modelo de Machine Learning

Os dados são uma coleção de mensagens SMS marcadas como spam que podem ser encontradas aqui. Primeiro, usaremos esse conjunto de dados para criar um modelo de previsão que classifique com precisão quais textos são spam ou não.

Os classificadores Naive Bayes são uma técnica estatística popular de filtragem de e-mail. Eles normalmente usam recursos de conjunto de palavras para identificar e-mails de spam. Portanto, criaremos um classificador de mensagens simples usando o teorema de Naive Bayes.

Não só o classificador Naive Bayes é fácil de implementar, mas também fornece um resultado muito bom.

Depois de treinar o modelo, é desejável ter uma maneira de persistir o modelo para uso futuro sem ter que reciclar. Para conseguir isso, adicionamos as seguintes linhas para salvar nosso modelo como um arquivo .pkl para o uso posterior.

from sklearn.externals import joblib
joblib.dump(clf, 'NB_spam_model.pkl')

E podemos carregar e usar o modelo salvo mais tarde da seguinte forma:

NB_spam_model = open('NB_spam_model.pkl','rb')
clf = joblib.load(NB_spam_model)

O processo acima denominado “persist model em um formato padrão”, ou seja, os modelos são mantidos em um determinado formato específico para a linguagem em desenvolvimento.

E o modelo será servido em um micro-serviço que expõe pontos de extremidade para receber solicitações do cliente. Esse é o próximo passo.

Transformando o classificador de mensagens de spam em um aplicativo da Web

Tendo preparado o código para classificar mensagens SMS na seção anterior, desenvolveremos um aplicativo da Web que consiste em uma página da web simples com um campo de formulário que nos permite inserir uma mensagem. Depois de enviar a mensagem para o aplicativo da web, ela será renderizada em uma nova página que nos dá um resultado de spam ou não spam.

Primeiro, criamos uma pasta para este projeto chamada SMS-Message-Spam-Detector, esta é a árvore de diretórios dentro da pasta. Vamos explicar cada arquivo.

spam.csv
app.py
templates/
        home.html
        result.html
static/
        style.css

Os modelos de subdiretórios são o diretório no qual o Flask irá procurar por arquivos HTML estáticos para renderização no navegador da web, no nosso caso, temos dois arquivos html: home.html e result.html.

App.py

O arquivo app.py contém o código principal que será executado pelo interpretador Python para executar o aplicativo da web Flask, incluindo o código ML para classificar as mensagens SMS:

• Nós rodamos nosso aplicativo como um único módulo; Assim, inicializamos uma nova instância do Flask com o argumento __name__ para informar ao Flask que ele pode encontrar a pasta de modelos HTML (templates) no mesmo diretório em que está localizada.
• Em seguida, usamos o decorador de rotas (@ app.route ('/')) para especificar a URL que deveria acionar a execução da função home.
• Nossa função inicial simplesmente renderizou o arquivo HTML home.html, localizado na pasta de modelos.
• Dentro da função de previsão, acessamos o conjunto de dados de spam, pré-processamos o texto, fazemos previsões e armazenamos o modelo. Acessamos a nova mensagem inserida pelo usuário e usamos nosso modelo para fazer uma previsão para seu rótulo.
• Usamos o método POST para transportar os dados do formulário para o servidor no corpo da mensagem. Finalmente, definindo o argumento debug = True dentro do método app.run, ativamos ainda mais o depurador do Flask.
• Por fim, usamos a função run para executar somente o aplicativo no servidor quando esse script é executado diretamente pelo interpretador Python, o que garantimos usando a instrução if com __name__ == '__main__'.

home.html

A seguir, o conteúdo do arquivo home.html que renderizará um formulário de texto no qual um usuário pode inserir uma mensagem:

style.css

Na seção de cabeçalho de home.html, nós carregamos styles.cssfile. CSS é determinar como a aparência de documentos HTML. O styles.css deve ser salvo em um subdiretório chamadostatic, que é o diretório padrão onde o Flask procura por arquivos estáticos, como o CSS.

result.html

Criamos um arquivo result.html que será renderizado por meio do retorno da linha render_template ('result.html', prediction = my_prediction) dentro da função de previsão, que definimos no script app.py para exibir o texto que um usuário enviou por meio do campo de texto. O arquivo result.html contém o seguinte conteúdo:

De result.htm, podemos ver que algum código usando a sintaxe normalmente não encontrada em arquivos HTML: {% se a previsão == 1%}, {% elif prediction == 0%}, {% endif%} Esta é a sintaxe jinja, e Ele é usado para acessar a previsão retornada de nossa solicitação HTTP no arquivo HTML.

Estamos quase lá!

Continuaremos no próximo artigo!