😭 👨🏽‍🏭 📣 Implantando o Keras Deep Learning Model como um aplicativo da Web Python 🏳️‍🌈 👩‍🎓 🙎🏽

A tradução do artigo foi preparada especificamente para os alunos do curso "Desenvolvedor Web em Python" .

Criar um projeto interessante de aprendizado de máquina é uma coisa, outra coisa quando você precisa que outras pessoas possam vê-lo também. Claro, você pode colocar todo o projeto no GitHub, mas como seus avós entenderão o que você fez? Não, precisamos implantar nosso modelo de aprendizado profundo como um aplicativo da Web que estará disponível para qualquer pessoa no mundo.

Neste artigo, aprenderemos como escrever um aplicativo Web que usa a rede neural recorrente treinada por Keras e permite que os usuários criem novas anotações de patentes. Este projeto é baseado no trabalho do artigo "Redes Neurais Recorrentes por Exemplo" , no entanto, não é necessário saber como a RNN é construída agora. No momento, consideraremos apenas uma caixa preta: definimos a sequência inicial e ela exibe uma anotação de patente completamente nova, que pode ser visualizada em um navegador!

Normalmente, os analistas de dados desenvolvem modelos e o front-end os mostra ao mundo. Neste projeto, teremos que desempenhar ambos os papéis e mergulhar no desenvolvimento da Web (embora quase inteiramente em Python).

Este projeto exigirá a combinação de várias ferramentas:

Flask : para criar uma aplicação web básica em Python;
Keras : implantando uma rede neural recorrente pré-treinada
Modelos do mecanismo de modelos Jinja ;
HTML e CSS para criar páginas da web.

Por fim, obtemos um aplicativo da Web que permitirá aos usuários criar anotações de patentes completamente novas usando uma rede neural recorrente treinada.

Todo o código do projeto está disponível no GitHub .

A abordagem

O objetivo era implantar o aplicativo Web o mais rápido possível. Para isso, escolhi o Flask, que permite escrever aplicativos em Python. Como não gosto de mexer com estilos (acho que você já viu), copio e colo quase todo o CSS de fontes de terceiros. Este artigo da equipe Keras foi útil para aprender o básico, e este artigo também é um guia útil.

Em geral, este projeto atende aos meus princípios de design: crie um protótipo que funcione rapidamente (copie e cole o código necessário) e depois repita a mesma coisa para melhorar o produto.

Aplicativo Web básico no Flask

A maneira mais rápida de criar um aplicativo Web Python é usar o Flask (http://flask.pocoo.org/). Para criar nosso próprio aplicativo, podemos usar o seguinte:

from flask import Flask app = Flask(__name__) @app.route("/") def hello(): return "<h1>Not Much Going On Here</h1>" app.run(host='0.0.0.0', port=50000)

Se você executar esse código, verá seu próprio aplicativo em localhost: 50000. Obviamente, precisamos de algo mais, portanto, usaremos uma função mais complexa que geralmente faz o mesmo: processa solicitações do seu navegador e exibe algum conteúdo na forma de HTML.

Formulário de entrada do usuário

Quando os usuários acessam a página principal do aplicativo, mostraremos a eles um formulário com três opções:

Digite a sequência de origem para o RNN ou gere-a aleatoriamente.
Seleção da “diversidade” das previsões da RNN.
A escolha do número de palavras emitidas pelo RNN

Para criar um formulário em Python, usamos wtforms . Você verá o código para sua criação abaixo:

 from wtforms import (Form, TextField, validators, SubmitField, DecimalField, IntegerField) class ReusableForm(Form): """User entry form for entering specifics for generation""" # Starting seed seed = TextField("Enter a seed string or 'random':", validators=[ validators.InputRequired()]) # Diversity of predictions diversity = DecimalField('Enter diversity:', default=0.8, validators=[validators.InputRequired(), validators.NumberRange(min=0.5, max=5.0, message='Diversity must be between 0.5 and 5.')]) # Number of words words = IntegerField('Enter number of words to generate:', default=50, validators=[validators.InputRequired(), validators.NumberRange(min=10, max=100, message='Number of words must be between 10 and 100')]) # Submit button submit = SubmitField("Enter")

Utilizando-o, criamos o formulário mostrado abaixo (com estilos de main.css ):

Uma verificação no código é necessária para garantir que o usuário insira as informações corretas. Por exemplo, verificamos se todos os campos estão preenchidos e se o valor do parâmetro de diversidade está entre 0,5 e 5. Essas condições devem ser atendidas para começar.

Erro ao validar os dados inseridos

Processamos este formulário usando modelos no Flask .

Padrões

Um modelo é um arquivo com um "quadro" já preparado que simplesmente precisa ser preenchido de uma certa maneira. Para um aplicativo Web Flask, podemos usar a biblioteca de modelos Jinja para converter o código Python em um documento HTML. Por exemplo, em nossa função principal, enviaremos o conteúdo do formulário para um modelo chamado index.html .

 from flask import render_template # Home page @app.route("/", methods=['GET', 'POST']) def home(): """Home page of app with form""" # Create form form = ReusableForm(request.form) # Send template information to index.html return render_template('index.html', form=form)

Quando o usuário acessa a página principal, nosso aplicativo fornece ao index.html entrada do formulário. O modelo é uma estrutura HTML completa na qual nos referimos às variáveis Python usando a sintaxe {{variable}} .

 <!DOCTYPE html> <html> <head> <title>RNN Patent Writing</title> <link rel="stylesheet" href="/static/css/main.css"> <link rel="shortcut icon" href="/static/images/lstm.ico"> </head> <body> <div class="container"> <h1> <center>Writing Novel Patent Abstracts with Recurrent Neural Networks</center> </h1> {% block content %} {% for message in form.seed.errors %} <div class="flash">{{ message }}</div> {% endfor %} {% for message in form.diversity.errors %} <div class="flash">{{ message }}</div> {% endfor %} {% for message in form.words.errors %} <div class="flash">{{ message }}</div> {% endfor %} <form method=post> {{ form.seed.label }} {{ form.seed }} {{ form.diversity.label }} {{ form.diversity }} {{ form.words.label }} {{ form.words }} {{ form.submit }} </form> {% endblock %} </div> </body> </html>

Quando ocorre um erro no formulário (entrada que não pode ser verificada), uma mensagem de erro pisca. Além disso, o formulário será exibido como no arquivo acima.

Quando o usuário digita informações e clica em submit (solicitação POST ), se as informações estiverem corretas, redirecionamos os dados de entrada para a função correspondente para fazer previsões usando RNN treinado. Isso significa que você precisa modificar home() .

 from flask import request # User defined utility functions from utils import generate_random_start, generate_from_seed # Home page @app.route("/", methods=['GET', 'POST']) def home(): """Home page of app with form""" # Create form form = ReusableForm(request.form) # On form entry and all conditions met if request.method == 'POST' and form.validate(): # Extract information seed = request.form['seed'] diversity = float(request.form['diversity']) words = int(request.form['words']) # Generate a random sequence if seed == 'random': return render_template('random.html', input=generate_random_start(model=model, graph=graph, new_words=words, diversity=diversity)) # Generate starting from a seed sequence else: return render_template('seeded.html', input=generate_from_seed(model=model, graph=graph, seed=seed, new_words=words, diversity=diversity)) # Send template information to index.html return render_template('index.html', form=form)

Agora, quando o usuário pressiona submit e as informações inseridas estão corretas, dependendo da entrada, a entrada é enviada para generate_random_start ou generate_from_seed . Esses recursos usam o modelo treinado por Keras para criar uma nova patente com os parâmetros de usuário e diversity num_words . A saída dessa função, por sua vez, é enviada aleatoriamente para os modelos seeded.html ou seeded.html para exibição como uma página da web.

Criando previsões usando o modelo pré-treinado Keras

O parâmetro parâmetro contém o modelo Keras pré-treinado, que carrega da seguinte maneira:

 from keras.models import load_model import tensorflow as tf def load_keras_model(): """Load in the pre-trained model""" global model model = load_model('../models/train-embeddings-rnn.h5') # Required for model to work global graph graph = tf.get_default_graph() load_keras_model()

(Basicamente, existe uma solução alternativa que se parece com tf.get_default_graph() )
Não mostrarei completamente duas funções util (o código que você encontrará aqui ), porque tudo o que você precisa entender é que elas armazenam o modelo Keras já treinado junto com os parâmetros e fazem previsões - anotações de patentes.

Ambas as funções retornam uma string em Python com HTML formatado. Essa linha é enviada para outro modelo, que aparecerá como uma página da web. Por exemplo, generate_random_start retorna HTML formatado enviado para random.html :

 <!DOCTYPE html> <html> <header> <title>Random Starting Abstract </title> <link rel="stylesheet" href="/static/css/main.css"> <link rel="shortcut icon" href="/static/images/lstm.ico"> <ul> <li><a href="/">Home</a></li> </ul> </header> <body> <div class="container"> {% block content %} {{input|safe}} {% endblock %} </div> </body>

Aqui, novamente, usamos o mecanismo de modelo Jinja para exibir um arquivo HTML formatado. Como a string Python já está traduzida para HTML, tudo o que precisamos fazer para exibi-la é usar {{input|safe}} (onde input é uma variável Python). No main.css , no entanto, podemos adicionar estilos a esta página, assim como a outras páginas HTML.

Resultado do trabalho

A função generate_random_start seleciona uma anotação aleatória de patente como uma sequência de entrada e faz previsões com base nela. Em seguida, exibe a sequência de entrada, a saída gerada pela RNN e a saída real:

A saída é baseada em uma sequência de entrada aleatória.

A função generate_from_seed aceita a sequência inicial inserida pelo usuário e constrói previsões com base nela. A saída é a seguinte:

Saída baseada na sequência de entrada do usuário.

Embora os resultados nem sempre formem sequências lógicas, eles mostram que a rede neural está familiarizada com o básico do idioma inglês. Ela foi treinada para prever cada palavra seguinte com base nas 50 anteriores e, assim, selecionar uma anotação atraente. Dependendo do parâmetro de diversity , a saída pode ser completamente aleatória ou cíclica.

Lançamento do aplicativo

Para iniciar o aplicativo, basta fazer o download do repositório, acessar o diretório em que está a implantação e inserir run_keras_server.py . O aplicativo estará disponível no localhost:10000 .

Dependendo de como o Wi-Fi doméstico estiver configurado, você poderá acessar o aplicativo a partir de qualquer computador na rede usando o seu endereço IP.

Próximas etapas

O aplicativo da Web em execução no seu computador pessoal é ótimo para compartilhar com amigos e familiares. No entanto, eu definitivamente não recomendo abri-lo para todos na sua rede doméstica. Mais tarde, aprenderemos como implantar o aplicativo no AWS EC2 e, finalmente, mostrá-lo ao mundo.

Para melhorar o aplicativo, você pode alterar os estilos ( em main.css ) e, opcionalmente, adicionar parâmetros adicionais, como a capacidade de selecionar uma rede pré-treinada. O melhor de projetos pessoais é que você pode desenvolvê-los pelo tempo que quiser. Se você quiser jogar com o aplicativo, faça o download do repositório e comece.

Conclusão

Neste artigo, aprendemos como implantar um modelo de aprendizado profundo pré-treinado Keras como um aplicativo da Web. Isso exigiu a integração de várias tecnologias diferentes, incluindo redes neurais recorrentes, aplicativos da web, modelos, HTML, CSS e, é claro, Python .

Embora esse seja um aplicativo básico, mostra que você pode criar aplicativos da Web usando aprendizado profundo com relativamente pouco esforço. Poucas pessoas podem dizer que conseguiram implantar um modelo de aprendizado profundo na forma de um aplicativo Web, mas se você seguir as instruções deste artigo, poderá se tornar um deles!

Implantando o Keras Deep Learning Model como um aplicativo da Web Python