Oktatóanyag: Támogatási problémák kategorizálása többosztályos besorolással ML.NET

Ez a minta oktatóanyag bemutatja, hogy a ML.NET használatával hoz létre egy GitHub-problémaosztályozót egy olyan modell betanítása céljából, amely osztályozza és előrejelzi a GitHub-problémák területcímkéjét egy .NET Core-konzolalkalmazáson keresztül a Visual Studióban c# használatával.

Eben az oktatóanyagban az alábbiakkal fog megismerkedni:

• Adatok előkészítése
• Az adatok átalakítása
• A modell betanítása
• A modell értékelése
• Előrejelzés a betanított modellel
• Üzembe helyezés és előrejelzés betöltött modellel

Az oktatóanyag forráskódját a dotnet/samples adattárban találja.

Előfeltételek

• A Visual Studio 2022 telepített ".NET Desktop Development" számítási feladattal.
• A GitHub problémák lapjának külön fájlja (issues_train.tsv).
• A GitHub a tesztfülekre bontott fájlt (issues_test.tsv) bocsátja ki.

Konzolalkalmazás létrehozása

Projekt létrehozása

1. Hozzon létre egy "GitHubIssueClassification" nevű C# -konzolalkalmazást . Kattintson a Tovább gombra.

2. Válassza a .NET 7-et a használni kívánt keretrendszerként. Válassza a Létrehozás lehetőséget.

3. Hozzon létre egy Data (Adatok ) nevű könyvtárat a projektben az adatkészletfájlok mentéséhez:

   A Megoldáskezelő kattintson a jobb gombbal a projektre, és válassza azÚj mappahozzáadása> lehetőséget. Írja be az "Adatok" kifejezést, és nyomja le az Enter billentyűt.

4. Hozzon létre egy Modellek nevű könyvtárat a projektben a modell mentéséhez:

   A Megoldáskezelő kattintson a jobb gombbal a projektre, és válassza azÚj mappahozzáadása> lehetőséget. Írja be a "Modellek" kifejezést, és nyomja le az Enter billentyűt.

5. Telepítse a Microsoft.ML NuGet-csomagot:

   Megjegyzés

   Ez a minta az említett NuGet-csomagok legújabb stabil verzióját használja, hacsak másként nem rendelkezik.

   A Megoldáskezelő kattintson a jobb gombbal a projektre, és válassza a Manage NuGet Packages (NuGet-csomagok kezelése) lehetőséget. Válassza a "nuget.org" lehetőséget a Csomag forrásaként, válassza a Tallózás lapot, keresse meg a Microsoft.ML , és válassza a Telepítés gombot. Válassza az OK gombot a Változások előnézete párbeszédpanelen, majd válassza az Elfogadom gombot a Licenc elfogadása párbeszédpanelen, ha elfogadja a felsorolt csomagok licencfeltételét.

Adatok előkészítése

1. Töltse le a issues_train.tsv és a issues_test.tsv adatkészleteket , és mentse őket a korábban létrehozott Adatok mappába. Az első adatkészlet betanítása a gépi tanulási modellt, a második pedig a modell pontosságának kiértékelésére használható.

2. A Megoldáskezelő kattintson a jobb gombbal az egyes *.tsv fájlokra, és válassza a Tulajdonságok lehetőséget. A Speciális területen módosítsa a Másolás kimeneti könyvtárra értékét másolásra, ha újabb.

Osztályok létrehozása és elérési utak definiálása

Adja hozzá a következő további using utasításokat a Program.cs fájl elejéhez:

using Microsoft.ML;
using GitHubIssueClassification;

Hozzon létre három globális mezőt a nemrég letöltött fájlok elérési útjainak, valamint a ésDataViewPredictionEngine a MLContextglobális változóinak tárolásához:

• _trainDataPath rendelkezik a modell betanítása során használt adatkészlet elérési útjára.
• _testDataPath a modell kiértékeléséhez használt adatkészlet elérési útját használja.
• _modelPath a betanított modell mentési útvonalával rendelkezik.
• _mlContext a MLContext feldolgozási környezetet biztosító.
• _trainingDataView a betanítási IDataView adatkészlet feldolgozására szolgál.
• _predEnginePredictionEngine<TSrc,TDst> az egyszeri előrejelzésekhez használt.

Adja hozzá a következő kódot a következő sorhoz közvetlenül a using utasítás alatt, hogy megadja ezeket az elérési utakat és a többi változót:

string _appPath = Path.GetDirectoryName(Environment.GetCommandLineArgs()[0]) ?? ".";
string _trainDataPath = Path.Combine(_appPath, "..", "..", "..", "Data", "issues_train.tsv");
string _testDataPath = Path.Combine(_appPath, "..", "..", "..", "Data", "issues_test.tsv");
string _modelPath = Path.Combine(_appPath, "..", "..", "..", "Models", "model.zip");

MLContext _mlContext;
PredictionEngine<GitHubIssue, IssuePrediction> _predEngine;
ITransformer _trainedModel;
IDataView _trainingDataView;

Hozzon létre néhány osztályt a bemeneti adatokhoz és előrejelzésekhez. Adjon hozzá egy új osztályt a projekthez:

1. A Megoldáskezelő kattintson a jobb gombbal a projektre, majd válassza azÚj elemhozzáadása> lehetőséget.

2. Az Új elem hozzáadása párbeszédpanelen válassza az Osztály lehetőséget, és módosítsa a Név mezőt GitHubIssueData.cs értékre. Ezután válassza a Hozzáadás gombot.

   Megnyílik a GitHubIssueData.cs fájl a kódszerkesztőben. Adja hozzá a következő usingutasítást a GitHubIssueData.cs elejéhez:

using Microsoft.ML.Data;

Távolítsa el a meglévő osztálydefiníciót, és adja hozzá a következő, két osztályt GitHubIssue tartalmazó IssuePredictionkódot a GitHubIssueData.cs fájlhoz:

public class GitHubIssue
{
    [LoadColumn(0)]
    public string? ID { get; set; }
    [LoadColumn(1)]
    public string? Area { get; set; }
    [LoadColumn(2)]
    public required string Title { get; set; }
    [LoadColumn(3)]
    public required string Description { get; set; }
}

public class IssuePrediction
{
    [ColumnName("PredictedLabel")]
    public string? Area;
}

Az label az oszlop, amelyet előre szeretne jelezni. Az azonosítottak Features azok a bemenetek, amelyeket a modellnek a címke előrejelzéséhez ad.

A LoadColumnAttribute használatával adja meg az adatkészlet forrásoszlopainak indexeit.

GitHubIssue a bemeneti adathalmaz osztály, és a következő String mezőkkel rendelkezik:

• az első oszlop ID (GitHub-probléma azonosítója)
• a második oszlop Area (a betanítás előrejelzése)
• a harmadik oszlop Title (GitHub-probléma címe) az első feature , amely a Area
• a negyedik oszlop Description a második feature , amelyet a Area

IssuePrediction a modell betanítása után az előrejelzéshez használt osztály. Egyetlen string (Area) és attribútummal PredictedLabelColumnName rendelkezik. Ez PredictedLabel az előrejelzés és a kiértékelés során használatos. A kiértékeléshez a betanítási adatokat, az előrejelzett értékeket és a modellt tartalmazó bemenetet használja a rendszer.

Minden ML.NET művelet az MLContext osztályban kezdődik. Az inicializálás mlContext új ML.NET környezetet hoz létre, amely megosztható a modelllétrehozás munkafolyamat-objektumai között. Fogalmilag hasonló a következőhözEntity Framework: DBContext .

Változók inicializálása

Inicializálja a _mlContext globális változót egy új példánysal MLContext egy véletlenszerű maggal (seed: 0) a több betanítás során megismételhető/determinisztikus eredmények érdekében. Cserélje le a Console.WriteLine("Hello World!") sort a következő kódra:

_mlContext = new MLContext(seed: 0);

Az adatok betöltése

ML.NET az IDataView felületet használja a numerikus vagy szöveges táblázatos adatok rugalmas, hatékony leírására. IDataView betölthet szöveges fájlokat vagy valós időben (például SQL-adatbázist vagy naplófájlokat).

A globális változó inicializálásához és betöltéséhez _trainingDataView adja hozzá a következő kódot az mlContext inicializálás után:

_trainingDataView = _mlContext.Data.LoadFromTextFile<GitHubIssue>(_trainDataPath,hasHeader: true);

A LoadFromTextFile() meghatározza az adatsémát, és beolvassa a fájlt. Az adatútvonal változóit veszi fel, és egy IDataViewértéket ad vissza.

Adja hozzá a következőt a metódus meghívása LoadFromTextFile() után:

var pipeline = ProcessData();

A ProcessData metódus a következő feladatokat hajtja végre:

• Kinyeri és átalakítja az adatokat.
• A feldolgozási folyamatot adja vissza.

Hozza létre a metódust ProcessData a Program.cs fájl alján a következő kóddal:

IEstimator<ITransformer> ProcessData()
{

}

Funkciók kinyerése és az adatok átalakítása

A Area GitHub-címke előrejelzéséhez GitHubIssuehasználja a MapValueToKey() metódust, hogy az Area oszlopot numerikus kulcs típusú Label oszlopmá (a besorolási algoritmusok által elfogadott formátumban) alakítsa át, és adja hozzá új adathalmazoszlopként:

var pipeline = _mlContext.Transforms.Conversion.MapValueToKey(inputColumnName: "Area", outputColumnName: "Label")

Ezután hívja meg a , mlContext.Transforms.Text.FeaturizeText-t, amely a szöveget (Title és Description) tartalmazó oszlopokat számvektorlá alakítja az egyes hívott TitleFeaturized és DescriptionFeaturized. Fűzze hozzá mindkét oszlop featurizációját a folyamathoz a következő kóddal:

.Append(_mlContext.Transforms.Text.FeaturizeText(inputColumnName: "Title", outputColumnName: "TitleFeaturized"))
.Append(_mlContext.Transforms.Text.FeaturizeText(inputColumnName: "Description", outputColumnName: "DescriptionFeaturized"))

Az adat-előkészítés utolsó lépése az összes funkcióoszlopot egyesíti a Szolgáltatások oszlopban az Összefűzés() metódus használatával. Alapértelmezés szerint a tanulási algoritmus csak a Szolgáltatások oszlopban szereplő funkciókat dolgozza fel. Fűzze hozzá ezt az átalakítást a folyamathoz a következő kóddal:

.Append(_mlContext.Transforms.Concatenate("Features", "TitleFeaturized", "DescriptionFeaturized"))

Ezután fűzze hozzá az a fájlt AppendCacheCheckpoint a DataView gyorsítótárazásához, így ha többször is iterálja az adatokat a gyorsítótár használatával, jobb teljesítményt érhet el, mint az alábbi kód esetében:

.AppendCacheCheckpoint(_mlContext);

Figyelmeztetés

Az AppendCacheCheckpoint használatával csökkentheti a betanítási időt a kis- és közepes adathalmazokhoz. Ne használja (távolítsa el a következőt: . AppendCacheCheckpoint()) a nagy méretű adathalmazok kezelésekor.

Adja vissza a folyamatot a ProcessData metódus végén.

return pipeline;

Ez a lépés kezeli az előfeldolgozást/featurizációt. A ML.NET elérhető további összetevők használatával jobb eredményeket érhet el a modellel.

A modell létrehozása és betanítása

Adja hozzá a következő hívást a BuildAndTrainModelmetódushoz a metódus hívását ProcessData() követő következő sorként:

var trainingPipeline = BuildAndTrainModel(_trainingDataView, pipeline);

A BuildAndTrainModel metódus a következő feladatokat hajtja végre:

• Létrehozza a betanítási algoritmus osztályt.
• A modell betanítása.
• A betanítási adatok alapján előrejelzi a területet.
• A modellt adja vissza.

Hozza létre a metódust BuildAndTrainModel közvetlenül a metódus deklarációja ProcessData() után a következő kóddal:

IEstimator<ITransformer> BuildAndTrainModel(IDataView trainingDataView, IEstimator<ITransformer> pipeline)
{

}

A besorolási feladat ismertetése

A besorolás olyan gépi tanulási feladat, amely adatokat használ egy elem vagy adatsor kategóriájának, típusának vagy osztályának meghatározásához , és gyakran az alábbi típusok egyike:

• Bináris: A vagy B.
• Többosztályos: több kategória, amelyek egyetlen modellel előre jelezhetők.

Ilyen típusú probléma esetén használjon többosztályos besorolású tanulási algoritmust, mivel a problémakategória előrejelzése több kategória (többosztályos) egyike lehet, nem csak kettő (bináris).

Fűzze hozzá a gépi tanulási algoritmust az adatátalakítási definíciókhoz, és adja hozzá a következőt a kód első soraként a következőben BuildAndTrainModel():

var trainingPipeline = pipeline.Append(_mlContext.MulticlassClassification.Trainers.SdcaMaximumEntropy("Label", "Features"))
        .Append(_mlContext.Transforms.Conversion.MapKeyToValue("PredictedLabel"));

A SdcaMaximumEntropy a többosztályos besorolási betanítási algoritmus. Ez hozzá lesz fűzve a pipeline fájlhoz, és elfogadja a featurizált Title és a (Features) és Description a Label bemeneti paramétereket, hogy tanuljanak az előzményadatokból.

A modell betanítása

Illesztse a modellt az splitTrainSet adatokhoz, és adja vissza a betanított modellt úgy, hogy a metódus következő kódsoraként adja hozzá a BuildAndTrainModel() következőt:

_trainedModel = trainingPipeline.Fit(trainingDataView);

A Fit()metódus az adathalmaz átalakításával és a betanítás alkalmazásával tanítja be a modellt.

A PredictionEngine egy kényelmi API, amely lehetővé teszi, hogy egyetlen adatpéldányon adjon át egy előrejelzést, majd végezzen el egy előrejelzést. Adja hozzá ezt a metódus következő soraként BuildAndTrainModel() :

_predEngine = _mlContext.Model.CreatePredictionEngine<GitHubIssue, IssuePrediction>(_trainedModel);

Előrejelzés a betanított modellel

Adjon hozzá egy GitHub-problémát a betanított modell előrejelzésének teszteléséhez a metódusban a Predict következő példány GitHubIssuelétrehozásával:

GitHubIssue issue = new GitHubIssue() {
    Title = "WebSockets communication is slow in my machine",
    Description = "The WebSockets communication used under the covers by SignalR looks like is going slow in my development machine.."
};

A Predict() függvénnyel egyetlen adatsoron készít előrejelzést:

var prediction = _predEngine.Predict(issue);

A modell használata: előrejelzési eredmények

Megjelenítheti GitHubIssue és a megfelelő Area címke-előrejelzést jelenítheti meg, hogy megossza az eredményeket, és ennek megfelelően járjon el rajtuk. Hozzon létre egy megjelenítést az eredményekhez a következő Console.WriteLine() kóddal:

Console.WriteLine($"=============== Single Prediction just-trained-model - Result: {prediction.Area} ===============");

A kiértékeléshez betanított modell visszaadása

Adja vissza a modellt a BuildAndTrainModel metódus végén.

return trainingPipeline;

A modell értékelése

Most, hogy létrehozta és betanította a modellt, ki kell értékelnie egy másik adatkészlettel a minőségbiztosítás és az ellenőrzés érdekében. A metódusban a Evaluate rendszer átadja a metódusban BuildAndTrainModel létrehozott modellt az értékeléshez. Hozza létre a metódust közvetlenül a Evaluate után BuildAndTrainModel, az alábbi kódhoz hasonlóan:

void Evaluate(DataViewSchema trainingDataViewSchema)
{

}

A Evaluate metódus a következő feladatokat hajtja végre:

• Betölti a tesztadatkészletet.
• Létrehozza a többosztályos kiértékelőt.
• Kiértékeli a modellt, és metrikákat hoz létre.
• Megjeleníti a metrikákat.

Adjon hozzá egy hívást az új metódushoz közvetlenül a BuildAndTrainModel metódushívás alatt, a következő kóddal:

Evaluate(_trainingDataView.Schema);

Ahogy korábban a betanítási adatkészlettel is tette, töltse be a tesztadatkészletet úgy, hogy hozzáadja a következő kódot a Evaluate metódushoz:

var testDataView = _mlContext.Data.LoadFromTextFile<GitHubIssue>(_testDataPath,hasHeader: true);

Az Evaluate() metódus kiszámítja a modell minőségi metrikáit a megadott adatkészlet használatával. Egy objektumot MulticlassClassificationMetrics ad vissza, amely a többosztályos besorolási kiértékelők által kiszámított általános metrikákat tartalmazza. A metrikáknak a modell minőségének meghatározásához először le kell őket szereznie. Figyelje meg, hogy a gépi tanulási _trainedModel globális változó (egy ITransformer) Transform() metódusának használatával adja meg a funkciókat, és előrejelzéseket ad vissza. Adja hozzá a következő kódot a Evaluate metódushoz a következő sorként:

var testMetrics = _mlContext.MulticlassClassification.Evaluate(_trainedModel.Transform(testDataView));

A rendszer a következő metrikákat értékeli ki a többosztályos besoroláshoz:

• Mikropontosság – Minden mintaosztálypár egyenlő mértékben járul hozzá a pontossági metrikához. Azt szeretné, hogy a mikropontosság a lehető legközelebb legyen az egyikhez.

• Makró pontossága – Minden osztály egyenlő mértékben járul hozzá a pontossági metrikához. A kisebbségi osztályok ugyanolyan súlyt kapnak, mint a nagyobb osztályok. Azt szeretné, hogy a makró pontossága a lehető legközelebb legyen az egyikhez.

• Naplóvesztés – lásd: Naplóvesztés. Azt szeretné, hogy a naplóvesztés a lehető legközelebb legyen a nullához.

• Naplóveszteség csökkentése – Az [-inf, 1,00] tartományai, ahol az 1,00 tökéletes előrejelzés, a 0 pedig az átlagos előrejelzéseket jelzi. Azt szeretné, hogy a naplóveszteség csökkentése a lehető legközelebb legyen az egyikhez.

A modellérvényesítés metrikáinak megjelenítése

A metrikák megjelenítéséhez, az eredmények megosztásához és azok végrehajtásához használja az alábbi kódot:

Console.WriteLine($"*************************************************************************************************************");
Console.WriteLine($"*       Metrics for Multi-class Classification model - Test Data     ");
Console.WriteLine($"*------------------------------------------------------------------------------------------------------------");
Console.WriteLine($"*       MicroAccuracy:    {testMetrics.MicroAccuracy:0.###}");
Console.WriteLine($"*       MacroAccuracy:    {testMetrics.MacroAccuracy:0.###}");
Console.WriteLine($"*       LogLoss:          {testMetrics.LogLoss:#.###}");
Console.WriteLine($"*       LogLossReduction: {testMetrics.LogLossReduction:#.###}");
Console.WriteLine($"*************************************************************************************************************");

A modell mentése fájlba

Ha elégedett a modellel, mentse egy fájlba, hogy később vagy egy másik alkalmazásban előrejelzéseket készítsen. Adja hozzá a következő kódot a Evaluate metódushoz:

SaveModelAsFile(_mlContext, trainingDataViewSchema, _trainedModel);

Hozza létre a SaveModelAsFile metódust a Evaluate metódus alatt.

void SaveModelAsFile(MLContext mlContext,DataViewSchema trainingDataViewSchema, ITransformer model)
{

}

Adja hozzá a következő kódot a SaveModelAsFile metódushoz. Ez a kód a metódussal Save szerializálja és zip-fájlként tárolja a betanított modellt.

mlContext.Model.Save(model, trainingDataViewSchema, _modelPath);

Üzembe helyezés és előrejelzés modellel

Adjon hozzá egy hívást az új metódushoz közvetlenül a Evaluate metódushívás alatt, a következő kóddal:

PredictIssue();

Hozza létre a metódust PredictIssue közvetlenül a Evaluate metódus után (és közvetlenül a SaveModelAsFile metódus előtt) a következő kóddal:

void PredictIssue()
{

}

A PredictIssue metódus a következő feladatokat hajtja végre:

• A mentett modell betöltése
• A tesztadatok egyetlen problémáját hozza létre.
• A tesztadatok alapján előrejelzi a területet.
• A tesztelési adatokat és a jelentéskészítési előrejelzéseket kombinálja.
• Megjeleníti az előrejelzett eredményeket.

Töltse be a mentett modellt az alkalmazásba úgy, hogy hozzáadja a következő kódot a PredictIssue metódushoz:

ITransformer loadedModel = _mlContext.Model.Load(_modelPath, out var modelInputSchema);

Adjon hozzá egy GitHub-problémát a betanított modell előrejelzésének teszteléséhez a metódusban a Predict következő példány GitHubIssuelétrehozásával:

GitHubIssue singleIssue = new GitHubIssue() { Title = "Entity Framework crashes", Description = "When connecting to the database, EF is crashing" };

Ahogy korábban is tette, hozzon létre egy példányt PredictionEngine a következő kóddal:

_predEngine = _mlContext.Model.CreatePredictionEngine<GitHubIssue, IssuePrediction>(loadedModel);

A PredictionEngine egy kényelmi API, amely lehetővé teszi, hogy egyetlen adatpéldányon végezzen előrejelzést. PredictionEngine nem szálbiztos. Egyszálas vagy prototípusos környezetben is használható. Az éles környezetekben a jobb teljesítmény és a szálbiztonság érdekében használja a PredictionEnginePool szolgáltatást, amely objektumokat hoz létre ObjectPoolPredictionEngine az alkalmazás teljes területén való használatra. Ebből az útmutatóból megtudhatja, hogyan használható PredictionEnginePool ASP.NET Core webes API-ban.

Megjegyzés

PredictionEnginePool A szolgáltatásbővítmény jelenleg előzetes verzióban érhető el.

PredictionEngine A használatával előrejelezheti a Area GitHub-címkét, ha hozzáadja a következő kódot az PredictIssue előrejelzés metódusához:

var prediction = _predEngine.Predict(singleIssue);

A betöltött modell használata előrejelzéshez

Megjelenítés Area a probléma kategorizálásához és a probléma megfelelő megoldásához. Hozzon létre egy megjelenítést az eredményekhez a következő Console.WriteLine() kóddal:

Console.WriteLine($"=============== Single Prediction - Result: {prediction.Area} ===============");

Results (Eredmények)

Az eredményeknek az alábbihoz hasonlónak kell lenniük. A folyamat folyamata során üzeneteket jelenít meg. Megjelenhetnek figyelmeztetések vagy üzenetek feldolgozása. Ezeket az üzeneteket eltávolítottuk az alábbi eredményekből az egyértelműség érdekében.

=============== Single Prediction just-trained-model - Result: area-System.Net ===============
*************************************************************************************************************
*       Metrics for Multi-class Classification model - Test Data
*------------------------------------------------------------------------------------------------------------
*       MicroAccuracy:    0.738
*       MacroAccuracy:    0.668
*       LogLoss:          .919
*       LogLossReduction: .643
*************************************************************************************************************
=============== Single Prediction - Result: area-System.Data ===============

Gratulálunk! Sikeresen létrehozott egy gépi tanulási modellt egy GitHub-probléma területcímkéinek besorolásához és előrejelzéséhez. Az oktatóanyag forráskódját a dotnet/samples adattárban találja.

További lépések

Ez az oktatóanyag bemutatta, hogyan végezheti el az alábbi műveleteket:

• Adatok előkészítése
• Az adatok átalakítása
• A modell betanítása
• A modell értékelése
• Előrejelzés a betanított modellel
• Üzembe helyezés és előrejelzés betöltött modellel

További információért lépjen tovább a következő oktatóanyagra

Taxi viteldíj-előrejelző