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

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 pour les noms des colonnes d’entrée Features et Label, ML.NET utilise des noms par défaut pour les colonnes de valeurs prédites produites par un modèle. Les noms peuvent différer selon la tâche.

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

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

Configurer un pipeline de prédiction

Qu’il s’agisse d’une prédiction unique ou par lot, le pipeline de prédiction doit être chargé dans l’application. Ce pipeline contient les transformations de prétraitement des données et le modèle entraîné. L’extrait de code suivant 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 seule prédiction, créez un PredictionEngine à l’aide du pipeline de prédiction chargé.

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

Ensuite, utilisez la Predict méthode et transmettez vos données d’entrée en tant que paramètre. Notez que l’utilisation de la Predict méthode ne nécessite pas que l’entrée soit un IDataView. C’est parce qu’il prend en charge de manière transparente la gestion du type des données d’entrée, ce qui vous permet de fournir en entrée un objet de ce type de données. En outre, étant donné que CurrentPrice est la variable cible ou l’étiquette que vous essayez de prédire à partir de nouvelles données, on suppose qu’aucune valeur n’est disponible 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 Score propriété de l’objet prediction , vous devez obtenir une valeur similaire à 150079.

Prédictions multiples (IDataView)

Étant donné les données suivantes, chargez-les dans un IDataView. Dans ce cas, le nom du IDataView fichier est inputData. Comme CurrentPrice est la cible ou l’étiquette que vous essayez de prédire à partir de nouvelles données, on suppose qu’elle n’a pas encore de valeur 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 Transform méthode 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 GetColumn méthode.

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

Les valeurs prédites dans la colonne de score doivent ressembler aux valeurs suivantes :

Prédictions multiples (PredictionEnginePool)

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

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 une IEnumerable instance contenant vos prédictions. Dans ce cas, ce serait IEnumerable<HousingPrediction>.