Göra förutsägelser med en tränad modell

Lär dig hur du använder en tränad modell för att göra förutsägelser.

Skapa datamodeller

Inmatningsdata

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; }
}

Utdata

Precis som för indatakolumnnamnen Features och Label har ML.NET standardnamn på de kolumner för predikterade värden som skapas av en modell. Namnen kan variera beroende på aktiviteten.

Eftersom algoritmen som används i det här exemplet är en linjär regressionsalgoritm är Scorestandardnamnet för utdatakolumnen , som definieras av ColumnName attributet på PredictedPrice egenskapen.

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

Konfigurera en förutsägelsepipeline

Oavsett om du gör en enskild förutsägelse eller en batchförutsägelse måste prediktionspipelinen laddas in i applikationen. Den här pipelinen innehåller både dataförbearbetningstransformeringar och den tränade modellen. Följande kodfragment läser in förutsägelsepipelinen från en fil med namnet model.zip.

Important

Läs bara in modeller från betrodda källor. Att läsa in modeller från ej betrodda källor är en säkerhetsrisk.

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

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

Enkel förutsägelse

Om du vill göra en enskild förutsägelse skapar du en PredictionEngine med den inladdade prediktionspipelinen.

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

Predict Använd sedan metoden och skicka in dina indata som en parameter. Observera att användning av Predict metoden inte kräver att indata är en IDataView. Det beror på att det på ett bekvämt sätt internaliserar manipuleringen av indatatypen så att du kan skicka in ett objekt av indatatypen. Eftersom CurrentPrice är målet eller etiketten som du försöker förutsäga med nya data antas det dessutom att det inte finns något värde för det just nu.

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

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

Om du har åtkomst till Score objektets prediction egenskap bör du få ett värde som liknar 150079.

Tips

PredictionEngine är inte trådsäkert. Dessutom måste du skapa en instans av den överallt där den behövs i ditt program. När programmet växer kan den här processen bli ohanterlig. För bättre prestanda och trådsäkerhet använder du en kombination av beroendeinmatning och tjänsten PredictionEnginePool , som skapar ett ObjectPool objekt PredictionEngine som ska användas i hela programmet.

Exempel på hur du använder tjänsten PredictionEnginePool finns i distribuera en modell till ett webb-API och distribuera en modell till Azure Functions.

Mer information finns i Beroendeinmatning i ASP.NET Core.

Flera förutsägelser (IDataView)

Läs in följande data i en IDataView. I det här fallet är namnet på IDataViewinputData. Eftersom CurrentPrice är målet eller etiketten som du försöker förutsäga med nya data antas det att det inte finns något värde för det just nu.

// 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 }
    }
};

Transform Använd sedan metoden för att tillämpa datatransformeringar och generera förutsägelser.

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

Inspektera de predikterade värdena med hjälp av metoden GetColumn.

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

De förutsagda värdena i poängkolumnen bör likna följande värden:

Observation Prediction
1 144638.2
2 150079.4
3 107789.8

Flera förutsägelser (PredictionEnginePool)

Om du vill göra flera förutsägelser med PredictionEnginePool kan du ta en IEnumerable som innehåller flera instanser av dina modellindata. Ta till exempel en IEnumerable<HousingInput> och tillämpa metoden Predict på varje element med LINQ-metoden Select.

Det här kodexemplet förutsätter att du har en PredictionEnginePool som heter predictionEnginePool och heter IEnumerable<HousingData>housingData.

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

Resultatet är en IEnumerable som innehåller instanser av dina prediktioner. I det här fallet skulle det vara IEnumerable<HousingPrediction>.

  • Last updated on