Dela via

Självstudie: Förutsäga priser med regression med ML.NET

  • Artikel

Den här självstudien illustrerar hur du skapar en regressionsmodell med hjälp av ML.NET för att förutsäga priser, särskilt taxipriser i New York City.

I den här guiden får du lära dig att:

  • Förbereda och förstå data
  • Läsa in och transformera data
  • Välj en inlärningsalgoritm
  • Träna modellen
  • Utvärdera modellen
  • Använda modellen för förutsägelser

Krav

Skapa ett konsolprogram

  1. Skapa ett C# -konsolprogram med namnet "TaxiFarePrediction".

  2. Välj .NET 6 som ramverk att använda. Klicka på knappen Skapa.

  3. Skapa en katalog med namnet Data i projektet för att lagra datauppsättningen och modellfilerna.

  4. Installera nuget-paketet Microsoft.ML och Microsoft.ML.FastTree :

    Anteckning

    Det här exemplet använder den senaste stabila versionen av De NuGet-paket som nämns om inget annat anges.

    I Solution Explorer högerklickar du på projektet och väljer Hantera NuGet-paket. Välj "nuget.org" som paketkälla, välj fliken Bläddra , sök efter Microsoft.ML, välj paketet i listan och välj knappen Installera . Välj knappen OK i dialogrutan Förhandsgranska ändringar och välj sedan knappen Jag accepterar i dialogrutan Licensgodkännande om du godkänner licensvillkoren för de paket som anges. Gör samma sak för NuGet-paketet Microsoft.ML.FastTree .

Förbereda och förstå data

  1. Ladda ned taxi-fare-train.csv och taxi-fare-test.csv datauppsättningar och spara dem i mappen Data som du skapade i föregående steg. Vi använder dessa datauppsättningar för att träna maskininlärningsmodellen och utvärderar sedan hur exakt modellen är. Dessa datauppsättningar kommer ursprungligen från datauppsättningen NYC TLC Taxi Trip.

  2. I Solution Explorer högerklickar du på var och en av *.csv-filerna och väljer Egenskaper. Under Avancerat ändrar du värdet för Kopiera till utdatakatalog till Kopiera om nyare.

  3. Öppna taxi-fare-train.csv datauppsättningen och titta på kolumnrubriker på den första raden. Ta en titt på var och en av kolumnerna. Förstå data och bestäm vilka kolumner som är funktioner och vilken som är etiketten.

label är den kolumn som du vill förutsäga. FeaturesIdentifierade är de indata som du ger modellen för att förutsäga Label.

Den angivna datauppsättningen innehåller följande kolumner:

  • vendor_id: ID:t för taxileverantören är en funktion.
  • rate_code: Taxetypen för taxiresan är en funktion.
  • passenger_count: Antalet passagerare på resan är en funktion.
  • trip_time_in_secs: Hur lång tid resan tog. Du vill förutsäga resans pris innan resan är klar. I det ögonblicket vet du inte hur lång tid resan skulle ta. Därför är restiden inte en funktion och du utesluter den här kolumnen från modellen.
  • trip_distance: Resans avstånd är en funktion.
  • payment_type: Betalningsmetoden (kontanter eller kreditkort) är en funktion.
  • fare_amount: Det totala taxipriset som betalas är etiketten.

Skapa dataklasser

Skapa klasser för indata och förutsägelser:

  1. I Solution Explorer högerklickar du på projektet och väljer sedan Lägg till>nytt objekt.

  2. I dialogrutan Lägg till nytt objekt väljer du Klass och ändrar fältet Namn till TaxiTrip.cs. Välj sedan knappen Lägg till .

  3. Lägg till följande using direktiv i den nya filen:

    using Microsoft.ML.Data;

Ta bort den befintliga klassdefinitionen och lägg till följande kod, som har två klasser TaxiTrip och TaxiTripFarePrediction, i filen TaxiTrip.cs :

public class TaxiTrip
{
    [LoadColumn(0)]
    public string? VendorId;

    [LoadColumn(1)]
    public string? RateCode;

    [LoadColumn(2)]
    public float PassengerCount;

    [LoadColumn(3)]
    public float TripTime;

    [LoadColumn(4)]
    public float TripDistance;

    [LoadColumn(5)]
    public string? PaymentType;

    [LoadColumn(6)]
    public float FareAmount;
}

public class TaxiTripFarePrediction
{
    [ColumnName("Score")]
    public float FareAmount;
}

TaxiTrip är indataklassen och har definitioner för var och en av datauppsättningskolumnerna. LoadColumnAttribute Använd attributet för att ange index för källkolumnerna i datauppsättningen.

Klassen TaxiTripFarePrediction representerar förutsagda resultat. Det har ett enda flyttalfält, FareAmount, med ett ScoreColumnNameAttribute attribut tillämpat. Om det gäller regressionsaktiviteten innehåller kolumnen Poäng förutsagda etikettvärden.

Anteckning

Använd typen float för att representera flyttalsvärden i indata- och förutsägelsedataklasserna.

Definiera data- och modellsökvägar

Lägg till följande ytterligare using instruktioner överst i Filen Program.cs :

using Microsoft.ML;
using TaxiFarePrediction;

Du måste skapa tre fält för att lagra sökvägarna till filerna med datauppsättningar och filen för att spara modellen:

  • _trainDataPath innehåller sökvägen till filen med datauppsättningen som används för att träna modellen.
  • _testDataPath innehåller sökvägen till filen med datauppsättningen som används för att utvärdera modellen.
  • _modelPath innehåller sökvägen till filen där den tränade modellen lagras.

Lägg till följande kod direkt under användningsavsnittet för att ange dessa sökvägar och för variabeln _textLoader :

string _trainDataPath = Path.Combine(Environment.CurrentDirectory, "Data", "taxi-fare-train.csv");
string _testDataPath = Path.Combine(Environment.CurrentDirectory, "Data", "taxi-fare-test.csv");
string _modelPath = Path.Combine(Environment.CurrentDirectory, "Data", "Model.zip");

Alla ML.NET åtgärder startar i MLContext-klassen. När du initierar mlContext skapas en ny ML.NET miljö som kan delas mellan arbetsflödesobjekten för modellskapande. Det är ungefär som konceptuellt DBContext i Entity Framework.

Initiera variabler

Console.WriteLine("Hello World!") Ersätt raden med följande kod för att deklarera och initiera variabelnmlContext:

MLContext mlContext = new MLContext(seed: 0);

Lägg till följande som nästa kodrad för att anropa Train metoden:

var model = Train(mlContext, _trainDataPath);

Metoden Train() kör följande uppgifter:

  • Läser in data.
  • Extraherar och transformerar data.
  • Tränar modellen.
  • Returnerar modellen.

Metoden Train tränar modellen. Skapa den metoden precis nedan med hjälp av följande kod:

ITransformer Train(MLContext mlContext, string dataPath)
{

}

Läsa in och transformera data

ML.NET använder IDataView-gränssnittet som ett flexibelt och effektivt sätt att beskriva numeriska data eller tabelldata i text. IDataView kan läsa in antingen textfiler eller i realtid (till exempel SQL-databas eller loggfiler). Lägg till följande kod som den första raden i Train() metoden:

IDataView dataView = mlContext.Data.LoadFromTextFile<TaxiTrip>(dataPath, hasHeader: true, separatorChar: ',');

När du vill förutsäga taxiresans biljettpris FareAmount är Label kolumnen den som du kommer att förutsäga (modellens utdata). Använd transformeringsklassen CopyColumnsEstimator för att kopiera FareAmountoch lägg till följande kod:

var pipeline = mlContext.Transforms.CopyColumns(outputColumnName: "Label", inputColumnName:"FareAmount")

Algoritmen som tränar modellen kräver numeriska funktioner, så du måste omvandla kategoridatavärdena (VendorId, RateCodeoch PaymentType) till tal (VendorIdEncoded, RateCodeEncodedoch PaymentTypeEncoded). Det gör du genom att använda transformeringsklassen OneHotEncodingTransformer , som tilldelar olika numeriska nyckelvärden till de olika värdena i var och en av kolumnerna, och lägger till följande kod:

.Append(mlContext.Transforms.Categorical.OneHotEncoding(outputColumnName: "VendorIdEncoded", inputColumnName:"VendorId"))
.Append(mlContext.Transforms.Categorical.OneHotEncoding(outputColumnName: "RateCodeEncoded", inputColumnName: "RateCode"))
.Append(mlContext.Transforms.Categorical.OneHotEncoding(outputColumnName: "PaymentTypeEncoded", inputColumnName: "PaymentType"))

Det sista steget i förberedelsen av data kombinerar alla funktionskolumner i kolumnen Funktioner med hjälp av transformeringsklassenmlContext.Transforms.Concatenate. Som standard bearbetar en inlärningsalgoritm endast funktioner från kolumnen Funktioner . Lägg till följande kod:

.Append(mlContext.Transforms.Concatenate("Features", "VendorIdEncoded", "RateCodeEncoded", "PassengerCount", "TripDistance", "PaymentTypeEncoded"))

Välj en inlärningsalgoritm

Det här problemet handlar om att förutsäga en taxiresa i New York City. Vid första anblicken kan det tyckas bero helt enkelt på avståndet som färdas. Taxileverantörer i New York tar dock ut olika belopp för andra faktorer som ytterligare passagerare eller betalning med kreditkort istället för kontanter. Du vill förutsäga prisvärdet, som är ett verkligt värde, baserat på de andra faktorerna i datauppsättningen. Det gör du genom att välja en maskininlärningsuppgift för regression .

Lägg till machine learning-uppgiften FastTreeRegressionTrainer i definitionerna för datatransformering genom att lägga till följande som nästa kodrad i Train():

.Append(mlContext.Regression.Trainers.FastTree());

Träna modellen

Anpassa modellen till träningen dataview och returnera den tränade modellen genom att lägga till följande kodrad i Train() metoden :

var model = pipeline.Fit(dataView);

Metoden Fit() tränar din modell genom att transformera datauppsättningen och tillämpa träningen.

Returnera den tränade modellen med följande kodrad i Train() metoden :

return model;

Utvärdera modellen

Utvärdera sedan modellens prestanda med dina testdata för kvalitetssäkring och validering. Evaluate() Skapa -metoden, strax efter Train(), med följande kod:

void Evaluate(MLContext mlContext, ITransformer model)
{

}

Metoden Evaluate kör följande uppgifter:

  • Läser in testdatamängden.
  • Skapar regressionsutvärderingsorn.
  • Utvärderar modellen och skapar mått.
  • Visar måtten.

Lägg till ett anrop till den nya metoden direkt under metodanropet Train med hjälp av följande kod:

Evaluate(mlContext, model);

Läs in testdatauppsättningen med metoden LoadFromTextFile(). Utvärdera modellen med hjälp av den här datauppsättningen som en kvalitetskontroll genom att lägga till följande kod i Evaluate metoden :

IDataView dataView = mlContext.Data.LoadFromTextFile<TaxiTrip>(_testDataPath, hasHeader: true, separatorChar: ',');

Transformera Test sedan data genom att lägga till följande kod i Evaluate():

var predictions = model.Transform(dataView);

Metoden Transform() gör förutsägelser för testdatauppsättningens indatarader.

Metoden RegressionContext.Evaluate beräknar kvalitetsmåtten PredictionModel för med hjälp av den angivna datauppsättningen. Det returnerar ett RegressionMetrics -objekt som innehåller de övergripande måtten som beräknas av regressionsutvärderingar.

Om du vill visa dessa för att fastställa modellens kvalitet måste du hämta måtten först. Lägg till följande kod som nästa rad i Evaluate metoden :

var metrics = mlContext.Regression.Evaluate(predictions, "Label", "Score");

När du har angett förutsägelsen utvärderar metoden Evaluate() modellen, som jämför de förutsagda värdena med det faktiska Labels i testdatauppsättningen och returnerar mått om hur modellen presterar.

Lägg till följande kod för att utvärdera modellen och skapa utvärderingsmåtten:

Console.WriteLine();
Console.WriteLine($"*************************************************");
Console.WriteLine($"*       Model quality metrics evaluation         ");
Console.WriteLine($"*------------------------------------------------");

RSquared är ett annat utvärderingsmått för regressionsmodellerna. RSquared tar värden mellan 0 och 1. Desto närmare är värdet 1, desto bättre är modellen. Lägg till följande kod i Evaluate metoden för att visa RSquared-värdet:

Console.WriteLine($"*       RSquared Score:      {metrics.RSquared:0.##}");

RMS är ett av utvärderingsmåtten för regressionsmodellen. Ju lägre den är, desto bättre är modellen. Lägg till följande kod i Evaluate metoden för att visa RMS-värdet:

Console.WriteLine($"*       Root Mean Squared Error:      {metrics.RootMeanSquaredError:#.##}");

Använda modellen för förutsägelser

TestSinglePrediction Skapa -metoden, precis efter Evaluate -metoden, med hjälp av följande kod:

void TestSinglePrediction(MLContext mlContext, ITransformer model)
{

}

Metoden TestSinglePrediction kör följande uppgifter:

  • Skapar en enskild kommentar med testdata.
  • Förutsäger prisbeloppet baserat på testdata.
  • Kombinerar testdata och förutsägelser för rapportering.
  • Visar de förutsagda resultaten.

Lägg till ett anrop till den nya metoden direkt under metodanropet Evaluate med hjälp av följande kod:

TestSinglePrediction(mlContext, model);

PredictionEngine Använd för att förutsäga priset genom att lägga till följande kod i TestSinglePrediction():

var predictionFunction = mlContext.Model.CreatePredictionEngine<TaxiTrip, TaxiTripFarePrediction>(model);

PredictionEngine är ett bekvämlighets-API som gör att du kan utföra en förutsägelse på en enda instans av data. PredictionEngine är inte trådsäkert. Det är acceptabelt att använda i entrådade miljöer eller prototypmiljöer. För bättre prestanda och trådsäkerhet i produktionsmiljöer använder du PredictionEnginePool tjänsten, som skapar en ObjectPool av PredictionEngine objekt som ska användas i hela programmet. Se den här guiden om hur du använder PredictionEnginePool i ett ASP.NET Core webb-API.

Anteckning

PredictionEnginePool tjänsttillägget är för närvarande i förhandsversion.

I den här självstudien används en testresa i den här klassen. Senare kan du lägga till andra scenarier för att experimentera med modellen. Lägg till en resa för att testa den tränade modellens förutsägelse av kostnaden i TestSinglePrediction() metoden genom att skapa en instans av TaxiTrip:

var taxiTripSample = new TaxiTrip()
{
    VendorId = "VTS",
    RateCode = "1",
    PassengerCount = 1,
    TripTime = 1140,
    TripDistance = 3.75f,
    PaymentType = "CRD",
    FareAmount = 0 // To predict. Actual/Observed = 15.5
};

Sedan förutsäger du priset baserat på en enda instans av taxiresans data och skickar den till genom att lägga till PredictionEngine följande som nästa kodrader i TestSinglePrediction() metoden :

var prediction = predictionFunction.Predict(taxiTripSample);

Funktionen Predict() gör en förutsägelse på en enda instans av data.

Om du vill visa det förväntade priset för den angivna resan lägger du till följande kod i TestSinglePrediction metoden :

Console.WriteLine($"**********************************************************************");
Console.WriteLine($"Predicted fare: {prediction.FareAmount:0.####}, actual fare: 15.5");
Console.WriteLine($"**********************************************************************");

Kör programmet för att se den förväntade taxibiljetten för ditt testfall.

Grattis! Nu har du skapat en maskininlärningsmodell för att förutsäga taxipriser, utvärderat dess noggrannhet och använt den för att göra förutsägelser. Du hittar källkoden för den här självstudien på GitHub-lagringsplatsen dotnet/samples .

Nästa steg

I den här självstudiekursen lärde du dig att:

  • Förbereda och förstå data
  • Skapa en utbildningspipeline
  • Läsa in och transformera data
  • Välja en inlärningsalgoritm
  • Träna modellen
  • Utvärdera modellen
  • Använda modellen för förutsägelser

Gå vidare till nästa självstudie om du vill veta mer.

Iris-klustring