Tutorial: Aplicar modelos de machine learning em Funções do Azure com Python e TensorFlow

Artigo
06/01/2023

Neste artigo, vai aprender a utilizar Python, TensorFlow e Funções do Azure com um modelo de machine learning para classificar uma imagem com base nos respetivos conteúdos. Uma vez que trabalha localmente e não cria recursos do Azure na cloud, não há custos para concluir este tutorial.

Inicialize um ambiente local para desenvolver Funções do Azure em Python.
Importe um modelo de machine learning do TensorFlow personalizado para uma aplicação de funções.
Crie uma API HTTP sem servidor para classificar uma imagem como contendo um cão ou um gato.
Consumir a API numa aplicação Web.

Pré-requisitos

Uma conta do Azure com uma subscrição ativa. Crie uma conta gratuitamente.
Python 3.7.4. (O Python 3.7.4 e o Python 3.6.x são verificados com Funções do Azure; O Python 3.8 e versões posteriores ainda não são suportados.)
Ferramentas Funções do Azure Core
Um editor de código como o Visual Studio Code

Verificação de pré-requisitos

Numa janela de terminal ou comando, execute func --version para verificar se o Funções do Azure Core Tools é a versão 2.7.1846 ou posterior.
Execute python --version (Linux/MacOS) ou py --version (Windows) para verificar os relatórios de versão do Python 3.7.x.

Clonar o repositório do tutorial

Numa janela de terminal ou comando, clone o seguinte repositório com o Git:

git clone https://github.com/Azure-Samples/functions-python-tensorflow-tutorial.git

Navegue para a pasta e examine os respetivos conteúdos.
```
cd functions-python-tensorflow-tutorial
```
- start é a sua pasta de trabalho para o tutorial.
- o fim é o resultado final e a implementação completa da referência.
- os recursos contêm o modelo de machine learning e as bibliotecas auxiliares.
- o front-end é um site que chama a aplicação de funções.

Criar e ativar um ambiente virtual do Python

Navegue para a pasta iniciar e execute os seguintes comandos para criar e ativar um ambiente virtual com o nome .venv. Certifique-se de que utiliza o Python 3.7, que é suportado por Funções do Azure.

cd start
python -m venv .venv
source .venv/bin/activate

Se o Python não tiver instalado o pacote venv na distribuição do Linux, execute o seguinte comando:

sudo apt-get install python3-venv

cd start
py -3.7 -m venv .venv
.venv\scripts\activate

cd start
py -3.7 -m venv .venv
.venv\scripts\activate

Executa todos os comandos subsequentes neste ambiente virtual ativado. (Para sair do ambiente virtual, execute deactivate.)

Criar um projeto de funções locais

No Funções do Azure, um projeto de função é um contentor para uma ou mais funções individuais que cada uma responde a um acionador específico. Todas as funções num projeto partilham as mesmas configurações locais e de alojamento. Nesta secção, vai criar um projeto de função que contém uma única função boilerplate com o nome classify que fornece um ponto final HTTP. Pode adicionar código mais específico numa secção posterior.

Na pasta iniciar, utilize o Funções do Azure Core Tools para inicializar uma aplicação de funções Python:
```
func init --worker-runtime python
```
Após a inicialização, a pasta iniciar contém vários ficheiros para o projeto, incluindo ficheiros de configurações denominados local.settings.json e host.json. Uma vez que local.settings.json pode conter segredos transferidos do Azure, o ficheiro é excluído do controlo de origem por predefinição no ficheiro .gitignore .

Dica

Uma vez que um projeto de função está associado a um runtime específico, todas as funções no projeto têm de ser escritas com o mesmo idioma.
Adicione uma função ao projeto com o seguinte comando, em que o --name argumento é o nome exclusivo da função e o --template argumento especifica o acionador da função. func new crie uma subpasta que corresponda ao nome da função que contém um ficheiro de código adequado ao idioma escolhido do projeto e a um ficheiro de configuração com o nome function.json.
```
func new --name classify --template "HTTP trigger"
```
Este comando cria uma pasta que corresponde ao nome da função, classificar. Nessa pasta encontram-se dois ficheiros: __init__.py, que contém o código da função, e function.json, que descreve o acionador da função e os enlaces de entrada e saída. Para obter detalhes sobre o conteúdo destes ficheiros, veja Modelo de programação no guia para programadores do Python.

Executar a função localmente

Inicie a função ao iniciar o anfitrião de runtime Funções do Azure local na pasta iniciar:
```
func start
```
Assim que vir o classify ponto final a aparecer na saída, navegue para o URL, http://localhost:7071/api/classify?name=Azure. A mensagem "Olá Azure!" deve aparecer na saída.
Utilize Ctrl-C para parar o anfitrião.

Importar o modelo tensorFlow e adicionar código auxiliar

Para modificar a classify função para classificar uma imagem com base nos respetivos conteúdos, utilize um modelo do TensorFlow pré-criado com o qual foi preparado e exportado do Azure Visão Personalizada Service. O modelo, que está contido na pasta de recursos do exemplo que clonou anteriormente, classifica uma imagem com base no facto de conter um cão ou um gato. Em seguida, adicione alguns códigos auxiliares e dependências ao seu projeto.

Para criar o seu próprio modelo com a camada gratuita do Serviço Visão Personalizada, siga as instruções no repositório de projetos de exemplo.

Dica

Se quiser alojar o modelo TensorFlow independentemente da aplicação de funções, pode montar uma partilha de ficheiros que contenha o seu modelo na sua aplicação de funções do Linux. Para saber mais, veja Montar uma partilha de ficheiros numa aplicação de funções python com a CLI do Azure.

Na pasta Iniciar , execute o seguinte comando para copiar os ficheiros de modelo para a pasta classificar . Certifique-se de que inclui \* no comando.
- bash
- PowerShell
- Cmd
```
cp ../resources/model/* classify
```
```
copy ..\resources\model\* classify
```
```
copy ..\resources\model\* classify
```
Verifique se a pasta classify contém ficheiros denominados model.pb e labels.txt. Caso contrário, verifique se executou o comando na pasta Iniciar .
Na pasta Iniciar , execute o seguinte comando para copiar um ficheiro com código auxiliar para a pasta classificar :
- bash
- PowerShell
- Cmd
```
cp ../resources/predict.py classify
```
```
copy ..\resources\predict.py classify
```
```
copy ..\resources\predict.py classify
```
Verifique se a pasta classify contém agora um ficheiro com o nome predict.py.
Abra start/requirements.txt num editor de texto e adicione as seguintes dependências necessárias pelo código auxiliar:
```
tensorflow==1.14
Pillow
requests
```
Guarde requirements.txt.
Instale as dependências ao executar o seguinte comando na pasta Iniciar . A instalação pode demorar alguns minutos, período durante o qual pode continuar a modificar a função na secção seguinte.
```
pip install --no-cache-dir -r requirements.txt
```
No Windows, poderá encontrar o erro "Não foi possível instalar pacotes devido a um EnvironmentError: [Errno 2] Não existe tal ficheiro ou diretório:" seguido de um nome de caminho longo para um ficheiro como sharded_mutable_dense_hashtable.cpython-37.pyc. Normalmente, este erro ocorre porque a profundidade do caminho da pasta torna-se demasiado longa. Neste caso, defina a chave HKEY_LOCAL_MACHINE\SYSTEM\CurrentControlSet\Control\FileSystem@LongPathsEnabled de registo para 1 ativar caminhos longos. Em alternativa, verifique onde está instalado o seu interpretador python. Se essa localização tiver um caminho longo, tente reinstalar numa pasta com um caminho mais curto.

Dica

Ao chamar predict.py para fazer a sua primeira predição, uma função com o nome _initialize carrega o modelo TensorFlow do disco e coloca-o em cache em variáveis globais. Esta colocação em cache acelera as predições subsequentes. Para obter mais informações sobre como utilizar variáveis globais, veja o guia para programadores do Funções do Azure Python.

Atualizar a função para executar predições

Abra classify/__init__.py num editor de texto e adicione as seguintes linhas após as instruções existentes import para importar a biblioteca JSON padrão e os auxiliares de previsão :
```
import logging
import azure.functions as func
import json

# Import helper script
from .predict import predict_image_from_url
```
Substitua todo o conteúdo da main função pelo seguinte código:
```
def main(req: func.HttpRequest) -> func.HttpResponse:
    image_url = req.params.get('img')
    logging.info('Image URL received: ' + image_url)

    results = predict_image_from_url(image_url)

    headers = {
        "Content-type": "application/json",
        "Access-Control-Allow-Origin": "*"
    }

    return func.HttpResponse(json.dumps(results), headers = headers)
```
Esta função recebe um URL de imagem num parâmetro de cadeia de consulta com o nome img. Em seguida, chama predict_image_from_url a partir da biblioteca auxiliar para transferir e classificar a imagem com o modelo TensorFlow. Em seguida, a função devolve uma resposta HTTP com os resultados.

Importante

Uma vez que este ponto final HTTP é chamado por uma página Web alojada noutro domínio, a resposta inclui um Access-Control-Allow-Origin cabeçalho para satisfazer os requisitos de Partilha de Recursos De Várias Origens (CORS) do browser.

Numa aplicação de produção, altere * para a origem específica da página Web para maior segurança.
Guarde as alterações e, em seguida, partindo do princípio de que as dependências terminaram de instalar, inicie novamente o anfitrião da função local com func start. Certifique-se de que executa o anfitrião na pasta iniciar com o ambiente virtual ativado. Caso contrário, o anfitrião será iniciado, mas verá erros ao invocar a função.
```
func start
```

Num browser, abra o seguinte URL para invocar a função com o URL de uma imagem de gato e confirme que o JSON devolvido classifica a imagem como um gato.

http://localhost:7071/api/classify?img=https://raw.githubusercontent.com/Azure-Samples/functions-python-tensorflow-tutorial/master/resources/assets/samples/cat1.png

Mantenha o anfitrião em execução porque o utilizará no próximo passo.

Executar o front-end da aplicação Web local para testar a função

Para testar a invocação do ponto final de função de outra aplicação Web, existe uma aplicação simples na pasta de front-end do repositório.

Abra um novo terminal ou linha de comandos e ative o ambiente virtual (conforme descrito anteriormente em Criar e ativar um ambiente virtual python).
Navegue para a pasta de front-end do repositório.

Iniciar um servidor HTTP com Python:

python -m http.server

py -m http.server

py -m http.server

Num browser, navegue para localhost:8000e, em seguida, introduza um dos seguintes URLs de fotografia na caixa de texto ou utilize o URL de qualquer imagem acessível publicamente.
- https://raw.githubusercontent.com/Azure-Samples/functions-python-tensorflow-tutorial/master/resources/assets/samples/cat1.png
- https://raw.githubusercontent.com/Azure-Samples/functions-python-tensorflow-tutorial/master/resources/assets/samples/cat2.png
- https://raw.githubusercontent.com/Azure-Samples/functions-python-tensorflow-tutorial/master/resources/assets/samples/dog1.png
- https://raw.githubusercontent.com/Azure-Samples/functions-python-tensorflow-tutorial/master/resources/assets/samples/dog2.png
Selecione Submeter para invocar o ponto final da função para classificar a imagem.

Se o browser relatar um erro ao submeter o URL da imagem, verifique o terminal no qual está a executar a aplicação de funções. Se vir um erro como "Nenhum módulo encontrado 'PIL'", poderá ter iniciado a aplicação de funções na pasta iniciar sem ativar primeiro o ambiente virtual que criou anteriormente. Se continuar a ver erros, execute pip install -r requirements.txt novamente com o ambiente virtual ativado e procure erros.

Nota

O modelo classifica sempre o conteúdo da imagem como um gato ou um cão, independentemente de a imagem conter qualquer um deles, predefinindo para cão. Imagens de tigres e panteras, por exemplo, tipicamente classificam-se como gatos, mas imagens de elefantes, cenouras ou aviões classificam-se como cães.

Limpar os recursos

Uma vez que todo este tutorial é executado localmente no seu computador, não existem recursos ou serviços do Azure para limpar.

Passos seguintes

Neste tutorial, aprendeu a criar e personalizar um ponto final da API HTTP com Funções do Azure para classificar imagens com um modelo tensorFlow. Também aprendeu a chamar a API a partir de uma aplicação Web. Pode utilizar as técnicas neste tutorial para criar APIs de qualquer complexidade, todas em execução no modelo de computação sem servidor fornecido pelo Funções do Azure.

Implementar a função para Funções do Azure com o Guia da CLI do Azure

Veja também:

Partilhar via