Tutorial de aprendizado profundo – como treinar e implantar um modelo de aprendizado profundo com fast.ai

Tutorial de aprendizado profundo – como treinar e implantar um modelo de aprendizado profundo com fast.ai

6 de October, 2020 0 By António César de Andrade


O aprendizado profundo está trazendo mudanças revolucionárias para muitas disciplinas. Ele também está se tornando mais acessível para especialistas de domínio e entusiastas de IA com o advento de bibliotecas como TensorFlow, PyTorch e agora fast.ai.

A missão do fast.ai é democratizar o aprendizado profundo. É um instituto de pesquisa dedicado a ajudar a todos – de um programador de nível iniciante a um proficiente praticante de aprendizado profundo – a obter resultados de classe mundial com modelos e técnicas de última geração das pesquisas mais recentes no campo.

Esta postagem do blog orientará você no processo de desenvolvimento um classificador de cães usando fast.ai. O objetivo é aprender como é fácil começar com modelos de aprendizado profundo e ser capaz de obter resultados quase perfeitos com uma quantidade limitada de dados usando modelos pré-treinados.

Pré-requisito

O único pré-requisito para começar é que você saber como codificar em Python e que você está familiarizado com a matemática do ensino médio.

O que você aprenderá

  1. Importando as bibliotecas e configurando o notebook
  2. Coletando dados de imagens usando o Microsoft Azure
  3. Converter dados baixados em objetos DataLoader
  4. Aumento de dados
  5. Limpeza de dados usando treinamento de modelo
  6. Exportando o modelo treinado
  7. Construindo um aplicativo a partir de seu Jupyter Notebook

Então vamos começar.

Como importar as bibliotecas e configurar o notebook

Antes de começarmos a construir nosso modelo, precisamos importar as bibliotecas necessárias e a função de utilitário de o conjunto de cadernos chamado livro rápido. Ele foi desenvolvido para cobrir a introdução ao Deep Learning usando fast.ai e PyTorch.

Vamos instalar o pacote fastbook para configurar o notebook:

!pip install -Uqq fastbook
import fastbook
fastbook.setup_book()

Então, vamos importar todas as funções e classes do pacote fastbook e da API de widgets fast.ai vision:

from fastbook import *
from fastai.vision.widgets import *

Como coletar dados de imagens usando o Microsoft Azure

Para a maioria dos tipos de projetos, você pode encontrar os dados online de vários repositórios de dados e sites. Para desenvolver um classificador de cães, precisamos ter imagens de cães. Existem muitas imagens de cães disponíveis na Internet.

Para baixar essas imagens, usaremos o API Bing Image Search fornecido pelo Microsoft Azure. Então, inscreva-se para uma conta gratuita no Microsoft Azure e você receberá $ 200 em créditos.

Vá para o seu portal e crie um novo recurso de Serviço Cognitivo usando este guia de início rápido. Ative a API Bing Image Search. Então, do Keys and Endpoint opção no painel esquerdo, copie o chaves ao seu recurso.

Com as chaves recuperadas, defina essas chaves para o ambiente da seguinte maneira:

key = os.environ.get('AZURE_SEARCH_KEY', '<YOUR_KEY>')

Agora, o fastbook vem com funções utilitárias como search_images_bing que retorna URLs correspondentes à sua consulta de pesquisa. Você pode aprender sobre essas funções usando a função de ajuda:

help(fastbook)

Você pode verificar o search_image_bing função neste guia de ajuda. A função aceita uma chave para o seu recurso que você definiu acima e a consulta de pesquisa, e podemos acessar os URLs dos resultados da pesquisa usando o attrgot método:

results = search_images_bing(key, 'german shepherd dogs')
images = results.attrgot('content_url')
len(images)

Temos 150 URLs de imagens de cães pastor alemão:

Agora, podemos baixar essas imagens usando o download_url função. Mas vamos primeiro definir o tipo de cachorro que queremos.

Para este tutorial, irei trabalhar com três tipos de cães: Pastores Alemães, cães pretos e Labradores.

Então, vamos definir uma lista de tipos de cães:

dog_types = ['german shepherd', 'black', 'labrador']
path = Path('dogs')

Em seguida, você precisará definir o caminho onde suas imagens serão baixadas, juntamente com os nomes semânticos da pasta para cada classe de cão.

if not path.exists():
    path.mkdir()
    for t in dog_types:
        dest = (path/t)
        print(dest)
        dest.mkdir(exist_ok=True)
        results = search_images_bing(key, '{} dog'.format
        download_images(dest, urls=results.attrgot('content_url'))

Isso criará um diretório “cães” que contém mais 3 diretórios para cada tipo de imagem de cachorro.

Depois disso, passamos a consulta de pesquisa (que é o dog_type) e a chave para a função de pesquisa, seguida da função de download para baixar todos os URLs dos resultados da pesquisa em seus respectivos destinos (dest) diretórios.

Podemos verificar as imagens baixadas para um caminho usando o get_image_file função:

files = get_image_files(path)
files

Como verificar imagens

Você também pode verificar o número de arquivos / imagens corrompidos nos arquivos:

corrupt = verify_images(files)
corrupt

##output: (#0) []

Você pode remover todos os arquivos corrompidos (se houver) mapeando o método de desvinculação para a lista de arquivos corrompidos: corrupt.map (Path.unlink);

É isso, temos 379 imagens de cães prontas conosco para treinar e validar nosso modelo.

Como converter dados baixados em objetos DataLoader

Agora, precisamos de um mecanismo para fornecer dados ao nosso modelo. fast.ai tem este conceito de DataLoaders que armazena vários objetos DataLoader passados ​​para ele e os disponibiliza como um training e validation conjunto.

Agora, para converter os dados baixados em um objeto DataLoader, temos que fornecer quatro coisas:

  • Com quais tipos de dados estamos trabalhando
  • Como obter a lista de itens
  • Como rotular esses itens
  • Como criar o conjunto de validação

Agora, para criar esses objetos DataLoaders junto com as informações mencionadas acima, fast.ai oferece um sistema flexível chamado de API de bloco de dados. Podemos especificar todos os detalhes da criação do DataLoader usando os argumentos e uma série de métodos de transformação que a API oferece:

dogs = DataBlock(
                  blocks=(ImageBlock, CategoryBlock),
                  get_items=get_image_files,
                  splitter=RandomSplitter(valid_pct=0.2, seed=41),
                  get_y=parent_label,
                  item_tfms=Resize(128)
                  )

Aqui, temos um monte de argumentos que devemos entender:

  • blocos – especifica as variáveis ​​de recurso (imagens) e a variável de destino (uma categoria para cada imagem)
  • get_items– recupera os itens subjacentes (que são imagens no nosso caso) e temos um get_image_files função que retorna uma lista de todas as imagens nesse caminho.
  • divisor– divide os dados de acordo com o método fornecido. Estamos usando uma divisão aleatória com 20% dos dados reservados para o conjunto de validação e especificamos a semente para obter a mesma divisão em cada execução.
  • get_y –a variável de destino é conhecida como y. Para criar os rótulos, estamos usando o parent_label função que obtém o nome da pasta onde o arquivo reside como seu rótulo.
  • item_tfms– temos imagens de tamanhos diferentes e isso causa um problema porque sempre enviamos um lote de arquivos para o modelo em vez de um único arquivo. Portanto, precisamos pré-processar essas imagens redimensionando-as para um padrão e, em seguida, agrupando-as em um tensor para passar pelo modelo. Estamos usando o Resize transformação aqui.

Agora, temos o objeto DataBlock que precisa ser convertido em um DataLoader, fornecendo o caminho para o conjunto de dados:

dls = dogs.dataloaders(path)

Podemos então verificar as imagens no objeto dataloader usando o show_batch método:

dls.valid.show_batch()

Aumento de dados

Podemos adicionar transformações a essas imagens para criar variações aleatórias das imagens de entrada, de modo que pareçam diferentes, mas ainda representem os mesmos fatos.

Podemos girar, distorcer, inverter ou alterar o brilho / contraste das imagens para criar essas variações. Também temos um conjunto padrão de aumentos encapsulados no aug_transforms função que funciona muito bem para a maioria dos conjuntos de dados de visão computacional.

Agora podemos aplicar essas transformações a um lote inteiro de imagens, pois todas as imagens são do mesmo tamanho (224 pixels, padrão para problemas de classificação de imagens) usando o seguinte:

##adding item transformations
dogs = dogs.new(
        item_tfms=RandomResizedCrop(224, min_scale=0.5),
        batch_tfms=aug_transforms(mult=2)
        )
dls = dogs.dataloaders(path)
dls.train.show_batch(max_n=8, nrows=2, unique=True)

Treinamento de modelo e limpeza de dados

É hora de treinar o modelo com esse número limitado de imagens. fast.ai oferece muitas arquiteturas para usar, o que torna muito fácil usar a aprendizagem por transferência.

Podemos criar um modelo de rede neural convolucional (CNN) usando os modelos pré-treinados que funcionam para a maioria dos aplicativos / conjuntos de dados.

Usaremos a arquitetura ResNet, pois é rápida e precisa para muitos conjuntos de dados e problemas. Os 18 na resnet18 representa o número de camadas da rede neural.

Também passamos a métrica para medir a qualidade das previsões do modelo usando o conjunto de validação do dataloader. Nós estamos usando taxa de erroque nos diz com que frequência o modelo está fazendo previsões incorretas:

model = cnn_learner(dls, resnet18, metrics=error_rate)
model.fine_tune(4)

o fine_tune método é análogo ao fit() método em outras bibliotecas de ML. Agora, para treinar o modelo, precisamos especificar o número de vezes (épocas) que queremos treinar o modelo em cada imagem.

Aqui, estamos treinando por apenas 4 épocas:

Também podemos visualizar as previsões e compará-las com os rótulos reais usando a matriz de confusão:

interp = ClassificationInterpretation.from_learner(learn)
interp.plot_confusion_matrix()

Como você pode ver, temos apenas cinco previsões incorretas. Vamos verificar as perdas principais, ou seja, as imagens com a maior perda no conjunto de dados: interp.plot_top_losses (6, nrows = 3):

Você pode ver que o modelo se confundiu entre preto e labrador. Portanto, podemos especificar que essas imagens estejam em uma categoria particular usando a classe ImageClassifierCleaner.

Passe o modelo para a classe e ela abrirá um widget com uma GUI intuitiva para limpeza de dados. Podemos alterar os rótulos das imagens do conjunto de treinamento e validação e visualizar as imagens de maior perda.

Depois de adicionar cada imagem à sua respectiva classe correta, temos que movê-las para o diretório correto usando:

for idx,cat in cleaner.change():
    shutil.move(str(cleaner.fns[idx]), str(path/cat).split('.')[0] +"_fixed.jpg")

Como exportar o modelo treinado

Depois de algumas rodadas de ajuste de hiperparâmetros, e quando estiver satisfeito com seu modelo, você precisa salvá-lo para poder implantá-lo em um servidor para ser usado na produção.

Ao salvar um modelo, temos a arquitetura do modelo e os parâmetros treinados que são valiosos para nós. fast.ai oferece o export() método para salvar o modelo em um arquivo pickle com a extensão .pkl.

model.export()
path = Path()
path.ls(file_exts=".pkl")

Podemos então carregar o modelo e fazer inferências passando uma imagem para o modelo carregado:

model_inf = load_learner(path/'export.pkl')

Use este modelo carregado para fazer inferências:

model_inf.predict('dogs/labrador/00000000.jpg')

Podemos verificar os rótulos do vocabulário do dataloader dos modelos:

model_inf.dls.vocab

Como construir um aplicativo a partir do seu notebook Jupyter

A próxima etapa é criar um aplicativo que possamos compartilhar com nossos amigos, colegas, recrutadores e outras pessoas.

Para criar um aplicativo, precisamos adicionar elementos interativos para que possamos experimentar e testar os recursos do aplicativo. Também precisamos disponibilizá-lo na web como uma página da web, o que inclui implantá-lo por meio de algum framework como o Flask ou simplesmente usando Voila.

Você pode usar o Voila para converter este Notebook Jupyter em um aplicativo independente. Eu não cobri isso aqui, mas você pode ver o meu blog / vídeo que cobre todo o processo.

Implantando seu modelo

Abordei a implantação de um modelo de ML em minha postagem aqui. Mas se você quiser outra maneira fácil e gratuita de implantar seu aplicativo Voila, pode usar Encadernador.

Siga estas etapas para implantar o aplicativo no Binder:

  1. Adicione seu caderno a um Repositório GitHub.
  2. Insira a URL desse repositório no campo URL do Binder.
  3. Altere o menu suspenso do arquivo para selecionar o URL.
  4. No campo “URL para abrir”, digite /voila/render/<name>.ipynb
  5. Clique no botão da área de transferência no canto inferior direito para copiar o URL e colá-lo em um local seguro.
  6. Clique em Iniciar.

E pronto, seu classificador de cães está vivo!

Se você preferir me assistir passando por todas essas etapas, aqui está a versão em vídeo deste blog:

Ciência de Dados com Harshit

Com este canal, estou planejando lançar alguns série cobrindo todo o espaço da ciência de dados. Aqui está porque você deve se inscrever no canal:

Sinta-se à vontade para se conectar comigo no Twitter ou LinkedIn.





Fonte

Click to rate this post!
[Total: 0 Average: 0]