Vad är ML.NET och hur fungerar det?

ML.NET ger dig möjlighet att lägga till maskininlärning i .NET-program i online- eller offlinescenarier. Med den här funktionen kan du göra automatiska förutsägelser med hjälp av de data som är tillgängliga för ditt program. Maskininlärningsprogram använder mönster i data för att göra förutsägelser i stället för att behöva programmeras uttryckligen.

Central till ML.NET är en maskininlärningsmodell. Modellen anger de steg som krävs för att omvandla dina indata till en förutsägelse. Med ML.NET kan du träna en anpassad modell genom att ange en algoritm eller importera förtränade TensorFlow- och ONNX-modeller.

När du har en modell kan du lägga till den i ditt program för att göra förutsägelserna.

ML.NET körs i Windows, Linux och macOS med hjälp av .NET eller i Windows med hjälp av .NET Framework. 64-bitars stöds på alla plattformar. 32-bitars stöds i Windows, förutom TensorFlow, LightGBM och ONNX-relaterade funktioner.

I följande tabell visas exempel på vilken typ av förutsägelser du kan göra med ML.NET.

Förutsägelsetyp	Exempel
Klassificering/kategorisering	Dela automatiskt in kundfeedback i positiva och negativa kategorier.
Regression/Förutsäga kontinuerliga värden	Förutse priset på hus baserat på storlek och plats.
Avvikelseidentifiering	Identifiera bedrägliga banktransaktioner.
Rekommendationer	Föreslå produkter som onlinekunder kanske vill köpa, baserat på deras tidigare inköp.
Tidsserier/sekventiella data	Prognostisera väder- eller produktförsäljningen.
Bildklassificering	Kategorisera patologier i medicinska bilder.
Textklassificering	Kategorisera dokument baserat på deras innehåll.
Meningslikhet	Mät hur lika två meningar är.

Hello ML.NET World

Koden i följande kodfragment visar det enklaste ML.NET programmet. Det här exemplet konstruerar en linjär regressionsmodell för att förutsäga huspriser med hjälp av husstorlek och prisdata.

   using System;
   using Microsoft.ML;
   using Microsoft.ML.Data;

   class Program
   {
       public class HouseData
       {
           public float Size { get; set; }
           public float Price { get; set; }
       }

       public class Prediction
       {
           [ColumnName("Score")]
           public float Price { get; set; }
       }

       static void Main(string[] args)
       {
           MLContext mlContext = new MLContext();

           // 1. Import or create training data
           HouseData[] houseData = {
               new HouseData() { Size = 1.1F, Price = 1.2F },
               new HouseData() { Size = 1.9F, Price = 2.3F },
               new HouseData() { Size = 2.8F, Price = 3.0F },
               new HouseData() { Size = 3.4F, Price = 3.7F } };
           IDataView trainingData = mlContext.Data.LoadFromEnumerable(houseData);

           // 2. Specify data preparation and model training pipeline
           var pipeline = mlContext.Transforms.Concatenate("Features", new[] { "Size" })
               .Append(mlContext.Regression.Trainers.Sdca(labelColumnName: "Price", maximumNumberOfIterations: 100));

           // 3. Train model
           var model = pipeline.Fit(trainingData);

           // 4. Make a prediction
           var size = new HouseData() { Size = 2.5F };
           var price = mlContext.Model.CreatePredictionEngine<HouseData, Prediction>(model).Predict(size);

           Console.WriteLine($"Predicted price for size: {size.Size*1000} sq ft= {price.Price*100:C}k");

           // Predicted price for size: 2500 sq ft= $261.98k
       }
   }

Kodarbetsflöde

Följande diagram representerar programkodstrukturen samt den iterativa processen för modellutveckling:

• Samla in och läsa in träningsdata i ett IDataView-objekt
• Ange en pipeline med åtgärder för att extrahera funktioner och tillämpa en maskininlärningsalgoritm
• Träna en modell genom att anropa Fit() på pipelinen
• Utvärdera modellen och iterera för att förbättra
• Spara modellen i binärt format för användning i ett program
• Läs in modellen i ett ITransformer-objekt igen
• Gör förutsägelser genom att anropa CreatePredictionEngine.Predict()

Låt oss gå lite djupare in i dessa begrepp.

Maskininlärningsmodell

En ML.NET modell är ett objekt som innehåller transformeringar som ska utföras på dina indata för att komma fram till de förväntade utdata.

Grundläggande

Den mest grundläggande modellen är tvådimensionell linjär regression, där en kontinuerlig kvantitet är proportionell mot en annan, som i husprisexemplet ovan.

Modellen är helt enkelt: $Price = b + Storlek * w$. Parametrarna $b$ och $w$ beräknas genom att passa in en rad på en uppsättning par (storlek, pris). De data som används för att hitta modellens parametrar kallas träningsdata. Indata från en maskininlärningsmodell kallas funktioner. I det här exemplet är $Size$ den enda funktionen. De grundsanningsvärden som används för att träna en maskininlärningsmodell kallas etiketter. Här är $Price$-värdena i träningsdatauppsättningen etiketterna.

Mer komplext

En mer komplex modell klassificerar finansiella transaktioner i kategorier med hjälp av beskrivningen av transaktionstexten.

Varje transaktionsbeskrivning är uppdelad i en uppsättning funktioner genom att ta bort redundanta ord och tecken och räkna ord- och teckenkombinationer. Funktionsuppsättningen används för att träna en linjär modell baserat på uppsättningen kategorier i träningsdata. Ju mer lik en ny beskrivning är för dem i träningsuppsättningen, desto mer sannolikt tilldelas den till samma kategori.

Både husprismodellen och textklassificeringsmodellen är linjära modeller. Beroende på typen av data och det problem du löser kan du också använda beslutsträdsmodeller , generaliserade additiva modeller och andra. Du kan ta reda på mer om modellerna i Uppgifter.

Dataförberedelse

I de flesta fall är de data som du har tillgängliga inte lämpliga att användas direkt för att träna en maskininlärningsmodell. Rådata måste förberedas eller bearbetas i förväg innan de kan användas för att hitta parametrarna för din modell. Dina data kan behöva konverteras från strängvärden till en numerisk representation. Du kan ha redundant information i dina indata. Du kan behöva minska eller utöka dimensionerna för dina indata. Dina data kan behöva normaliseras eller skalas.

I självstudierna ML.NET lär du dig om olika databehandlingspipelines för text, bild, numeriska data och tidsseriedata som används för specifika maskininlärningsuppgifter.

Hur du förbereder dina data visar hur du tillämpar dataförberedelser mer allmänt.

Du hittar en bilaga för alla tillgängliga transformeringar i avsnittet resurser.

Modellutvärdering

Hur vet du hur bra den kommer att göra framtida förutsägelser när du har tränat din modell? Med ML.NET kan du utvärdera din modell mot några nya testdata.

Varje typ av maskininlärningsuppgift har mått som används för att utvärdera modellens noggrannhet och precision mot testdatauppsättningen.

I vårt husprisexempel använde vi uppgiften Regression . Om du vill utvärdera modellen lägger du till följande kod i det ursprungliga exemplet.

        HouseData[] testHouseData =
        {
            new HouseData() { Size = 1.1F, Price = 0.98F },
            new HouseData() { Size = 1.9F, Price = 2.1F },
            new HouseData() { Size = 2.8F, Price = 2.9F },
            new HouseData() { Size = 3.4F, Price = 3.6F }
        };

        var testHouseDataView = mlContext.Data.LoadFromEnumerable(testHouseData);
        var testPriceDataView = model.Transform(testHouseDataView);

        var metrics = mlContext.Regression.Evaluate(testPriceDataView, labelColumnName: "Price");

        Console.WriteLine($"R^2: {metrics.RSquared:0.##}");
        Console.WriteLine($"RMS error: {metrics.RootMeanSquaredError:0.##}");

        // R^2: 0.96
        // RMS error: 0.19

Utvärderingsmåtten visar att felet är låg-ish och att korrelationen mellan de förutsagda utdata och testutdata är hög. Det var enkelt! I verkliga exempel krävs det mer justering för att uppnå bra modellmått.

ML.NET arkitektur

I det här avsnittet beskrivs arkitekturmönster för ML.NET. Om du är en erfaren .NET-utvecklare är vissa av dessa mönster bekanta för dig, och vissa är mindre bekanta.

Ett ML.NET program börjar med ett MLContext objekt. Det här singleton-objektet innehåller kataloger. En katalog är en fabrik för datainläsning och -sparande, transformeringar, utbildare och modellåtgärdskomponenter. Varje katalogobjekt har metoder för att skapa olika typer av komponenter.

Uppgift	Katalog
Datainläsning och sparande	DataOperationsCatalog
Dataförberedelse	TransformsCatalog
Binär klassificering	BinaryClassificationCatalog
Klassificering med flera klasser	MulticlassClassificationCatalog
Avvikelseidentifiering	AnomalyDetectionCatalog
Klustring	ClusteringCatalog
Prognostisering	ForecastingCatalog
Rangordning	RankingCatalog
Regression	RegressionCatalog
Rekommendation	RecommendationCatalog
Tidsserier	TimeSeriesCatalog
Modellanvändning	ModelOperationsCatalog

Du kan navigera till skapandemetoderna i var och en av kategorierna ovan. Med Visual Studio visas katalogerna via IntelliSense.

Skapa pipelinen

I varje katalog finns en uppsättning tilläggsmetoder som du kan använda för att skapa en träningspipeline.

var pipeline = mlContext.Transforms.Concatenate("Features", new[] { "Size" })
    .Append(mlContext.Regression.Trainers.Sdca(labelColumnName: "Price", maximumNumberOfIterations: 100));

I kodfragmentet Concatenate och Sdca är båda metoderna i katalogen. Var och en skapar ett IEstimator-objekt som läggs till i pipelinen.

Objekten har nu skapats, men ingen körning har utförts.

Träna modellen

När objekten i pipelinen har skapats kan data användas för att träna modellen.

var model = pipeline.Fit(trainingData);

Anrop Fit() använder träningsdata för indata för att uppskatta modellens parametrar. Detta kallas för att träna modellen. Kom ihåg att den linjära regressionsmodellen som visades tidigare hade två modellparametrar: bias och vikt. Efter anropet Fit() är parametrarnas värden kända. (De flesta modeller har många fler parametrar än så.)

Du kan lära dig mer om modellträning i Träna din modell.

Det resulterande modellobjektet implementerar ITransformer gränssnittet. Modellen omvandlar alltså indata till förutsägelser.

IDataView predictions = model.Transform(inputData);

Använda modellen

Du kan omvandla indata till förutsägelser i bulk eller en indata i taget. Husprisexemplet gjorde både: i bulk för att utvärdera modellen och en i taget för att göra en ny förutsägelse. Nu ska vi titta på hur du gör enkla förutsägelser.

var size = new HouseData() { Size = 2.5F };
var predEngine = mlContext.CreatePredictionEngine<HouseData, Prediction>(model);
var price = predEngine.Predict(size);

Metoden CreatePredictionEngine() tar en indataklass och en utdataklass. Fältnamnen eller kodattributen bestämmer namnen på de datakolumner som används under modellträning och förutsägelse. Mer information finns i Göra förutsägelser med en tränad modell.

Datamodeller och schema

Kärnan i en ML.NET maskininlärningspipeline är DataView-objekt .

Varje transformering i pipelinen har ett indataschema (datanamn, typer och storlekar som transformeringen förväntar sig att se på sina indata); och ett utdataschema (datanamn, typer och storlekar som transformeringen genererar efter omvandlingen).

Om utdataschemat från en transformering i pipelinen inte matchar indataschemat för nästa transformering utlöser ML.NET ett undantag.

Ett datavyobjekt har kolumner och rader. Varje kolumn har ett namn och en typ och en längd. Till exempel är indatakolumnerna i husprisexemplet Storlek och Pris. De är båda av typen och de är skalära kvantiteter snarare än vektorer.

Alla ML.NET algoritmer letar efter en indatakolumn som är en vektor. Som standard kallas den här vektorkolumnen Funktioner. Därför sammanfogade husprisexemplet kolumnen Storlek i en ny kolumn med namnet Funktioner.

var pipeline = mlContext.Transforms.Concatenate("Features", new[] { "Size" })

Alla algoritmer skapar också nya kolumner när de har utfört en förutsägelse. De fasta namnen på dessa nya kolumner beror på typen av maskininlärningsalgoritm. För regressionsaktiviteten kallas en av de nya kolumnerna Poäng enligt prisdataattributet.

public class Prediction
{
    [ColumnName("Score")]
    public float Price { get; set; }
}

Du kan läsa mer om utdatakolumner för olika maskininlärningsuppgifter i guiden Maskininlärningsuppgifter .

En viktig egenskap för DataView-objekt är att de utvärderas lazily. Datavyer läses bara in och drivs på under modellträning och utvärdering samt dataförutsägelse. När du skriver och testar ditt ML.NET program kan du använda Visual Studio-felsökningsprogrammet för att ta en titt på alla datavyobjekt genom att anropa metoden Förhandsversion .

var debug = testPriceDataView.Preview();

Du kan titta på variabeln debug i felsökningsprogrammet och undersöka dess innehåll. Använd inte förhandsgranskningsmetoden i produktionskoden eftersom den avsevärt försämrar prestandan.

Modelldistribution

I verkliga program är din modelltränings- och utvärderingskod separat från din förutsägelse. Faktum är att dessa två aktiviteter ofta utförs av separata team. Ditt modellutvecklingsteam kan spara modellen för användning i förutsägelseprogrammet.

mlContext.Model.Save(model, trainingData.Schema,"model.zip");

Nästa steg

• Lär dig hur du skapar program med olika maskininlärningsuppgifter med mer realistiska datauppsättningar i självstudierna.

• Lär dig mer om specifika ämnen i guiderna.

• Om du är supersugen kan du gå direkt till API-referensdokumentationen.