Accettare le domande suggerite per l'apprendimento attivo nella knowledge base

L'apprendimento attivo modifica la knowledge base o il servizio di ricerca quando si approva il suggerimento, quindi si salva e si esegue il training. Se si approva il suggerimento, verrà aggiunto come domanda alternativa.

Attivare l'apprendimento attivo

Per visualizzare le domande suggerite, è necessario attivare l'apprendimento attivo per la risorsa QnA Maker.

Visualizzare le domande suggerite

1. Per vedere le domande suggerite, nella pagina della knowledge base Modifica, selezionare Opzioni di visualizzazione e quindi selezionare Mostra suggerimenti di apprendimento attivo. Questa opzione verrà disabilitata se non sono presenti suggerimenti per una delle coppie di domande e risposte.

   

2. Filtrare la knowledge base con le coppie di domande e risposte per mostrare solo i suggerimenti selezionando Filtra in base a suggerimenti.

   

3. Ogni coppia di domanda e risposta suggerisce le nuove domande alternative con un segno di spunta, ✔, per accettare la domanda o x per rifiutare i suggerimenti. Selezionare il segno di spunta per aggiungere la domanda.

   

   È possibile aggiungere o eliminare tutti i suggerimenti selezionando Aggiungi tutti oppure Rifiuta tutti nella barra degli strumenti contestuale.

4. Selezionare Save and Train (Salva ed esegui il training) per salvare le modifiche alla knowledge base.

5. Selezionare Pubblica per fare in modo che le modifiche siano disponibili dall'API GenerateAnswer.

   Quando vengono raggruppate 5 o più query simili, ogni 30 minuti QnA Maker suggerisce le domande alternative da accettare o rifiutare.

I suggerimenti di apprendimento attivo vengono salvati nella knowledge base esportata

Quando l'apprendimento attivo è abilitato per l'app e si esporta l'app, la colonna SuggestedQuestions nel file tsv mantiene i dati di apprendimento attivo.

La colonna SuggestedQuestions è un oggetto JSON di informazioni di feedback implicito, autosuggested, ed esplicito, usersuggested. Un esempio di questo oggetto JSON per una singola domanda inviata dall'utente di help è:

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

Quando si reimporta questa app, l'apprendimento attivo continua a raccogliere informazioni e a consigliare suggerimenti per la knowledge base.

Flusso architetturale per l'uso delle API GenerateAnswer e Train da un bot

Un bot o un'altra applicazione client deve usare il flusso architetturale seguente per usare l'apprendimento attivo:

1. Il bot ottiene la risposta dalla knowledge base con l'API GenerateAnswer, usando la proprietà top per ottenere una serie di risposte.

2. Il bot determina il feedback esplicito:

   • Usando la propria logica di business personalizzata, escludere i punteggi bassi.
   • Nel bot o nell'applicazione client visualizzare l'elenco delle risposte possibili all'utente e ottenere la risposta selezionata dell'utente.

3. Il bot invia la risposta selezionata a QnA Maker con l'API Train.

Usare la prima proprietà nella richiesta GenerateAnswer per ottenere più risposte corrispondenti

Quando si invia una domanda a QnA Maker per ottenere una risposta, la proprietà top del corpo JSON imposta il numero di risposte da restituire.

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

Usare la proprietà score insieme alla logica di business per ottenere un elenco di risposte da mostrare all'utente

Quando l'applicazione client (come un chatbot) riceve la risposta, vengono restituite le prime 3 domande. Usare la proprietà score per analizzare la prossimità tra i punteggi. Questo intervallo di prossimità è determinato dalla propria logica di business.

{
    "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": []
        }
    ]
}

Follow-up dell'applicazione client in caso di domande con punteggi simili

L'applicazione client visualizza tutte le domande permettendo all'utente di selezionare la singola domanda che meglio rappresenta la propria intenzione.

Dopo che l'utente seleziona una delle domande esistenti, l'applicazione client invia la scelta dell'utente come feedback usando l'API Train di QnA Maker. Questo feedback completa il ciclo di feedback di apprendimento attivo.

API Train

Il feedback di apprendimento attivo viene inviato a QnA Maker con una richiesta POST dell'API Train. La firma dell'API è:

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

Il corpo JSON ha diverse impostazioni:

Un corpo JSON di esempio è simile al seguente:

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

Una risposta con esito positivo restituisce lo stato 204 e nessun corpo della risposta JSON.

Riunire in batch molti record di feedback in una singola chiamata

Nell'applicazione lato client, ad esempio un bot, è possibile archiviare i dati, quindi inviare molti record in un singolo corpo JSON nella matrice feedbackRecords.

Un corpo JSON di esempio è simile al seguente:

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

Codice di esempio di Bot Framework

Il codice di Bot Framework deve chiamare l'API Train, se la query dell'utente deve essere usata per l'apprendimento attivo. Occorre scrivere due blocchi di codice:

• Determinare se la query deve essere usata per l'apprendimento attivo
• Inviare di nuovo la query all'API Train di QnA Maker per l'apprendimento attivo

Nell'esempio di Azure Bot sono state programmate entrambe queste attività.

Codice C# di esempio per l'API Train con Bot Framework 4.x

Il codice seguente illustra come restituire informazioni a QnA Maker con l'API Train.

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

Codice Node.js di esempio per l'API Train con Bot Framework 4.x

Il codice seguente illustra come restituire informazioni a QnA Maker con l'API Train.

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

Procedure consigliate

Per le procedure consigliate quando si usa l'apprendimento attivo, vedere Procedure consigliate.

Passaggi successivi