Göra förutsägelser med en AutoML ONNX-modell i .NET

Artikel
09/02/2024

I den här artikeln lär du dig hur du använder en ONNX-modell (Automated ML) Open Neural Network Exchange (AutoML) för att göra förutsägelser i ett C#-konsolprogram med ML.NET.

ML.NET är ett plattformsoberoende ramverk med öppen källkod för .NET-ekosystemet som gör att du kan träna och använda anpassade maskininlärningsmodeller med hjälp av en kodinlärningsmetod i C# eller F#, eller via verktyg med låg kod som Model Builder och ML.NET CLI. Ramverket är utökningsbart och gör att du kan använda andra populära maskininlärningsramverk som TensorFlow och ONNX.

ONNX är ett format med öppen källkod för AI-modeller. ONNX stöder samverkan mellan ramverk. Det innebär att du kan träna en modell i ett av de många populära maskininlärningsramverken som PyTorch, konvertera den till ONNX-format och använda ONNX-modellen i ett annat ramverk som ML.NET. Mer information finns på ONNX-webbplatsen.

Förutsättningar

.NET 6 SDK eller senare
Textredigerare eller IDE (till exempel Visual Studio eller Visual Studio Code)
ONNX-modell. Mer information om hur du tränar en AutoML ONNX-modell finns i följande notebook-fil för bankmarknadsföringsklassificering.
Netron (valfritt)

Skapa ett C#-konsolprogram

I det här exemplet använder du .NET CLI för att skapa ditt program, men du kan utföra samma uppgifter med Hjälp av Visual Studio. Läs mer om .NET CLI.

Öppna en terminal och skapa ett nytt C# .NET-konsolprogram. I det här exemplet är AutoMLONNXConsoleAppnamnet på programmet . En katalog skapas med samma namn som innehållet i ditt program.
```
dotnet new console -o AutoMLONNXConsoleApp
```
I terminalen går du till katalogen AutoMLONNXConsoleApp .
```
cd AutoMLONNXConsoleApp
```

Lägga till programvarupaket

Installera nuget-paketen Microsoft.ML, Microsoft.ML.OnnxRuntime och Microsoft.ML.OnnxTransformer med hjälp av .NET CLI.
```
dotnet add package Microsoft.ML
dotnet add package Microsoft.ML.OnnxRuntime
dotnet add package Microsoft.ML.OnnxTransformer
```
Dessa paket innehåller de beroenden som krävs för att använda en ONNX-modell i ett .NET-program. ML.NET tillhandahåller ett API som använder ONNX-körningen för förutsägelser.

Öppna filen Program.cs och lägg till följande using direktiv överst.

using System.Linq;
using Microsoft.ML;
using Microsoft.ML.Data;
using Microsoft.ML.Transforms.Onnx;

Lägga till en referens till ONNX-modellen

Ett sätt för konsolprogrammet att komma åt ONNX-modellen är att lägga till den i utdatakatalogen för bygget. Om du inte redan har en modell följer du den här notebook-filen för att skapa en exempelmodell.

Lägg till en referens till DIN ONNX-modellfil i ditt program:

Kopiera ONNX-modellen till programmets AutoMLONNXConsoleApp-rotkatalog .
Öppna filen AutoMLONNXConsoleApp.csproj och lägg till följande innehåll i Project noden.
```
<ItemGroup>
    <None Include="automl-model.onnx">
        <CopyToOutputDirectory>PreserveNewest</CopyToOutputDirectory>
    </None>
</ItemGroup>
```
I det här fallet är namnet på ONNX-modellfilen automl-model.onnx.

(Mer information om vanliga MSBuild-objekt finns i MSBuild-guide.)
Öppna filen Program.cs och lägg till följande rad i Program klassen.
```
static string ONNX_MODEL_PATH = "automl-model.onnx";
```

Initiera MLContext

I -metoden för Main klassen skapar du Program en ny instans av MLContext.

MLContext mlContext = new MLContext();

Klassen MLContext är en startpunkt för alla ML.NET åtgärder, och initiering mlContext skapar en ny ML.NET miljö som kan delas över modelllivscykeln. Det liknar konceptuellt DbContext i Entity Framework.

Definiera modelldataschemat

En modell förväntar sig indata och utdata i ett visst format. ML.NET kan du definiera formatet för dina data via klasser. Ibland kanske du redan vet hur formatet ser ut. Om du inte känner till dataformatet kan du använda verktyg som Netron för att inspektera ONNX-modellen.

Modellen som används i det här exemplet använder data från datauppsättningen NYC TLC Taxi Trip. Ett exempel på data visas i följande tabell:

vendor_id	rate_code	passenger_count	trip_time_in_secs	trip_distance	payment_type	fare_amount
VTS	1	1	1140	3.75	CRD	15,5
VTS	1	1	480	2.72	CRD	10,0
VTS	1	1	1680	7,8	CSH	26,5

Granska ONNX-modellen (valfritt)

Använd ett verktyg som Netron för att inspektera modellens indata och utdata.

Öppna Netron.
I den översta menyraden väljer du Öppna fil > och använder filwebbläsaren för att välja din modell.
Din modell öppnas. Strukturen för modellen automl-model.onnx ser till exempel ut så här:
Välj den sista noden längst ned i diagrammet (variable_out1 i det här fallet) för att visa modellens metadata. Indata och utdata i sidopanelen visar modellens förväntade indata, utdata och datatyper. Använd den här informationen för att definiera indata- och utdataschemat för din modell.

Definiera modellindataschema

Skapa en ny klass med namnet OnnxInput med följande egenskaper i filen Program.cs .

public class OnnxInput
{
    [ColumnName("vendor_id")]
    public string VendorId { get; set; }

    [ColumnName("rate_code"),OnnxMapType(typeof(Int64),typeof(Single))]
    public Int64 RateCode { get; set; }

    [ColumnName("passenger_count"), OnnxMapType(typeof(Int64), typeof(Single))]
    public Int64 PassengerCount { get; set; }

    [ColumnName("trip_time_in_secs"), OnnxMapType(typeof(Int64), typeof(Single))]
    public Int64 TripTimeInSecs { get; set; }

    [ColumnName("trip_distance")]
    public float TripDistance { get; set; }

    [ColumnName("payment_type")]
    public string PaymentType { get; set; }
}

Var och en av egenskaperna mappar till en kolumn i datamängden. Egenskaperna kommenteras ytterligare med attribut.

Med ColumnName attributet kan du ange hur ML.NET ska referera till kolumnen när du arbetar med data. Även om egenskapen TripDistance till exempel följer standardkonventionerna för .NET-namngivning känner modellen bara till en kolumn eller funktion som trip_distancekallas . För att åtgärda den här namngivningsavvikelsen ColumnName mappar TripDistance attributet egenskapen till en kolumn eller funktion med namnet trip_distance.

För numeriska värden fungerar ML.NET endast på Single värdetyper. Den ursprungliga datatypen för vissa kolumner är dock heltal. Attributet OnnxMapType mappar typerna mellan ONNX och ML.NET.

Mer information om dataattribut finns i guiden ML.NET läsa in data.

Definiera modellutdataschema

När data har bearbetats genereras utdata av ett visst format. Definiera datautdataschemat. Skapa en ny klass med namnet OnnxOutput med följande egenskaper i filen Program.cs .

public class OnnxOutput
{
    [ColumnName("variable_out1")]
    public float[] PredictedFare { get; set; }
}

OnnxInputPå liknande ColumnName sätt använder du attributet för att mappa variable_out1 utdata till ett mer beskrivande namn PredictedFare.

Definiera en förutsägelsepipeline

En pipeline i ML.NET är vanligtvis en serie länkade transformeringar som fungerar på indata för att generera utdata. Mer information om datatransformeringar finns i guiden ML.NET datatransformering.

Skapa en ny metod med namnet GetPredictionPipeline inuti Program klassen

static ITransformer GetPredictionPipeline(MLContext mlContext)
{

}

Definiera namnet på indata- och utdatakolumnerna. Lägg till följande kod i GetPredictionPipeline metoden.

var inputColumns = new string []
{
    "vendor_id", "rate_code", "passenger_count", "trip_time_in_secs", "trip_distance", "payment_type"
};

var outputColumns = new string [] { "variable_out1" };

Definiera din pipeline. En IEstimator innehåller en skiss över åtgärderna och indata- och utdatascheman för din pipeline.
```
var onnxPredictionPipeline =
    mlContext
        .Transforms
        .ApplyOnnxModel(
            outputColumnNames: outputColumns,
            inputColumnNames: inputColumns,
            ONNX_MODEL_PATH);
```
I det här fallet ApplyOnnxModel är den enda transformen i pipelinen, som tar in namnen på indata- och utdatakolumnerna samt sökvägen till ONNX-modellfilen.
En IEstimator definierar bara den uppsättning åtgärder som ska tillämpas på dina data. Det som fungerar på dina data kallas för .ITransformer Fit Använd metoden för att skapa en från .onnxPredictionPipeline
```
var emptyDv = mlContext.Data.LoadFromEnumerable(new OnnxInput[] {});

return onnxPredictionPipeline.Fit(emptyDv);
```
Metoden Fit förväntar sig att en IDataView som indata ska utföra åtgärderna på. Ett IDataView är ett sätt att representera data i ML.NET med ett tabellformat. Eftersom pipelinen i det här fallet endast används för förutsägelser kan du ange en tom IDataView för att ge nödvändig ITransformer information om in- och utdataschemat. Den monterade ITransformer returneras sedan för vidare användning i ditt program.

Dricks

I det här exemplet definieras och används pipelinen i samma program. Vi rekommenderar dock att du använder separata program för att definiera och använda din pipeline för att göra förutsägelser. I ML.NET kan dina pipelines serialiseras och sparas för ytterligare användning i andra .NET-slutanvändarprogram. ML.NET stöder olika distributionsmål, till exempel skrivbordsprogram, webbtjänster, WebAssembly-program och många fler. Mer information om hur du sparar pipelines finns i guiden ML.NET spara och läsa in tränade modeller.
Main I metoden anropar GetPredictionPipeline du metoden med de obligatoriska parametrarna.
```
var onnxPredictionPipeline = GetPredictionPipeline(mlContext);
```

Använda modellen för att göra förutsägelser

Nu när du har en pipeline är det dags att använda den för att göra förutsägelser. ML.NET tillhandahåller ett bekvämlighets-API för att göra förutsägelser på en enda datainstans med namnet PredictionEngine.

Main I metoden skapar du en PredictionEngine med hjälp CreatePredictionEngine av -metoden.

var onnxPredictionEngine = mlContext.Model.CreatePredictionEngine<OnnxInput, OnnxOutput>(onnxPredictionPipeline);

Skapa en testdatainmatning.

var testInput = new OnnxInput
{
    VendorId = "CMT",
    RateCode = 1,
    PassengerCount = 1,
    TripTimeInSecs = 1271,
    TripDistance = 3.8f,
    PaymentType = "CRD"
};

predictionEngine Använd för att göra förutsägelser baserat på nya testInput data med hjälp av Predict metoden .
```
var prediction = onnxPredictionEngine.Predict(testInput);
```

Mata ut resultatet av din förutsägelse till konsolen.

Console.WriteLine($"Predicted Fare: {prediction.PredictedFare.First()}");

Använd .NET CLI för att köra programmet.
```
dotnet run
```
Resultatet bör se ut ungefär så här:
```
Predicted Fare: 15.621523
```

Mer information om hur du gör förutsägelser i ML.NET finns i Använda en modell för att göra förutsägelser.

Dela via