Partager via

Lier un modèle

  • Article

Un modèle Machine Learning a des caractéristiques 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. Ceux-ci listent les types de caractéristiques d’entrée et de sortie attendus du modèle.

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

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


Types de caractéristiques

Windows ML prend en charge tous les types de caractéristiques ONNX, qui sont énumérés dans LearningModelFeatureKind. Ils sont mappés à différentes classes de descripteurs de caractéristiques :

Tenseurs

Les tenseurs sont des tableaux multidimensionnels, et le plus courant est un tenseur de valeurs à virgule flottante de 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 chaque dimension.

Séquences

Les séquences sont des vecteurs de valeurs. Une utilisation courante des types de séquences est un vecteur de probabilités float, que certains modèles de classification retournent pour indiquer l’évaluation de la justesse de chaque prédiction.

Maps

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

Valeurs scalaires

La plupart des cartes et des séquences auront des valeurs scalaires. Celles-ci s’affichent là où TensorFeatureDescriptor.Shape.Size a la valeur 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-à-float :

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 cartes est simplement un vecteur de paires clé-valeur. Par exemple, une séquence de cartes chaîne-à-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

Quand vous travaillez avec des images, vous devez être conscient des formats d’images et de la tenseurisation.

Formats d’images

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. Quand vous transmettez une entrée d’image dans le modèle, son format doit correspondre à celui 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’images attendus.

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

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

Tenseurisation

Les images sont représentées dans Windows ML dans un format de tenseur. 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 nombre de couleur de 8 bits qui est stocké dans la plage de 0 à 255, et compressé dans une valeur à virgule flottante de 32 bits.

Comment transmettre 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 il prend soin de la conversion et de la tenseurisation ; ainsi, les images correspondent au format d’image requis du modèle. Les types de formats de modèles actuellement pris en charge sont Gray8, Rgb8 et Bgr8, et la plage de pixels actuellement prise en charge est 0-255.

    Vous pouvez créer un 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 de modèle sont 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 la tenseur ressemble à NCHW (quatre dimensions, float32, N==1), le runtime suppose Gray8 (C==1) ou Bgr8 (C==3) en fonction du nombre de canaux.
    • NominalRange_0_255 est supposé.
    • SRVB est supposé.

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

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

    Pour les formes d’images, le modèle peut spécifier soit une forme spécifique qu’il prend (par exemple SqueezeNet prend 224,224), soit des dimensions libres pour toute 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 des conversions et la tenseurisation. Vous créerez un tenseur NCHW à quatre dimensions pour les valeurs float de 32 bits pour votre valeur d’entrée. Pour obtenir un exemple de la procédure à suivre, consultez l’exemple de tenseurisation personnalisée.

    Quand 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 effectuer une liaison à l’entrée d’un modèle. Ici, nous créons une liaison à partir de session, nous créons un ImageFeatureValue à partir d’inputFrame, puis nous 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

Remarque

Utilisez les ressources suivantes pour obtenir de l’aide sur Windows ML :

  • Pour poser des questions techniques ou apporter des réponses à des questions techniques sur Windows ML, veuillez utiliser le mot clé windows-machine-learning sur Stack Overflow.
  • Pour signaler un bogue, veuillez signaler un problème dans notre plateforme GitHub.