Lier un modèle

Un modèle Machine Learning a des fonctionnalités d’entrée et de sortie, qui transmettent des informations dans et hors du modèle.

Après avoir chargé votre modèle en tant que LearningModel, vous pouvez utiliser LearningModel.InputFeatures et LearningModel.OutputFeatures pour obtenir des objets ILearningModelFeatureDescriptor . Celles-ci répertorient les types de fonctionnalités d’entrée et de sortie attendus du modèle.

Vous utilisez un LearningModelBinding pour lier des valeurs à une fonctionnalité, en référençant iLearningModelFeatureDescriptor par sa propriété Name .

La vidéo suivante donne une brève vue d’ensemble des fonctionnalités de liaison des modèles Machine Learning.

Types de fonctionnalités

Windows ML prend en charge tous les types de fonctionnalités ONNX, qui sont énumérés dans LearningModelFeatureKind. Celles-ci sont mappées à différentes classes de descripteur de fonctionnalités :

• Tensor : TensorFeatureDescriptor
• Séquence : SequenceFeatureDescriptor
• Carte : MapFeatureDescriptor
• Image : ImageFeatureDescriptor

Tenseurs

Les tenseurs sont des tableaux multidimensionnels, et le tensoreur le plus courant est un tensoreur de floats 32 bits. Les dimensions des tenseurs sont d’ordre row-major, avec des données contiguës fortement compressées représentant chaque dimension. La taille totale du tenseur est le produit des tailles de chacune de ses dimensions.

Séquences

Les séquences sont des vecteurs de valeurs. Un usage courant des types de séquences est un vecteur de probabilités flottantes, que certains modèles de classification retournent pour indiquer l’évaluation de précision pour chaque prédiction.

Cartes

Les cartes sont des paires clé/valeur d’informations. Les modèles de classification retournent généralement une carte de chaîne/float qui décrit la probabilité flottante pour chaque nom de classification étiqueté. Par exemple, la sortie d’un modèle qui tente de prédire la race de chien dans une image peut être ["Boston terrier", 90.0], ["Golden retriever", 7.4], ["Poodle", 2.6].

Scalaires

La plupart des mappages et des séquences ont des valeurs scalaires. Ceux-ci indiquent où TensorFeatureDescriptor.Shape.Size est égal à zéro (0). Dans ce cas, la carte ou la séquence sera du type scalaire. Le plus courant est float. Voici un exemple de carte chaîne-à-flottant :

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

La valeur réelle de la caractéristique de carte sera un IMap<string, float>.

Séquence de cartes

Une séquence de mappages est simplement un vecteur de paires clé/valeur. Par exemple, une séquence de cartes string-to-float serait de type IVector<IMap<string, float>>. La sortie ci-dessus des prédictions de race du chien ["Boston terrier", 90.0], ["Golden retriever", 7.4], ["Poodle", 2.6] est un exemple de séquence de cartes.

Images

Lorsque vous travaillez avec des images, vous devez connaître les formats d'image et la tensorisation.

Formats d’image

Les modèles sont entraînés avec des données d’entraînement d’images, et les poids sont enregistrés et adaptés à ce jeu d’entraînement. Lorsque vous passez une entrée d’image dans le modèle, son format doit correspondre au format des images d’entraînement.

Dans de nombreux cas, le modèle décrit le format d’image attendu ; Les modèles ONNX peuvent utiliser des métadonnées pour décrire les formats d’image attendus.

La plupart des modèles utilisent les formats suivants, mais ce n’est pas universel pour tous les modèles :

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

Tenseurisation

Les images sont représentées dans Windows ML dans un format tensoriel. La tenseurisation est le processus de conversion d’une image en tenseur ; il se produit pendant la liaison.

Windows ML convertit les images en tenseurs à quatre dimensions de valeurs à virgule flottante 32 bits au « format de tenseur NCHW » :

• N : Taille du lot (ou nombre d’images). Windows ML prend actuellement en charge une taille de lot N de 1.
• C : Nombre de canaux (1 pour Gray8, 3 pour Bgr8).
• H : Hauteur.
• W : Largeur.

Chaque pixel de l’image est un numéro de couleur 8 bits stocké dans la plage de 0 à 255 et emballé dans un float 32 bits.

Comment passer des images dans le modèle

Il existe deux façons de transmettre des images dans des modèles :

• ImageFeatureValue

  Nous vous recommandons d’utiliser ImageFeatureValue pour lier des images en tant qu’entrées et sorties, car elle prend en charge à la fois la conversion et la tensorisation, afin que les images correspondent au format d’image requis du modèle. Les types de format de modèle actuellement pris en charge sont Gray8, Rgb8 et Bgr8, et la plage de pixels actuellement prise en charge est de 0 à 255.

  Vous pouvez créer une ImageFeatureValue à l’aide de la méthode statique ImageFeatureValue.CreateFromVideoFrame.

  Pour connaître le format dont le modèle a besoin, WinML utilise la logique et l’ordre de priorité suivants :

  1. Bind(String, Object, IPropertySet) remplace tous les paramètres d’image.
  2. Les métadonnées du modèle seront ensuite vérifiées et utilisées si elles sont disponibles.
  3. Si aucune métadonnée de modèle n’est fournie et qu’aucune propriété n’a été fournie par l’appelant, le runtime essaiera d’établir la meilleure correspondance.
  • Si le tensor ressemble à NCHW (float32 4 dimensions, N==1), le runtime suppose gray8 (C==1) ou Bgr8 (C==3) en fonction du nombre de canaux.
  • NominalRange_0_255 est supposé.
  • SRGB sera supposé être pris en compte

  Il existe plusieurs propriétés facultatives que vous pouvez transmettre à Bind(String, Object, IPropertySet) :

  • BitmapBounds : s’il est spécifié, il s’agit des limites de rognage à appliquer avant d’envoyer l’image au modèle.
  • BitmapPixelFormat : s’il est spécifié, il s’agit du format de pixel qui sera utilisé comme format de pixel de modèle pendant la conversion d’image.

  Pour les formes d’image, le modèle peut spécifier une forme spécifique qu’il prend (par exemple, SqueezeNet prend 224 224) ou le modèle peut spécifier des dimensions libres pour n’importe quelle image de forme (de nombreux modèles de type StyleTransfer peuvent prendre des images de taille variable). L’appelant peut utiliser BitmapBounds pour choisir la section de l’image qu’il souhaite utiliser. Si cette propriété n’est pas spécifiée, le runtime met à l’échelle l’image à la taille du modèle (en respectant les proportions), puis effectue un rognage centré.

• TensorFloat

  Si Windows ML ne prend pas en charge le format de couleur ou la plage de pixels de votre modèle, vous pouvez implémenter les conversions et la tensorisation. Vous créerez un tenseur NCHW à quatre dimensions pour les valeurs float de 32 bits pour votre valeur d’entrée. Consultez l’exemple de tensorisation personnalisé pour obtenir un exemple de procédure à suivre.

  Lorsque cette méthode est utilisée, toutes les métadonnées d’image sur le modèle sont ignorées.

Exemple :

L’exemple suivant montre comment établir une liaison à l’entrée d’un modèle. Dans ce cas, nous créons une liaison à partir de la session, créons une ImageFeatureValue à partir de inputFrame, et lions l'image à l'entrée du modèle, 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);
}

Voir aussi

• Précédent : Créer une session
• Suivant : Évaluer les entrées du modèle