Kurz: Kategorizace problémů s podporou pomocí klasifikace více tříd s ML.NET

Tento ukázkový kurz ukazuje použití ML.NET k vytvoření klasifikátoru problémů GitHubu pro trénování modelu, který klasifikuje a predikuje popisek Oblasti pro problém GitHubu prostřednictvím konzolové aplikace .NET Core pomocí jazyka C# v sadě Visual Studio.

V tomto kurzu se naučíte:

Zdrojový kód pro tento kurz najdete v úložišti dotnet/samples .

Požadavky

• Visual Studio 2022 s nainstalovanou úlohou ".NET Desktop Development".
• Soubor problémy GitHubu oddělený kartou (issues_train.tsv)
• Soubor s oddělovací kartou (issues_test.tsv) na GitHubu.

Vytvoření konzolové aplikace

Vytvoření projektu

1. Vytvořte konzolovou aplikaci jazyka C# s názvem GitHubIssueClassification. Vyberte Další.

2. Jako architekturu, kterou chcete použít, zvolte .NET 7. Vyberte Vytvořit.

3. Vytvořte v projektu adresář s názvem Data a uložte soubory datových sad:

   V Průzkumník řešení klikněte pravým tlačítkem na projekt a vyberte Přidat>novou složku. Zadejte "Data" a stiskněte Enter.

4. Vytvořte v projektu adresář s názvem Models a uložte model:

   V Průzkumník řešení klikněte pravým tlačítkem na projekt a vyberte Přidat>novou složku. Zadejte "Modely" a stiskněte Enter.

5. Nainstalujte balíček NuGet Microsoft.ML:

   Poznámka

   Tato ukázka používá nejnovější stabilní verzi uvedených balíčků NuGet, pokud není uvedeno jinak.

   V Průzkumník řešení klikněte pravým tlačítkem na projekt a vyberte Spravovat balíčky NuGet. Jako zdroj balíčku zvolte "nuget.org", vyberte kartu Procházet, vyhledejte Microsoft.ML a vyberte tlačítko Nainstalovat . V dialogovém okně Náhled změn vyberte tlačítko OK a pak v dialogovém okně Přijetí licence vyberte tlačítko Souhlasím, pokud souhlasíte s licenčními podmínkami pro uvedené balíčky.

Příprava dat

1. Stáhněte si datové sady issues_train.tsv a issues_test.tsv a uložte je do složky Data , kterou jste vytvořili dříve. První datová sada trénuje model strojového učení a druhá se dá použít k vyhodnocení přesnosti modelu.

2. V Průzkumník řešení klikněte pravým tlačítkem na jednotlivé soubory *.tsv a vyberte Vlastnosti. V části Upřesnit změňte hodnotu Kopírovat do výstupního adresáře na Kopírovat, pokud je novější.

Vytváření tříd a definování cest

Na začátek souboru Program.cs přidejte následující další using příkazy:

using Microsoft.ML;
using GitHubIssueClassification;

Vytvořte tři globální pole pro cesty k nedávno staženým souborům a globální proměnné pro MLContext,DataView a PredictionEngine:

• _trainDataPath má cestu k datové sadě použité k trénování modelu.
• _testDataPath má cestu k datové sadě použité k vyhodnocení modelu.
• _modelPath má cestu, kam je natrénovaný model uložen.
• _mlContext je ten MLContext , který poskytuje kontext zpracování.
• _trainingDataViewIDataView slouží ke zpracování trénovací datové sady.
• _predEnginePredictionEngine<TSrc,TDst> se používá pro jednotlivé předpovědi.

Do řádku přímo pod příkazy using přidejte následující kód, který určí tyto cesty a další proměnné:

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;

Vytvořte některé třídy pro vstupní data a předpovědi. Přidejte do projektu novou třídu:

1. V Průzkumník řešení klikněte pravým tlačítkem myši na projekt a pak vyberte Přidat>novou položku.

2. V dialogovém okně Přidat novou položku vyberte Třída a změňte pole Název na GitHubIssueData.cs. Pak vyberte tlačítko Přidat .

   Soubor GitHubIssueData.cs se otevře v editoru kódu. Na začátek souboru GitHubIssueData.cs přidejte následující using příkaz:

using Microsoft.ML.Data;

Odeberte existující definici třídy a do souboru GitHubIssueData.cs přidejte následující kód, který má dvě třídy GitHubIssue a IssuePrediction:

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;
}

Jedná se label o sloupec, který chcete předpovědět. Identifikované Features jsou vstupy, které poskytnete modelu k predikci popisku.

Pomocí LoadColumnAttribute určete indexy zdrojových sloupců v sadě dat.

GitHubIssue je třída vstupní datové sady a obsahuje následující String pole:

• první sloupec ID (ID problému GitHubu)
• druhý sloupec Area (předpověď pro trénování)
• třetí sloupec Title (název problému Na GitHubu) je první feature použitý k predikci Area
• čtvrtý sloupec je druhý feature sloupecDescription, který se používá k predikciArea

IssuePrediction je třída používaná pro predikci po vytrénování modelu. Má jeden string (Area) a PredictedLabelColumnName atribut. Používá se PredictedLabel při predikci a vyhodnocení. Pro vyhodnocení se používá vstup s trénovacími daty, predikovanými hodnotami a modelem.

Všechny ML.NET operace se spustí ve třídě MLContext . Inicializace mlContext vytvoří nové ML.NET prostředí, které lze sdílet mezi objekty pracovního postupu vytváření modelu. Koncepčně je to podobné jako DBContext v Entity Framework.

Inicializace proměnných

Inicializuje _mlContext globální proměnnou s novou instancí MLContext s náhodným počátečním (seed: 0) pro opakovatelné/deterministické výsledky napříč několika trénováním. Console.WriteLine("Hello World!") Nahraďte řádek následujícím kódem:

_mlContext = new MLContext(seed: 0);

Načtení dat

ML.NET používá rozhraní IDataView jako flexibilní a efektivní způsob popisu číselných nebo textových tabulkových dat. IDataView může načítat textové soubory nebo v reálném čase (například databáze SQL nebo soubory protokolů).

Pokud chcete inicializovat a načíst _trainingDataView globální proměnnou, abyste ji mohli použít pro kanál, přidejte po mlContext inicializaci následující kód:

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

LoadFromTextFile() definuje datové schéma a čte v souboru. Přebírá proměnné cesty k datům a vrací IDataViewhodnotu .

Po volání LoadFromTextFile() metody přidejte následující:

var pipeline = ProcessData();

Metoda ProcessData provede následující úlohy:

• Extrahuje a transformuje data.
• Vrátí kanál zpracování.

Vytvořte metodu ProcessData v dolní části souboru Program.cs pomocí následujícího kódu:

IEstimator<ITransformer> ProcessData()
{

}

Extrakce funkcí a transformace dat

Pokud chcete předpovědět popisek Oblasti GitHubu pro GitHubIssue, pomocí metody MapValueToKey() transformujte Area sloupec na sloupec typu Label číselného klíče (formát přijímaný klasifikačními algoritmy) a přidejte ho jako nový sloupec datové sady:

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

Dále zavolejte mlContext.Transforms.Text.FeaturizeText, který transformuje textové sloupce (Title a Description) na číselný vektor pro každý s názvem TitleFeaturized a DescriptionFeaturized. K kanálu připojte funkciaturizace pro oba sloupce pomocí následujícího kódu:

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

Poslední krok přípravy dat kombinuje všechny sloupce funkcí do sloupce Features pomocí metody Concatenate(). Ve výchozím nastavení algoritmus učení zpracovává pouze funkce ze sloupce Funkce . Tuto transformaci připojte do kanálu pomocí následujícího kódu:

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

Dále připojte AppendCacheCheckpoint objekt do mezipaměti DataView, aby při iteraci dat vícekrát pomocí mezipaměti mohl dosáhnout lepšího výkonu, jako u následujícího kódu:

.AppendCacheCheckpoint(_mlContext);

Vraťte kanál na konec ProcessData metody.

return pipeline;

Tento krok zpracovává předzpracování/funkciaturaci. Použití dalších komponent dostupných v ML.NET může s modelem dosáhnout lepších výsledků.

Sestavení a trénování modelu

Přidejte následující volání BuildAndTrainModelmetody jako další řádek za volání ProcessData() metody:

var trainingPipeline = BuildAndTrainModel(_trainingDataView, pipeline);

Metoda BuildAndTrainModel provede následující úlohy:

• Vytvoří třídu trénovacího algoritmu.
• Trénuje model.
• Predikuje oblast na základě trénovacích dat.
• Vrátí model.

Vytvořte metodu BuildAndTrainModel hned za deklarací ProcessData() metody pomocí následujícího kódu:

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

}

Informace o úkolu klasifikace

Klasifikace je úloha strojového učení, která používá data k určení kategorie, typu nebo třídy položky nebo řádku dat a často je jedním z následujících typů:

• Binární: A nebo B.
• Vícetřídní: více kategorií, které lze předpovědět pomocí jednoho modelu.

Pro tento typ problému použijte algoritmus učení klasifikace s více třídami, protože predikce kategorií problému může být jedna z více kategorií (více tříd), nikoli pouze dvě (binární).

Připojte algoritmus strojového učení k definicím transformace dat přidáním následujícího řádku jako prvního řádku kódu v BuildAndTrainModel():

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

SdcaMaximumEntropy je trénovací algoritmus klasifikace s více třídami. Toto je připojeno k pipeline a přijímá featurizované Title a Description (Features) a Label vstupní parametry pro učení z historických dat.

Trénování modelu

Přizpůsobení modelu datům splitTrainSet a vrácení natrénovaného modelu přidáním následujícího řádku kódu do BuildAndTrainModel() metody:

_trainedModel = trainingPipeline.Fit(trainingDataView);

Metoda Fit()trénuje model transformací datové sady a použitím trénování.

PredictionEngine je rozhraní API pro pohodlí, které umožňuje předat a pak provést predikci na jedné instanci dat. Přidejte tento řádek jako další řádek v BuildAndTrainModel() metodě:

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

Predikce pomocí natrénovaného modelu

Přidejte problém GitHubu a otestujte predikci natrénovaného modelu v Predict metodě vytvořením instance GitHubIssue:

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.."
};

Pomocí funkce Predict() můžete předpovědět na jeden řádek dat:

var prediction = _predEngine.Predict(issue);

Použití modelu: výsledky predikce

Zobrazte GitHubIssue a odpovídající Area predikci popisku, abyste mohli sdílet výsledky a odpovídajícím způsobem s nimi pracovat. Pomocí následujícího Console.WriteLine() kódu vytvořte zobrazení výsledků:

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

Vrácení modelu vytrénovaného pro vyhodnocení

Vraťte model na konci BuildAndTrainModel metody.

return trainingPipeline;

Vyhodnocení modelu

Teď, když jste vytvořili a vytrénovali model, potřebujete ho vyhodnotit s jinou datovou sadou pro zajištění kvality a ověření. V metodě Evaluate se model vytvořený v BuildAndTrainModel předá, aby se vyhodnotil. Vytvořte metodu Evaluate hned za BuildAndTrainModel, jako v následujícím kódu:

void Evaluate(DataViewSchema trainingDataViewSchema)
{

}

Metoda Evaluate provede následující úlohy:

• Načte testovací datovou sadu.
• Vytvoří vyhodnocovače s více třídami.
• Vyhodnotí model a vytvoří metriky.
• Zobrazí metriky.

Přidejte volání nové metody přímo pod BuildAndTrainModel volání metody pomocí následujícího kódu:

Evaluate(_trainingDataView.Schema);

Stejně jako dříve u trénovací datové sady načtěte testovací datovou sadu přidáním následujícího kódu do Evaluate metody:

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

Metoda Evaluate() vypočítá metriky kvality pro model pomocí zadané datové sady. Vrátí MulticlassClassificationMetrics objekt, který obsahuje celkové metriky vypočítané vyhodnocovačem klasifikace s více třídami. Pokud chcete zobrazit metriky pro určení kvality modelu, musíte je nejprve získat. Všimněte si použití metody Transform() globální proměnné strojového učení _trainedModel ( ITransformer) ke zadávání funkcí a návratových předpovědí. Jako další řádek přidejte do Evaluate metody následující kód:

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

Pro klasifikaci s více třídami se vyhodnocují následující metriky:

• Mikropřesnost – každý pár tříd vzorku přispívá rovnoměrně k metrice přesnosti. Chcete, aby se mikropřesnost co nejvíce blížil jedné z nich.

• Přesnost maker – každá třída přispívá rovnoměrně k metrice přesnosti. Menšinové třídy mají stejnou váhu jako větší třídy. Chcete, aby přesnost maker byla co nejblíže jedné přesnosti.

• Ztráta protokolů – viz Ztráta protokolu. Chcete, aby se ztráta protokolů co nejvíce blížil nule.

• Snížení ztráty protokolů – rozsah od [-inf, 1,00], kde 1,00 je dokonalé předpovědi a 0 označuje střední předpovědi. Chcete, aby snížení ztráty protokolů bylo co nejblíže k jedné z nich.

Zobrazení metrik pro ověření modelu

Pomocí následujícího kódu můžete zobrazit metriky, sdílet výsledky a pak s nimi pracovat:

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($"*************************************************************************************************************");

Uložení modelu do souboru

Jakmile budete s modelem spokojení, uložte ho do souboru, abyste mohli provádět předpovědi později nebo v jiné aplikaci. Do metody Evaluate přidejte následující kód.

SaveModelAsFile(_mlContext, trainingDataViewSchema, _trainedModel);

Vytvořte metodu SaveModelAsFile pod vaší Evaluate metodou.

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

}

Do metody SaveModelAsFile přidejte následující kód. Tento kód používá metodu Save k serializaci a uložení trénovaného modelu jako souboru ZIP.

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

Nasazení a predikce pomocí modelu

Přidejte volání nové metody přímo pod Evaluate volání metody pomocí následujícího kódu:

PredictIssue();

Pomocí následujícího kódu vytvořte metodu PredictIssue hned za metodou Evaluate (a těsně před metodou SaveModelAsFile ):

void PredictIssue()
{

}

Metoda PredictIssue provede následující úlohy:

• Načte uložený model.
• Vytvoří jediný problém s testovacími daty.
• Předpovídá oblast na základě testovacích dat.
• Kombinuje testovací data a předpovědi pro generování sestav.
• Zobrazí predikované výsledky.

Načtěte uložený model do aplikace přidáním následujícího kódu do PredictIssue metody:

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

Přidejte problém GitHubu a otestujte predikci natrénovaného modelu v Predict metodě vytvořením instance GitHubIssue:

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

Stejně jako dříve vytvořte PredictionEngine instanci s následujícím kódem:

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

PredictionEngine je rozhraní API pro pohodlí, které umožňuje provádět předpovědi na jedné instanci dat. PredictionEngine není bezpečný pro přístup z více vláken. Je přijatelné používat v jednovláknovém nebo prototypovém prostředí. Pokud chcete zvýšit výkon a zabezpečení vláken v produkčních prostředích, použijte PredictionEnginePool službu, která vytvoří PredictionEngineObjectPool objekty pro použití v celé aplikaci. Projděte si tohoto průvodce používáním PredictionEnginePool ve webovém rozhraní API ASP.NET Core.

Pomocí příkazu PredictionEngine můžete předpovědět popisek Oblasti Na GitHubu přidáním následujícího kódu do PredictIssue metody pro predikci:

var prediction = _predEngine.Predict(singleIssue);

Použití načteného modelu pro predikci

Zobrazí Area se, aby bylo možné problém zařadit do kategorií a odpovídajícím způsobem s ním jednat. Pomocí následujícího Console.WriteLine() kódu vytvořte zobrazení výsledků:

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

Výsledky

Výsledky by se měly podobat následujícímu. Jak kanál zpracovává, zobrazuje zprávy. Může se zobrazit upozornění nebo zpracování zpráv. Tyto zprávy byly pro přehlednost odebrány z následujících výsledků.

=============== 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 ===============

Gratulujeme! Teď jste úspěšně vytvořili model strojového učení pro klasifikaci a predikci popisku oblasti pro problém GitHubu. Zdrojový kód pro tento kurz najdete v úložišti dotnet/samples .

Další kroky

V tomto kurzu jste se naučili:

Další informace najdete v dalším kurzu.