Samouczek: kategoryzowanie problemów z pomocą techniczną przy użyciu klasyfikacji wieloklasowej przy użyciu ML.NET

Artykuł
04/08/2023

W tym przykładowym samouczku pokazano użycie ML.NET do utworzenia klasyfikatora problemów z usługą GitHub w celu wytrenowania modelu, który klasyfikuje i przewiduje etykietę Obszar dla problemu z usługą GitHub za pośrednictwem aplikacji konsolowej platformy .NET Core przy użyciu języka C# w programie Visual Studio.

Ten samouczek zawiera informacje na temat wykonywania następujących czynności:

Przygotowywanie danych
Przekształcanie danych
Trenowanie modelu
Ocena modelu
Przewidywanie za pomocą wytrenowanego modelu
Wdrażanie i przewidywanie przy użyciu załadowanego modelu

Kod źródłowy tego samouczka można znaleźć w repozytorium dotnet/samples .

Wymagania wstępne

Program Visual Studio 2022 z zainstalowanym obciążeniem .NET Desktop Development.
Plik rozdzielony kartą problemów z usługą GitHub (issues_train.tsv).
Plik rozdzielony kartą testowania problemów z usługą GitHub (issues_test.tsv).The GitHub issues tab tab separated file (plik rozdzielony issues_test.tsv).

Tworzenie aplikacji konsolowej

Tworzenie projektu

Utwórz aplikację konsolową języka C# o nazwie "GitHubIssueClassification". Wybierz opcję Dalej.
Wybierz platformę .NET 7 jako platformę do użycia. Wybierz przycisk Utwórz.
Utwórz katalog o nazwie Dane w projekcie, aby zapisać pliki zestawu danych:

W Eksplorator rozwiązań kliknij prawym przyciskiem myszy projekt i wybierz polecenie Dodaj>nowy folder. Wpisz "Dane" i naciśnij klawisz Enter.
Utwórz katalog o nazwie Models w projekcie, aby zapisać model:

W Eksplorator rozwiązań kliknij prawym przyciskiem myszy projekt i wybierz polecenie Dodaj>nowy folder. Wpisz "Modele" i naciśnij klawisz Enter.
Zainstaluj pakiet NuGet Microsoft.ML:

Uwaga

W tym przykładzie użyto najnowszej stabilnej wersji pakietów NuGet wymienionych, chyba że określono inaczej.

W Eksplorator rozwiązań kliknij prawym przyciskiem myszy projekt i wybierz polecenie Zarządzaj pakietami NuGet. Wybierz pozycję "nuget.org" jako źródło pakietu, wybierz kartę Przeglądaj, wyszukaj Microsoft.ML i wybierz przycisk Zainstaluj . Wybierz przycisk OK w oknie dialogowym Podgląd zmian , a następnie wybierz przycisk Akceptuję w oknie dialogowym Akceptacja licencji , jeśli zgadzasz się z postanowieniami licencyjnymi dla pakietów wymienionych.

Przygotowywanie danych

Pobierz zestawy danych issues_train.tsv i issues_test.tsv i zapisz je w utworzonym wcześniej folderze Data . Pierwszy zestaw danych szkoli model uczenia maszynowego, a drugi może służyć do oceny dokładności modelu.
W Eksplorator rozwiązań kliknij prawym przyciskiem myszy każdy z plików *.tsv i wybierz pozycję Właściwości. W obszarze Zaawansowane zmień wartość opcji Kopiuj do katalogu wyjściowego , aby skopiować, jeśli jest nowsza.

Tworzenie klas i definiowanie ścieżek

Dodaj następujące dodatkowe using instrukcje na początku pliku Program.cs :

using Microsoft.ML;
using GitHubIssueClassification;

Utwórz trzy pola globalne do przechowywania ścieżek do ostatnio pobranych plików oraz zmiennych globalnych dla zmiennych MLContext,DataView i PredictionEngine:

_trainDataPath zawiera ścieżkę do zestawu danych używanego do trenowania modelu.
_testDataPath zawiera ścieżkę do zestawu danych używanego do oceny modelu.
_modelPath ma ścieżkę, w której jest zapisywany wytrenowany model.
_mlContextMLContext to element, który zapewnia kontekst przetwarzania.
_trainingDataViewIDataView jest używany do przetwarzania zestawu danych trenowania.
_predEnginePredictionEngine<TSrc,TDst> jest używany w przypadku pojedynczych przewidywań.

Dodaj następujący kod do wiersza bezpośrednio poniżej instrukcji using, aby określić te ścieżki i inne zmienne:

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;

Utwórz kilka klas dla danych wejściowych i przewidywań. Dodaj nową klasę do projektu:

W Eksplorator rozwiązań kliknij prawym przyciskiem myszy projekt, a następnie wybierz polecenie Dodaj>nowy element.
W oknie dialogowym Dodawanie nowego elementu wybierz pozycję Klasa i zmień pole Nazwa na GitHubIssueData.cs. Następnie wybierz przycisk Dodaj .

Plik GitHubIssueData.cs zostanie otwarty w edytorze kodu. Dodaj następującą using instrukcję na początku pliku GitHubIssueData.cs:

using Microsoft.ML.Data;

Usuń istniejącą definicję klasy i dodaj następujący kod, który zawiera dwie klasy GitHubIssue i IssuePrediction, do pliku GitHubIssueData.cs :

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

Jest label to kolumna, którą chcesz przewidzieć. Zidentyfikowane Features są dane wejściowe, które dają modelowi do przewidywania etykiety.

Użyj atrybutu LoadColumnAttribute , aby określić indeksy kolumn źródłowych w zestawie danych.

GitHubIssue jest klasą wejściowego zestawu danych i ma następujące String pola:

pierwsza kolumna (identyfikator problemu w usłudze ID GitHub)
druga kolumna Area (przewidywanie trenowania)
trzecia kolumna Title (tytuł problemu w usłudze GitHub) jest pierwszym feature używanym do przewidywania Area
czwarta kolumna Description jest drugą feature używaną do przewidywania wartości Area

IssuePrediction jest klasą używaną do przewidywania po wytrenowanym modelu. Ma jeden string (Area) i PredictedLabelColumnName atrybut. Element PredictedLabel jest używany podczas przewidywania i oceny. Do oceny są używane dane wejściowe z danymi treningowymi, wartościami przewidywanymi i modelem.

Wszystkie operacje ML.NET są uruchamiane w klasie MLContext . Inicjowanie mlContext tworzy nowe środowisko ML.NET, które może być współużytkowane przez obiekty przepływu pracy tworzenia modelu. Jest ona podobna, koncepcyjnie, do DBContext w pliku Entity Framework.

Inicjowanie zmiennych

Zainicjuj _mlContext zmienną globalną przy użyciu nowego wystąpienia MLContext elementu z losowym inicjatorem (seed: 0) w celu powtarzalnych/deterministycznych wyników w wielu szkoleniach. Zastąp Console.WriteLine("Hello World!") wiersz następującym kodem:

_mlContext = new MLContext(seed: 0);

Ładowanie danych

ML.NET używa interfejsu IDataView jako elastycznego, wydajnego sposobu opisywania danych liczbowych lub tekstowych tabelarycznych. IDataView może ładować pliki tekstowe lub w czasie rzeczywistym (na przykład bazę danych SQL lub pliki dziennika).

Aby zainicjować i załadować zmienną _trainingDataView globalną w celu użycia jej dla potoku, dodaj następujący kod po zainicjowaniu mlContext :

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

Element LoadFromTextFile() definiuje schemat danych i odczytuje go w pliku. Pobiera zmienne ścieżki danych i zwraca wartość IDataView.

Dodaj następujące elementy po wywołaniu LoadFromTextFile() metody :

var pipeline = ProcessData();

Metoda ProcessData wykonuje następujące zadania:

Wyodrębnia i przekształca dane.
Zwraca potok przetwarzania.

Utwórz metodę ProcessData w dolnej części pliku Program.cs przy użyciu następującego kodu:

IEstimator<ITransformer> ProcessData()
{

}

Wyodrębnianie funkcji i przekształcanie danych

Aby przewidzieć etykietę Area GitHub dla elementu GitHubIssue, użyj metody MapValueToKey(), aby przekształcić Area kolumnę w kolumnę typu Label klucza liczbowego (format akceptowany przez algorytmy klasyfikacji) i dodać ją jako nową kolumnę zestawu danych:

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

Następnie wywołaj metodę mlContext.Transforms.Text.FeaturizeText, która przekształca kolumny tekstowe (Title i Description) w wektor liczbowy dla każdej z wywołań TitleFeaturized i DescriptionFeaturized. Dołącz cechowanie obu kolumn do potoku przy użyciu następującego kodu:

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

Ostatni krok przygotowywania danych łączy wszystkie kolumny funkcji w kolumnie Funkcje przy użyciu metody Concatenate(). Domyślnie algorytm uczenia przetwarza tylko funkcje z kolumny Funkcje . Dołącz to przekształcenie do potoku przy użyciu następującego kodu:

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

Następnie dołącz element , AppendCacheCheckpoint aby buforować obiekt DataView, aby podczas iterowania danych wiele razy przy użyciu pamięci podręcznej mógł uzyskać lepszą wydajność, tak jak w przypadku następującego kodu:

.AppendCacheCheckpoint(_mlContext);

Ostrzeżenie

Użyj funkcji AppendCacheCheckpoint dla małych/średnich zestawów danych, aby zmniejszyć czas trenowania. NIE używaj go (usuń wartość . AppendCacheCheckpoint()) podczas obsługi bardzo dużych zestawów danych.

Zwróć potok na końcu ProcessData metody .

return pipeline;

Ten krok obsługuje przetwarzanie wstępne/cechowanie. Korzystanie z dodatkowych składników dostępnych w ML.NET może zapewnić lepsze wyniki w modelu.

Kompilowanie i trenowanie modelu

Dodaj następujące wywołanie do BuildAndTrainModelmetody jako następny wiersz po wywołaniu metody ProcessData() :

var trainingPipeline = BuildAndTrainModel(_trainingDataView, pipeline);

Metoda BuildAndTrainModel wykonuje następujące zadania:

Tworzy klasę algorytmu trenowania.
Trenuje model.
Przewiduje obszar na podstawie danych szkoleniowych.
Zwraca model.

Utwórz metodę BuildAndTrainModel tuż po deklaracji metody przy użyciu następującego ProcessData() kodu:

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

}

Informacje o zadaniu klasyfikacji

Klasyfikacja to zadanie uczenia maszynowego, które używa danych do określania kategorii, typu lub klasy elementu lub wiersza danych i jest często jednym z następujących typów:

Binarne: A lub B.
Wieloklasowa: wiele kategorii, które można przewidzieć przy użyciu jednego modelu.

W przypadku tego typu problemu użyj algorytmu uczenia klasyfikacji wieloklasowej, ponieważ przewidywanie kategorii problemów może być jedną z wielu kategorii (wieloklasowych), a nie tylko dwie (binarne).

Dołącz algorytm uczenia maszynowego do definicji przekształcania danych, dodając następujący wiersz kodu w pliku BuildAndTrainModel():

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

SdcaMaximumEntropy to algorytm trenowania klasyfikacji wieloklasowej. Jest to dołączane do elementu pipeline i akceptuje cechowane Title i Description (Features) oraz Label parametry wejściowe do nauki z danych historycznych.

Trenowanie modelu

Dopasuj model do splitTrainSet danych i zwróć wytrenowany model, dodając następujący wiersz kodu w metodzie BuildAndTrainModel() :

_trainedModel = trainingPipeline.Fit(trainingDataView);

Metoda Fit()trenuje model, przekształcając zestaw danych i stosując szkolenie.

PredictionEngine to wygodny interfejs API, który umożliwia przekazanie, a następnie wykonanie przewidywania dla pojedynczego wystąpienia danych. Dodaj to jako następny wiersz w metodzie BuildAndTrainModel() :

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

Przewidywanie za pomocą wytrenowanego modelu

Dodawanie problemu z usługą GitHub w celu przetestowania przewidywania wytrenowanego modelu w metodzie Predict przez utworzenie wystąpienia elementu 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.."
};

Użyj funkcji Predict() prognozowania dla pojedynczego wiersza danych:

var prediction = _predEngine.Predict(issue);

Korzystanie z modelu: wyniki przewidywania

Wyświetlanie GitHubIssue i odpowiednie Area przewidywanie etykiet w celu udostępnienia wyników i odpowiedniego działania na nich. Utwórz wyświetlanie wyników przy użyciu następującego Console.WriteLine() kodu:

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

Zwracanie modelu wytrenowanego do użycia do oceny

Zwróć model na końcu BuildAndTrainModel metody.

return trainingPipeline;

Ocena modelu

Teraz, po utworzeniu i wytrenowanym modelu, musisz ocenić go przy użyciu innego zestawu danych w celu zapewnienia jakości i weryfikacji. W metodzie Evaluate model utworzony w BuildAndTrainModel pliku jest przekazywany do oceny. Utwórz metodę Evaluate tuż po BuildAndTrainModelmetodzie , jak w poniższym kodzie:

void Evaluate(DataViewSchema trainingDataViewSchema)
{

}

Metoda Evaluate wykonuje następujące zadania:

Ładuje testowy zestaw danych.
Tworzy wieloklasowy ewaluator.
Ocenia model i tworzy metryki.
Wyświetla metryki.

Dodaj wywołanie do nowej metody, bezpośrednio pod BuildAndTrainModel wywołaniem metody, używając następującego kodu:

Evaluate(_trainingDataView.Schema);

Podobnie jak wcześniej w przypadku zestawu danych trenowania, załaduj zestaw danych testowego, dodając następujący kod do Evaluate metody:

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

Metoda Evaluate() oblicza metryki jakości modelu przy użyciu określonego zestawu danych. Zwraca MulticlassClassificationMetrics obiekt zawierający ogólne metryki obliczane przez ewaluatorów klasyfikacji wieloklasowej. Aby wyświetlić metryki w celu określenia jakości modelu, należy je najpierw pobrać. Zwróć uwagę na użycie metody Transform() zmiennej globalnej uczenia _trainedModel maszynowego ( ITransformer) do wprowadzania funkcji i zwracania przewidywań. Dodaj następujący kod do Evaluate metody jako następny wiersz:

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

Następujące metryki są oceniane pod kątem klasyfikacji wieloklasowej:

Micro Accuracy — każda para klas próbek współtworzy metryki dokładności. Chcesz, aby mikro dokładności był jak najbardziej zbliżony do jednego.
Dokładność makr — każda klasa współtworzy metryki dokładności. Klasy mniejszości mają taką samą wagę jak większe klasy. Chcesz, aby dokładność makra był jak najbardziej zbliżona do jednego.
Log-loss — zobacz Log Loss (Utrata dziennika). Chcesz, aby strata dziennika był jak najbardziej zbliżona do zera.
Redukcja utraty dzienników — zakresy od [-inf, 1,00], gdzie 1,00 jest doskonałymi przewidywaniami, a 0 oznacza średnie przewidywania. Chcesz, aby zmniejszenie strat dzienników było jak najbardziej zbliżone do jednego.

Wyświetlanie metryk weryfikacji modelu

Użyj następującego kodu, aby wyświetlić metryki, udostępnić wyniki, a następnie wykonać na nich działania:

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

Zapisywanie modelu w pliku

Po zakończeniu pracy z modelem zapisz go w pliku w celu przewidywania w późniejszym czasie lub w innej aplikacji. Dodaj następujący kod do metody Evaluate:

SaveModelAsFile(_mlContext, trainingDataViewSchema, _trainedModel);

Utwórz metodę SaveModelAsFile poniżej Evaluate metody .

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

}

Dodaj następujący kod do SaveModelAsFile metody . Ten kod używa Save metody do serializacji i przechowywania wytrenowanego modelu jako pliku zip.

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

Wdrażanie i przewidywanie za pomocą modelu

Dodaj wywołanie do nowej metody, bezpośrednio pod Evaluate wywołaniem metody, używając następującego kodu:

PredictIssue();

Utwórz metodę PredictIssue tuż po Evaluate metodzie (i tuż przed metodą), używając następującego SaveModelAsFile kodu:

void PredictIssue()
{

}

Metoda PredictIssue wykonuje następujące zadania:

Ładuje zapisany model
Tworzy pojedynczy problem z danymi testowym.
Przewiduje obszar na podstawie danych testowych.
Łączy dane testowe i przewidywania na potrzeby raportowania.
Wyświetla przewidywane wyniki.

Załaduj zapisany model do aplikacji, dodając następujący kod do PredictIssue metody:

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

Dodawanie problemu z usługą GitHub w celu przetestowania przewidywania wytrenowanego modelu w metodzie Predict przez utworzenie wystąpienia elementu GitHubIssue:

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

Podobnie jak wcześniej, utwórz PredictionEngine wystąpienie przy użyciu następującego kodu:

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

PredictionEngine to wygodny interfejs API, który umożliwia przewidywanie dla pojedynczego wystąpienia danych. PredictionEngine nie jest bezpieczne wątkowo. Dopuszczalne jest użycie w środowiskach jednowątkowych lub prototypowych. Aby zwiększyć wydajność i bezpieczeństwo wątków w środowiskach produkcyjnych, użyj PredictionEnginePool usługi, która tworzy ObjectPoolPredictionEngine obiekty do użycia w całej aplikacji. Zobacz ten przewodnik dotyczący używania PredictionEnginePool w internetowym interfejsie API ASP.NET Core.

Uwaga

PredictionEnginePool Rozszerzenie usługi jest obecnie w wersji zapoznawczej.

Użyj elementu , PredictionEngine aby przewidzieć etykietę Area GitHub (Obszar w usłudze GitHub), dodając następujący kod do PredictIssue metody przewidywania:

var prediction = _predEngine.Predict(singleIssue);

Używanie załadowanego modelu do przewidywania

Wyświetl Area w celu kategoryzowania problemu i odpowiedniego działania. Utwórz wyświetlanie wyników przy użyciu następującego Console.WriteLine() kodu:

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

Wyniki

Wyniki powinny być podobne do poniższych. W miarę przetwarzania potoku są wyświetlane komunikaty. Mogą pojawić się ostrzeżenia lub komunikaty przetwarzania. Te komunikaty zostały usunięte z poniższych wyników w celu uzyskania jasności.

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

Gratulacje! Udało Ci się pomyślnie skompilować model uczenia maszynowego do klasyfikowania i przewidywania etykiety Obszar dla problemu z usługą GitHub. Kod źródłowy tego samouczka można znaleźć w repozytorium dotnet/samples .

Następne kroki

W niniejszym samouczku zawarto informacje na temat wykonywania następujących czynności:

Przygotowywanie danych
Przekształcanie danych
Trenowanie modelu
Ocena modelu
Przewidywanie za pomocą wytrenowanego modelu
Wdrażanie i przewidywanie przy użyciu załadowanego modelu

Przejdź do następnego samouczka, aby dowiedzieć się więcej

Predyktor taryf taksówek