Vincular um modelo

Um modelo de aprendizado de máquina tem recursos de entrada e saída, que passam informações para dentro e para fora do modelo.

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

Você usa um LearningModelBinding para vincular valores a um recurso, fazendo referência ao ILearningModelFeatureDescriptor por sua propriedade Name .

O vídeo a seguir fornece uma breve visão geral dos recursos de vinculação de modelos de aprendizado de máquina.

Tipos de funcionalidades

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

• Tensor: TensorFeatureDescriptor
• Sequência: DescritorDeCaracterísticasDeSequência
• Mapa: MapFeatureDescriptor
• Imagem: Descritor de Características de Imagem

Tensores

Os tensores são matrizes multidimensionais, e o tensor mais comum é um tensor de flutuadores de 32 bits. As dimensões dos tensores são de linha maior, com dados contíguos bem compactados representando 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 flutuantes, 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 chave/valor de informação. Os modelos de classificação geralmente retornam um mapa de cadeia de caracteres/flutuação que descreve a probabilidade de flutuação para cada nome de classificação rotulado. Por exemplo, a saída de um modelo que tenta prever a raça de cão 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 escalares. Estes aparecem onde TensorFeatureDescriptor.Shape.Size é zero (0). Neste caso, o mapa ou sequência será do tipo escalar. O mais comum é float. Por exemplo, uma cadeia de caracteres para flutuar mapa seria:

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

O valor real do recurso de 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 string-to-float seria do tipo IVector<IMap<string, float>>. A saída acima das previsões das raças de cães ["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 e os pesos são salvos e adaptados para esse conjunto de treinamento. Quando você passa uma entrada de imagem para o modelo, seu formato 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 formatos de imagem esperados.

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

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

Tensorização

As imagens são representadas no Windows ML em um formato tensor. Tensorização é o processo de conversão de uma imagem em um tensor e acontece durante o bind.

Windows ML converte imagens em tensores 4D de valores de ponto flutuante de 32 bits no formato "tensor NCHW".

• N: Tamanho do lote (ou número de imagens). Atualmente, o Windows ML oferece 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 de cor de 8 bits que é armazenado no intervalo de 0-255 e embalado em um float de 32 bits.

Como passar imagens para o modelo

Há duas maneiras de passar imagens para modelos:

• ImageFeatureValue

  Recomendamos o uso de ImageFeatureValue para vincular imagens como entradas e saídas, pois ele cuida da conversão e da tensorização, para que as imagens correspondam ao formato de imagem necessário do modelo. Os tipos de formato de modelo atualmente suportados são Gray8, Rgb8 e Bgr8, e o intervalo de pixels atualmente suportado é de 0 a 255.

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

  Para descobrir qual formato o modelo precisa, o WinML usa a seguinte lógica e ordem de precedência:

  1. Bind(String, Object, IPropertySet) substituirá todas as configurações de imagem.
  2. Os metadados do modelo serão então verificados e utilizados, se disponíveis.
  3. Se nenhum metadado de modelo for fornecido e nenhuma propriedade fornecida pelo utilizador, o tempo de execução tentará fazer o melhor ajuste.
  • Se o tensor se parece com NCHW (float32 de 4 dimensões, N==1), o tempo de execução assumirá Gray8 (C==1) ou Bgr8 (C==3), dependendo da contagem de canais.
  • NominalRange_0_255 será considerado
  • Assume-se SRGB

  Há várias propriedades opcionais que você pode passar para Bind(String, Object, IPropertySet):

  • BitmapBounds: Se especificado, esses são os limites de corte a serem aplicados antes de enviar a imagem para o modelo.
  • BitmapPixelFormat: Se especificado, este é o formato de pixel que será usado como o formato de pixel do modelo durante a conversão de imagem.

  Para formatos de imagem, o modelo pode especificar um formato específico que aceita (por exemplo, o SqueezeNet aceita 224, 224) ou o modelo pode especificar dimensões livres para qualquer imagem de formato (muitos modelos do tipo StyleTransfer podem aceitar imagens de tamanho variável). 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 ajustará a dimensão da imagem para o tamanho do modelo (respeitando a proporção) e depois cortará centralmente.

• TensorFloat

  Se o Windows ML não oferecer suporte ao formato de cores ou intervalo de pixels do seu modelo, você poderá implementar conversões e tensorização. Você criará um tensor quadridimensional NCHW para flutuadores de 32 bits para seu valor de entrada. Consulte 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 ligar à entrada de um modelo. Nesse caso, criamos uma associação a partir da sessão, criamos um ImageFeatureValue a partir de 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);
}

Ver também

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