Associar um modelo

Um modelo de machine learning tem recursos de entrada e saída, que transmitem 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 ILearningModelFeatureDescriptor . Elas listam os tipos de recursos de entrada e saída esperados do modelo.

Você usa um LearningModelBinding para associar 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 associação de modelos de machine learning.

Tipos de características

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

• Tensor: TensorFeatureDescriptor
• Sequência: SequenceFeatureDescriptor
• Mapa: MapFeatureDescriptor
• Imagem: DescritorDeCaracterísticasDeImagem

Tensores

Tensores são matrizes multidimensionais e 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

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

Mapas são pares 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 escalares. Eles aparecem onde TensorFeatureDescriptor.Shape.Size é zero (0). Nesse caso, o mapa ou 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 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 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 da 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, 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 os formatos de imagem esperados.

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

• Imagem.BitmapPixelFormato: Bgr8
• Image.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 ocorre durante a vinculaçã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). Atualmente, 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 de cor de 8 bits armazenado no intervalo de 0 a 255 e empacotado em um float de 32 bits.

Como passar imagens para o modelo

Há duas maneiras de passar imagens para modelos:

• ValorDaCaracterísticaDaImagem

  É recomendável usar ImageFeatureValue para associar imagens como entradas e saídas, pois ela 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 com suporte no momento são Gray8, Rgb8 e Bgr8, e o intervalo de pixels atualmente compatível é 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 verificados e usados se 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 tiver o formato NCHW (float32 de 4 dimensões, N==1), o tempo de execução assumirá Gray8 (C==1) ou Bgr8 (C==3), dependendo do número de canais.
  • NominalRange_0_255 será presumido
  • SRGB será presumido

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

  • BitmapBounds: se especificado, estes são os limites de corte a serem aplicados antes de enviar a imagem para o modelo.
  • BitmapPixelFormat: se especificado, esse é 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 ele usa (por exemplo, SqueezeNet usa 224x224), ou o modelo pode especificar dimensões livres para imagens de qualquer 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 deseja usar. Se não for especificado, o runtime 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 cores 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. 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 associar uma entrada do modelo. Nesse caso, criamos uma associação a partir da sessão, criamos um ImageFeatureValue do 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);
}

Consulte também

• Anterior: Criar uma sessão
• Em seguida: Avaliar as entradas do modelo