Fazer previsões com um modelo treinado

Saiba como usar um modelo treinado para fazer previsões

Criar modelo de dados

Dados de entrada

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

Dados de saída

Como os nomes de coluna de entrada Features e Label, do ML.NET tem nomes padrão para as colunas de valor previsto produzidas por um modelo. Dependendo da tarefa, o nome pode diferir.

Como o algoritmo usado neste exemplo é um algoritmo de regressão linear, o nome padrão da coluna de saída é Score, que é definido pelo atributo ColumnName na propriedade PredictedPrice.

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

Configurar um pipeline de previsão

Seja fazendo uma previsão única ou em lotes, o pipeline de previsão precisa ser carregado no aplicativo. Esse pipeline contém as transformações de pré-processamento de dados, bem como o modelo treinado. O snippet de código a seguir carrega o pipeline de previsão de um arquivo chamado model.zip.

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

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

Previsão única

Para criar uma previsão única, crie um PredictionEngine usando o pipeline de previsão carregado.

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

Em seguida, use o método Predict e passe seus dados de entrada como um parâmetro. Observe que usar o método Predict não exige que a entrada seja uma IDataView. Isso ocorre porque ele internaliza convenientemente a manipulação do tipo de dados de entrada para que você possa passar um objeto do tipo de dados de entrada. Além disso, uma vez que CurrentPrice é o destino ou o rótulo que você está tentando prever usando novos dados, supõe-se não há nenhum valor para ele no momento.

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

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

Se você acessar a propriedade Score do objeto prediction, deverá obter um valor semelhante ao 150079.

Dica

PredictionEngine não é thread-safe. Além disso, você precisa criar uma instância dele em qualquer lugar em que seja necessário dentro de seu aplicativo. À medida que seu aplicativo cresce, esse processo pode se tornar não gerenciável. Para melhorar o desempenho e o acesso thread-safe, use uma combinação de injeção de dependência e o serviço PredictionEnginePool, que cria um ObjectPool de objetos PredictionEngine para uso em todo o aplicativo.

Para obter exemplos sobre como usar o serviço PredictionEnginePool, confira implantar um modelo em uma API Web e implantar um modelo para Azure Functions.

Confira injeção de dependência no ASP.NET Core para obter mais informações.

Várias previsões (IDataView)

Considerando os seguintes dados, carregue-os em um IDataView. Nesse caso, o nome do IDataView é inputData. Uma vez que CurrentPrice é o destino ou o rótulo que você está tentando prever usando novos dados, supõe-se que não há valor para ele no momento.

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

Em seguida, use o método Transform para aplicar as transformações de dados e gerar previsões.

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

Inspecione os valores previstos usando o método GetColumn.

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

Os valores previstos da coluna de pontuação devem ser semelhantes aos seguintes:

Observação	Previsão
1	144638,2
2	150079,4
3	107789,8

Várias previsões (PredictionEnginePool)

Para fazer várias previsões usando PredictionEnginePool, você pode usar um IEnumerable contendo várias instâncias da entrada do modelo. Por exemplo, use um IEnumerable<HousingInput> e aplique o método Predict a cada elemento usando o método Select do LINQ.

Este exemplo de código pressupõe que você tenha um PredictionEnginePool chamado predictionEnginePool e um IEnumerable<HousingData> chamado housingData.

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

O resultado é uma instância IEnumerable que contém suas previsões. Nesse caso, ele seria IEnumerable<HousingPrediction>.