Effectuer des prédictions avec un modèle entraîné

Article
06/01/2023

Découvrez comment utiliser un modèle entraîné pour effectuer des prédictions.

Créer des modèles de données

Données d’entrée

public class HousingData
{
    [LoadColumn(0)]
    public float Size { get; set; }

    [LoadColumn(1, 3)]
    [VectorType(3)]
    public float[] HistoricalPrices { get; set; }

    [LoadColumn(4)]
    [ColumnName("Label")]
    public float CurrentPrice { get; set; }
}

Données de sortie

Comme les noms de colonne d’entrée Features et Label, ML.NET a des noms par défaut pour les colonnes de valeur prédite produites par un modèle. Selon la tâche, le nom peut différer.

L’algorithme utilisé dans cet exemple étant un algorithme de régression linéaire, le nom par défaut de la colonne de sortie est Score, défini par l’attribut ColumnName sur la propriété PredictedPrice.

class HousingPrediction
{
    [ColumnName("Score")]
    public float PredictedPrice { get; set; }
}

Configurer un pipeline de prédiction

Que vous effectuiez une prédiction unique ou par lot, vous devez charger le pipeline de prédiction dans l’application. Ce pipeline contient les transformations de prétraitement de données ainsi que le modèle entraîné. L’extrait de code ci-dessous charge le pipeline de prédiction à partir d’un fichier nommé model.zip.

//Create MLContext
MLContext mlContext = new MLContext();

// Load Trained Model
DataViewSchema predictionPipelineSchema;
ITransformer predictionPipeline = mlContext.Model.Load("model.zip", out predictionPipelineSchema);

Prédiction unique

Pour effectuer une prédiction unique, créez un PredictionEngine en utilisant le pipeline de prédiction chargé.

// Create PredictionEngines
PredictionEngine<HousingData, HousingPrediction> predictionEngine = mlContext.Model.CreatePredictionEngine<HousingData, HousingPrediction>(predictionPipeline);

Ensuite, utilisez la méthode Predict pour transmettre vos données d’entrée en tant que paramètre. Notez que l’utilisation de la méthode Predict ne requiert pas que l’entrée soit un IDataView). En effet, elle internalise facilement la manipulation du type de données d’entrée afin que vous puissiez passer un objet du type de données d’entrée. De plus, CurrentPrice étant la cible ou l’étiquette que vous tentez de prédire à l’aide de nouvelles données, aucune valeur correspondante n’est censée exister pour le moment.

// Input Data
HousingData inputData = new HousingData
{
    Size = 900f,
    HistoricalPrices = new float[] { 155000f, 190000f, 220000f }
};

// Get Prediction
HousingPrediction prediction = predictionEngine.Predict(inputData);

Si vous accédez à la propriété Score de l’objet prediction, vous devez obtenir une valeur similaire à 150079.

Conseil

PredictionEngine n’est pas thread-safe. En outre, vous devez créer une instance de celui-ci partout où il est nécessaire dans votre application. À mesure que votre application croît, ce processus peut devenir non gérable. Pour améliorer les performances et la sécurité des threads, utilisez une combinaison d’injection de dépendances et du service PredictionEnginePool, qui crée un ObjectPool d’objets PredictionEngine à utiliser dans votre application.

Pour obtenir des exemples sur l’utilisation du service PredictionEnginePool, consultez Déployer un modèle sur une API web et Déployer un modèle sur Azure Functions.

Pour plus d’informations, consultez Injection de dépendances dans ASP.NET Core.

Prédictions multiples (IDataView)

Soient les données suivantes. Chargez-les dans un IDataView. Dans ce cas, le nom de notre IDataView est inputData. CurrentPrice étant la cible ou l’étiquette que vous tentez de prédire à l’aide de nouvelles données, aucune valeur correspondante n’est censée exister pour le moment.

// Actual data
HousingData[] housingData = new HousingData[]
{
    new HousingData
    {
        Size = 850f,
        HistoricalPrices = new float[] { 150000f, 175000f, 210000f }
    },
    new HousingData
    {
        Size = 900f,
        HistoricalPrices = new float[] { 155000f, 190000f, 220000f }
    },
    new HousingData
    {
        Size = 550f,
        HistoricalPrices = new float[] { 99000f, 98000f, 130000f }
    }
};

Ensuite, utilisez la méthode Transform pour appliquer les transformations de données et générer des prédictions.

// Predicted Data
IDataView predictions = predictionPipeline.Transform(inputData);

Inspectez les valeurs prédites à l’aide de la méthode GetColumn.

// Get Predictions
float[] scoreColumn = predictions.GetColumn<float>("Score").ToArray();

Les valeurs prédites dans la colonne des scores doivent se présenter comme suit :

Observation	Prédiction
1	144638.2
2	150079.4
3	107789.8

Prédictions multiples (PredictionEnginePool)

Pour effectuer plusieurs prédictions à l’aide de PredictionEnginePool, vous pouvez prendre un IEnumerable contenant plusieurs instances de votre entrée de modèle. Par exemple un IEnumerable<HousingInput>, puis appliquez la méthode Predict à chaque élément à l’aide de la méthode Select LINQ.

Cet exemple de code suppose que vous avez un PredictionEnginePool appelé predictionEnginePool et un IEnumerable<HousingData> appelé housingData.

IEnumerable<HousingPrediction> predictions = housingData.Select(input => predictionEnginePool.Predict(input));

Le résultat est un IEnumerable contenant des instances de vos prédictions. Dans cet exemple, il s’agit de IEnumerable<HousingPrediction>.

Partager via