Erste Schritte mit mehreren Slots für die Azure KI Personalisierung

Referenzdokumentation | Bibliotheksquellcode | Paket (NuGet) | Multi-Slot-Konzept | Beispiele

Voraussetzungen

• Azure-Abonnement – Erstellen eines kostenlosen Kontos
• Aktuelle Version von .NET Core.
• Sobald Sie über Ihr Azure-Abonnement verfügen, sollten Sie im Azure-Portal eine Personalisierung-Ressource erstellen, um Ihren Schlüssel und Endpunkt abzurufen. Wählen Sie nach Abschluss der Bereitstellung Zu Ressource wechseln aus.
  • Sie benötigen den Schlüssel und Endpunkt der von Ihnen erstellten Ressource, um Ihre Anwendung mit der Personalisierungs-API zu verbinden. Der Schlüssel und der Endpunkt werden weiter unten in der Schnellstartanleitung in den Code eingefügt.
  • Sie können den kostenlosen Tarif (F0) verwenden, um den Dienst zu testen, und später für die Produktion auf einen kostenpflichtigen Tarif upgraden.

Einrichten

Upgraden der Instanz für die Personalisierung zur Verwendung mehrerer Slots

1. Deaktivieren der automatischen Optimierung im Microsoft Azure-Portal. Deaktivieren Sie in der Ressource „Personalisierung“ unter Ressourcenverwaltung auf der Seite Modell- und Lerneinstellungen die automatische Optimierung und speichern Sie.

2. Aktualisieren Sie die Personalisierung auf mehrere Slots: Wählen Sie im Azure-Portal für die Ressource „Personalisierung“ in der Ressourcenverwaltung auf der Seite Modell- und Lerneinstellungen die Option Lerneinstellungen exportieren aus. Das Argumentfeld in der heruntergeladenen JSON-Datei beginnt mit --cb_explore_adf. Ändern Sie dies in --ccb_explore_adf und speichern Sie die Datei. CB (kontextbezogene Banditen) und CCB (bedingt kontextbezogene Banditen) sind die Algorithmen, die von der Personalisierung für Vorgänge mit einem Slot bzw. mehreren Slots verwendet werden. ADF (Aktionsabhängige Funktionen) bedeutet, dass die Aktionen mit Funktionen ausgedrückt/identifiziert werden.

Navigieren Sie auf der gleichen Registerkarte im Portal unter Lerneinstellungen importieren zu Ihrer zuletzt geänderten JSON-Datei, und laden Sie die Datei hoch. Durch diesen Vorgang wird Ihre Personalisierungsinstanz für die Unterstützung mehrerer Slots aktualisiert, sodass ab diesem Zeitpunkt das Einstufen von Aufrufen nach Rangfolge und Relevanz mit mehreren Slots unterstützt wird.

Ändern der Häufigkeit der Modellaktualisierung

Wechseln Sie im Azure-Portal zur Seite Konfiguration Ihrer Personalisierungsressource, und ändern Sie Häufigkeit der Modellaktualisierung auf 30 Sekunden. Mit dieser kurzen Dauer wird das Modell schnell trainiert, und Sie können sehen, wie sich die empfohlene Aktion für jede Iteration ändert.

Ändern der Belohnungswartezeit

Wechseln Sie im Azure-Portal zur Seite Konfiguration Ihrer Personalisierungsressource, und ändern Sie die Belohnungswartezeit in 10 Minuten. Dadurch wird bestimmt, wie lange das Modell nach dem Senden einer Empfehlung wartet, um das Belohnungsfeedback für diese Empfehlung zu erhalten. Das Training findet erst statt, wenn die Belohnungswartezeit verstrichen ist.

Erstellen einer neuen C#-Anwendung

Erstellen Sie eine neue .NET Core-Anwendung in Ihrem bevorzugten Editor oder Ihrer bevorzugten IDE.

Verwenden Sie in einem Konsolenfenster (z. B. cmd, PowerShell oder Bash) den Befehl dotnet new zum Erstellen einer neuen Konsolen-App mit dem Namen personalizer-quickstart. Dieser Befehl erstellt ein einfaches „Hallo Welt“-C#-Projekt mit einer einzigen Quelldatei: Program.cs.

dotnet new console -n personalizer-quickstart

Wechseln Sie zum Ordner der neu erstellten App. Sie können die Anwendung mit folgendem Befehl erstellen:

dotnet build

Die Buildausgabe sollte keine Warnungen oder Fehler enthalten.

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

Installieren der Clientbibliothek

Installieren Sie im Anwendungsverzeichnis mit dem folgenden Befehl die Personalisierungsclientbibliothek für .NET:

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

Öffnen Sie über das Projektverzeichnis die Datei Program.cs in Ihrem bevorzugten Editor oder in Ihrer bevorzugten IDE. Fügen Sie die folgenden using-Direktiven hinzu:

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

Objektmodell

Der Personalisierungsclient ist ein Objekt vom Typ PersonalizerClient, das mithilfe der Klasse Azure.AzureKeyCredential, die Ihren Schlüssel enthält, bei Azure authentifiziert wird.

Um das beste Element des Inhalts für jeden Slot abzufragen, müssen Sie ein PersonalizerRankMultiSlotOptions-Objekt erstellen und es dann an PersonalizerClient.RankMultiSlot übergeben. Die RankMultiSlot-Methode gibt ein PersonalizerMultiSlotRankResult zurück.

Um eine Relevanzbewertung an Personalizer zu senden, erstellen Sie PersonalizerRewardMultiSlotOptions, was Sie dann zusammen mit der entsprechenden Ereignis-ID an die PersonalizerClient.RewardsMultiSlot-Methode übergeben.

Im Rahmen dieser Schnellstartanleitung ist die Relevanzbewertung ganz einfach. In einem Produktionssystem kann die Bestimmung der Einflussfaktoren für die Relevanzbewertung sowie deren jeweilige Gewichtung allerdings eine komplexe Angelegenheit sein und muss unter Umständen im Laufe der Zeit überarbeitet werden. Diese Entwurfsentscheidung sollte eine der wichtigsten Entscheidungen im Zusammenhang mit Ihrer Personalisierungsarchitektur sein.

Codebeispiele

In diesen Codeausschnitten werden folgende Aufgaben mit der Personalisierungsclientbibliothek für .NET veranschaulicht:

• Erstellen eines Personalisierungsclients
• Rangfolge-API mit mehreren Slots
• Belohnungs-API mit mehreren Slots

Authentifizieren des Clients

In diesem Abschnitt führen Sie zwei Aktionen aus:

• Angeben Ihres Schlüssels und Endpunkts
• Erstellen eines Personalisierungsclients

Fügen Sie zunächst der Program-Klasse die unten angegebenen Zeilen hinzu. Fügen Sie unbedingt den Schlüssel und Endpunkt Ihrer Personalisierungsressource hinzu.

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

Erstellen Sie als Nächstes die Rangfolge- und Belohnungs-URLs.

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

Abrufen von Inhaltsoptionen, dargestellt als Aktionen

Aktionen stellen die Inhaltsoptionen dar, aus denen die Personalisierung das beste Inhaltselement auswählen soll. Fügen Sie der Klasse „Program“ die folgenden Methoden hinzu, um die Gruppe der Aktionen und deren Features darzustellen.

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

Slots abrufen

Slots machen die Seite aus, mit der der Benutzer interagiert. Personalizer entscheidet, welche Aktion in jedem der definierten Slots angezeigt werden soll. Aktionen können aus bestimmten Slots ausgeschlossen werden, die als ExcludeActions angezeigt werden. BaselineAction ist die Standardaktion für den Slot, die ohne die Verwendung der Personalisierung angezeigt worden wäre.

Diese Schnellstartanleitung enthält einfache Slotfeatures. In Produktionssystemen kann die Bestimmung und Auswertung von Merkmalen allerdings eine komplexe Angelegenheit sein.

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

Abrufen von Benutzerwünschen für den Kontext

Fügen Sie der Program-Klasse die folgenden Methoden hinzu, um die Eingabe eines Benutzers über die Befehlszeile für die Tageszeit und den Gerätetyp des Benutzers zu erhalten. Diese Methoden werden als Kontextfeatures verwendet.

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

Bei beiden Methoden wird die Methode GetKey verwendet, um die Auswahl des Benutzers aus der Befehlszeile zu lesen.

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

Erstellen der Lernschleife

Die Lernschleife der Personalisierung ist ein Zyklus aus RankMultiSlot- und RewardMultiSlot-Aufrufen. In dieser Schnellstartanleitung folgt auf jeden Rangfolgeaufruf zur Personalisierung des Inhalts ein Relevanzaufruf, um der Personalisierung mitzuteilen, wie gut der Dienst abgeschnitten hat.

Der folgende Code durchläuft einen Zyklus durch eine Schleife: Der Benutzer wird an der Befehlszeile nach seinen Präferenzen befragt, die Angaben werden zur Wahl der besten Aktion für jeden Slot an die Personalisierung gesendet, die Auswahl wird dem Kunden in einer Auswahlliste angezeigt, und anschließend wird eine Relevanzbewertung an die Personalisierung gesendet, die angibt, wie gut die Wahl des Diensts war.

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

Sehen Sie sich die Rangfolge- und Relevanzaufrufe in den folgenden Abschnitten genauer an. Fügen Sie die folgenden Methoden hinzu, die die Inhaltsauswahl abrufen, Slots abrufen und Rangfolge- und Belohnungsanforderungen mit mehreren Slots senden, bevor die Codedatei ausgeführt wird:

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

Anfordern der besten Aktion

Für die Rangfolgeanforderung erfragt das Programm die Präferenzen des Benutzers, um für die Inhaltsoptionen ein Element vom Typ Context zu erstellen. Die Anforderung enthält den Kontext, die Aktionen und Slots mit ihren entsprechenden Features sowie eine eindeutige Ereignis-ID, um die Antwort zu empfangen.

In dieser Schnellstartanleitung werden die einfachen Kontextmerkmale „Tageszeit“ und „Gerätewunsch des Benutzers“ verwendet. In Produktionssystemen kann die Bestimmung und Auswertung von Aktionen und Merkmalen allerdings eine komplexe Angelegenheit sein.

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

Senden einer Relevanz

Um die Relevanzbewertung für die Relevanzanforderung zu erhalten, ruft das Programm die Auswahl des Benutzers für jeden Slot über die Befehlszeile ab, weist der Auswahl einen numerischen Wert (Relevanzbewertung) zu und sendet dann die eindeutige Ereignis-ID, Slot-ID und die Relevanzbewertung für jeden Slot als numerischen Wert an die Relevanz-API. Eine Relevanz muss nicht für jeden Slot definiert werden.

In dieser Schnellstartanleitung wird als Relevanzbewertung eine einfache Zahl (0 oder 1) zugewiesen. In Produktionssystemen ist die Entscheidung, was wann an den Relevanzaufruf gesendet werden soll (abhängig von Ihren spezifischen Anforderungen), unter Umständen etwas komplizierter.

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

Ausführen des Programms

Führen Sie die Anwendung mit dem Befehl dotnet run über das Anwendungsverzeichnis aus.

dotnet run

Der Quellcode für diese Schnellstartanleitung ist verfügbar.

Referenzdokumentation | Multi-Slot-Konzept | Beispiele

Voraussetzungen

• Azure-Abonnement – Erstellen eines kostenlosen Kontos
• Installieren von Node.js und NPM (überprüft mit Node.js v14.16.0 und NPM 6.14.11).
• Sobald Sie über Ihr Azure-Abonnement verfügen, sollten Sie im Azure-Portal eine Personalisierung-Ressource erstellen, um Ihren Schlüssel und Endpunkt abzurufen. Wählen Sie nach Abschluss der Bereitstellung Zu Ressource wechseln aus.
  • Sie benötigen den Schlüssel und Endpunkt der von Ihnen erstellten Ressource, um Ihre Anwendung mit der Personalisierungs-API zu verbinden. Der Schlüssel und der Endpunkt werden weiter unten in der Schnellstartanleitung in den Code eingefügt.
  • Sie können den kostenlosen Tarif (F0) verwenden, um den Dienst zu testen, und später für die Produktion auf einen kostenpflichtigen Tarif upgraden.

Einrichten

Upgraden der Instanz für die Personalisierung zur Verwendung mehrerer Slots

1. Deaktivieren der automatischen Optimierung im Microsoft Azure-Portal. Deaktivieren Sie in der Ressource „Personalisierung“ unter Ressourcenverwaltung auf der Seite Modell- und Lerneinstellungen die automatische Optimierung und speichern Sie.

2. Aktualisieren Sie die Personalisierung auf mehrere Slots: Wählen Sie im Azure-Portal für die Ressource „Personalisierung“ in der Ressourcenverwaltung auf der Seite Modell- und Lerneinstellungen die Option Lerneinstellungen exportieren aus. Das Argumentfeld in der heruntergeladenen JSON-Datei beginnt mit --cb_explore_adf. Ändern Sie dies in --ccb_explore_adf und speichern Sie die Datei. CB (kontextbezogene Banditen) und CCB (bedingt kontextbezogene Banditen) sind die Algorithmen, die von der Personalisierung für Vorgänge mit einem Slot bzw. mehreren Slots verwendet werden. ADF (Aktionsabhängige Funktionen) bedeutet, dass die Aktionen mit Funktionen ausgedrückt/identifiziert werden.

Navigieren Sie auf der gleichen Registerkarte im Portal unter Lerneinstellungen importieren zu Ihrer zuletzt geänderten JSON-Datei, und laden Sie die Datei hoch. Durch diesen Vorgang wird Ihre Personalisierungsinstanz für die Unterstützung mehrerer Slots aktualisiert, sodass ab diesem Zeitpunkt das Einstufen von Aufrufen nach Rangfolge und Relevanz mit mehreren Slots unterstützt wird.

Ändern der Häufigkeit der Modellaktualisierung

Wechseln Sie im Azure-Portal zur Seite Konfiguration Ihrer Personalisierungsressource, und ändern Sie Häufigkeit der Modellaktualisierung auf 30 Sekunden. Mit dieser kurzen Dauer wird das Modell schnell trainiert, und Sie können sehen, wie sich die empfohlene Aktion für jede Iteration ändert.

Ändern der Belohnungswartezeit

Wechseln Sie im Azure-Portal zur Seite Konfiguration Ihrer Personalisierungsressource, und ändern Sie die Belohnungswartezeit in 10 Minuten. Dadurch wird bestimmt, wie lange das Modell nach dem Senden einer Empfehlung wartet, um das Belohnungsfeedback für diese Empfehlung zu erhalten. Das Training findet erst statt, wenn die Belohnungswartezeit verstrichen ist.

Erstellen einer neuen Node.js-Anwendung

Erstellen Sie in einem Konsolenfenster (etwa cmd, PowerShell oder Bash) ein neues Verzeichnis für Ihre App, und rufen Sie es auf.

mkdir myapp && cd myapp

Führen Sie den Befehl npm init -y aus, um die Datei package.json zu erstellen.

npm init -y

Erstellen Sie in Ihrem bevorzugten Editor oder Ihrer bevorzugten IDE eine neue Node.js-Anwendung mit dem Namen sample.js sowie Variablen für den Endpunkt und Abonnementschlüssel Ihrer Ressource.

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>';

Installieren der NPM-Pakete für den Schnellstart

npm install readline-sync uuid axios --save

Objektmodell

Um das beste Element des Inhalts für jeden Slot zu erfragen, erstellen Sie eine rankRequest und senden Sie dann eine Postanforderung an multislot/rank. Die Antwort wird dann in eine rankResponse analysiert.

Um eine Relevanzbewertung an den Personalizer zu senden, erstellen Sie eine rewards und senden dann eine Postanforderung an multislot/events/{eventId}/reward.

Im Rahmen dieser Schnellstartanleitung ist die Bestimmung der Relevanzbewertung ganz einfach. In einem Produktionssystem kann die Bestimmung der Einflussfaktoren für die Relevanzbewertung sowie deren jeweilige Gewichtung allerdings eine komplexe Angelegenheit sein und muss unter Umständen im Laufe der Zeit überarbeitet werden. Diese Entwurfsentscheidung sollte eine der wichtigsten Entscheidungen im Zusammenhang mit Ihrer Personalisierungsarchitektur sein.

Codebeispiele

In diesen Codeausschnitten wird gezeigt, wie Sie die folgenden Aufgaben ausführen, indem Sie HTTP-Anforderungen für NodeJS senden:

• Erstellen von Basis-URLs
• Rangfolge-API
• Relevanz-API

Erstellen von Basis-URLs

In diesem Abschnitt erstellen Sie die Rangfolge-/Relevanz-URLs mithilfe der Basis-URL und die Anforderungsheader mithilfe des Ressourcenschlüssels.

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

Abrufen von Inhaltsoptionen, dargestellt als Aktionen

Aktionen stellen die Inhaltsoptionen dar, aus denen die Personalisierung das beste Inhaltselement auswählen soll. Fügen Sie dem Skript die folgenden Methoden hinzu, um die Gruppe der Aktionen und deren Features darzustellen.

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

Abrufen von Benutzerwünschen für den Kontext

Fügen Sie dem Skript die folgenden Methoden hinzu, um die Eingabe eines Benutzers über die Befehlszeile für die Tageszeit und den Gerätetyp des Benutzers zu erhalten. Diese werden als Kontextfeatures verwendet.

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

Slots abrufen

Slots machen die Seite aus, mit der der Benutzer interagiert. Personalizer entscheidet, welche Aktion in jedem der definierten Slots angezeigt werden soll. Aktionen können aus bestimmten Slots ausgeschlossen werden, die als ExcludeActions angezeigt werden. BaselineAction ist die Standardaktion für den Slot, die ohne die Verwendung von Personalizer angezeigt worden wäre.

Diese Schnellstartanleitung enthält einfache Slotfeatures. In Produktionssystemen kann die Bestimmung und Auswertung von Merkmalen allerdings eine komplexe Angelegenheit sein.

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

Übermitteln von HTTP-Anforderungen

Fügen Sie diese Funktionen hinzu, um Postanforderungen für Rangfolge- und Relevanzaufrufe mit mehreren Slots an den Personalizer-Endpunkt zu senden.

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

Feedback zu Personalizer-Entscheidungen

Fügen Sie dem Skript die folgende Methode hinzu. Sie signalisieren, ob Personalizer über die Befehlszeileneingabeaufforderung eine gute Entscheidung für jeden Slot getroffen hat.

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

Erstellen der Lernschleife

Die Lernschleife der Personalisierung ist ein Zyklus aus Rangfolge- und Relevanzaufrufen. In dieser Schnellstartanleitung folgt auf jeden Rangfolgeaufruf zur Personalisierung des Inhalts ein Relevanzaufruf, um der Personalisierung mitzuteilen, wie gut der Dienst abgeschnitten hat.

Der folgende Code durchläuft einen Zyklus durch eine Schleife: Der Benutzer wird an der Befehlszeile nach seinen Präferenzen befragt, die Angaben werden zur Wahl der besten Aktion für jeden Slot an die Personalisierung gesendet, die Auswahl wird dem Kunden in einer Auswahlliste angezeigt, und anschließend wird eine Relevanzbewertung an die Personalisierung gesendet, die angibt, wie gut die Wahl des Diensts war.

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

Sehen Sie sich die Rangfolge- und Relevanzaufrufe in den folgenden Abschnitten genauer an.

Fügen Sie die folgenden Methoden hinzu, die die Inhaltsauswahl abrufen, die Benutzereinstellungen für den Kontext abrufen, die Slots abrufen, HTTP-Anforderungen stellen und Belohnung für jeden Slot abrufen, bevor Sie die Codedatei ausführen:

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

Anfordern der besten Aktion

Für die Rangfolgeanforderung erfragt das Programm die Präferenzen des Benutzers, um Inhaltsoptionen zu erstellen. Der Anforderungstext enthält den Ausführungskontext, Aktionen und Slots mit ihren jeweiligen Funktionen. Die sendMultiSlotRank-Methode verarbeitet einen rankRequest und führt die Rangfolgeanforderung mit mehreren Slots aus.

In dieser Schnellstartanleitung werden die einfachen Kontextmerkmale „Tageszeit“ und „Gerätewunsch des Benutzers“ verwendet. In Produktionssystemen kann die Bestimmung und Auswertung von Aktionen und Merkmalen allerdings eine komplexe Angelegenheit sein.

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

Senden einer Relevanz

Um die Relevanzbewertung für die Relevanzanforderung zu erhalten, ruft das Programm die Auswahl des Benutzers für jeden Slot über die Befehlszeile ab, weist der Auswahl einen numerischen Wert zu und sendet dann die eindeutige Ereignis-ID, Slot-ID und die Relevanzbewertung für jeden Slot an die sendMultiSlotReward-Methode. Eine Belohnung muss nicht für jeden Slot definiert werden.

In dieser Schnellstartanleitung wird als Relevanzbewertung eine einfache Zahl (0 oder 1) zugewiesen. In Produktionssystemen ist die Entscheidung, was wann an den Relevanzaufruf gesendet werden soll (abhängig von Ihren spezifischen Anforderungen), unter Umständen etwas komplizierter.

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

Ausführen des Programms

Führen Sie die Anwendung mit dem Node.js-Beispiel aus dem Anwendungsverzeichnis aus.

node sample.js

Der Quellcode für diese Schnellstartanleitung ist verfügbar.

Multi-Slot-Konzepte | Beispiele

Voraussetzungen

• Azure-Abonnement – Erstellen eines kostenlosen Kontos
• Python 3.x
• Sobald Sie über Ihr Azure-Abonnement verfügen, sollten Sie im Azure-Portal eine Personalisierung-Ressource erstellen, um Ihren Schlüssel und Endpunkt abzurufen. Wählen Sie nach Abschluss der Bereitstellung Zu Ressource wechseln aus.
  • Sie benötigen den Schlüssel und Endpunkt der von Ihnen erstellten Ressource, um Ihre Anwendung mit der Personalisierungs-API zu verbinden. Der Schlüssel und der Endpunkt werden weiter unten in der Schnellstartanleitung in den Code eingefügt.
  • Sie können den kostenlosen Tarif (F0) verwenden, um den Dienst zu testen, und später für die Produktion auf einen kostenpflichtigen Tarif upgraden.

Einrichten

Upgraden der Instanz für die Personalisierung zur Verwendung mehrerer Slots

1. Deaktivieren der automatischen Optimierung im Microsoft Azure-Portal. Deaktivieren Sie in der Ressource „Personalisierung“ unter Ressourcenverwaltung auf der Seite Modell- und Lerneinstellungen die automatische Optimierung und speichern Sie.

2. Aktualisieren Sie die Personalisierung auf mehrere Slots: Wählen Sie im Azure-Portal für die Ressource „Personalisierung“ in der Ressourcenverwaltung auf der Seite Modell- und Lerneinstellungen die Option Lerneinstellungen exportieren aus. Das Argumentfeld in der heruntergeladenen JSON-Datei beginnt mit --cb_explore_adf. Ändern Sie dies in --ccb_explore_adf und speichern Sie die Datei. CB (kontextbezogene Banditen) und CCB (bedingt kontextbezogene Banditen) sind die Algorithmen, die von der Personalisierung für Vorgänge mit einem Slot bzw. mehreren Slots verwendet werden. ADF (Aktionsabhängige Funktionen) bedeutet, dass die Aktionen mit Funktionen ausgedrückt/identifiziert werden.

Navigieren Sie auf der gleichen Registerkarte im Portal unter Lerneinstellungen importieren zu Ihrer zuletzt geänderten JSON-Datei, und laden Sie die Datei hoch. Durch diesen Vorgang wird Ihre Personalisierungsinstanz für die Unterstützung mehrerer Slots aktualisiert, sodass ab diesem Zeitpunkt das Einstufen von Aufrufen nach Rangfolge und Relevanz mit mehreren Slots unterstützt wird.

Ändern der Häufigkeit der Modellaktualisierung

Wechseln Sie im Azure-Portal zur Seite Konfiguration Ihrer Personalisierungsressource, und ändern Sie Häufigkeit der Modellaktualisierung auf 30 Sekunden. Mit dieser kurzen Dauer wird das Modell schnell trainiert, und Sie können sehen, wie sich die empfohlene Aktion für jede Iteration ändert.

Ändern der Belohnungswartezeit

Wechseln Sie im Azure-Portal zur Seite Konfiguration Ihrer Personalisierungsressource, und ändern Sie die Belohnungswartezeit in 10 Minuten. Dadurch wird bestimmt, wie lange das Modell nach dem Senden einer Empfehlung wartet, um das Belohnungsfeedback für diese Empfehlung zu erhalten. Das Training findet erst statt, wenn die Belohnungswartezeit verstrichen ist.

Erstellen einer neuen Python-Anwendung

Erstellen Sie eine neue Python-Datei sowie Variablen für den Endpunkt und den Abonnementschlüssel Ihrer Ressource.

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

Objektmodell

Um das beste Element des Inhalts für jeden Slot zu erfragen, erstellen Sie eine rank_request und senden Sie dann eine Postanforderung an multislot/rank. Die Antwort wird dann in eine rank_response analysiert.

Um eine Relevanzbewertung an den Personalizer zu senden, erstellen Sie eine rewards und senden dann eine Postanforderung an multislot/events/{eventId}/reward.

In dieser Schnellstartanleitung ist die Bestimmung der Relevanzbewertung ganz einfach. In einem Produktionssystem kann die Bestimmung der Einflussfaktoren für die Relevanzbewertung sowie deren jeweilige Gewichtung allerdings eine komplexe Angelegenheit sein und muss unter Umständen im Laufe der Zeit überarbeitet werden. Diese Entwurfsentscheidung sollte eine der wichtigsten Entscheidungen im Zusammenhang mit Ihrer Personalisierungsarchitektur sein.

Codebeispiele

In diesen Codeausschnitten wird gezeigt, wie Sie die folgenden Aufgaben ausführen, indem Sie HTTP-Anforderungen für Python senden:

• Erstellen von Basis-URLs
• Rangfolge-API
• Relevanz-API

Erstellen von Basis-URLs

In diesem Abschnitt erstellen Sie die Rangfolge-/Relevanz-URLs mithilfe der Basis-URL und die Anforderungsheader mithilfe des Ressourcenschlüssels.

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

Abrufen von Inhaltsoptionen, dargestellt als Aktionen

Aktionen stellen die Inhaltsoptionen dar, aus denen die Personalisierung das beste Inhaltselement auswählen soll. Fügen Sie dem Skript die folgenden Methoden hinzu, um die Gruppe der Aktionen und deren Features darzustellen.

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

Abrufen von Benutzerwünschen für den Kontext

Fügen Sie dem Skript die folgenden Methoden hinzu, um die Eingabe eines Benutzers über die Befehlszeile für die Tageszeit und den Gerätetyp des Benutzers zu erhalten. Diese werden als Kontextfeatures verwendet.

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

Slots abrufen

Slots machen die Seite aus, mit der der Benutzer interagiert. Personalizer entscheidet, welche Aktion in jedem der definierten Slots angezeigt werden soll. Aktionen können aus bestimmten Slots ausgeschlossen werden, die als ExcludeActions angezeigt werden. BaselineAction ist die Standardaktion für den Slot, die ohne die Verwendung von Personalizer angezeigt worden wäre.

Diese Schnellstartanleitung enthält einfache Slotfeatures. In Produktionssystemen kann die Bestimmung und Auswertung von Merkmalen allerdings eine komplexe Angelegenheit sein.

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

Übermitteln von HTTP-Anforderungen

Fügen Sie diese Funktionen hinzu, um Postanforderungen für Rangfolge- und Relevanzaufrufe mit mehreren Slots an den Personalizer-Endpunkt zu senden.

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)

Feedback zu Personalizer-Entscheidungen

Fügen Sie dem Skript die folgende Methode hinzu. Sie signalisieren, ob Personalizer über die Befehlszeileneingabeaufforderung eine gute Entscheidung für jeden Slot getroffen hat.

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

Erstellen der Lernschleife

Die Lernschleife der Personalisierung ist ein Zyklus aus Rangfolge- und Relevanzaufrufen. In dieser Schnellstartanleitung folgt auf jeden Rangfolgeaufruf zur Personalisierung des Inhalts ein Relevanzaufruf, um der Personalisierung mitzuteilen, wie gut der Dienst abgeschnitten hat.

Der folgende Code durchläuft einen Zyklus durch eine Schleife: Der Benutzer wird an der Befehlszeile nach seinen Präferenzen befragt, die Angaben werden zur Wahl der besten Aktion für jeden Slot an die Personalisierung gesendet, die Auswahl wird dem Kunden in einer Auswahlliste angezeigt, und anschließend wird eine Relevanzbewertung an die Personalisierung gesendet, die angibt, wie gut die Wahl des Diensts war.

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

Sehen Sie sich die Rangfolge- und Relevanzaufrufe in den folgenden Abschnitten genauer an.

Fügen Sie die folgenden Methoden hinzu, die die Inhaltsauswahl abrufen, die Benutzereinstellungen für den Kontext abrufen, die Slots abrufen, HTTP-Anforderungen stellen und Belohnung für jeden Slot abrufen, bevor Sie die Codedatei ausführen:

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

Anfordern der besten Aktion

Für die Rangfolgeanforderung erfragt das Programm die Präferenzen des Benutzers, um Inhaltsoptionen zu erstellen. Der Anforderungstext enthält den Ausführungskontext, Aktionen und Slots mit ihren jeweiligen Funktionen. Die send_multi_slot_rank-Methode verarbeitet einen rankRequest und führt die Rangfolgeanforderung mit mehreren Slots aus.

In dieser Schnellstartanleitung werden die einfachen Kontextmerkmale „Tageszeit“ und „Gerätewunsch des Benutzers“ verwendet. In Produktionssystemen kann die Bestimmung und Auswertung von Aktionen und Merkmalen allerdings eine komplexe Angelegenheit sein.

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)

Senden einer Relevanz

Um die Relevanzbewertung für die Relevanzanforderung zu erhalten, ruft das Programm die Auswahl des Benutzers für jeden Slot über die Befehlszeile ab, weist der Auswahl einen numerischen Wert zu und sendet dann die eindeutige Ereignis-ID, Slot-ID und die Relevanzbewertung für jeden Slot an die send_multi_slot_reward-Methode. Eine Belohnung muss nicht für jeden Slot definiert werden.

In dieser Schnellstartanleitung wird als Relevanzbewertung eine einfache Zahl (0 oder 1) zugewiesen. In Produktionssystemen ist die Entscheidung, was wann an den Relevanzaufruf gesendet werden soll (abhängig von Ihren spezifischen Anforderungen), unter Umständen etwas komplizierter.

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'])

Ausführen des Programms

Führen Sie die Anwendung mit dem Python-Beispiel aus dem Anwendungsverzeichnis aus.

python sample.py

Der Quellcode für diese Schnellstartanleitung ist verfügbar.