Crie e implante um serviço preditivo do Custom Vision no R com o AzureVision

cupom com desconto - o melhor site de cupom de desconto cupomcomdesconto.com.br


O pacote AzureVision é um front-end do R para o Azure Computer Vision e o Azure Custom Vision. Esses serviços permitem que você aproveite a nuvem do Azure da Microsoft para executar tarefas de reconhecimento visual usando modelos avançados de processamento de imagem, com o mínimo de conhecimento em aprendizado de máquina.

A idéia básica por trás do Custom Vision é usar um modelo de reconhecimento de imagem pré-criado fornecido pelo Azure e personalizá-lo para suas necessidades, fornecendo um conjunto de imagens com as quais você pode atualizá-lo. Todo o treinamento e previsão de modelos são feitos na nuvem, para que você não precise de uma máquina poderosa. Da mesma forma, como você está começando com um modelo que já foi treinado, não precisa de um conjunto de dados muito grande ou de longos períodos de treinamento para obter boas previsões (idealmente).

Este artigo explica como criar, treinar e implantar um modelo de Visão Personalizada no R, usando o AzureVision.

Criando os recursos

Você pode criar os recursos do Vision personalizado por meio do portal do Azure ou no R usando os recursos fornecidos pelo AzureVision. Observe que o Custom Vision requer pelo menos dois recursos a serem criados: um para treinamento e outro para previsão. As camadas de serviço disponíveis para o Custom Vision são F0 (gratuito, limitado a 2 projetos para treinamento e 10.000 transações / mês para previsão) e S0. Aqui está o código R para criar os recursos:

library(AzureVision)

# insert your tenant, subscription, resgroup name and location here
rg ::get_azure_login(tenant)$
    get_subscription(sub_id)$
    create_resource_group(rg_name, location=rg_location)

# insert your desired Custom Vision resource names here
res $create_cognitive_service(custvis_resname,
    service_type="CustomVision.Training", service_tier="S0")
pred_res $create_cognitive_service(custvis_predresname,
    service_type="CustomVision.Prediction", service_tier="S0")

Treinamento

O Custom Vision define dois tipos diferentes de terminal: um terminal de treinamento e um terminal de previsão. De maneira um tanto confusa, eles podem usar o mesmo nome de host, mas com diferentes caminhos de URL e chaves de autenticação. Para começar, ligue para o customvision_training_endpoint função com a URL e a chave do serviço.

url $properties$endpoint
key $list_keys()[1]

endp customvision_training_endpoint(url=url, key=key)

O Custom Vision é organizado hierarquicamente. No nível superior, temos um projeto, que representa os dados e o modelo para uma tarefa específica. Dentro de um projeto, temos um ou mais iterações do modelo, construído em diferentes conjuntos de imagens de treinamento. Cada iteração em um projeto é independente: você pode criar (treinar) uma iteração, implantá-la e excluí-la sem afetar outras iterações.

Leia Também  modelador 1.3.0 | R-bloggers

Por sua vez, existem três tipos diferentes de projetos:

  • UMA classificação multiclasse O projeto é para classificar imagens em um conjunto de Tagou segmentar marcadores. Uma imagem pode ser atribuída a apenas uma tag.
  • UMA classificação multilabel O projeto é semelhante, mas cada imagem pode ter várias tags atribuídas.
  • A detecção de objetos O projeto é para detectar quais objetos, se houver, de um conjunto de candidatos estão presentes em uma imagem.

Vamos criar um projeto de classificação:

testproj create_classification_project(endp, "testproj",
    export_target="standard")

Aqui, especificamos o destino de exportação a ser standard para suportar a exportação do modelo final para um dos vários formatos independentes, por exemplo, TensorFlow, CoreML ou ONNX. O padrão é none, nesse caso, o modelo permanece no servidor Custom Vision. A vantagem de none é que o modelo pode ser mais complexo, resultando em uma precisão potencialmente melhor.

Adicionando e etiquetando imagens

Como um modelo de Visão Personalizada é treinado no Azure e não localmente, precisamos carregar algumas imagens. Os dados que usaremos são do projeto Microsoft Computer Vision Best Practices. Este é um conjunto simples de imagens contendo 4 tipos de objetos que podem ser encontrados na geladeira: latas, caixas de papelão, garrafas de leite e garrafas de água.

download.file(
    "https://cvbp.blob.core.windows.net/public/datasets/image_classification/fridgeObjects.zip",
    "fridgeObjects.zip"
)
unzip("fridgeObjects.zip")

A função genérica para adicionar imagens a um projeto é add_images, que utiliza um vetor de nomes de arquivos, URLs da Internet ou vetores brutos como imagens a serem carregadas. Retorna um vetor de IDs de imagem, que é como o Custom Vision monitora as imagens que usa.

Vamos fazer o upload dos objetos da geladeira para o projeto. O método para projetos de classificação tem um tags argumento que pode ser usado para atribuir rótulos às imagens conforme elas são carregadas. Manteremos de lado cinco imagens de cada classe de objeto para usar como dados de validação.

cans dir("fridgeObjects/can", full.names=TRUE)
cartons dir("fridgeObjects/carton", full.names=TRUE)
milk dir("fridgeObjects/milk_bottle", full.names=TRUE)
water dir("fridgeObjects/water_bottle", full.names=TRUE)

# upload all but 5 images from cans and cartons, and tag them
can_ids add_images(testproj, cans[-(1:5)], tags="can")
carton_ids add_images(testproj, cartons[-(1:5)], tags="carton")

Se você não marcar as imagens no momento do upload, poderá fazê-lo mais tarde com add_image_tags:

cupom com desconto - o melhor site de cupom de desconto cupomcomdesconto.com.br
# upload all but 5 images from milk and water bottles
milk_ids add_images(testproj, milk[-(1:5)])
water_ids add_images(testproj, water[-(1:5)])

add_image_tags(testproj, milk_ids, tags="milk_bottle")
add_image_tags(testproj, water_ids, tags="water_bottle")

Outras funções de imagem que você deve conhecer incluem list_images, remove_imagese add_image_regions (que é para projetos de detecção de objetos). Um útil é browse_images, que pega um vetor de IDs e exibe as imagens correspondentes no seu navegador.

browse_images(testproj, water_ids[1:5])
Leia Também  Desenvolvendo um aplicativo R Shiny complexo - o bom, o ruim e o feio

Treinando o modelo

Após o upload dos dados, podemos treinar o modelo Custom Vision com train_model. Isso treina o modelo no servidor e retorna um iteração do modelo, que é o resultado da execução do algoritmo de treinamento no conjunto de imagens atual. Cada vez que você liga train_model, por exemplo, para atualizar o modelo após adicionar ou remover imagens, você obterá uma iteração de modelo diferente. Em geral, você pode confiar no AzureVision para acompanhar as iterações e retornar automaticamente os resultados relevantes para a iteração mais recente.

mod train_model(testproj)

Podemos examinar o desempenho do modelo nos dados de treinamento com o summary método. Para esse problema de brinquedo, o modelo consegue obter um ajuste perfeito.

A obtenção de previsões do modelo treinado é feita com o predict método. Por padrão, isso retorna a tag prevista (rótulo de classe) para a imagem, mas você também pode obter as probabilidades de classe previstas especificando type="prob".

validation_imgs c(cans[1:5], cartons[1:5], milk[1:5], water[1:5])
validation_tags rep(c("can", "carton", "milk_bottle", "water_bottle"), each=5)

predicted_tags predict(mod, validation_imgs)

table(predicted_tags, validation_tags)
##               validation_tags
## predicted_tags can carton milk_bottle water_bottle
##   can            4      0           0            0
##   carton         0      5           0            0
##   milk_bottle    1      0           5            0
##   water_bottle   0      0           0            5

Isso mostra que o modelo obteve 19 das 20 previsões corretas nos dados de validação, classificando incorretamente uma das latas como uma garrafa de leite.

Desdobramento, desenvolvimento

Publicando em um recurso de previsão

O código acima demonstra o uso do ponto de extremidade de treinamento para obter previsões, o que realmente significa apenas para teste e validação de modelo. Em um ambiente de produção, normalmente publicar um modelo treinado para um recurso de previsão do Custom Vision. Entre outras coisas, um usuário com acesso ao terminal de treinamento tem total liberdade para modificar o modelo e os dados, enquanto o acesso ao terminal de previsão apenas permite obter previsões.

Leia Também  Screenager: tempos de triagem no bioRxiv

A publicação de um modelo exige o conhecimento da ID do recurso do Azure do recurso de previsão. Aqui, usaremos o objeto de recurso que criamos anteriormente; você também pode obter essas informações no Portal do Azure.

# publish to the prediction resource we created above
publish_model(mod, "iteration1", pred_res)

Depois que um modelo é publicado, podemos obter previsões a partir do ponto final de previsão de uma maneira muito semelhante à anterior. Criamos um objeto de serviço preditivo com classification_servicee chame o predict método. Observe que uma entrada necessária é o ID do projeto; você pode fornecer isso diretamente ou através do objeto de projeto. Também pode levar algum tempo até que um modelo publicado apareça no terminal de previsão.

Sys.sleep(60)  # wait for Azure to finish publishing

pred_url $properties$endpoint
pred_key $list_keys()[1]

pred_endp customvision_prediction_endpoint(url=pred_url, key=pred_key)

project_id $project$id
pred_svc classification_service(pred_endp, project_id, "iteration1")

# predictions from prediction endpoint -- same as before
predsvc_tags predict(pred_svc, validation_imgs)
table(predsvc_tags, validation_tags)
##               validation_tags
## predsvc_tags   can carton milk_bottle water_bottle
##   can            4      0           0            0
##   carton         0      5           0            0
##   milk_bottle    1      0           5            0
##   water_bottle   0      0           0            5

Exportando como autônomo

Como alternativa à implantação do modelo em um recurso de serviço preditivo online, por exemplo, se você deseja criar uma solução de implantação customizada, também pode exportar o modelo como um objeto independente. Isso só é possível se o projeto foi criado para dar suporte à exportação. Os formatos suportados incluem:

  • ONNX 1.2
  • CoreML
  • TensorFlow ou TensorFlow Lite
  • Uma imagem do Docker para o ambiente Linux, Windows ou Raspberry Pi
  • Kit de desenvolvimento do Vision AI (VAIDK)

Para exportar o modelo, basta chamar export_model e especifique o formato de destino. Isso fará o download do modelo na sua máquina local.

export_model(mod, "tensorflow")

Mais Informações

AzureVision faz parte da família de pacotes AzureR. Isso fornece uma variedade de ferramentas para facilitar o acesso aos serviços do Azure para cientistas de dados que trabalham no R, como autenticação AAD, armazenamento de blobs e arquivos, Gerenciador de Recursos, serviços de contêiner, Data Explorer (Kusto) e muito mais.

Se você está interessado no Custom Vision, também pode consultar o CustomVision.ai, um front-end interativo para a criação de modelos do Custom Vision.



cupom com desconto - o melhor site de cupom de desconto cupomcomdesconto.com.br