Voorgestelde vragen over actief leren accepteren in de knowledge base

Actieve Learning wijzigt de Knowledge Base of Search-service nadat u de suggestie hebt goedgekeurd, en sla vervolgens op en train. Als u de suggestie goedkeurt, wordt deze toegevoegd als een alternatieve vraag.

Actief leren inschakelen

Als u voorgestelde vragen wilt bekijken, moet u actief leren in QnA Maker resource.

Voorgestelde vragen weergeven

1. Als u de voorgestelde vragen wilt zien, selecteert u op de pagina Knowledge base bewerken de optie Opties weergeven en selecteert u vervolgens Actieve leersuggesties weergeven. Deze optie wordt uitgeschakeld als er geen suggesties aanwezig zijn voor een van de vraag- en antwoordparen.

   

2. Filter de knowledge base met vraag-en-antwoordparen om alleen suggesties weer te geven door Filteren op suggesties te selecteren.

   

3. Elk QnA-paar stelt de nieuwe vraagalternatieven voor met een vinkje, , om de vraag te accepteren of een om ✔ x de suggesties te weigeren. Selecteer het vinkje om de vraag toe te voegen.

   

   U kunt alle suggesties toevoegen of verwijderen door Alles toevoegen of Alles weigeren te selecteren in de contextuele werkbalk.

4. Selecteer Opslaan en trainen om de wijzigingen in de knowledge base op te slaan.

5. Selecteer Publiceren om toe te staan dat de wijzigingen beschikbaar zijn via de GenerateAnswer-API.

   Wanneer er elke 30 minuten vijf of meer vergelijkbare query's worden geclusterd, stelt QnA Maker alternatieve vragen voor die u kunt accepteren of afwijzen.

Actieve leersuggesties worden opgeslagen in de geëxporteerde Knowledge Base

Wanneer actief leren is ingeschakeld voor uw app en u de app exporteert, blijven de actieve leergegevens behouden in de kolom in het SuggestedQuestions tsv-bestand.

De SuggestedQuestions kolom is een JSON-object met informatie over autosuggested impliciete, en expliciete usersuggested feedback. Een voorbeeld van dit JSON-object voor één door de gebruiker ingediende vraag help is:

[
    {
        "clusterHead": "help",
        "totalAutoSuggestedCount": 1,
        "totalUserSuggestedCount": 0,
        "alternateQuestionList": [
            {
                "question": "help",
                "autoSuggestedCount": 1,
                "userSuggestedCount": 0
            }
        ]
    }
]

Wanneer u deze app opnieuwimporteert, blijft het actieve leerproces informatie verzamelen en suggesties voor uw Knowledge Base aanbevelen.

Architectuurstroom voor het gebruik van GenerateAnswer en API's trainen vanuit een bot

Een bot of andere clienttoepassing moet de volgende architectuurstroom gebruiken om actief leren te gebruiken:

1. Bot haalt het antwoord op uit de knowledge base met de GenerateAnswer-API, met behulp van de eigenschap om een aantal antwoorden te top krijgen.

2. Bot bepaalt expliciete feedback:

   • Filter lage scores uit met behulpvan uw eigen aangepaste bedrijfslogica.
   • Geef in de bot of clienttoepassing een lijst weer met mogelijke antwoorden voor de gebruiker en haal het geselecteerde antwoord van de gebruiker op.

3. Bot stuurt het geselecteerde antwoord terug naar QnA Maker met de Api trainen.

Gebruik de bovenste eigenschap in de GenerateAnswer-aanvraag om verschillende overeenkomende antwoorden te krijgen

Bij het verzenden van een vraag QnA Maker om een antwoord te vinden, stelt de eigenschap van de JSON-body het aantal antwoorden top in dat moet worden beantwoord.

{
    "question": "wi-fi",
    "isTest": false,
    "top": 3
}

Gebruik de eigenschap score samen met bedrijfslogica om een lijst met antwoorden op te halen om de gebruiker weer te geven

Wanneer de clienttoepassing (zoals een chatbot) het antwoord ontvangt, worden de drie belangrijkste vragen geretourneerd. Gebruik de score eigenschap om de nabijheid tussen scores te analyseren. Dit nabijheidsbereik wordt bepaald door uw eigen bedrijfslogica.

{
    "answers": [
        {
            "questions": [
                "Wi-Fi Direct Status Indicator"
            ],
            "answer": "**Wi-Fi Direct Status Indicator**\n\nStatus bar icons indicate your current Wi-Fi Direct connection status:  \n\nWhen your device is connected to another device using Wi-Fi Direct, '$  \n\n+ *+ ' Wi-Fi Direct is displayed in the Status bar.",
            "score": 74.21,
            "id": 607,
            "source": "Bugbash KB.pdf",
            "metadata": []
        },
        {
            "questions": [
                "Wi-Fi - Connections"
            ],
            "answer": "**Wi-Fi**\n\nWi-Fi is a term used for certain types of Wireless Local Area Networks (WLAN). Wi-Fi communication requires access to a wireless Access Point (AP).",
            "score": 74.15,
            "id": 599,
            "source": "Bugbash KB.pdf",
            "metadata": []
        },
        {
            "questions": [
                "Turn Wi-Fi On or Off"
            ],
            "answer": "**Turn Wi-Fi On or Off**\n\nTurning Wi-Fi on makes your device able to discover and connect to compatible in-range wireless APs.  \n\n1.  From a Home screen, tap ::: Apps > e Settings .\n2.  Tap Connections > Wi-Fi , and then tap On/Off to turn Wi-Fi on or off.",
            "score": 69.99,
            "id": 600,
            "source": "Bugbash KB.pdf",
            "metadata": []
        }
    ]
}

Clienttoepassingsvervolging wanneer vragen vergelijkbare scores hebben

Uw clienttoepassing geeft de vragen weer met een optie voor de gebruiker om de enkele vraag te selecteren die het beste bij de bedoeling van de gebruiker is.

Zodra de gebruiker een van de bestaande vragen heeft geselecteerd, verzendt de clienttoepassing de keuze van de gebruiker als feedback met behulp van QnA Maker Train API. Met deze feedback wordt de actieve lus voor leerfeedback voltooid.

API trainen

Actieve feedback over leertrajecten wordt verzonden QnA Maker met de POST-aanvraag api trainen. De API-handtekening is:

POST https://<QnA-Maker-resource-name>.azurewebsites.net/qnamaker/knowledgebases/<knowledge-base-ID>/train
Authorization: EndpointKey <endpoint-key>
Content-Type: application/json
{"feedbackRecords": [{"userId": "1","userQuestion": "<question-text>","qnaId": 1}]}

De JSON-body heeft verschillende instellingen:

Een voorbeeld van een JSON-body ziet er als voorbeeld uit:

{
    "feedbackRecords": [
        {
            "userId": "1",
            "userQuestion": "<question-text>",
            "qnaId": 1
        }
    ]
}

Een geslaagd antwoord retourneert de status 204 en geen JSON-antwoord.

Batch veel feedbackrecords in één aanroep

In de toepassing aan de clientzijde, zoals een bot, kunt u de gegevens opslaan en vervolgens veel records verzenden in één JSON-body in de feedbackRecords matrix.

Een voorbeeld van een JSON-body ziet er als voorbeeld uit:

{
    "feedbackRecords": [
        {
            "userId": "1",
            "userQuestion": "How do I ...",
            "qnaId": 1
        },
        {
            "userId": "2",
            "userQuestion": "Where is ...",
            "qnaId": 40
        },
        {
            "userId": "3",
            "userQuestion": "When do I ...",
            "qnaId": 33
        }
    ]
}

Voorbeeldcode van bot-framework

Uw bot-frameworkcode moet de Train-API aanroepen als de query van de gebruiker moet worden gebruikt voor actief leren. Er zijn twee stukjes code om te schrijven:

• Bepalen of de query moet worden gebruikt voor actief leren
• Query terugsturen naar de QnA Maker Train-API voor actief leren

In het Azure Bot-voorbeeldzijn beide activiteiten geprogrammeerd.

Voorbeeld van C#-code voor API trainen met Bot Framework 4.x

De volgende code laat zien hoe u informatie terug verzendt naar QnA Maker train-API.

public class FeedbackRecords
{
    // <summary>
    /// List of feedback records
    /// </summary>
    [JsonProperty("feedbackRecords")]
    public FeedbackRecord[] Records { get; set; }
}

/// <summary>
/// Active learning feedback record
/// </summary>
public class FeedbackRecord
{
    /// <summary>
    /// User id
    /// </summary>
    public string UserId { get; set; }

    /// <summary>
    /// User question
    /// </summary>
    public string UserQuestion { get; set; }

    /// <summary>
    /// QnA Id
    /// </summary>
    public int QnaId { get; set; }
}

/// <summary>
/// Method to call REST-based QnAMaker Train API for Active Learning
/// </summary>
/// <param name="endpoint">Endpoint URI of the runtime</param>
/// <param name="FeedbackRecords">Feedback records train API</param>
/// <param name="kbId">Knowledgebase Id</param>
/// <param name="key">Endpoint key</param>
/// <param name="cancellationToken"> Cancellation token</param>
public async static void CallTrain(string endpoint, FeedbackRecords feedbackRecords, string kbId, string key, CancellationToken cancellationToken)
{
    var uri = endpoint + "/knowledgebases/" + kbId + "/train/";

    using (var client = new HttpClient())
    {
        using (var request = new HttpRequestMessage())
        {
            request.Method = HttpMethod.Post;
            request.RequestUri = new Uri(uri);
            request.Content = new StringContent(JsonConvert.SerializeObject(feedbackRecords), Encoding.UTF8, "application/json");
            request.Headers.Add("Authorization", "EndpointKey " + key);

            var response = await client.SendAsync(request, cancellationToken);
            await response.Content.ReadAsStringAsync();
        }
    }
}

Voorbeeld van Node.js code voor API trainen met Bot Framework 4.x

De volgende code laat zien hoe u informatie terug verzendt naar QnA Maker train-API.

async callTrain(stepContext){

    var trainResponses = stepContext.values[this.qnaData];
    var currentQuery = stepContext.values[this.currentQuery];

    if(trainResponses.length > 1){
        var reply = stepContext.context.activity.text;
        var qnaResults = trainResponses.filter(r => r.questions[0] == reply);

        if(qnaResults.length > 0){

            stepContext.values[this.qnaData] = qnaResults;

            var feedbackRecords = {
                FeedbackRecords:[
                    {
                        UserId:stepContext.context.activity.id,
                        UserQuestion: currentQuery,
                        QnaId: qnaResults[0].id
                    }
                ]
            };

            // Call Active Learning Train API
            this.activeLearningHelper.callTrain(this.qnaMaker.endpoint.host, feedbackRecords, this.qnaMaker.endpoint.knowledgeBaseId, this.qnaMaker.endpoint.endpointKey);

            return await stepContext.next(qnaResults);
        }
        else{

            return await stepContext.endDialog();
        }
    }

    return await stepContext.next(stepContext.result);
}

Aanbevolen procedures

Zie Best practices voor best practices bij het gebruik van actief leren.

Volgende stappen