Zelfstudie: Sentiment van websiteopmerkingen in een webtoepassing analyseren met behulp van ML.NET Model Builder

Artikel
12/21/2024

Meer informatie over het analyseren van sentiment vanuit opmerkingen in realtime in een webtoepassing.

In deze zelfstudie leert u hoe u een ASP.NET Core Razor Pages-toepassing maakt die het gevoel classificeert op basis van websiteopmerkingen in realtime.

In deze zelfstudie leert u het volgende:

Een ASP.NET Core Razor Pages-toepassing maken
De gegevens voorbereiden en begrijpen
Een scenario kiezen
De gegevens laden
Het model trainen
Het model evalueren
Het model gebruiken voor voorspellingen

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

Voorwaarden

Ga voor een lijst met vereisten en installatie-instructies naar de installatiehandleiding van Model Builder.

Een Razor Pages-toepassing maken

Maak een ASP.NET Core Razor Pages-toepassing.

Open in Visual Studio het dialoogvenster Een nieuw project maken.
Selecteer in het dialoogvenster "Een nieuw project maken" de ASP.NET Core Web App projectsjabloon.
Typ 'SentimentRazor' in het tekstvak Naam en selecteer Volgende.
Laat in het dialoogvenster Aanvullende informatie alle standaardinstellingen staan en selecteer maken.

De gegevens voorbereiden en begrijpen

Download Wikipedia-ontgiftingsgegevensset. Wanneer de webpagina wordt geopend, klikt u met de rechtermuisknop op de pagina, selecteert u Opslaan als en slaat u het bestand ergens op uw computer op.

Elke rij in de wikipedia-detox-250-line-data.tsv gegevensset vertegenwoordigt een andere beoordeling die door een gebruiker op Wikipedia wordt achtergelaten. De eerste kolom vertegenwoordigt het gevoel van de tekst (0 is niet-giftig, 1 is giftig) en de tweede kolom vertegenwoordigt de opmerking links van de gebruiker. De kolommen worden gescheiden door tabbladen. De gegevens zien er als volgt uit:

Gevoel	SentimentTekst
1	==RUDE== Dude, je bent onbeleefd. Upload die Carl-foto weer, of anders.
1	== OK! == DAN GA IK DE WILD ONES WIKI VANDALISEREN!!
0	Ik hoop dat dit helpt.

Een configuratiebestand voor Model Builder maken

Wanneer u voor het eerst een machine learning-model toevoegt aan de oplossing, wordt u gevraagd een mbconfig-bestand te maken. Het bestand mbconfig houdt alles bij wat u in Model Builder doet, zodat u de sessie opnieuw kunt openen.

Klik in Solution Explorermet de rechtermuisknop op het project SentimentRazor en selecteer >Machine Learning-model toevoegen.
Geef in het dialoogvenster de naam van het project Model Builder SentimentAnalysis.mbconfigen selecteer toevoegen.

Een scenario kiezen

Als u uw model wilt trainen, moet u een keuze maken uit de lijst met beschikbare machine learning-scenario's van Model Builder.

Voor dit voorbeeld is de taak tekstclassificatie. Selecteer in de Scenario stap van de extensie Modelbouwer het Tekstclassificatie scenario.

Een omgeving selecteren

Model Builder kan trainen op verschillende omgevingen, afhankelijk van het geselecteerde scenario.

Selecteer lokale (GPU) als je omgeving en klik op de knop Volgende stap.

Notitie

In dit scenario worden deep learning-technieken gebruikt die het beste werken in GPU-omgevingen. Als u geen GPU hebt, kiest u de lokale (CPU)-omgeving, maar houd er rekening mee dat de verwachte tijd om te trainen aanzienlijk langer is. Zie de GPU-ondersteuning in de handleiding voor modelbouwervoor meer informatie over het gebruik van GPU's met Model Builder.

De gegevens laden

Model Builder accepteert gegevens uit twee bronnen, een SQL Server-database of een lokaal bestand in csv- of tsv-indeling.

Selecteer in de gegevensstap van het hulpprogramma Modelbouwer Bestand in de opties voor de gegevensbron.
Selecteer de knop naast het Selecteer een bestand tekstvak en gebruik Verkenner om te bladeren en het wikipedia-detox-250-line-data.tsv bestand te selecteren.
Kies Sentiment uit de Kolom om te voorspellen in de vervolgkeuzelijst (Label).
Kies SentimentText uit de vervolgkeuzelijst Tekstkolom.
Selecteer de knop Volgende stap om naar de volgende stap in Model builder te gaan.

Het model trainen

De machine learning-taak die wordt gebruikt om het model voor sentimentanalyse in deze zelfstudie te trainen, is tekstclassificatie. Tijdens het modeltrainingsproces traint Model Builder een model voor tekstclassificatie voor uw gegevensset met behulp van de NAS-BERT neurale netwerkarchitectuur.

Selecteer Training starten.
Zodra de training is voltooid, worden de resultaten van het trainingsproces weergegeven in het gedeelte Trainingsresultaten van het scherm Train. Naast het leveren van trainingsresultaten worden er drie code-behind-bestanden gemaakt onder het bestand SentimentAnalysis.mbconfig.
- SentimentAnalysis.consumption.cs: dit bestand bevat de ModelInput- en ModelOutput schema's, evenals de Predict functie die is gegenereerd voor het gebruik van het model.
- SentimentAnalysis.training.cs - Dit bestand bevat de trainingspijplijn (gegevenstransformaties, trainer, trainer hyperparameters) die door Model Builder zijn gekozen om het model te trainen. U kunt deze pijplijn gebruiken om uw model opnieuw te trainen.
- * SentimentAnalysis.zip: dit is een geserialiseerd zip-bestand dat uw getrainde ML.NET model vertegenwoordigt.
Selecteer de knop Volgende stap om naar de volgende stap te gaan.

Het model evalueren

Het resultaat van de trainingsstap is één model met de beste prestaties. In de evaluatiestap van het Model Builder-hulpprogramma bevat de uitvoersectie de trainer die door het best presterende model wordt gebruikt, evenals evaluatiestatistieken.

Als u niet tevreden bent met uw metrische evaluatiegegevens, kunt u eenvoudig proberen de modelprestaties te verbeteren door meer gegevens te gebruiken.

Als alternatief kunt u de knop Volgende stap selecteren om naar de stap Verbruiken te gaan in Model Builder.

Projectsjablonen voor verbruik toevoegen (optioneel)

In de stap Verbruiken bevat Model Builder projectsjablonen die u kunt gebruiken om het model te gebruiken. Deze stap is optioneel en u kunt de methode kiezen die het beste past bij uw behoeften voor het gebruik van het model.

Console-applicatie
Web-API

Voeg de code toe om voorspellingen te doen

De PredictionEngine-pool configureren

Als u één voorspelling wilt doen, moet u een PredictionEngine<TSrc,TDst>maken. PredictionEngine<TSrc,TDst> is niet draadveilig. Daarnaast moet u overal waar het nodig is binnen uw toepassing een instantie ervan maken. Naarmate uw toepassing groeit, kan dit proces onbeheerbaar worden. Gebruik een combinatie van afhankelijkheidsinjectie en de PredictionEnginePool-service om een ObjectPool<T> van PredictionEngine<TSrc,TDst> objecten te maken voor gebruik in uw toepassing voor betere prestaties en threadveiligheid.

Installeer het Microsoft.Extensions.ML NuGet-pakket:
1. Klik in Solution Explorermet de rechtermuisknop op het project en selecteer NuGet-pakketten beheren.
2. Kies 'nuget.org' als pakketbron.
3. Selecteer het tabblad Bladeren en zoek op Microsoft.Extensions.ML.
4. Selecteer het pakket in de lijst en selecteer Installeren.
5. Selecteer de knop OK in het dialoogvenster Voorbeeld van wijzigingen
6. Selecteer de knop Ik ga akkoord in het dialoogvenster Licentie accepteren als u akkoord gaat met de licentievoorwaarden voor de vermelde pakketten.
Open het bestand Program.cs in het project SentimentRazor.
Voeg de volgende using instructies toe om te verwijzen naar het Microsoft.Extensions.ML NuGet-pakket en SentimentRazorML.Model project:
```
using Microsoft.Extensions.ML;
using static SentimentRazor.SentimentAnalysis;
```

Configureer de PredictionEnginePool<TData,TPrediction> voor uw toepassing in het Program.cs-bestand:

builder.Services.AddPredictionEnginePool<ModelInput, ModelOutput>()
    .FromFile("SentimentAnalysis.zip");

Handler voor sentimentanalyse maken

Er worden voorspellingen gedaan op de hoofdpagina van de toepassing. Daarom moet een methode die de gebruikersinvoer gebruikt en de PredictionEnginePool<TData,TPrediction> gebruikt om een voorspelling te retourneren, worden toegevoegd.

Open het Index.cshtml.cs bestand in de map Pages en voeg de volgende using instructies toe:
```
using Microsoft.Extensions.ML;
using static SentimentRazor.SentimentAnalysis;
```
Als u de PredictionEnginePool<TData,TPrediction> wilt gebruiken die in het Program.cs-bestand is geconfigureerd, moet u deze injecteren in de constructor van het model waar u het wilt gebruiken.
Voeg een variabele toe om te verwijzen naar de PredictionEnginePool<TData,TPrediction> in de IndexModel-klasse in het bestand Pages/Index.cshtml.cs.
```
private readonly PredictionEnginePool<ModelInput, ModelOutput> _predictionEnginePool;
```

Wijzig de constructor in de klasse IndexModel en injecteer de PredictionEnginePool<TData,TPrediction>-service erin.

public IndexModel(ILogger<IndexModel> logger, PredictionEnginePool<ModelInput, ModelOutput> predictionEnginePool)
{
    _logger = logger;
    _predictionEnginePool = predictionEnginePool;
}

Maak een methode-handler die gebruikmaakt van de PredictionEnginePool om voorspellingen te doen van gebruikersinvoer die is ontvangen van de webpagina.
1. Maak onder de methode OnGet een nieuwe methode met de naam OnGetAnalyzeSentiment
```
public IActionResult OnGetAnalyzeSentiment([FromQuery] string text)
{

}
```
2. Retourneer in de methode OnGetAnalyzeSentimentNeutrale als de invoer van de gebruiker leeg of null is.
```
if (String.IsNullOrEmpty(text)) return Content("Neutral");
```
3. Met een geldige invoer maakt u een nieuw exemplaar van ModelInput.
```
var input = new ModelInput { SentimentText = text };
```
4. Gebruik de PredictionEnginePool<TData,TPrediction> om sentiment te voorspellen.
```
var prediction = _predictionEnginePool.Predict(input);
```
5. Converteer de voorspelde bool waarde naar giftig of niet giftig met de volgende code.
```
var sentiment = Convert.ToBoolean(prediction.PredictedLabel) ? "Toxic" : "Not Toxic";
```
6. Stuur ten slotte de sentimentanalyse terug naar de webpagina.
```
return Content(sentiment);
```

De webpagina configureren

De resultaten die door de OnGetAnalyzeSentiment worden geretourneerd, worden dynamisch weergegeven op de Index webpagina.

Open het bestand Index.cshtml in de map Pages en vervang de inhoud door de volgende code:

@page
@model IndexModel
@{
    ViewData["Title"] = "Home page";
}

<div class="text-center">
    <h2>Live Sentiment</h2>

    <p><textarea id="Message" cols="45" placeholder="Type any text like a short review"></textarea></p>

    <div class="sentiment">
        <h4>Your sentiment is...</h4>
        <p>😡 😐 😍</p>

        <div class="marker">
            <div id="markerPosition" style="left: 45%;">
                <div>▲</div>
                <label id="markerValue">Neutral</label>
            </div>
        </div>
    </div>
</div>

Voeg vervolgens css-stijlcode toe aan het einde van de site.css pagina in de map wwwroot\css:

/* Style for sentiment display */

.sentiment {
    background-color: #eee;
    position: relative;
    display: inline-block;
    padding: 1rem;
    padding-bottom: 0;
    border-radius: 1rem;
}

.sentiment h4 {
    font-size: 16px;
    text-align: center;
    margin: 0;
    padding: 0;
}

.sentiment p {
    font-size: 50px;
}

.sentiment .marker {
    position: relative;
    left: 22px;
    width: calc(100% - 68px);
}

.sentiment .marker > div {
    transition: 0.3s ease-in-out;
    position: absolute;
    margin-left: -30px;
    text-align: center;
}

.sentiment .marker > div > div {
    font-size: 50px;
    line-height: 20px;
    color: green;
}

.sentiment .marker > div label {
    font-size: 30px;
    color: gray;
}

Voeg daarna code toe om invoer van de webpagina naar de OnGetAnalyzeSentiment handler te verzenden.

Maak in het site.js bestand in de map wwwroot\js een functie met de naam getSentiment om een GET HTTP-aanvraag te maken met de gebruikersinvoer voor de OnGetAnalyzeSentiment handler.

function getSentiment(userInput) {
    return fetch(`Index?handler=AnalyzeSentiment&text=${userInput}`)
        .then((response) => {
            return response.text();
        })
}

Voeg daaronder een andere functie met de naam updateMarker toe om de positie van de indicator op de webpagina dynamisch bij te werken naarmate het sentiment wordt voorspeld.
```
function updateMarker(markerPosition, sentiment) {
    $("#markerPosition").attr("style", `left:${markerPosition}%`);
    $("#markerValue").text(sentiment);
}
```

Maak een gebeurtenishandlerfunctie met de naam updateSentiment om de invoer van de gebruiker op te halen, deze naar de OnGetAnalyzeSentiment functie te verzenden met behulp van de functie getSentiment en de markering bij te werken met de functie updateMarker.

function updateSentiment() {

    var userInput = $("#Message").val();

    getSentiment(userInput)
        .then((sentiment) => {
            switch (sentiment) {
                case "Not Toxic":
                    updateMarker(100.0, sentiment);
                    break;
                case "Toxic":
                    updateMarker(0.0, sentiment);
                    break;
                default:
                    updateMarker(45.0, "Neutral");
            }
        });
}

Registreer ten slotte de gebeurtenis-handler en bind deze aan het textarea-element met het kenmerk id=Message.
```
$("#Message").on('change input paste', updateSentiment)
```

De toepassing uitvoeren

Nu uw toepassing is ingesteld, voert u de toepassing uit, die in uw browser moet worden gestart.

Wanneer de toepassing wordt gestart, voert u Dit model beschikt niet over voldoende gegevens. in het tekstgebied. Het voorspelde sentiment dat moet worden weergegeven, is Toxic.

Venster dat wordt uitgevoerd met het voorspelde sentimentvenster