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

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

V tomto návodu se naučíte, jak:

• Příprava dat
• Transformace dat
• Trénování modelu
• Vyhodnocení modelu
• Předpověď pomocí natrénovaného modelu
• Nasazení a předpověď s využitím načteného modelu

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

Požadavky

• Visual Studio 2022 nebo novější s nainstalovanou pracovní zátěží ".NET Desktop Development".
• GitHub problémy s trénovacím souborem odděleným tabulátorem (issues_train.tsv)
• Testovací soubor GitHub issues oddělený tabulátorem (issues_test.tsv)

Vytvoření konzolové aplikace

Vytvoření projektu

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

2. Jako architekturu, která se má použít, zvolte .NET 7. Vyberte Vytvořit.

3. Vytvořte adresář s názvem Data v projektu pro uložení souborů datové sady:

   V Průzkumníku ř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íku ř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íku ř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 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 Přijmout, 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íku řešení klikněte pravým tlačítkem na všechny 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 using přidejte následující další direktivy:

using Microsoft.ML;
using GitHubIssueClassification;

Vytvořte tři globální pole pro uložení cest k nedávno staženým souborům a globálních proměnných pro objekt MLContext, DataViewa PredictionEngine:

• _trainDataPath obsahuje cestu k datové sadě použité k trénování modelu.
• _testDataPath obsahuje cestu k datové sadě použité k vyhodnocení modelu.
• _modelPath obsahuje cestu, kam je trénovaný model uložen.
• _mlContext je to, MLContext co poskytuje kontext zpracování.
• _trainingDataView IDataView slouží ke zpracování trénovací datové sady.
• _predEngine PredictionEngine<TSrc,TDst> se používá pro jednoduché předpovědi.

Přidejte následující kód na řádek přímo pod using direktivy, které určují 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íku ř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 Přidat.

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

   using Microsoft.ML.Data;
   

3. Odeberte existující definici třídy a do souboru GitHubIssueData.cs přidejte následující kód. Tento kód má dvě třídy a GitHubIssueIssuePrediction.

   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é modelu poskytnete k predikci popisku.

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

   GitHubIssue je vstupní třída datové sady a má 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 úkolu na GitHubu) je prvním prvkem feature, který se používá k predikování Area.
   • Čtvrtý sloupec Description je druhý feature , který slouží k predikci Area.

   IssuePrediction je třída použitá 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žije vstup s trénovacími daty, predikovanými hodnotami a modelem.

   Všechny ML.NET operace se spouštějí ve třídě MLContext . Inicializace mlContext vytvoří nové ML.NET prostředí, které lze sdílet napříč objekty pracovního postupu vytváření modelu. Je to podobné, koncepčně, jako DBContext in Entity Framework.

Inicializujte proměnné

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

_mlContext = new MLContext(seed: 0);

Načtení dat

ML.NET používá rozhraní IDataView jako flexibilní efektivní způsob popisu číselných nebo textových tabulkových dat. IDataView může načíst 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, aby ji bylo možné 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 schéma dat a přeč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í zpracovatelský řetězec.

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

IEstimator<ITransformer> ProcessData()
{

}

Extrahování funkcí a transformace dat

Pokud chcete předpovědět popisek area GitHub pro GitHubIssue, použijte metodu MapValueToKey() k transformaci sloupce Area na sloupec typu číselného klíče Label (formát akceptovaný algoritmy klasifikace) a přidejte ho jako nový sloupec v datové sadě:

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

Dále volejte mlContext.Transforms.Text.FeaturizeTextvolání , které transformuje text (Title a Description) sloupce na číselný vektor pro každý volaný TitleFeaturized a DescriptionFeaturized. K pipeline připojte featurizaci obou sloupců 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 . K kanálu připojte tuto transformaci pomocí následujícího kódu:

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

Dále připojte AppendCacheCheckpoint dataView k mezipaměti, takže při iteraci dat vícekrát pomocí mezipaměti může dojít k lepšímu výkonu, jako u následujícího kódu:

.AppendCacheCheckpoint(_mlContext);

Výstraha

Pro zkrácení doby trénování použijte AppendCacheCheckpoint pro malé nebo střední datové sady. Nepoužívejte ji (odeberte . AppendCacheCheckpoint()) při zpracování velmi velkých datových sad.

Na konci ProcessData metody vraťte kanál.

return pipeline;

Tento krok zpracovává předběžné zpracování/featurizaci. Použití dalších komponent dostupných v ML.NET vám umožní dosáhnout lepších výsledků s vaším modelem.

Sestavení a trénování modelu

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

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 po deklaraci ProcessData() metody pomocí následujícího kódu:

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

}

O úloze 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 se jedná o jeden z následujících typů:

• Binární: A nebo B.
• Vícetřídy: 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 kategorie problému může být jedna z více kategorií (vícetříd) místo jen dvou (binární).

Přidejte algoritmus strojového učení k definicím transformace dat přidáním následujícího řádku kódu: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 objektu pipeline a přijímá featurizované Title a Description (Features) a Label vstupní parametry, které se mají učit z historických dat.

Trénování modelu

Přizpůsobit model splitTrainSet datům a vrátit trénovaný model 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 pohodlné rozhraní API, které umožňuje předávat a pak provádět predikci pro jednu instanci dat. Přidejte tento řádek jako další řádek v BuildAndTrainModel() metodě:

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

Předpověď pomocí natrénovaného modelu

Přidání problému GitHubu pro otestování předpovědi tré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 vytvořit předpověď na jednom řádku dat:

var prediction = _predEngine.Predict(issue);

Použití modelu: Výsledky předpovědi

Zobrazte GitHubIssue a odpovídající popisek Area předpovědi, abyste mohli sdílet výsledky a odpovídajícím způsobem na ně reagovat. 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 natrénovaného k vyhodnocení

Vrátí model na konci BuildAndTrainModel metody.

return trainingPipeline;

Vyhodnocení modelu

Teď, když jste model vytvořili a vytrénovali, potřebujete ho vyhodnotit s jinou datovou sadou pro zajištění kvality a ověření. Metoda Evaluate využívá model vytvořený BuildAndTrainModel, který je následně předán k vyhodnocení. Vytvořte metodu Evaluate hned za BuildAndTrainModelnásledujícím kódem:

void Evaluate(DataViewSchema trainingDataViewSchema)
{

}

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

• Načte testovací datovou sadu.
• Vytvoří vícetřídního vyhodnocovače.
• Vyhodnotí model a vytvoří metriky.
• Zobrazí metriky.

Přidejte volání nové metody hned pod volání metody BuildAndTrainModel pomocí následujícího kódu.

Evaluate(_trainingDataView.Schema);

Stejně jako jste to udělali předtím s trénovací datovou sadou 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 modelu pomocí zadané datové sady. Vrátí MulticlassClassificationMetrics objekt, který obsahuje celkové metriky vypočítané vyhodnocovači klasifikace s více třídami. Pokud chcete zobrazit metriky pro určení kvality modelu, musíte je nejdřív získat. Všimněte si použití metody Transform() globální proměnné strojového učení _trainedModel ( ITransformer) ke vstupu funkcí a vrácení předpovědí. Do metody přidejte Evaluate následující kód jako další řádek:

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řídy vzorků přispívá rovnoměrně k metrice přesnosti. Chcete, aby byla mikropřesnost co nejblíže k jedné z nich.
• Přesnost maker – Každá třída přispívá stejně ke 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 k přesnosti makra.
• Ztráta protokolu – viz Ztráta protokolu. Chcete, aby ztráta protokolu byla co nejblíže nule.
• Snížení logaritmické ztráty – pohybuje se v rozmezí [-inf, 1,00], kde 1,00 označuje ideální předpovědi a 0 průměrné předpovědi. Chcete, aby bylo snížení ztráty protokolů co nejblíže k jedné z nich.

Zobrazení metrik pro ověření modelu

Pomocí následujícího kódu zobrazte metriky, sdílejte výsledky a pak s nimi zareagujte:

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 a vytvořte 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 metodou Evaluate .

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 předpověď pomocí modelu

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

PredictIssue();

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

void PredictIssue()
{

}

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

• Načte uložený model.
• Vytvoří jeden problém s testovacími daty.
• Predikuje 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řidání problému GitHubu pro otestování předpovědi tré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 instanci s následujícím kódem PredictionEngine :

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

PredictionEngine je pohodlné rozhraní API, které umožňuje provádět predikce pro jednu instanci dat. PredictionEngine není bezpečný pro přístup z více vláken. Je přijatelné použít v jednovláknovém nebo prototypovém prostředí. Pokud chcete zvýšit výkon a bezpečnost vláken v produkčních prostředích, použijte PredictionEnginePool službu, která vytvoří ObjectPoolPredictionEngine objekty pro použití v celé aplikaci. V tomto průvodci se dozvíte, jak používat PredictionEnginePool webové rozhraní API ASP.NET Core.

Poznámka:

PredictionEnginePool Rozšíření služby je aktuálně ve verzi Preview.

PredictionEngine Pomocí možnosti předpovědět popisek Oblasti Na GitHubu přidejte do PredictIssue metody pro predikci následující kód:

var prediction = _predEngine.Predict(singleIssue);

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

Zobrazí se Area, aby bylo možné problém přiřadit kategorie a přiměřeně na něj reagovat. Pomocí následujícího Console.WriteLine() kódu vytvořte zobrazení výsledků:

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

Results

Výsledky by měly být podobné následujícímu. Při zpracování kanálu se zobrazují zprávy. Můžete vidět varování nebo zprávy o zpracování. Tyto zprávy byly odebrány z následujících výsledků, aby byly přehledné.

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

• Příprava dat
• Transformace dat
• Trénování modelu
• Vyhodnocení modelu
• Předpověď pomocí natrénovaného modelu
• Nasazení a předpověď s využitím načteného modelu

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

Prediktor jízdy taxíkem