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 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éma területfeliratát egy .NET-konzolalkalmazáson keresztül a Visual Studióban a C# használatával.

Ebben az oktatóanyagban a következőket sajátíthatja el:

Az adatok előkészítése
Az adatok átalakítása
A modell betanítása
A modell kié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 vagy újabb verziója telepítve van a ".NET Desktop Development" számítási feladattal.
A GitHub a betanítási laptól elválasztott fájlt (issues_train.tsv) használja.
A GitHub a tabulátorral elválasztott fájl (issues_test.tsv) tesztelésével foglalkozik.

Konzolalkalmazás létrehozása

Projekt létrehozása

Hozzon létre egy "GitHubIssueClassification" nevű C# -konzolalkalmazást . Válassza a Következőlehetőséget.
Válassza a .NET 7-et a használni kívánt keretrendszerként. Válassza a Create gombot.
Hozzon létre egy Data nevű könyvtárat a projektben az adatkészletfájlok mentéséhez:

A Megoldáskezelőben kattintson a jobb gombbal a projektre, és válassza azÚj mappa>. Írja be az "Adatok" kifejezést, és nyomja le az Enter billentyűt.
Hozzon létre egy Modellek nevű könyvtárat a projektben a modell mentéséhez:

A Megoldáskezelőben kattintson a jobb gombbal a projektre, és válassza azÚj mappa>. Írja be a "Modellek" kifejezést, és nyomja le az Enter billentyűt.
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őben kattintson a jobb gombbal a projektre, és válassza a NuGet-csomagok kezelése lehetőséget. Válassza a "nuget.org" lehetőséget csomagforrásként, válassza a Tallózás lapot, keresse meg a Microsoft.ML , és válassza a Telepítés lehetőséget. Kattintson az OK gombra 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.

Az adatok előkészítése

Töltse le a issues_train.tsv és a issues_test.tsv adatkészleteket , és mentse őket a korábban létrehozott Adatmappába . Az első adatkészlet betanítja a gépi tanulási modellt, a második pedig a modell pontosságának értékelésére szolgál.
A Megoldáskezelőben 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 Kimeneti könyvtárba másolás értékét Másolás, ha újabb.

Osztályok létrehozása és útvonalak definiálása

Adja hozzá a következő további using irányelveket 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 tárolásához, valamint a MLContext, DataViewés PredictionEngine:

_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 útja.
_modelPath a betanított modell mentési útvonalával rendelkezik.
_mlContext a MLContext feldolgozási környezetet biztosító környezet.
_trainingDataView a IDataView betanítási adatkészlet feldolgozására szolgál.
_predEngine PredictionEngine<TSrc,TDst> az egyszeri előrejelzésekhez használt.

Adja hozzá a következő kódot az irányelvek alatti sorhoz az using elérési utak és a többi változó megadásához:

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 az előrejelzésekhez. Adjon hozzá egy új osztályt a projekthez:

A Megoldáskezelőben kattintson a jobb gombbal a projektre, majd válassza azÚj elem>.
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. Ezután válassza a Hozzáadás lehetőséget.

A GitHubIssueData.cs fájl megnyílik a kódszerkesztőben. Adja hozzá a következő using irányelvet 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ódot a GitHubIssueData.cs fájlhoz. Ez a kód két osztályt, GitHubIssue és IssuePrediction tartalmaz.
```
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;
}
```
Ez label az az oszlop, amelyet előre szeretne jelezni. Az azonosított Features bemenetek, amelyeket a modellnek a címke előrejelzéséhez ad.

A LoadColumnAttribute használatával adja meg az adathalmaz forrásoszlopainak indexeit.

GitHubIssue a bemeneti adathalmaz osztály, és a következő String mezőket tartalmazza:
- 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 () és attribútummal rendelkezikAreaPredictedLabel.ColumnName Ez PredictedLabel az előrejelzés és az é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áljuk.

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. Ez hasonló, fogalmilag, hogy DBContext a .Entity Framework

Változók inicializálása

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

_mlContext = new MLContext(seed: 0);

Töltse be az adatokat

ML.NET az IDataView felületet használja a numerikus vagy szöveges táblázatos adatok rugalmas és 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 _trainingDataView globális változó inicializálásához, betöltéséhez és a pipeline-ban való használatához 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ájlban. Felveszi az adatelérési út változóit, és visszaad egy IDataView.

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 GitHubIssueelőrejelzéséhez használja a MapValueToKey() metódust, hogy az Area oszlopot numerikus kulcs típusú Label oszlopmá (besorolási algoritmusok által elfogadott formátum) alakítsa át, és adja hozzá új adathalmazoszlopként:

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

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

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

Az adatelőkészítés utolsó lépése az összes funkcióoszlopot egyesíti a Szolgáltatások oszlopban a Concatenate() 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á a AppendCacheCheckpoint DataView-t a gyorsítótárhoz, hogy ha többször is átterjed az adatokra a gyorsítótár használatával, jobb teljesítményt érhet el, mint az alábbi kód esetén:

.AppendCacheCheckpoint(_mlContext);

Figyelmeztetés

Az AppendCacheCheckpoint használata kis- és közepes adathalmazokhoz a betanítási idő csökkentéséhez. NE használja (távolítsa el. 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/featurálást. A ML.NET elérhető további összetevőkkel 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ása ProcessData() után 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ályát.
A modell betanítása.
Betanítási adatok alapján előrejelzi a területet.
A modellt adja vissza.

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

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

}

Tudnivalók a besorolási feladatról

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 modell használatával előre jelezhetők.

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

Fűzze hozzá a gépi tanulási algoritmust az adatátalakítási definíciókhoz úgy, hogy a következőt adja hozzá első kódsorként a következőhöz 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 rendszerhez, és elfogadja a featurizált Title és Description (Features) bemeneti paramétereket, Label 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 következő kódsort adja hozzá a BuildAndTrainModel() metódushoz:

_trainedModel = trainingPipeline.Fit(trainingDataView);

A Fit()módszer 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 adatokat adjon át, majd egy előrejelzést végezzen egyetlen adatpéldányon. 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

Hozz létre egy GitHub-ügyet a betanított modell előrejelzésének teszteléséhez a Predict metódusban, azáltal, hogy létrehozol egy GitHubIssue példányt.

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 előrejelzést készíthet egyetlen adatsoron:

var prediction = _predEngine.Predict(issue);

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

Megjelenítheti GitHubIssue és megjelenítheti a megfelelő Area címke-előrejelzést, 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 kié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áshoz és az ellenőrzéshez. A metódusban a Evaluate rendszer átadja a létrehozott BuildAndTrainModel modellt az értékeléshez. Hozza létre a metódust Evaluate , a BuildAndTrainModelkövetkező 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 a következő kód hozzáadásával a Evaluate metódushoz:

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

A 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. Ahhoz, hogy megjelenítse a metrikákat a modell minőségének meghatározásához, először be kell szereznie őket. Figyelje meg, hogy a gépi tanulási globális változó (_trainedModel) Transform() metódusá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 Micro Accuracy a lehető legközelebb legyen az egyhez.
Makró pontossága – Minden osztály egyformán járul hozzá a pontossági metrikához. A kisebbségi osztályok egyenlő 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 – [-inf, 1,00] tartomány, 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 Save metódussal 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 a metódus után Evaluate (és a metódus előtt SaveModelAsFile ) a következő kóddal:

void PredictIssue()
{

}

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

Betölti a mentett modellt.
Egyetlen tesztadat-problémát hoz létre.
A tesztadatok alapján előrejelzi a területet.
A jelentéskészítéshez használt tesztadatokat és előrejelzéseket egyesíti.
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);

Hozz létre egy GitHub-ügyet a betanított modell előrejelzésének teszteléséhez a Predict metódusban, azáltal, hogy létrehozol egy GitHubIssue példányt.

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

Ahogyan 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 az előrejelzés végrehajtását egyetlen adatpéldányon. PredictionEngine nincs 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 egy ASP.NET Core Web API-ban.

Megjegyzés:

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

PredictionEngine A Terület GitHub-címke előrejelzéséhez adja hozzá a következő kódot az PredictIssue előrejelzési módszerhez:

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 megfelelő intézkedések megtételéhez. 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

Az eredményeknek az alábbihoz hasonlónak kell lenniük. A folyamat folyamatában üzeneteket jelenít meg. Előfordulhat, hogy figyelmeztetések vagy üzenetek feldolgozása jelenik meg. Ezeket az üzeneteket a rendszer eltávolította 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álok! 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.

Következő lépések

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

Az adatok előkészítése
Az adatok átalakítása
A modell betanítása
A modell kié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ő

Visszajelzés

Hasznosnak találta ezt az oldalt?

Last updated on 2025-12-06