Zelfstudie: Ondersteuningsproblemen categoriseren met classificatie met meerdere klassen met ML.NET

Deze voorbeeldzelfstudie illustreert het gebruik van ML.NET om een GitHub-probleemclassificatie te maken om een model te trainen dat het gebiedslabel classificeert en voorspelt voor een GitHub-probleem via een .NET-consoletoepassing met behulp van C# in Visual Studio.

In deze handleiding leer je hoe je:

• Uw gegevens voorbereiden
• De gegevens transformeren
• Het model trainen
• Het model evalueren
• Voorspellen met het getrainde model
• Implementeren en voorspellen met een geladen model

U vindt de broncode voor deze zelfstudie in de opslagplaats dotnet/samples .

Vereiste voorwaarden

• Visual Studio 2022 of hoger waarop de workload .NET Desktop Development is geïnstalleerd.
• GitHub geeft problemen met het door het trainingstabblad gescheiden bestand (issues_train.tsv).
• Het tabgescheiden bestand met GitHub-issues voor testdoeleinden (issues_test.tsv).

Een consoletoepassing maken

Een project maken

1. Maak een C# -consoletoepassing met de naam 'GitHubIssueClassification'. Kies Volgende.

2. Kies .NET 7 als het framework dat u wilt gebruiken. Klik op Creëren.

3. Maak een map met de naam Gegevens in uw project om uw gegevensbestanden op te slaan:

   Klik in Solution Explorer met de rechtermuisknop op uw project en selecteerNieuwe map>. Typ 'Gegevens' en druk op Enter.

4. Maak een map met de naam Modellen in uw project om uw model op te slaan:

   Klik in Solution Explorer met de rechtermuisknop op uw project en selecteerNieuwe map>. Typ 'Modellen' en druk op Enter.

5. Installeer het Microsoft.ML NuGet-pakket:

   Opmerking

   In dit voorbeeld wordt de laatste stabiele versie van de vermelde NuGet-pakketten gebruikt, tenzij anders vermeld.

   Klik in Solution Explorer met de rechtermuisknop op uw project en selecteer NuGet-pakketten beheren. Kies 'nuget.org' als pakketbron, selecteer het tabblad Bladeren, zoek Microsoft.ML en selecteer Installeren. Selecteer de knop OK in het dialoogvenster Voorbeeld van wijzigingen en selecteer vervolgens de knop Accepteren in het dialoogvenster Acceptatie van licenties als u akkoord gaat met de licentievoorwaarden voor de vermelde pakketten.

Uw gegevens voorbereiden

1. Downloaden de issues_train.tsv en de issues_test.tsv gegevenssets en sla deze op in de map Gegevens die u eerder hebt gemaakt. De eerste gegevensset traint het machine learning-model en de tweede kan worden gebruikt om te evalueren hoe nauwkeurig uw model is.

2. Klik in Solution Explorer met de rechtermuisknop op elk van de *.tsv-bestanden en selecteer Eigenschappen. Wijzig onder Geavanceerd de waarde van Kopiëren naar Uitvoermap naar Kopiëren als nieuwer.

Klassen maken en paden definiëren

Voeg de volgende aanvullende using instructies toe aan het begin van het bestand Program.cs :

using Microsoft.ML;
using GitHubIssueClassification;

Maak drie globale velden voor het opslaan van de paden naar de onlangs gedownloade bestanden en globale variabelen voor de MLContext, DataViewen PredictionEngine:

• _trainDataPath heeft het pad naar de gegevensset die wordt gebruikt om het model te trainen.
• _testDataPath heeft het pad naar de gegevensset die wordt gebruikt om het model te evalueren.
• _modelPath heeft het pad naar de locatie waar het getrainde model is opgeslagen.
• _mlContext is het dat de MLContext verwerkingscontext biedt.
• _trainingDataView IDataView wordt gebruikt om de trainingsgegevensset te verwerken.
• _predEngine PredictionEngine<TSrc,TDst> wordt gebruikt voor enkele voorspellingen.

Voeg de volgende code toe aan de regel direct onder de using instructies om deze paden en de andere variabelen op te geven:

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;

Maak enkele klassen voor uw invoergegevens en voorspellingen. Voeg een nieuwe klasse toe aan uw project:

1. Klik in Solution Explorer met de rechtermuisknop op het project en selecteerNieuw item>.

2. Selecteer in het dialoogvenster Nieuw item toevoegen de optie Klasse en wijzig het veld Naamin GitHubIssueData.cs. Selecteer vervolgens Toevoegen.

   Het bestand GitHubIssueData.cs wordt geopend in de code-editor. Voeg de volgende using instructie toe aan het begin van GitHubIssueData.cs:

   using Microsoft.ML.Data;
   

3. Verwijder de bestaande klassedefinitie en voeg de volgende code toe aan het GitHubIssueData.cs-bestand . Deze code heeft twee klassen en 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;
   }
   

   De label kolom die u wilt voorspellen. De geïdentificeerde Features invoer zijn de invoer die u het model geeft om het label te voorspellen.

   Gebruik loadColumnAttribute om de indexen van de bronkolommen in de gegevensset op te geven.

   GitHubIssue is de klasse invoergegevensset en heeft de volgende String velden:

   • De eerste kolom ID (GitHub Issue ID).
   • De tweede kolom Area (de voorspelling voor trainingsdoeleinden).
   • De derde kolom Title (titel van het GitHub-probleem) is de eerste feature die wordt gebruikt voor het voorspellen van de Area.
   • De vierde kolom Description is de tweede feature die wordt gebruikt voor het voorspellen van de Area.

   IssuePrediction is de klasse die wordt gebruikt voor voorspelling nadat het model is getraind. Het heeft één string (Area) en een PredictedLabelColumnName kenmerk. De PredictedLabel wordt gebruikt tijdens de voorspelling en evaluatie. Voor evaluatie worden invoer met trainingsgegevens, de voorspelde waarden en het model gebruikt.

   Alle ML.NET bewerkingen beginnen in de MLContext-klasse . Als u initialiseert mlContext , wordt er een nieuwe ML.NET omgeving gemaakt die kan worden gedeeld in de werkstroomobjecten voor het maken van modellen. Het is vergelijkbaar met DBContext conceptueel gezien in Entity Framework.

Variabelen initialiseren

Initialiseer de _mlContext globale variabele met een nieuw exemplaar van MLContext een willekeurig seed (seed: 0) voor herhaalbare/deterministische resultaten voor meerdere trainingen. Vervang de Console.WriteLine("Hello World!") regel door de volgende code:

_mlContext = new MLContext(seed: 0);

De gegevens laden

ML.NET maakt gebruik van de IDataView-interface als een flexibele, efficiënte manier om numerieke of tekstgegevens in tabelvorm te beschrijven. IDataView kan tekstbestanden of in realtime laden (bijvoorbeeld SQL-database- of logboekbestanden).

Als u de _trainingDataView globale variabele wilt initialiseren en laden om deze te gebruiken voor de pijplijn, voegt u de volgende code toe na de mlContext initialisatie:

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

De LoadFromTextFile() definieert het gegevensschema en leest in het bestand. Het neemt de gegevenspadvariabelen in en retourneert een IDataView.

Voeg het volgende toe nadat u de methode hebt LoadFromTextFile() aangeroepen:

var pipeline = ProcessData();

De ProcessData methode voert de volgende taken uit:

• Hiermee worden de gegevens geëxtraheerd en getransformeerd.
• Retourneert de verwerkingspijplijn.

Maak de ProcessData methode onder aan het Program.cs-bestand met behulp van de volgende code:

IEstimator<ITransformer> ProcessData()
{

}

Functies extraheren en de gegevens transformeren

Als u het Area GitHub-label voor een GitHubIssue wilt voorspellen, gebruikt u de MapValueToKey() methode om de kolom te transformeren in een kolom met numeriek sleuteltype Area (een indeling die door classificatiealgoritmen wordt geaccepteerd) en voegt u deze toe als een nieuwe kolom van de gegevensset:

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

mlContext.Transforms.Text.FeaturizeTextRoep vervolgens aan, waarmee de tekst (Title en Description) kolommen worden omgezet in een numerieke vector voor elke aangeroepen TitleFeaturized en DescriptionFeaturized. Gebruik de volgende code om de featurisatie voor beide kolommen aan de pijplijn toe te voegen:

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

De laatste stap in gegevensvoorbereiding combineert alle functiekolommen in de kolom Functies met behulp van de methode Concatenate(). Standaard verwerkt een leeralgoritmen alleen functies uit de kolom Functies . Voeg deze transformatie toe aan de pijplijn met de volgende code:

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

Voeg vervolgens een AppendCacheCheckpoint gegevenscache toe aan de DataView, zodat wanneer u de gegevens meerdere keren herhaald met behulp van de cache betere prestaties krijgt, zoals met de volgende code:

.AppendCacheCheckpoint(_mlContext);

Waarschuwing

Gebruik AppendCacheCheckpoint voor kleine/middelgrote gegevenssets om de trainingstijd te verlagen. Gebruik het niet (verwijder het. AppendCacheCheckpoint()) bij het verwerken van zeer grote gegevenssets.

Retourneer de pijplijn aan het einde van de ProcessData methode.

return pipeline;

Deze stap verwerkt preprocessing/featurization. Door extra onderdelen te gebruiken die beschikbaar zijn in ML.NET kunt u betere resultaten met uw model inschakelen.

Het model bouwen en trainen

Voeg de volgende aanroep toe aan de BuildAndTrainModelmethode als de volgende regel na de aanroep naar de ProcessData() methode:

var trainingPipeline = BuildAndTrainModel(_trainingDataView, pipeline);

De BuildAndTrainModel methode voert de volgende taken uit:

• Hiermee maakt u de klasse trainingsalgoritmen.
• Traint het model.
• Voorspelt het gebied op basis van trainingsgegevens.
• Retourneert het model.

Maak de BuildAndTrainModel methode, net na de declaratie van de ProcessData() methode, met behulp van de volgende code:

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

}

Over de classificatietaak

Classificatie is een machine learning-taak die gegevens gebruikt om de categorie, het type of de klasse van een item of rij met gegevens te bepalen en die vaak een van de volgende typen is:

• Binair: A of B.
• Meerdere klassen: meerdere categorieën die kunnen worden voorspeld met behulp van één model.

Gebruik voor dit type probleem een leeralgoritmen voor classificatie met meerdere klassen, omdat de voorspelling van uw probleemcategorie een van meerdere categorieën (meerdere klassen) kan zijn in plaats van slechts twee (binair).

Voeg het machine learning-algoritme toe aan de definities van gegevenstransformatie door het volgende toe te voegen als de eerste coderegel in BuildAndTrainModel():

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

De SdcaMaximumEntropy is uw trainingsalgoritme voor classificatie met meerdere klassen. Dit wordt toegevoegd aan de pipeline en accepteert de gefeaturiseerde Title en Description (Features) en de Label-invoerparameters om van historische gegevens te leren.

Het model trainen

Pas het model aan de splitTrainSet gegevens toe en retourneer het getrainde model door het volgende toe te voegen als de volgende regel code in de BuildAndTrainModel() methode:

_trainedModel = trainingPipeline.Fit(trainingDataView);

De Fit()methode traint uw model door de gegevensset te transformeren en de training toe te passen.

De PredictionEngine is een handige API waarmee u een voorspelling kunt doorgeven en vervolgens een voorspelling kunt uitvoeren op één exemplaar van gegevens. Voeg dit toe als de volgende regel in de BuildAndTrainModel() methode:

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

Voorspellen met het getrainde model

Voeg een GitHub-kwestie toe om de voorspelling van het model dat is getraind in de Predict methode te testen door een instantie van GitHubIssue te creëren.

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

Gebruik de functie Predict() om een voorspelling te doen voor één rij gegevens:

var prediction = _predEngine.Predict(issue);

Het model gebruiken: voorspellingsresultaten

Weergave GitHubIssue en bijbehorende Area labelvoorspelling om de resultaten te delen en erop te reageren. Maak een weergave voor de resultaten met behulp van de volgende Console.WriteLine() code:

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

Het model retourneren dat is getraind voor evaluatie

Retourneert het model aan het einde van de BuildAndTrainModel methode.

return trainingPipeline;

Het model evalueren

Nu u het model hebt gemaakt en getraind, moet u het evalueren met een andere gegevensset voor kwaliteitscontrole en validatie. In de Evaluate methode wordt het model dat in BuildAndTrainModel is gemaakt doorgegeven om te worden geëvalueerd. Maak de Evaluate methode, net na BuildAndTrainModel, zoals in de volgende code:

void Evaluate(DataViewSchema trainingDataViewSchema)
{

}

De Evaluate methode voert de volgende taken uit:

• Laadt de testgegevensset.
• Hiermee maakt u de multiklasse-evaluator.
• Evalueert het model en maakt metrische gegevens.
• Geeft de metrische gegevens weer.

Voeg een aanroep toe aan de nieuwe methode, direct onder de BuildAndTrainModel methode-aanroep, met behulp van de volgende code:

Evaluate(_trainingDataView.Schema);

Zoals u eerder hebt gedaan met de trainingsgegevensset, laadt u de testgegevensset door de volgende code toe te voegen aan de Evaluate methode:

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

Met de methode Evaluate() worden de metrische kwaliteitsgegevens voor het model berekend met behulp van de opgegeven gegevensset. Het retourneert een MulticlassClassificationMetrics object dat de algemene metrische gegevens bevat die worden berekend door classificatie-evaluators met meerdere klassen. Als u de metrische gegevens wilt weergeven om de kwaliteit van het model te bepalen, moet u ze eerst ophalen. Let op het gebruik van de Transform() -methode van de globale machine learning-variabele _trainedModel (een ITransformer) om de functies in te voeren en voorspellingen te retourneren. Voeg de volgende code toe aan de Evaluate methode als de volgende regel:

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

De volgende metrische gegevens worden geëvalueerd voor classificatie met meerdere klassen:

• Micronauwkeurigheid: elk paar van voorbeeldklassen draagt evengoed bij aan de nauwkeurigheidsmetrie. U wilt dat Micro Nauwkeurigheid zo dicht mogelijk bij één is.
• Macronauwkeurigheid: elke klasse draagt ook bij aan de metrische nauwkeurigheid. Minderheidsklassen krijgen gelijk gewicht als de grotere klassen. U wilt dat macronauwkeurigheid zo dicht mogelijk bij elkaar ligt.
• Logboekverlies- zie Logboekverlies. U wilt dat logboekverlies zo dicht mogelijk bij nul ligt.
• Vermindering van logboekverlies - Bereiken van [-inf, 1.00], waarbij 1,00 perfecte voorspellingen zijn en 0 gemiddelde voorspellingen aangeeft. U wilt dat de log-verliesreductie zo dicht mogelijk bij één ligt.

De metrische gegevens voor modelvalidatie weergeven

Gebruik de volgende code om de metrische gegevens weer te geven, de resultaten te delen en er vervolgens actie op te ondernemen:

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

Het model opslaan in een bestand

Zodra u tevreden bent met uw model, slaat u het op in een bestand om voorspellingen te doen op een later tijdstip of in een andere toepassing. Voeg de volgende code toe aan de methode Evaluate.

SaveModelAsFile(_mlContext, trainingDataViewSchema, _trainedModel);

Maak de SaveModelAsFile methode onder uw Evaluate methode.

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

}

Voeg de volgende code toe aan uw SaveModelAsFile methode. Deze code gebruikt de Save methode om het getrainde model te serialiseren en op te slaan als een zip-bestand.

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

Implementeren en voorspellen met een model

Voeg een aanroep toe aan de nieuwe methode, direct onder de Evaluate methode-aanroep, met behulp van de volgende code:

PredictIssue();

Maak de PredictIssue methode, net na de Evaluate methode (en net vóór de SaveModelAsFile methode), met behulp van de volgende code:

void PredictIssue()
{

}

De PredictIssue methode voert de volgende taken uit:

• Laadt het opgeslagen model.
• Hiermee maakt u een enkele set testgegevens aan.
• Voorspelt het gebied op basis van testgegevens.
• Combineert testgegevens en voorspellingen voor rapportage.
• Geeft de voorspelde resultaten weer.

Laad het opgeslagen model in uw toepassing door de volgende code toe te voegen aan de PredictIssue methode:

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

Voeg een GitHub-kwestie toe om de voorspelling van het model dat is getraind in de Predict methode te testen door een instantie van GitHubIssue te creëren.

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

Zoals u eerder hebt gedaan, maakt u een PredictionEngine exemplaar met de volgende code:

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

PredictionEngine is een handige API waarmee u een voorspelling kunt uitvoeren op één exemplaar van gegevens. PredictionEngine is niet thread-safe. Het is acceptabel om te gebruiken in omgevingen met één thread of prototype. Voor verbeterde prestaties en threadveiligheid in productieomgevingen gebruikt u de PredictionEnginePool service, waarmee u objecten ObjectPoolPredictionEngine maakt voor gebruik in uw toepassing. Raadpleeg deze handleiding voor het gebruik PredictionEnginePool in een ASP.NET Core Web-API.

Opmerking

PredictionEnginePool de service-extensie is momenteel beschikbaar als preview-versie.

Gebruik het PredictionEngine om het Area GitHub-label te voorspellen door de volgende code toe te voegen aan de PredictIssue methode voor de voorspelling:

var prediction = _predEngine.Predict(singleIssue);

Het geladen model gebruiken voor voorspelling

Weergeven Area om het probleem te categoriseren en erop te reageren. Maak een weergave voor de resultaten met behulp van de volgende Console.WriteLine() code:

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

Results

Uw resultaten moeten er ongeveer als volgt uitzien. Terwijl de pijpleiding verwerkt, worden berichten weergegeven. Mogelijk worden er waarschuwingen weergegeven of berichten verwerkt. Deze berichten zijn voor duidelijkheid verwijderd uit de volgende resultaten.

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

Gefeliciteerd! U hebt nu een machine learning-model gebouwd voor het classificeren en voorspellen van een Gebiedslabel voor een GitHub-probleem. U vindt de broncode voor deze zelfstudie in de opslagplaats dotnet/samples .

Volgende stappen

In deze tutorial leerde je hoe je:

• Uw gegevens voorbereiden
• De gegevens transformeren
• Het model trainen
• Het model evalueren
• Voorspellen met het getrainde model
• Implementeren en voorspellen met een geladen model

Ga naar de volgende tutorial om meer te leren.

Taxi Fare Predictor