Condividi tramite

Introduzione a più slot per Personalizza esperienze di intelligenza artificiale di Azure

  • Articolo

Importante

A partire dal 20 settembre 2023 non sarà possibile creare nuove risorse di Personalizza esperienze. Il servizio Personalizza esperienze viene ritirato il 1° ottobre 2026.

La personalizzazione multi-slot (anteprima) consente di specificare come destinazione il contenuto nei layout Web, nelle etichette e negli elenchi in cui vengono visualizzate più azioni (ad esempio un prodotto o una parte di contenuto) agli utenti. Con le API multi-slot di Personalizza esperienze, è possibile avere i modelli di intelligenza artificiale in Personalizza esperienze per scoprire quali contesti utente e prodotti determinano determinati comportamenti, considerando e imparando dal posizionamento nell'interfaccia utente. Ad esempio, Personalizza esperienze può apprendere che determinati prodotti o contenuti determinano più clic come barra laterale o piè di pagina che come evidenziazione principale in una pagina.

In questa guida si apprenderà come usare le API multi-slot di Personalizza esperienze.

Documentazione di riferimento Pacchetto del codice | sorgente della libreria | (NuGet) | Esempi concettuali | di più slot

Prerequisiti

  • Sottoscrizione di Azure: creare un account gratuito
  • Versione corrente di .NET Core
  • Dopo aver creato la sottoscrizione di Azure, creare una risorsa personalizza esperienze nel portale di Azure per ottenere la chiave e l'endpoint. Al termine della distribuzione, fare clic su Vai alla risorsa.
    • Sarà necessaria la chiave e l'endpoint dalla risorsa creata per connettere l'applicazione all'API Personalizza esperienze. Incollare la chiave e l'endpoint nel codice seguente più avanti nella guida introduttiva.
    • È possibile usare il piano tariffario gratuito (F0) per provare il servizio ed eseguire in un secondo momento l'aggiornamento a un livello a pagamento per la produzione.

Configurazione

Aggiornare l'istanza di Personalizza esperienze a più slot

Nota

La personalizzazione multi-slot (anteprima) influisce su altre funzionalità del servizio Personalizza esperienze. Questa modifica non può essere annullata. Prima di abilitare la personalizzazione con più slot, vedere Personalizzazione di più slot (anteprima).

  1. Disabilitare l'ottimizzazione automatica Nella portale di Azure, nella risorsa Personalizza esperienze, in Gestione risorse, nella pagina Impostazioni modello e apprendimento, disattivare e salvare l'ottimizzazione automatica.

Nota

La personalizzazione di più slot non funzionerà a meno che non si disabiliti l'ottimizzazione automatica. L'ottimizzazione automatica per la personalizzazione multi-slot sarà supportata in futuro.

  1. Aggiornare Personalizza esperienze a più slot Nella portale di Azure, nella risorsa Personalizza esperienze, in Gestione risorse, nella pagina Impostazioni modello e apprendimento selezionare Esporta impostazioni di apprendimento. Il campo arguments nel file JSON scaricato inizierà con --cb_explore_adf. Passare a --ccb_explore_adf e salvare il file. CB (banditi contestuali) e CCB (banditi contestuali condizionali) sono gli algoritmi usati rispettivamente da Personalizza esperienze per la personalizzazione a slot singolo e multi-slot. ADF (funzionalità dipendenti dall'azione) indica che le azioni sono espresse/identificate con le funzionalità.

Learning settings before change

Learning settings after change

Nella stessa scheda del portale, in Importa impostazioni di apprendimento individuare il file JSON modificato di recente e caricarlo. In questo modo l'istanza di Personalizza esperienze verrà aggiornata in modo che sia un personalizza esperienze "Multi Slot" e ora supporterà chiamate di classificazione e ricompensa multi-slot.

Modificare la frequenza di aggiornamento del modello

Nella portale di Azure passare alla pagina Configurazione della risorsa personalizza esperienze e modificare la frequenza di aggiornamento del modello in 30 secondi. Questa breve durata eseguirà rapidamente il training del modello, consentendo di vedere come cambia l'azione consigliata per ogni iterazione.

Change model update frequency

Modificare il tempo di attesa della ricompensa

Nella portale di Azure passare alla pagina Configurazione della risorsa personalizza esperienze e modificare il tempo di attesa ricompensa su 10 minuti. Ciò determina per quanto tempo il modello attenderà dopo l'invio di una raccomandazione, per ricevere il feedback sulla ricompensa da tale raccomandazione. Il training non verrà eseguito fino a quando non è trascorso il tempo di attesa della ricompensa.

Change reward wait time

Creare una nuova applicazione C#

Creare una nuova applicazione .NET Core nell'ambiente di sviluppo integrato o nell'editor preferito.

Nella finestra di una console (ad esempio cmd, PowerShell o Bash) usare il comando dotnet new per creare una nuova app console con il nome personalizer-quickstart. Questo comando crea un semplice progetto C# "Hello World" con un singolo file di origine: Program.cs.

dotnet new console -n personalizer-quickstart

Spostarsi nella cartella dell'app appena creata. È possibile compilare l'applicazione con il comando seguente:

dotnet build

L'output di compilazione non deve contenere alcun avviso o errore.

...
Build succeeded.
 0 Warning(s)
 0 Error(s)
...

Installare la libreria client

Nella directory dell'applicazione installare la libreria client di Personalizza esperienze per .NET con il comando seguente:

dotnet add package Azure.AI.Personalizer --version 2.0.0-beta.2

Dalla directory del progetto aprire il file Program.cs nell'editor o nell'IDE preferito. Aggiungere le direttive using seguenti:

using System;
using Azure;
using Azure.AI.Personalizer;
using System.Collections.Generic;
using System.Linq;

Modello a oggetti

Il client di Personalizza esperienze è un oggetto Personalizza esperienzeClient che esegue l'autenticazione in Azure usando Azure.AzureKeyCredential, che contiene la chiave.

Per richiedere il singolo elemento migliore del contenuto per ogni slot, creare un oggetto Personalizza esperienzeMultiSlotOptions e quindi passarlo a Personalizza esperienzeClient.RankMultiSlot. Il metodo RankMultiSlot restituisce un oggetto Personalizza esperienzeMultiSlotRankResult.

Per inviare un punteggio di ricompensa a Personalizza esperienze, creare un oggetto Personalizza esperienzeRewardMultiSlotOptions, quindi passarlo al metodo Personalizza esperienzeClient.RewardMultiSlot insieme all'ID evento corrispondente.

Il punteggio di ricompensa in questo argomento di avvio rapido è semplice. In un sistema di produzione invece, stabilire cosa influisce sul punteggio di ricompensa e in quale misura può essere un processo complesso, che si può decidere di cambiare nel tempo. Questa dovrebbe essere una delle principali decisioni di progettazione da prendere nell'architettura di Personalizza esperienze.

Esempi di codice

Questi frammenti di codice mostrano come eseguire le operazioni seguenti con la libreria client di Personalizza esperienze per .NET:

Autenticare il client

In questa sezione verranno eseguite due operazioni:

  • Specificare la chiave e l'endpoint
  • Creare un client di Personalizza esperienze

Per iniziare, aggiungere le righe seguenti alla classe Program. Assicurarsi di aggiungere la chiave e l'endpoint dalla risorsa Personalizza esperienze.

Importante

Vai al portale di Azure. Se la risorsa Personalizza esperienze creata nella sezione Prerequisiti è stata distribuita correttamente, fare clic sul pulsante Vai alla risorsa in Passaggi successivi. La chiave e l'endpoint saranno disponibili nella pagina Chiavi ed endpoint della risorsa in Gestione risorse.

Al termine, ricordarsi di rimuovere la chiave dal codice e non renderlo mai pubblico. Per la produzione, è consigliabile usare un modo sicuro per archiviare e accedere alle credenziali, ad esempio Azure Key Vault.

private const string ServiceEndpoint  = "https://REPLACE-WITH-YOUR-PERSONALIZER-RESOURCE-NAME.cognitiveservices.azure.com";
private const string ResourceKey = "<REPLACE-WITH-YOUR-PERSONALIZER-KEY>";

Creare quindi gli URL di classificazione e ricompensa.

static PersonalizerClient InitializePersonalizerClient(Uri url)
{
    return new PersonalizerClient(url, new AzureKeyCredential(ResourceKey));
}

Ottenere scelte di contenuto rappresentate come azioni

Le azioni rappresentano le scelte di contenuto da cui si vuole che Personalizza esperienze selezioni l'elemento di contenuto migliore. Aggiungere i metodi seguenti alla classe Program per rappresentare il set di azioni e le relative caratteristiche.

private static IList<PersonalizerRankableAction> GetActions()
{
    IList<PersonalizerRankableAction> actions = new List<PersonalizerRankableAction>
    {
        new PersonalizerRankableAction(
            id: "Red-Polo-Shirt-432",
            features:
            new List<object>() { new { onSale = "true", price = "20", category = "Clothing" } }
        ),

        new PersonalizerRankableAction(
            id: "Tennis-Racket-133",
            features:
            new List<object>() { new { onSale = "false", price = "70", category = "Sports" } }
        ),

        new PersonalizerRankableAction(
            id: "31-Inch-Monitor-771",
            features:
            new List<object>() { new { onSale = "true", price = "200", category = "Electronics" } }
        ),

        new PersonalizerRankableAction(
            id: "XBox-Series X-117",
            features:
            new List<object>() { new { onSale = "false", price = "499", category = "Electronics" } }
        )
    };

    return actions;
}

Ottenere gli slot

Gli slot costituiscono la pagina con cui l'utente interagirà. Personalizza esperienze deciderà quale azione visualizzare in ognuno degli slot definiti. Le azioni possono essere escluse da slot specifici, come ExcludeActions. BaselineAction è l'azione predefinita per lo slot, che sarebbe stata visualizzata senza l'uso di Personalizza esperienze.

Questa guida introduttiva include funzionalità di slot semplici. Nei sistemi di produzione, determinare e valutarele funzionalità può essere una questione non semplice.

private static IList<PersonalizerSlotOptions> GetSlots()
{
    IList<PersonalizerSlotOptions> slots = new List<PersonalizerSlotOptions>
    {
        new PersonalizerSlotOptions(
            id: "BigHeroPosition",
            features: new List<object>() { new { size = "large", position = "left" } },
            excludedActions: new List<string>() { "31-Inch-Monitor-771" },
            baselineAction: "Red-Polo-Shirt-432"

        ),

        new PersonalizerSlotOptions(
            id: "SmallSidebar",
            features: new List<object>() { new { size = "small", position = "right" } },
            excludedActions: new List<string>() { "Tennis-Racket-133" },
            baselineAction: "XBox-Series X-117"
        ),
    };

    return slots;
}

Recuperare le preferenze dell'utente per il contesto

Aggiungere i metodi seguenti alla classe Program per ottenere l'input di un utente dalla riga di comando per l'ora del giorno e il tipo di dispositivo su cui si trova l'utente. Questi metodi verranno usati come funzionalità di contesto.

static string GetTimeOfDayForContext()
{
    string[] timeOfDayFeatures = new string[] { "morning", "afternoon", "evening", "night" };

    Console.WriteLine("\nWhat time of day is it (enter number)? 1. morning 2. afternoon 3. evening 4. night");
    if (!int.TryParse(GetKey(), out int timeIndex) || timeIndex < 1 || timeIndex > timeOfDayFeatures.Length)
    {
        Console.WriteLine("\nEntered value is invalid. Setting feature value to " + timeOfDayFeatures[0] + ".");
        timeIndex = 1;
    }

    return timeOfDayFeatures[timeIndex - 1];
}

static string GetDeviceForContext()
{
    string[] deviceFeatures = new string[] { "mobile", "tablet", "desktop" };

    Console.WriteLine("\nWhat is the device type (enter number)? 1. Mobile 2. Tablet 3. Desktop");
    if (!int.TryParse(GetKey(), out int deviceIndex) || deviceIndex < 1 || deviceIndex > deviceFeatures.Length)
    {
        Console.WriteLine("\nEntered value is invalid. Setting feature value to " + deviceFeatures[0] + ".");
        deviceIndex = 1;
    }

    return deviceFeatures[deviceIndex - 1];
}

Entrambi i metodi usano il metodo GetKey per leggere la selezione dell'utente dalla riga di comando.

private static string GetKey()
{
    return Console.ReadKey().Key.ToString().Last().ToString().ToUpper();
}

private static IList<object> GetContext(string time, string device)
{
    return new List<object>()
    {
        new { time = time },
        new { device = device }
    };
}

Creare il ciclo di apprendimento

Il ciclo di apprendimento di Personalizza esperienze è un ciclo di chiamate RankMultiSlot e RewardMultiSlot . In questo argomento di avvio rapido ogni chiamata Rank per personalizzare il contenuto è seguita da una chiamata Reward per indicare a Personalizza esperienze il livello di prestazioni del servizio.

Il codice seguente scorre un ciclo di richiesta all'utente delle proprie preferenze tramite la riga di comando, inviando tali informazioni a Personalizza esperienze per selezionare l'azione migliore per ogni slot, presentando la selezione al cliente da scegliere tra l'elenco, quindi inviando un punteggio di ricompensa a Personalizza esperienze segnalando quanto sia stato eseguito il servizio nella selezione.

static void Main(string[] args)
{
    Console.WriteLine($"Welcome to this Personalizer Quickstart!\n" +
    $"This code will help you understand how to use the Personalizer APIs (multislot rank and multislot reward).\n" +
    $"Each iteration represents a user interaction and will demonstrate how context, actions, slots, and rewards work.\n" +
    $"Note: Personalizer AI models learn from a large number of user interactions:\n" +
    $"You won't be able to tell the difference in what Personalizer returns by simulating a few events by hand.\n" +
    $"If you want a sample that focuses on seeing how Personalizer learns, see the Python Notebook sample.");

    int iteration = 1;
    bool runLoop = true;

    IList<PersonalizerRankableAction> actions = GetActions();
    IList<PersonalizerSlotOptions> slots = GetSlots();
    PersonalizerClient client = InitializePersonalizerClient(new Uri(ServiceEndpoint));

    do
    {
        Console.WriteLine("\nIteration: " + iteration++);

        string timeOfDayFeature = GetTimeOfDayForContext();
        string deviceFeature = GetDeviceForContext();

        IList<object> currentContext = GetContext(timeOfDayFeature, deviceFeature);

        string eventId = Guid.NewGuid().ToString();

        var multiSlotRankOptions = new PersonalizerRankMultiSlotOptions(actions, slots, currentContext, eventId);
        PersonalizerMultiSlotRankResult multiSlotRankResult = client.RankMultiSlot(multiSlotRankOptions);

        for (int i = 0; i < multiSlotRankResult.Slots.Count(); ++i)
        {
            string slotId = multiSlotRankResult.Slots[i].SlotId;
            Console.WriteLine($"\nPersonalizer service decided you should display: { multiSlotRankResult.Slots[i].RewardActionId} in slot {slotId}. Is this correct? (y/n)");

            string answer = GetKey();

            if (answer == "Y")
            {
                client.RewardMultiSlot(eventId, slotId, 1f);
                Console.WriteLine("\nGreat! The application will send Personalizer a reward of 1 so it learns from this choice of action for this slot.");
            }
            else if (answer == "N")
            {
                client.RewardMultiSlot(eventId, slotId, 0f);
                Console.WriteLine("\nYou didn't like the recommended item. The application will send Personalizer a reward of 0 for this choice of action for this slot.");
            }
            else
            {
                client.RewardMultiSlot(eventId, slotId, 0f);
                Console.WriteLine("\nEntered choice is invalid. Service assumes that you didn't like the recommended item.");
            }
        }

        Console.WriteLine("\nPress q to break, any other key to continue:");
        runLoop = !(GetKey() == "Q");

    } while (runLoop);
}

Nelle sezioni seguenti verranno esaminate più in dettaglio le chiamate rank e reward. Aggiungere i metodi seguenti, che ottengono le opzioni di contenuto, recupera gli slot e inviano richieste di classificazione e ricompensa multi-slot prima di eseguire il file di codice:

  • GetActions
  • GetSlots
  • GetTimeOfDayForContext
  • GetDeviceForContext
  • GetKey
  • GetContext

Richiedere l'azione migliore

Per completare la richiesta Rank, il programma richiede le preferenze dell'utente per creare un oggetto Context delle scelte di contenuto. La richiesta contiene il contesto, le azioni e gli slot con le rispettive caratteristiche e un ID evento univoco, per ricevere una risposta.

Questa guida introduttiva include semplici funzionalità di contesto dell'ora del giorno e del dispositivo utente. Nei sistemi di produzione, determinare e valutareazioni e funzionalità può non essere altrettanto semplice.

string timeOfDayFeature = GetTimeOfDayForContext();
string deviceFeature = GetDeviceForContext();

IList<object> currentContext = GetContext(timeOfDayFeature, deviceFeature);

string eventId = Guid.NewGuid().ToString();

var multiSlotRankOptions = new PersonalizerRankMultiSlotOptions(actions, slots, currentContext, eventId);
PersonalizerMultiSlotRankResult multiSlotRankResult = client.RankMultiSlot(multiSlotRankOptions);

Inviare una ricompensa

Per ottenere il punteggio di ricompensa per la richiesta di ricompensa, il programma ottiene la selezione dell'utente per ogni slot tramite la riga di comando, assegna un valore numerico (punteggio di ricompensa) alla selezione, quindi invia l'ID evento univoco, l'ID slot e il punteggio di ricompensa per ogni slot come valore numerico all'API Reward. Non è necessario definire una ricompensa per ogni slot.

Questo argomento di avvio rapido assegna un numero semplice come punteggio di ricompensa, ovvero 0 o 1. Nei sistemi di produzione, determinare quando e cosa inviare alla chiamata Reward può essere un'operazione non banale, a seconda delle esigenze specifiche.

for (int i = 0; i < multiSlotRankResult.Slots.Count(); ++i)
{
    string slotId = multiSlotRankResult.Slots[i].SlotId;
    Console.WriteLine($"\nPersonalizer service decided you should display: { multiSlotRankResult.Slots[i].RewardActionId} in slot {slotId}. Is this correct? (y/n)");

    string answer = GetKey();

    if (answer == "Y")
    {
        client.RewardMultiSlot(eventId, slotId, 1f);
        Console.WriteLine("\nGreat! The application will send Personalizer a reward of 1 so it learns from this choice of action for this slot.");
    }
    else if (answer == "N")
    {
        client.RewardMultiSlot(eventId, slotId, 0f);
        Console.WriteLine("\nYou didn't like the recommended item. The application will send Personalizer a reward of 0 for this choice of action for this slot.");
    }
    else
    {
        client.RewardMultiSlot(eventId, slotId, 0f);
        Console.WriteLine("\nEntered choice is invalid. Service assumes that you didn't like the recommended item.");
    }
}

Eseguire il programma

Eseguire l'applicazione con il comando dotnet run dalla directory dell'applicazione.

dotnet run

The quickstart program asks a couple of questions to gather user preferences, known as features, then provides the top action.

Per questo argomento di avvio rapido, è disponibile il codice sorgente.

Documentazione | di riferimento esempi concettuali | su più slot

Prerequisiti

  • Sottoscrizione di Azure: creare un account gratuito
  • Installare Node.js e NPM (verificato con Node.js v14.16.0 e NPM 6.14.11).
  • Dopo aver creato la sottoscrizione di Azure, creare una risorsa personalizza esperienze nel portale di Azure per ottenere la chiave e l'endpoint. Al termine della distribuzione, fare clic su Vai alla risorsa.
    • La chiave e l'endpoint della risorsa creata sono necessari per connettere l'applicazione all'API Personalizza esperienze. Incollare la chiave e l'endpoint nel codice seguente più avanti nella guida introduttiva.
    • È possibile usare il piano tariffario gratuito (F0) per provare il servizio ed eseguire in un secondo momento l'aggiornamento a un livello a pagamento per la produzione.

Configurazione

Aggiornare l'istanza di Personalizza esperienze a più slot

Nota

La personalizzazione multi-slot (anteprima) influisce su altre funzionalità del servizio Personalizza esperienze. Questa modifica non può essere annullata. Prima di abilitare la personalizzazione con più slot, vedere Personalizzazione di più slot (anteprima).

  1. Disabilitare l'ottimizzazione automatica Nella portale di Azure, nella risorsa Personalizza esperienze, in Gestione risorse, nella pagina Impostazioni modello e apprendimento, disattivare e salvare l'ottimizzazione automatica.

Nota

La personalizzazione di più slot non funzionerà a meno che non si disabiliti l'ottimizzazione automatica. L'ottimizzazione automatica per la personalizzazione multi-slot sarà supportata in futuro.

  1. Aggiornare Personalizza esperienze a più slot Nella portale di Azure, nella risorsa Personalizza esperienze, in Gestione risorse, nella pagina Impostazioni modello e apprendimento selezionare Esporta impostazioni di apprendimento. Il campo arguments nel file JSON scaricato inizierà con --cb_explore_adf. Passare a --ccb_explore_adf e salvare il file. CB (banditi contestuali) e CCB (banditi contestuali condizionali) sono gli algoritmi usati rispettivamente da Personalizza esperienze per la personalizzazione a slot singolo e multi-slot. ADF (funzionalità dipendenti dall'azione) indica che le azioni sono espresse/identificate con le funzionalità.

Learning settings before change

Learning settings after change

Nella stessa scheda del portale, in Importa impostazioni di apprendimento individuare il file JSON modificato di recente e caricarlo. In questo modo l'istanza di Personalizza esperienze verrà aggiornata in modo che sia un personalizza esperienze "Multi Slot" e ora supporterà chiamate di classificazione e ricompensa multi-slot.

Modificare la frequenza di aggiornamento del modello

Nella portale di Azure passare alla pagina Configurazione della risorsa personalizza esperienze e modificare la frequenza di aggiornamento del modello in 30 secondi. Questa breve durata eseguirà rapidamente il training del modello, consentendo di vedere come cambia l'azione consigliata per ogni iterazione.

Change model update frequency

Modificare il tempo di attesa della ricompensa

Nella portale di Azure passare alla pagina Configurazione della risorsa personalizza esperienze e modificare il tempo di attesa ricompensa su 10 minuti. Ciò determina per quanto tempo il modello attenderà dopo l'invio di una raccomandazione, per ricevere il feedback sulla ricompensa da tale raccomandazione. Il training non verrà eseguito fino a quando non è trascorso il tempo di attesa della ricompensa.

Change reward wait time

Creare una nuova applicazione Node.js

In una finestra della console, ad esempio cmd, PowerShell o Bash, creare e passare a una nuova directory per l'app.

mkdir myapp && cd myapp

Eseguire il comando npm init -y per creare un file package.json.

npm init -y

Creare una nuova applicazione Node.js nell'editor preferito o nell'IDE denominato sample.js e creare le variabili per l'endpoint e la chiave di sottoscrizione della risorsa.

Importante

Vai al portale di Azure. Se la risorsa Personalizza esperienze creata nella sezione Prerequisiti è stata distribuita correttamente, fare clic sul pulsante Vai alla risorsa in Passaggi successivi. La chiave e l'endpoint saranno disponibili nella pagina Chiavi ed endpoint della risorsa in Gestione risorse.

Al termine, ricordarsi di rimuovere la chiave dal codice e non renderlo mai pubblico. Per la produzione, è consigliabile usare un modo sicuro per archiviare e accedere alle credenziali, ad esempio Azure Key Vault.

const axios = require('axios');
const { v4: uuidv4 } = require('uuid');
const readline = require('readline-sync');
// The endpoint specific to your personalization service instance; 
// e.g. https://<your-resource-name>.cognitiveservices.azure.com
const PersonalizationBaseUrl = '<REPLACE-WITH-YOUR-PERSONALIZER-ENDPOINT>';
// The key specific to your personalization service instance; e.g. "0123456789abcdef0123456789ABCDEF"
const ResourceKey = '<REPLACE-WITH-YOUR-PERSONALIZER-KEY>';

Installare i pacchetti NPM per una guida introduttiva

npm install readline-sync uuid axios --save

Modello a oggetti

Per richiedere il singolo elemento migliore del contenuto per ogni slot, creare un oggetto rankRequest, quindi inviare una richiesta post a multislot/rank. La risposta viene quindi analizzata in rankResponse.

Per inviare un punteggio di ricompensa a Personalizza esperienze, creare un premio, quindi inviare una richiesta post a multislot/events/{eventId}/reward.

In questo argomento di avvio rapido, determinare il punteggio di ricompensa è semplice. In un sistema di produzione invece, stabilire cosa influisce sul punteggio di ricompensa e in quale misura può essere un processo complesso, che si può decidere di cambiare nel tempo. Questa dovrebbe essere una delle principali decisioni di progettazione da prendere nell'architettura di Personalizza esperienze.

Esempi di codice

Questi frammenti di codice illustrano come eseguire le attività seguenti inviando richieste HTTP per NodeJS:

Creare URL di base

In questa sezione si creeranno gli URL di classificazione/ricompensa usando l'URL di base e le intestazioni della richiesta usando la chiave di risorsa.

const MultiSlotRankUrl = PersonalizationBaseUrl.concat('personalizer/v1.1-preview.1/multislot/rank');
const MultiSlotRewardUrlBase = PersonalizationBaseUrl.concat('personalizer/v1.1-preview.1/multislot/events/');
const Headers = {
    'ocp-apim-subscription-key': ResourceKey,
    'Content-Type': 'application/json'
};

Ottenere scelte di contenuto rappresentate come azioni

Le azioni rappresentano le scelte di contenuto da cui si vuole che Personalizza esperienze selezioni l'elemento di contenuto migliore. Aggiungere i metodi seguenti allo script per rappresentare il set di azioni e le relative funzionalità.

function getActions() {
    return [
        {
            'id': 'Red-Polo-Shirt-432',
            'features': [
                {
                    'onSale': 'true',
                    'price': 20,
                    'category': 'Clothing'
                }
            ]
        },
        {
            'id': 'Tennis-Racket-133',
            'features': [
                {
                    'onSale': 'false',
                    'price': 70,
                    'category': 'Sports'
                }
            ]
        },
        {
            'id': '31-Inch-Monitor-771',
            'features': [
                {
                    'onSale': 'true',
                    'price': 200,
                    'category': 'Electronics'
                }
            ]
        },
        {
            'id': 'XBox-Series X-117',
            'features': [
                {
                    'onSale': 'false',
                    'price': 499,
                    'category': 'Electronics'
                }
            ]
        }
    ];
}

Recuperare le preferenze dell'utente per il contesto

Aggiungere i metodi seguenti allo script per ottenere l'input di un utente dalla riga di comando per l'ora del giorno e il tipo di dispositivo in cui si trova l'utente. Si useranno come caratteristiche del contesto.

function getContextFeatures() {
    const timeOfDayFeatures = ['morning', 'afternoon', 'evening', 'night'];
    const deviceFeatures = ['mobile', 'tablet', 'desktop'];

    let answer = readline.question('\nWhat time of day is it (enter number)? 1. morning 2. afternoon 3. evening 4. night\n');
    let selection = parseInt(answer);
    const timeOfDay = selection >= 1 && selection <= 4 ? timeOfDayFeatures[selection - 1] : timeOfDayFeatures[0];

    answer = readline.question('\nWhat type of device is the user on (enter number)? 1. mobile 2. tablet 3. desktop\n');
    selection = parseInt(answer);
    const device = selection >= 1 && selection <= 3 ? deviceFeatures[selection - 1] : deviceFeatures[0];

    console.log('Selected features:\n');
    console.log('Time of day: ' + timeOfDay + '\n');
    console.log('Device: ' + device + '\n');

    return [
        {
            'time': timeOfDay
        },
        {
            'device': device
        }
    ];
}

Ottenere gli slot

Gli slot costituiscono la pagina con cui l'utente interagirà. Personalizza esperienze deciderà quale azione visualizzare in ognuno degli slot definiti. Le azioni possono essere escluse da slot specifici, come ExcludeActions. BaselineAction è l'azione predefinita per lo slot che sarebbe stato visualizzato senza l'uso di Personalizza esperienze.

Questa guida introduttiva include funzionalità di slot semplici. Nei sistemi di produzione, determinare e valutarele funzionalità può essere una questione non semplice.

function getSlots() {
    return [
        {
            'id': 'BigHeroPosition',
            'features': [
                {
                    'size': 'large',
                    'position': 'left',
                }
            ],
            'excludedActions': ['31-Inch-Monitor-771'],
            'baselineAction': 'Red-Polo-Shirt-432'
        },
        {
            'id': 'SmallSidebar',
            'features': [
                {
                    'size': 'small',
                    'position': 'right',
                }
            ],
            'excludedActions': ['Tennis-Racket-133'],
            'baselineAction': 'XBox-Series X-117'
        }
    ];
}

Effettuare richieste HTTP

Aggiungere queste funzioni per inviare richieste post all'endpoint di Personalizza esperienze per chiamate di classificazione e ricompensa multi-slot.

async function sendMultiSlotRank(rankRequest) {
    try {
        let response = await axios.post(MultiSlotRankUrl, rankRequest, { headers: Headers })
        return response.data;
    }
    catch (err) {
        if(err.response)
        {
            throw err.response.data
        }
        console.log(err)
        throw err;
    }
}

async function sendMultiSlotReward(rewardRequest, eventId) {
    try {
        let rewardUrl = MultiSlotRewardUrlBase.concat(eventId, '/reward');
        let response = await axios.post(rewardUrl, rewardRequest, { headers: Headers })
    }
    catch (err) {
        console.log(err);
        throw err;
    }
}

Ottenere commenti e suggerimenti per le decisioni di Personalizza esperienze

Aggiungere il metodo seguente allo script. Si segnalerà se Personalizza esperienze ha preso una buona decisione per ogni slot tramite prompt della riga di comando.

function getRewardForSlot() {
    let answer = readline.question('\nIs this correct? (y/n)\n').toUpperCase();
    if (answer === 'Y') {
        console.log('\nGreat! The application will send Personalizer a reward of 1 so it learns from this choice of action for this slot.\n');
        return 1;
    }
    else if (answer === 'N') {
        console.log('\nYou didn\'t like the recommended item.The application will send Personalizer a reward of 0 for this choice of action for this slot.\n');
        return 0;
    }
    console.log('\nEntered choice is invalid. Service assumes that you didn\'t like the recommended item.\n');
    return 0;
}

Creare il ciclo di apprendimento

Il ciclo di apprendimento di Personalizza esperienze è un ciclo di chiamate Rank e Reward. In questo argomento di avvio rapido ogni chiamata Rank per personalizzare il contenuto è seguita da una chiamata Reward per indicare a Personalizza esperienze il livello di prestazioni del servizio.

Il codice seguente scorre un ciclo di richiesta all'utente delle proprie preferenze tramite la riga di comando, inviando tali informazioni a Personalizza esperienze per selezionare l'azione migliore per ogni slot, presentando la selezione al cliente da scegliere tra l'elenco, quindi inviando un punteggio di ricompensa a Personalizza esperienze segnalando quanto sia stato eseguito il servizio nella selezione.

let runLoop = true;

(async () => {
    do {

        let multiSlotRankRequest = {};

        // Generate an ID to associate with the request.
        multiSlotRankRequest.eventId = uuidv4();

        // Get context information from the user.
        multiSlotRankRequest.contextFeatures = getContextFeatures();

        // Get the actions list to choose from personalization with their features.
        multiSlotRankRequest.actions = getActions();

        // Get the list of slots for which Personalizer will pick the best action.
        multiSlotRankRequest.slots = getSlots();

        multiSlotRankRequest.deferActivation = false;

        try {
            //Rank the actions for each slot
            let multiSlotRankResponse = await sendMultiSlotRank(multiSlotRankRequest);
            let multiSlotrewards = {};
            multiSlotrewards.reward = [];
    
            for (let i = 0; i < multiSlotRankResponse.slots.length; i++) {
                console.log('\nPersonalizer service decided you should display: '.concat(multiSlotRankResponse.slots[i].rewardActionId, ' in slot ', multiSlotRankResponse.slots[i].id, '\n'));
    
                let slotReward = {};
                slotReward.slotId = multiSlotRankResponse.slots[i].id;
                // User agrees or disagrees with Personalizer decision for slot
                slotReward.value = getRewardForSlot();
                multiSlotrewards.reward.push(slotReward);
            }
    
            // Send the rewards for the event
            await sendMultiSlotReward(multiSlotrewards, multiSlotRankResponse.eventId);
    
            let answer = readline.question('\nPress q to break, any other key to continue:\n').toUpperCase();
            if (answer === 'Q') {
                runLoop = false;
            }
        }
        catch (err) {
            console.log(err);
            throw err;
        }



    } while (runLoop);
})()

Nelle sezioni seguenti verranno esaminate più in dettaglio le chiamate rank e reward.

Aggiungere i metodi seguenti, che ottengono le scelte di contenuto, ottengono le preferenze utente per il contesto, ottengono gli slot, Effettua richieste HTTP, Ottieni ricompensa per ogni slot prima di eseguire il file di codice:

  • getActions
  • getContextFeatures
  • getSlots
  • sendRank
  • sendReward
  • getRewardForSlot

Richiedere l'azione migliore

Per completare la richiesta Rank, il programma chiede le preferenze dell'utente per creare scelte di contenuto. Il corpo della richiesta contiene il contesto, le azioni e gli slot con le rispettive funzionalità. Il sendMultiSlotRank metodo accetta rankRequest ed esegue la richiesta di classificazione a più slot.

Questa guida introduttiva include semplici funzionalità di contesto dell'ora del giorno e del dispositivo utente. Nei sistemi di produzione, determinare e valutareazioni e funzionalità può non essere altrettanto semplice.

let multiSlotRankRequest = {};

// Generate an ID to associate with the request.
multiSlotRankRequest.eventId = uuidv4();

// Get context information from the user.
multiSlotRankRequest.contextFeatures = getContextFeatures();

// Get the actions list to choose from personalization with their features.
multiSlotRankRequest.actions = getActions();

// Get the list of slots for which Personalizer will pick the best action.
multiSlotRankRequest.slots = getSlots();

multiSlotRankRequest.deferActivation = false;

//Rank the actions for each slot
try {
    let multiSlotRankResponse = await sendMultiSlotRank(multiSlotRankRequest);
}
catch (err) {
    console.log(err);
    throw err;
}

Inviare una ricompensa

Per ottenere il punteggio di ricompensa per la richiesta di ricompensa, il programma ottiene la selezione dell'utente per ogni slot tramite la riga di comando, assegna un valore numerico (punteggio di ricompensa) alla selezione, quindi invia l'ID evento univoco, l'ID slot e il punteggio di ricompensa per ogni slot al sendMultiSlotReward metodo. Non è necessario definire una ricompensa per ogni slot.

Questo argomento di avvio rapido assegna un numero semplice come punteggio di ricompensa, ovvero 0 o 1. Nei sistemi di produzione, determinare quando e cosa inviare alla chiamata Reward può essere un'operazione non banale, a seconda delle esigenze specifiche.

let multiSlotrewards = {};
multiSlotrewards.reward = [];

for (i = 0; i < multiSlotRankResponse.slots.length; i++) {
    console.log('\nPersonalizer service decided you should display: '.concat(multiSlotRankResponse.slots[i].rewardActionId, ' in slot ', multiSlotRankResponse.slots[i].id, '\n'));

    let slotReward = {};
    slotReward.slotId = multiSlotRankResponse.slots[i].id;
    // User agrees or disagrees with Personalizer decision for slot
    slotReward.value = getRewardForSlot();
    multiSlotrewards.reward.push(slotReward);
}

// Send the rewards for the event
await sendMultiSlotReward(multiSlotrewards, multiSlotRankResponse.eventId);

Eseguire il programma

Eseguire l'applicazione con Node.js dalla directory dell'applicazione.

node sample.js

The quickstart program asks a couple of questions to gather user preferences, known as features, then provides the top action.

Per questo argomento di avvio rapido, è disponibile il codice sorgente.

Esempi concettuali | di più slot

Prerequisiti

  • Sottoscrizione di Azure: creare un account gratuito
  • Python 3.x
  • Dopo aver creato la sottoscrizione di Azure, creare una risorsa personalizza esperienze nel portale di Azure per ottenere la chiave e l'endpoint. Al termine della distribuzione, fare clic su Vai alla risorsa.
    • La chiave e l'endpoint della risorsa creata sono necessari per connettere l'applicazione all'API Personalizza esperienze. Incollare la chiave e l'endpoint nel codice seguente più avanti nella guida introduttiva.
    • È possibile usare il piano tariffario gratuito (F0) per provare il servizio ed eseguire in un secondo momento l'aggiornamento a un livello a pagamento per la produzione.

Configurazione

Aggiornare l'istanza di Personalizza esperienze a più slot

Nota

La personalizzazione multi-slot (anteprima) influisce su altre funzionalità del servizio Personalizza esperienze. Questa modifica non può essere annullata. Prima di abilitare la personalizzazione con più slot, vedere Personalizzazione di più slot (anteprima).

  1. Disabilitare l'ottimizzazione automatica Nella portale di Azure, nella risorsa Personalizza esperienze, in Gestione risorse, nella pagina Impostazioni modello e apprendimento, disattivare e salvare l'ottimizzazione automatica.

Nota

La personalizzazione di più slot non funzionerà a meno che non si disabiliti l'ottimizzazione automatica. L'ottimizzazione automatica per la personalizzazione multi-slot sarà supportata in futuro.

  1. Aggiornare Personalizza esperienze a più slot Nella portale di Azure, nella risorsa Personalizza esperienze, in Gestione risorse, nella pagina Impostazioni modello e apprendimento selezionare Esporta impostazioni di apprendimento. Il campo arguments nel file JSON scaricato inizierà con --cb_explore_adf. Passare a --ccb_explore_adf e salvare il file. CB (banditi contestuali) e CCB (banditi contestuali condizionali) sono gli algoritmi usati rispettivamente da Personalizza esperienze per la personalizzazione a slot singolo e multi-slot. ADF (funzionalità dipendenti dall'azione) indica che le azioni sono espresse/identificate con le funzionalità.

Learning settings before change

Learning settings after change

Nella stessa scheda del portale, in Importa impostazioni di apprendimento individuare il file JSON modificato di recente e caricarlo. In questo modo l'istanza di Personalizza esperienze verrà aggiornata in modo che sia un personalizza esperienze "Multi Slot" e ora supporterà chiamate di classificazione e ricompensa multi-slot.

Modificare la frequenza di aggiornamento del modello

Nella portale di Azure passare alla pagina Configurazione della risorsa personalizza esperienze e modificare la frequenza di aggiornamento del modello in 30 secondi. Questa breve durata eseguirà rapidamente il training del modello, consentendo di vedere come cambia l'azione consigliata per ogni iterazione.

Change model update frequency

Modificare il tempo di attesa della ricompensa

Nella portale di Azure passare alla pagina Configurazione della risorsa personalizza esperienze e modificare il tempo di attesa ricompensa su 10 minuti. Ciò determina per quanto tempo il modello attenderà dopo l'invio di una raccomandazione, per ricevere il feedback sulla ricompensa da tale raccomandazione. Il training non verrà eseguito fino a quando non è trascorso il tempo di attesa della ricompensa.

Change reward wait time

Creare una nuova applicazione Python

Creare un nuovo file Python, oltre alle variabili per l'endpoint e la chiave della sottoscrizione della risorsa.

Importante

Vai al portale di Azure. Se la risorsa Personalizza esperienze creata nella sezione Prerequisiti è stata distribuita correttamente, fare clic sul pulsante Vai alla risorsa in Passaggi successivi. La chiave e l'endpoint saranno disponibili nella pagina Chiavi ed endpoint della risorsa in Gestione risorse.

Al termine, ricordarsi di rimuovere la chiave dal codice e non renderlo mai pubblico. Per la produzione, è consigliabile usare un modo sicuro per archiviare e accedere alle credenziali, ad esempio Azure Key Vault.

import json, uuid, requests

# The endpoint specific to your personalization service instance; 
# e.g. https://<your-resource-name>.cognitiveservices.azure.com
PERSONALIZATION_BASE_URL = "<REPLACE-WITH-YOUR-PERSONALIZER-ENDPOINT>"
# The key specific to your personalization service instance; e.g. "0123456789abcdef0123456789ABCDEF"
RESOURCE_KEY = "<REPLACE-WITH-YOUR-PERSONALIZER-KEY>"

Modello a oggetti

Per richiedere il singolo elemento migliore del contenuto per ogni slot, creare un rank_request, quindi inviare una richiesta post a multislot/rank. La risposta viene quindi analizzata in un rank_response.

Per inviare un punteggio di ricompensa a Personalizza esperienze, creare un premio, quindi inviare una richiesta post a multislot/events/{eventId}/reward.

In questa guida introduttiva, determinare il punteggio di ricompensa è semplice. In un sistema di produzione, la determinazione di ciò che influisce sul punteggio di ricompensa e di quanto può essere un processo complesso che è possibile decidere di cambiare nel tempo. Questa dovrebbe essere una delle principali decisioni di progettazione da prendere nell'architettura di Personalizza esperienze.

Esempi di codice

Questi frammenti di codice illustrano come eseguire le attività seguenti inviando richieste HTTP per Python:

Creare URL di base

In questa sezione si creeranno gli URL di classificazione/ricompensa usando l'URL di base e le intestazioni della richiesta usando la chiave di risorsa.

MULTI_SLOT_RANK_URL = '{0}personalizer/v1.1-preview.1/multislot/rank'.format(PERSONALIZATION_BASE_URL)
MULTI_SLOT_REWARD_URL_BASE = '{0}personalizer/v1.1-preview.1/multislot/events/'.format(PERSONALIZATION_BASE_URL)
HEADERS = {
    'ocp-apim-subscription-key': RESOURCE_KEY,
    'Content-Type': 'application/json'
}

Ottenere scelte di contenuto rappresentate come azioni

Le azioni rappresentano le scelte di contenuto da cui si vuole che Personalizza esperienze selezioni l'elemento di contenuto migliore. Aggiungere i metodi seguenti allo script per rappresentare il set di azioni e le relative funzionalità.

def get_actions():
    return [
        {
            "id": "Red-Polo-Shirt-432",
            "features": [
                {
                    "onSale": "true",
                    "price": 20,
                    "category": "Clothing"
                }
            ]
        },
        {
            "id": "Tennis-Racket-133",
            "features": [
                {
                    "onSale": "false",
                    "price": 70,
                    "category": "Sports"
                }
            ]
        },
        {
            "id": "31-Inch-Monitor-771",
            "features": [
                {
                    "onSale": "true",
                    "price": 200,
                    "category": "Electronics"
                }
            ]
        },
        {
            "id": "XBox-Series X-117",
            "features": [
                {
                    "onSale": "false",
                    "price": 499,
                    "category": "Electronics"
                }
            ]
        }
    ]

Recuperare le preferenze dell'utente per il contesto

Aggiungere i metodi seguenti allo script per ottenere l'input di un utente dalla riga di comando per l'ora del giorno e il tipo di dispositivo in cui si trova l'utente. Si useranno come caratteristiche del contesto.

def get_context_features():
    time_features = ["morning", "afternoon", "evening", "night"]
    time_pref = input("What time of day is it (enter number)? 1. morning 2. afternoon 3. evening 4. night\n")
    try:
        parsed_time = int(time_pref)
        if(parsed_time <=0 or parsed_time > len(time_features)):
            raise IndexError
        time_of_day = time_features[parsed_time-1]
    except (ValueError, IndexError):
        print("Entered value is invalid. Setting feature value to", time_features[0] + ".")
        time_of_day = time_features[0]

    device_features = ['mobile', 'tablet', 'desktop']
    device_pref = input("What type of device is the user on (enter number)? 1. mobile 2. tablet 3. desktop\n")
    try:
        parsed_device = int(device_pref)
        if(parsed_device <=0 or parsed_device > len(device_features)):
            raise IndexError
        device = device_features[parsed_device-1]
    except (ValueError, IndexError):
        print("Entered value is invalid. Setting feature value to", device_features[0]+ ".")
        device = device_features[0]

    return [
        {'time': time_of_day},
        {'device': device}
        ]

Ottenere gli slot

Gli slot costituiscono la pagina con cui l'utente interagirà. Personalizza esperienze deciderà quale azione visualizzare in ognuno degli slot definiti. Le azioni possono essere escluse da slot specifici, come ExcludeActions. BaselineAction è l'azione predefinita per lo slot che sarebbe stato visualizzato senza l'uso di Personalizza esperienze.

Questa guida introduttiva include funzionalità di slot semplici. Nei sistemi di produzione, determinare e valutarele funzionalità può essere una questione non semplice.

def get_slots():
    return [
        {
            "id": "BigHeroPosition",
            "features": [
                {
                    "size": "large",
                    "position": "left",
                }
            ],
            "excludedActions": ["31-Inch-Monitor-771"],
            "baselineAction": "Red-Polo-Shirt-432"
        },
        {
            "id": "SmallSidebar",
            "features": [
                {
                    "size": "small",
                    "position": "right",
                }
            ],
            "excludedActions": ["Tennis-Racket-133"],
            "baselineAction": "XBox-Series X-117"
        }
    ]

Effettuare richieste HTTP

Aggiungere queste funzioni per inviare richieste post all'endpoint di Personalizza esperienze per chiamate di classificazione e ricompensa multi-slot.

def send_multi_slot_rank(rank_request):
multi_slot_response = requests.post(MULTI_SLOT_RANK_URL, data=json.dumps(rank_request), headers=HEADERS)
if multi_slot_response.status_code != 201:
    raise Exception(multi_slot_response.text)
return json.loads(multi_slot_response.text)

def send_multi_slot_reward(reward_request, event_id):
    reward_url = '{0}{1}/reward'.format(MULTI_SLOT_REWARD_URL_BASE, event_id)
    requests.post(reward_url, data=json.dumps(reward_request), headers=HEADERS)

Ottenere commenti e suggerimenti per le decisioni di Personalizza esperienze

Aggiungere il metodo seguente allo script. Si segnalerà se Personalizza esperienze ha preso una buona decisione per ogni slot tramite prompt della riga di comando.

def get_reward_for_slot():
    answer = input('\nIs this correct? (y/n)\n').upper()
    if (answer == 'Y'):
        print('\nGreat! The application will send Personalizer a reward of 1 so it learns from this choice of action for this slot.\n')
        return 1
    elif (answer == 'N'):
        print('\nYou didn\'t like the recommended item.The application will send Personalizer a reward of 0 for this choice of action for this slot.\n')
        return 0
    print('\nEntered choice is invalid. Service assumes that you didn\'t like the recommended item.\n')
    return 0

Creare il ciclo di apprendimento

Il ciclo di apprendimento di Personalizza esperienze è un ciclo di chiamate Rank e Reward. In questo argomento di avvio rapido ogni chiamata Rank per personalizzare il contenuto è seguita da una chiamata Reward per indicare a Personalizza esperienze il livello di prestazioni del servizio.

Il codice seguente scorre un ciclo di richiesta all'utente delle proprie preferenze tramite la riga di comando, inviando tali informazioni a Personalizza esperienze per selezionare l'azione migliore per ogni slot, presentando la selezione al cliente da scegliere tra l'elenco, quindi inviando un punteggio di ricompensa a Personalizza esperienze segnalando quanto sia stato eseguito il servizio nella selezione.

run_loop = True

while run_loop:

    eventId = str(uuid.uuid4())
    context = get_context_features()
    actions = get_actions()
    slots = get_slots()

    rank_request = {
        "eventId": eventId,
        "contextFeatures": context,
        "actions": actions,
        "slots": slots,
        "deferActivation": False
      }

    #Rank the actions for each slot
    multi_slot_rank_response = send_multi_slot_rank(rank_request)
    multi_slot_rewards = {"reward": []}

    for i in range(len(multi_slot_rank_response['slots'])):
        print('\nPersonalizer service decided you should display: {0} in slot {1}\n'.format(multi_slot_rank_response['slots'][i]['rewardActionId'], multi_slot_rank_response['slots'][i]['id']))

        slot_reward = {'slotId': multi_slot_rank_response['slots'][i]['id']}
        # User agrees or disagrees with Personalizer decision for slot
        slot_reward['value'] = get_reward_for_slot()
        multi_slot_rewards['reward'].append(slot_reward)

    # Send the rewards for the event
    send_multi_slot_reward(multi_slot_rewards, multi_slot_rank_response['eventId'])

    answer = input('\nPress q to break, any other key to continue:\n').upper()
    if (answer == 'Q'):
        run_loop = False

Nelle sezioni seguenti verranno esaminate più in dettaglio le chiamate rank e reward.

Aggiungere i metodi seguenti, che ottengono le scelte di contenuto, ottengono le preferenze utente per il contesto, ottengono gli slot, Effettua richieste HTTP, Ottieni ricompensa per ogni slot prima di eseguire il file di codice:

  • get_actions
  • get_context_features
  • get_slots
  • send_rank
  • send_reward
  • get_reward_for_dsot

Richiedere l'azione migliore

Per completare la richiesta Rank, il programma chiede le preferenze dell'utente per creare scelte di contenuto. Il corpo della richiesta contiene il contesto, le azioni e gli slot con le rispettive funzionalità. Il send_multi_slot_rank metodo accetta rankRequest ed esegue la richiesta di classificazione a più slot.

Questa guida introduttiva include semplici funzionalità di contesto dell'ora del giorno e del dispositivo utente. Nei sistemi di produzione, determinare e valutareazioni e funzionalità può non essere altrettanto semplice.

eventId = str(uuid.uuid4())
context = get_context_features()
actions = get_actions()
slots = get_slots()

rank_request = {
    "eventId": eventId,
    "contextFeatures": context,
    "actions": actions,
    "slots": slots,
    "deferActivation": False
    }

#Rank the actions for each slot
multi_slot_rank_response = send_multi_slot_rank(rank_request)

Inviare una ricompensa

Per ottenere il punteggio di ricompensa per la richiesta di ricompensa, il programma ottiene la selezione dell'utente per ogni slot tramite la riga di comando, assegna un valore numerico (punteggio di ricompensa) alla selezione, quindi invia l'ID evento univoco, l'ID slot e il punteggio di ricompensa per ogni slot al send_multi_slot_reward metodo. Non è necessario definire una ricompensa per ogni slot.

Questo argomento di avvio rapido assegna un numero semplice come punteggio di ricompensa, ovvero 0 o 1. Nei sistemi di produzione, determinare quando e cosa inviare alla chiamata Reward può essere un'operazione non banale, a seconda delle esigenze specifiche.

multi_slot_rewards = {"reward": []}

for i in range(len(multi_slot_rank_response['slots'])):
    print('\nPersonalizer service decided you should display: {0} in slot {1}\n'.format(multi_slot_rank_response['slots'][i]['rewardActionId'], multi_slot_rank_response['slots'][i]['id']))

    slot_reward = {'slotId': multi_slot_rank_response['slots'][i]['id']}
    # User agrees or disagrees with Personalizer decision for slot
    slot_reward['value'] = get_reward_for_slot()
    multi_slot_rewards['reward'].append(slot_reward)

# Send the rewards for the event
send_multi_slot_reward(multi_slot_rewards, multi_slot_rank_response['eventId'])

Eseguire il programma

Eseguire l'applicazione con Python dalla directory dell'applicazione.

python sample.py

The quickstart program asks a couple of questions to gather user preferences, known as features, then provides the top action.

Per questo argomento di avvio rapido, è disponibile il codice sorgente.

Passaggi successivi