Faça previsões com um modelo treinado

Aprenda a usar um modelo treinado para fazer previsões.

Criar modelos 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

Tal como os nomes das colunas de entrada Features e Label, o ML.NET tem nomes predefinidos para as colunas de valores previstos produzidas por um modelo. Os nomes podem variar consoante a tarefa.

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

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

Configure um pipeline de previsão

Quer se trate de uma previsão única ou de um lote de previsões, o pipeline de previsão tem de ser carregado na aplicação. Este pipeline contém tanto as transformações de pré-processamento de dados como o modelo treinado. O seguinte excerto de código carrega o pipeline de previsão a partir de um ficheiro chamado model.zip.

Importante

Carregue apenas modelos de fontes confiáveis. Carregar modelos a partir de fontes não confiáveis é um risco de segurança.

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

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

Previsão única

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

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

Depois, usa o Predict método e passa os teus dados de entrada como parâmetro. Note que usar o Predict método não exige que a entrada seja um IDataView. Isto porque internaliza convenientemente a manipulação do tipo de dados de entrada, permitindo que possas passar um objeto do tipo de dados de entrada. Além disso, como CurrentPrice é o alvo ou rótulo que está a tentar prever com dados novos, assume-se que não há valor para isso neste momento.

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

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

Se aceder à Score propriedade do prediction objeto, deverá obter um valor semelhante a 150079.

Sugestão

PredictionEngine não é seguro para threads. Além disso, você precisa criar uma instância dele em todos os lugares em que for necessário em seu aplicativo. À medida que seu aplicativo cresce, esse processo pode se tornar incontrolável. Para melhorar o desempenho e a segurança das threads, utilize uma combinação de injeção de dependências e o serviço PredictionEnginePool , que cria um ObjectPool conjunto de PredictionEngine objetos para utilização em toda a sua aplicação.

Para exemplos sobre como usar o serviço PredictionEnginePool, veja implementar um modelo numa API web e implantar um modelo no Funções do Azure.

Para mais informações, consulte Injeção de Dependências no ASP.NET Core.

Previsões múltiplas (IDataView)

Dados os dados seguintes, carregue-os num IDataView. Neste caso, o nome do IDataView é inputData. Porque CurrentPrice é o alvo ou rótulo que estás a tentar prever com dados novos, assume-se que não há valor para isso neste 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 }
    }
};

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

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

Inspecione os valores previstos utilizando o GetColumn método.

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

Os valores previstos na coluna de pontuação devem assemelhar-se aos seguintes valores:

Observação Prediction
1 144638,2
2 150079.4
3 107789.8

Previsões múltiplas (PredictionEnginePool)

Para fazer várias previsões utilizando PredictionEnginePool, pode utilizar um IEnumerable que contenha várias instâncias da entrada do modelo. Por exemplo, considere um IEnumerable<HousingInput> e aplique o método Predict a cada elemento usando o método LINQ Select.

Este exemplo de código assume que tem um PredictionEnginePool chamado predictionEnginePool e um IEnumerable<HousingData> chamado housingData.

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

O resultado é uma IEnumerable contenção de exemplos das suas previsões. Neste caso, seria IEnumerable<HousingPrediction>.

  • Last updated on