Associar um modelo

Artigo
07/11/2023

Um modelo de machine learning tem recursos de entrada e saída, que transmitem informações para dentro e fora do modelo.

Depois de carregar seu modelo como um LearningModel, você pode usar LearningModel.InputFeatures e LearningModel.OutputFeatures para conseguir objetos ILearningModelFeatureDescriptor. Eles listam os tipos de recursos de entrada e saída esperados do modelo.

Você usa um LearningModelBinding para associar valores a um recurso, referenciando o ILearningModelFeatureDescriptor pela propriedade Nome.

O vídeo a seguir oferece uma visão geral rápida dos recursos de associação de modelos de machine learning.

Tipos de recursos

O Windows ML dá suporte a todos os tipos de recursos ONNX, que são enumerados em LearningModelFeatureKind. Eles são mapeados para diferentes classes de descritor de recursos:

Tensor: TensorFeatureDescriptor
Sequência: SequenceFeatureDescriptor
Mapa: MapFeatureDescriptor
Imagem: ImageFeatureDescriptor

Tensores

Os tensores são matrizes multidimensionais. O tensor mais comum é um tensor de floats de 32 bits. As dimensões de tensores são da linha principal, com dados contíguos totalmente empacotados que representam cada dimensão. O tamanho total do tensor é o produto dos tamanhos de cada dimensão.

Sequências

As sequências são vetores de valores. Um uso comum de tipos de sequência é um vetor de probabilidades de float, que alguns modelos de classificação retornam para indicar a classificação de precisão para cada previsão.

Mapas

Os mapas são pares de chave/valor de informações. Os modelos de classificação normalmente retornam um mapa de cadeia de caracteres/float que descreve a probabilidade de float para cada nome de classificação rotulado. Por exemplo, a saída de um modelo que tenta prever a raça de cachorro em uma imagem pode ser ["Boston terrier", 90.0], ["Golden retriever", 7.4], ["Poodle", 2.6].

Escalares

A maioria dos mapas e sequências terá valores que são escalares. Eles aparecem onde TensorFeatureDescriptor.Shape.Size é zero (0). Nesse caso, o mapa ou a sequência será do tipo escalar. O mais comum é float. Por exemplo, uma cadeia de caracteres para o mapa de float seria:

MapFeatureDescriptor.KeyKind == TensorKind.String
MapFeatureDescriptor.ValueDescriptor.Kind == LearningModelFeatureKind.Tensor
MapFeatureDescriptor.ValueDescriptor.as<TensorFeatureDescriptor>().Shape.Size == 0

O valor real do recurso do mapa será um IMap<string, float>.

Sequência de mapas

Uma sequência de mapas é apenas um vetor de pares chave/valor. Por exemplo, uma sequência de mapas de cadeia de caracteres para float seria do tipo IVector<IMap<string, float>>. A saída acima de previsões de raça de cachorro ["Boston terrier", 90.0], ["Golden retriever", 7.4], ["Poodle", 2.6] é um exemplo de uma sequência de mapas.

Imagens

Ao trabalhar com imagens, você precisará estar ciente dos formatos de imagem e tensorização.

Formatos de imagem

Os modelos são treinados com dados de treinamento de imagem. Os pesos são salvos e adaptados para esse conjunto de treinamento. Quando você passa uma entrada de imagem para o modelo, o formato dela deve corresponder ao formato das imagens de treinamento.

Em muitos casos, o modelo descreve o formato de imagem esperado. Os modelos ONNX podem usar metadados para descrever os formatos de imagem esperados.

A maioria dos modelos usa os formatos a seguir, mas isso não é universal para todos os modelos:

Image.BitmapPixelFormat: Bgr8
Image.ColorSpaceGamma: SRGB
Image.NominalPixelRange: NominalRange_0_255

Tensorização

As imagens são representadas no Windows ML, em formato de tensor. A tensorização é o processo de converter uma imagem em um tensor. Ela acontece durante a associação.

O Windows ML converte imagens em tensores de 4 dimensões de floats de 32 bits, no "formato de tensor NCHW":

N: tamanho do lote (ou número de imagens). No momento, o Windows ML dá suporte a um tamanho de lote N de 1.
C: contagem de canais (1 para Gray8, 3 para Bgr8).
H: altura.
W: largura.

Cada pixel da imagem é um número colorido de 8 bits que é armazenado no intervalo de 0-255 e empacotado em um float de 32 bits.

Como passar imagens para o modelo

Há duas maneiras de passar imagens para modelos:

ImageFeatureValue

É recomendável usar ImageFeatureValue para associar imagens como entradas e saídas, pois ele cuida de conversão e da tensorização. Assim, as imagens correspondem ao formato de imagem necessário do modelo. Os tipos de formato de modelo com suporte no momento são Gray8, Rgb8 e Bgr8. O intervalo de pixels com suporte no momento é 0-255.

Você pode criar um ImageFeatureValue usando o método estático ImageFeatureValue.CreateFromVideoFrame.

Para descobrir de qual formato o modelo precisa, o WinML usa a ordem de lógica e precedência a seguir:
1. Bind(String, Object, IPropertySet) substituirá todas as configurações de imagem.
2. Os metadados do modelo serão verificados e usados, se estiverem disponíveis.
3. Se nenhum metadado de modelo for fornecido, assim como nenhuma propriedade fornecida pelo chamador, o tempo de execução tentará fazer a melhor correspondência.
- Se o tensor se parecer com NCHW (float32 de 4 dimensões, N==1), o tempo de execução presumirá Gray8 (C==1) ou Bgr8 (C==3) dependendo da contagem de canais.
- NominalRange_0_255 será presumido
- SRGB será presumido
Há várias propriedades opcionais que podem ser passadas para Bind(String, Object, IPropertySet):
- BitmapBounds: se especificados, serão os limites de corte a serem aplicados antes do envio da imagem para o modelo.
- BitmapPixelFormat: se especificado, será o formato de pixel usado no modelo durante a conversão da imagem.
Para formas de imagem, o modelo pode especificar uma forma específica que ele assume (por exemplo, SqueezeNet assume 224.224) ou pode especificar dimensões livres para qualquer imagem de forma (muitos modelos do tipo StyleTransfer conseguem assumir imagens de tamanhos variáveis). O chamador pode usar BitmapBounds para escolher qual seção da imagem gostaria de usar. Se não for especificado, o tempo de execução dimensionará a imagem para o tamanho do modelo (respeitando a taxa de proporção) e, em seguida, centralizará o corte.
TensorFloat

Se o Windows ML não der suporte ao formato de cor ou ao intervalo de pixels do modelo, você poderá implementar conversões e tensorização. Você criará um NCHW tensor de quatro dimensões para floats de 32 bits para seu valor de entrada. Veja o Exemplo de tensorização personalizada para obter um exemplo de como fazer isso.

Quando esse método é usado, todos os metadados de imagem no modelo são ignorados.

Exemplo

O exemplo a seguir mostra como associar uma entrada do modelo. Nesse caso, criamos uma associação na sessão, criamos um ImageFeatureValue com base no inputFrame e associamos a imagem à entrada do modelo, inputName.

private void BindModel(
    LearningModelSession session,
    VideoFrame inputFrame,
    string inputName)
{
    // Create a binding object from the session
    LearningModelBinding binding = new LearningModelBinding(session);

    // Create an image tensor from a video frame
    ImageFeatureValue image =
        ImageFeatureValue.CreateFromVideoFrame(inputFrame);

    // Bind the image to the input
    binding.Bind(inputName, image);
}

Confira também

Anterior: Criar uma sessão
Próximo: Avaliar as entradas do modelo

Observação

Use os recursos a seguir para obter ajuda com o Windows ML:

Para fazer perguntas ou responder a perguntas técnicas sobre o Windows ML, use a marca windows-machine-learning no Stack Overflow.
Para relatar um bug, registre um problema no nosso GitHub.

Partilhar via