Oktatóanyag: A Personalizer használata az Azure Notebookban

Fontos

2023. szeptember 20-tól nem hozhat létre új Personalizer-erőforrásokat. A Personalizer szolgáltatás 2026. október 1-jén megszűnik.

Ez az oktatóanyag egy Personalizer-ciklust futtat egy Azure Notebookban, amely bemutatja egy Personalizer-ciklus végpontok közötti életciklusát.

A hurok azt javasolja, hogy az ügyfél milyen típusú kávét rendeljen. A felhasználók és beállításaik egy felhasználói adatkészletben vannak tárolva. A kávéval kapcsolatos információkat egy kávéadatkészlet tárolja.

Felhasználók és kávé

A jegyzetfüzet, amely szimulálja a felhasználók webhelyekkel való interakcióját, kiválaszt egy véletlenszerű felhasználót, a nap időpontját és az adathalmaz időjárási típusát. A felhasználói adatok összegzése:

Ügyfelek – környezeti funkciók	Napszakok	Az időjárás típusai
Alice Bob Cathy Dave	Délelőtt Délután Este	Napos Esős Havas

A Personalizer megismerése érdekében a rendszer idővel az egyes személyek kávéválasztásának részleteit is ismeri.

Kávé – akciófunkciók	A hőmérséklet típusai	Származási helyek	A pörkölés típusai	Szerves
Cappacino	Gyakori	Kenya	Sötét	Szerves
Hideg sör	Ritka elérésű	Brazília	Alapszintű	Szerves
Jeges mokka	Ritka elérésű	Etiópia	Alapszintű	Nem organikus
Latte	Gyakori	Brazília	Sötét	Nem organikus

A Personalizer hurok célja , hogy a lehető legtöbb idő alatt megtalálja a legjobb egyezést a felhasználók és a kávé között.

Az oktatóanyag kódja a Personalizer Samples GitHub-adattárban érhető el.

A szimuláció működése

A futó rendszer elején a Personalizer javaslatai csak 20% és 30% között sikeresek. Ezt a sikert jelzi a Personalizer Reward API-nak visszaküldött jutalom 1 pontszámmal. Néhány Rang- és Reward-hívás után a rendszer javul.

A kezdeti kérések után futtasson offline értékelést. Ez lehetővé teszi, hogy a Personalizer áttekintse az adatokat, és jobb tanulási szabályzatot javasoljon. Alkalmazza az új tanulási szabályzatot, és futtassa újra a jegyzetfüzetet az előző kérések számának 20%-ával. A ciklus jobban fog teljesíteni az új tanulási szabályzattal.

Rang- és jutalomhívások

A Personalizer szolgáltatáshoz intézett néhány ezer hívás mindegyikéhez az Azure Notebook elküldi a Rangsor kérést a REST API-nak:

• A Rangsor/Kérés esemény egyedi azonosítója
• Környezeti funkciók – A felhasználó véletlenszerű választása, időjárás és napidő – a felhasználó szimulálása egy webhelyen vagy mobileszközön
• Funkciókkal kapcsolatos műveletek – Minden kávéadat – amelyből a Personalizer javaslatot tesz

A rendszer megkapja a kérést, majd összehasonlítja ezt az előrejelzést a felhasználó által az adott nap és időjárás által ismert választással. Ha az ismert választás megegyezik az előrejelzett választási lehetőségével, az 1 jutalom vissza lesz küldve a Personalizernek. Ellenkező esetben a visszaküldött jutalom 0.

Megjegyzés:

Ez egy szimuláció, így a jutalom algoritmusa egyszerű. Egy valós forgatókönyvben az algoritmusnak üzleti logikát kell használnia, esetleg súlyokkal az ügyfél tapasztalatának különböző aspektusaihoz, hogy meghatározza a jutalompontszámot.

Előfeltételek

• Egy Azure Notebook-fiók .
• Azure AI Personalizer-erőforrás.
  • Ha már használta a Personalizer erőforrást, törölje az adatokat az Azure Portalon az erőforráshoz.
• Töltse fel a mintához tartozó összes fájlt egy Azure Notebook-projektbe.

Fájlleírások:

• A Personalizer.ipynb az oktatóanyag Jupyter-jegyzetfüzete.
• A felhasználói adatkészlet egy JSON-objektumban van tárolva.
• A kávéadatkészlet egy JSON-objektumban van tárolva.
• A JSON-példakérés a Rank API-nak küldött POST-kérések várt formátuma.

Personalizer-erőforrás konfigurálása

Az Azure Portalon konfigurálja a Personalizer-erőforrást úgy, hogy a frissítési modell gyakorisága 15 másodperc, a jutalom várakozási ideje pedig 10 perc. Ezek az értékek a Konfiguráció lapon találhatók.

Beállítás	Value
modell gyakoriságának frissítése	15 másodperc
jutalom várakozási ideje	10 perc

Ezek az értékek nagyon rövid időtartamot tartalmaznak az oktatóanyag változásainak megjelenítéséhez. Ezeket az értékeket nem szabad éles környezetben használni anélkül, hogy érvényesítenék a célt a Personalizer-ciklussal.

Az Azure Notebook beállítása

1. Módosítsa a kernelt a következőre Python 3.6: .
2. Nyissa meg a Personalizer.ipynb fájlt.

Jegyzetfüzetcellák futtatása

Futtassa az egyes végrehajtható cellákat, és várja meg, amíg visszatér. Tudja, hogy ez akkor történik, ha a cella melletti zárójelek számokat jelenítenek meg ahelyett, hogy egy számot jelenítenek meg *. A következő szakaszok ismertetik, hogy az egyes cellák mit végeznek programozott módon, és mit várnak el a kimenettől.

A Python-modulok belefoglalása

Adja meg a szükséges Python-modulokat. A cellának nincs kimenete.

import json
import matplotlib.pyplot as plt
import random
import requests
import time
import uuid

A Personalizer erőforráskulcsának és nevének beállítása

Az Azure Portalon keresse meg a kulcsot és a végpontot a Personalizer-erőforrás rövid útmutató lapján. Módosítsa a Personalizer-erőforrás nevének értékét <your-resource-name> . Módosítsa a Personalizer-kulcs értékét <your-resource-key> .

# Replace 'personalization_base_url' and 'resource_key' with your valid endpoint values.
personalization_base_url = "https://<your-resource-name>.cognitiveservices.azure.com/"
resource_key = "<your-resource-key>"

Aktuális dátum és idő nyomtatása

Ezzel a függvénnyel jegyezheti fel az iteratív függvény, az iterációk kezdési és befejezési idejét.

Ezek a cellák nem rendelkeznek kimenettel. A függvény az aktuális dátumot és időpontot adja ki, amikor meghívják.

# Print out current datetime
def currentDateTime():
    currentDT = datetime.datetime.now()
    print (str(currentDT))

Az utolsó modellfrissítési idő lekérése

A függvény get_last_updatedmeghívásakor a függvény a modell frissítésének utolsó módosított dátumát és időpontját nyomtatja ki.

Ezek a cellák nem rendelkeznek kimenettel. A függvény meghívásakor a modell utolsó betanítási dátumát adja ki.

A függvény EGY GET REST API-t használ a modell tulajdonságainak lekéréséhez.

# ititialize variable for model's last modified date
modelLastModified = ""

def get_last_updated(currentModifiedDate):

    print('-----checking model')

    # get model properties
    response = requests.get(personalization_model_properties_url, headers = headers, params = None)

    print(response)
    print(response.json())

    # get lastModifiedTime
    lastModifiedTime = json.dumps(response.json()["lastModifiedTime"])

    if (currentModifiedDate != lastModifiedTime):
        currentModifiedDate = lastModifiedTime
        print(f'-----model updated: {lastModifiedTime}')

Szabályzat és szolgáltatáskonfiguráció lekérése

Ellenőrizze a szolgáltatás állapotát ezzel a két REST-hívással.

Ezek a cellák nem rendelkeznek kimenettel. A függvény meghívásakor a szolgáltatásértékeket adja ki.

def get_service_settings():

    print('-----checking service settings')

    # get learning policy
    response = requests.get(personalization_model_policy_url, headers = headers, params = None)

    print(response)
    print(response.json())

    # get service settings
    response = requests.get(personalization_service_configuration_url, headers = headers, params = None)

    print(response)
    print(response.json())

URL-címek létrehozása és JSON-adatfájlok olvasása

Ez a cella

• LÉTREHOZZA a REST-hívásokban használt URL-címeket
• beállítja a biztonsági fejlécet a Personalizer erőforráskulcs használatával
• A Rangsor eseményazonosító véletlenszerű magját állítja be
• olvasás a JSON-adatfájlokban
• hívási get_last_updated módszer – a tanulási szabályzat el lett távolítva a példakimenetben
• hívási get_service_settings módszer

A cella kimenete a hívásból és get_service_settings a függvényekből származikget_last_updated.

# build URLs
personalization_rank_url = personalization_base_url + "personalizer/v1.0/rank"
personalization_reward_url = personalization_base_url + "personalizer/v1.0/events/" #add "{eventId}/reward"
personalization_model_properties_url = personalization_base_url + "personalizer/v1.0/model/properties"
personalization_model_policy_url = personalization_base_url + "personalizer/v1.0/configurations/policy"
personalization_service_configuration_url = personalization_base_url + "personalizer/v1.0/configurations/service"

headers = {'Ocp-Apim-Subscription-Key' : resource_key, 'Content-Type': 'application/json'}

# context
users = "users.json"

# action features
coffee = "coffee.json"

# empty JSON for Rank request
requestpath = "example-rankrequest.json"

# initialize random
random.seed(time.time())

userpref = None
rankactionsjsonobj = None
actionfeaturesobj = None

with open(users) as handle:
    userpref = json.loads(handle.read())

with open(coffee) as handle:
    actionfeaturesobj = json.loads(handle.read())

with open(requestpath) as handle:
    rankactionsjsonobj = json.loads(handle.read())

get_last_updated(modelLastModified)
get_service_settings()

print(f'User count {len(userpref)}')
print(f'Coffee count {len(actionfeaturesobj)}')

Ellenőrizze, hogy a kimenet rewardWaitTime 10 percre van-e állítva, és modelExportFrequency 15 másodpercre van-e állítva.

-----checking model
<Response [200]>
{'creationTime': '0001-01-01T00:00:00+00:00', 'lastModifiedTime': '0001-01-01T00:00:00+00:00'}
-----model updated: "0001-01-01T00:00:00+00:00"
-----checking service settings
<Response [200]>
{...learning policy...}
<Response [200]>
{'rewardWaitTime': '00:10:00', 'defaultReward': 0.0, 'rewardAggregation': 'earliest', 'explorationPercentage': 0.2, 'modelExportFrequency': '00:00:15', 'logRetentionDays': -1}
User count 4
Coffee count 4

Az első REST-hívás hibaelhárítása

Ez az előző cella az első cella, amely meghívja a Personalizert. Győződjön meg arról, hogy a kimenet REST állapotkódja .<Response [200]> Ha hibaüzenetet kap ,például a 404-et, de biztos benne, hogy az erőforráskulcs és a név helyes, töltse be újra a jegyzetfüzetet.

Győződjön meg arról, hogy a kávé és a felhasználók száma egyaránt 4. Ha hibaüzenetet kap, ellenőrizze, hogy feltöltötte-e mind a 3 JSON-fájlt.

Metrikadiagram beállítása az Azure Portalon

Az oktatóanyag későbbi részében 10 000 kérés hosszú ideig futó folyamata látható a böngészőben egy frissítő szövegmezővel. Előfordulhat, hogy egy diagramon vagy teljes összegként könnyebben látható, ha a hosszú ideig futó folyamat véget ér. Az információk megtekintéséhez használja az erőforráshoz megadott metrikákat. Létrehozhatja a diagramot most, hogy teljesített egy kérést a szolgáltatáshoz, majd rendszeresen frissítheti a diagramot, amíg a hosszú ideig futó folyamat tart.

1. Az Azure Portalon válassza ki a Personalizer-erőforrást.

2. Az erőforrás-navigációban válassza a Metrika elemet a Figyelés alatt.

3. A diagramon válassza a Metrika hozzáadása lehetőséget.

4. Az erőforrás- és metrikanévtér már be van állítva. Csak a sikeres hívások metrikáját és az összeg összesítését kell kiválasztania.

5. Módosítsa az időszűrőt az elmúlt 4 órára.

   

   A diagramon három sikeres hívásnak kell megjelennie.

Egyedi eseményazonosító létrehozása

Ez a függvény minden ranghíváshoz létrehoz egy egyedi azonosítót. Az azonosító a rang- és jutalomhívási információk azonosítására szolgál. Ez az érték üzleti folyamatból, például webes nézetazonosítóból vagy tranzakcióazonosítóból származhat.

A cellának nincs kimenete. A függvény meghívásakor az egyedi azonosítót adja ki.

def add_event_id(rankjsonobj):
    eventid = uuid.uuid4().hex
    rankjsonobj["eventId"] = eventid
    return eventid

Véletlenszerű felhasználó, időjárás és napidő lekérése

Ez a függvény kiválaszt egy egyedi felhasználót, időjárást és napidőt, majd hozzáadja ezeket az elemeket a JSON-objektumhoz, hogy elküldje a Rangsor kérésnek.

A cellának nincs kimenete. A függvény meghívásakor visszaadja a véletlenszerű felhasználó nevét, a véletlenszerű időjárást és a véletlenszerű napidőt.

A 4 felhasználó és a hozzájuk tartozó beállítások listája – csak néhány beállítás jelenik meg a rövidség kedvéért:

{
  "Alice": {
    "Sunny": {
      "Morning": "Cold brew",
      "Afternoon": "Iced mocha",
      "Evening": "Cold brew"
    }...
  },
  "Bob": {
    "Sunny": {
      "Morning": "Cappucino",
      "Afternoon": "Iced mocha",
      "Evening": "Cold brew"
    }...
  },
  "Cathy": {
    "Sunny": {
      "Morning": "Latte",
      "Afternoon": "Cold brew",
      "Evening": "Cappucino"
    }...
  },
  "Dave": {
    "Sunny": {
      "Morning": "Iced mocha",
      "Afternoon": "Iced mocha",
      "Evening": "Iced mocha"
    }...
  }
}

def add_random_user_and_contextfeatures(namesoption, weatheropt, timeofdayopt, rankjsonobj):
    name = namesoption[random.randint(0,3)]
    weather = weatheropt[random.randint(0,2)]
    timeofday = timeofdayopt[random.randint(0,2)]
    rankjsonobj['contextFeatures'] = [{'timeofday': timeofday, 'weather': weather, 'name': name}]
    return [name, weather, timeofday]

Az összes kávéadat hozzáadása

Ez a függvény hozzáadja a kávé teljes listáját a JSON-objektumhoz, hogy elküldje a Rangsor kérésnek.

A cellának nincs kimenete. A függvény módosítja a meghívott állapotot rankjsonobj .

Egyetlen kávé jellemzőinek példája a következő:

{
    "id": "Cappucino",
    "features": [
    {
        "type": "hot",
        "origin": "kenya",
        "organic": "yes",
        "roast": "dark"

    }
}

def add_action_features(rankjsonobj):
    rankjsonobj["actions"] = actionfeaturesobj

Előrejelzés összehasonlítása az ismert felhasználói beállítással

Ezt a függvényt a Rank API meghívása után hívjuk meg minden iterációhoz.

Ez a függvény összehasonlítja a felhasználó kávéra vonatkozó előnyét az időjárás és a nap időpontja alapján, és a Személyre szabó javaslatát a felhasználónak az adott szűrőkhöz. Ha a javaslat egyezik, 1-es pontszámot ad vissza, ellenkező esetben a pontszám 0. A cellának nincs kimenete. A függvény a pontszámot a híváskor adja ki.

def get_reward_from_simulated_data(name, weather, timeofday, prediction):
    if(userpref[name][weather][timeofday] == str(prediction)):
        return 1
    return 0

A Rang és a Jutalom hívásának átcsúszása

A következő cella a Jegyzetfüzet fő feladata, egy véletlenszerű felhasználó lekérése, a kávélista lekérése, mindkettő elküldése a Rank API-nak. Összehasonlítja az előrejelzést a felhasználó ismert beállításaival, majd visszaküldi a jutalmat a Personalizer szolgáltatásnak.

A hurok időről időre num_requests fut. A Personalizernek néhány ezer hívásra van szüksége a Rank és a Reward felé egy modell létrehozásához.

Példa a Rank API-nak küldött JSON-ra. A kávé listája nem teljes, a rövidség kedvéért. A teljes JSON-t láthatja a kávéhoz.coffee.json

A Rank API-nak küldött JSON:

{
   'contextFeatures':[
      {
         'timeofday':'Evening',
         'weather':'Snowy',
         'name':'Alice'
      }
   ],
   'actions':[
      {
         'id':'Cappucino',
         'features':[
            {
               'type':'hot',
               'origin':'kenya',
               'organic':'yes',
               'roast':'dark'
            }
         ]
      }
        ...rest of coffee list
   ],
   'excludedActions':[

   ],
   'eventId':'b5c4ef3e8c434f358382b04be8963f62',
   'deferActivation':False
}

JSON-válasz a Rank API-tól:

{
    'ranking': [
        {'id': 'Latte', 'probability': 0.85 },
        {'id': 'Iced mocha', 'probability': 0.05 },
        {'id': 'Cappucino', 'probability': 0.05 },
        {'id': 'Cold brew', 'probability': 0.05 }
    ],
    'eventId': '5001bcfe3bb542a1a238e6d18d57f2d2',
    'rewardActionId': 'Latte'
}

Végül minden ciklus megjeleníti a felhasználó véletlenszerű kiválasztását, az időjárást, a nap idejét és a meghatározott jutalmat. Az 1 jutalom azt jelzi, hogy a Personalizer erőforrás a megfelelő kávétípust választotta ki az adott felhasználónak, időjárásnak és napnak.

1 Alice Rainy Morning Latte 1

A függvény a következőket használja:

• Rang: egy POST REST API a rangsoroláshoz.
• Jutalom: egy POST REST API a jutalom jelentéséhez.

def iterations(n, modelCheck, jsonFormat):

    i = 1

    # default reward value - assumes failed prediction
    reward = 0

    # Print out dateTime
    currentDateTime()

    # collect results to aggregate in graph
    total = 0
    rewards = []
    count = []

    # default list of user, weather, time of day
    namesopt = ['Alice', 'Bob', 'Cathy', 'Dave']
    weatheropt = ['Sunny', 'Rainy', 'Snowy']
    timeofdayopt = ['Morning', 'Afternoon', 'Evening']


    while(i <= n):

        # create unique id to associate with an event
        eventid = add_event_id(jsonFormat)

        # generate a random sample
        [name, weather, timeofday] = add_random_user_and_contextfeatures(namesopt, weatheropt, timeofdayopt, jsonFormat)

        # add action features to rank
        add_action_features(jsonFormat)

        # show JSON to send to Rank
        print('To: ', jsonFormat)

        # choose an action - get prediction from Personalizer
        response = requests.post(personalization_rank_url, headers = headers, params = None, json = jsonFormat)

        # show Rank prediction
        print ('From: ',response.json())

        # compare personalization service recommendation with the simulated data to generate a reward value
        prediction = json.dumps(response.json()["rewardActionId"]).replace('"','')
        reward = get_reward_from_simulated_data(name, weather, timeofday, prediction)

        # show result for iteration
        print(f'   {i} {currentDateTime()} {name} {weather} {timeofday} {prediction} {reward}')

        # send the reward to the service
        response = requests.post(personalization_reward_url + eventid + "/reward", headers = headers, params= None, json = { "value" : reward })

        # for every N rank requests, compute total correct  total
         total =  total + reward

        # every N iteration, get last updated model date and time
        if(i % modelCheck == 0):

            print("**** 10% of loop found")

            get_last_updated(modelLastModified)

        # aggregate so chart is easier to read
        if(i % 10 == 0):
            rewards.append( total)
            count.append(i)
             total = 0

        i = i + 1

    # Print out dateTime
    currentDateTime()

    return [count, rewards]

10 000 iteráció futtatása

Futtassa a Personalizer ciklust 10 000 iterációhoz. Ez egy hosszú ideig futó esemény. Ne zárja be a jegyzetfüzetet futtató böngészőt. Rendszeresen frissítse a metrikák diagramját az Azure Portalon a szolgáltatás összes hívásának megtekintéséhez. Ha körülbelül 20 000 hívása van, a ciklus egyes iterációinak rang- és jutalomhívása, az iterációk befejeződnek.

# max iterations
num_requests = 200

# check last mod date N% of time - currently 10%
lastModCheck = int(num_requests * .10)

jsonTemplate = rankactionsjsonobj

# main iterations
[count, rewards] = iterations(num_requests, lastModCheck, jsonTemplate)

Diagrameredmények a javulás megtekintéséhez

Diagram létrehozása a count következőből: és rewards.

def createChart(x, y):
    plt.plot(x, y)
    plt.xlabel("Batch of rank events")
    plt.ylabel("Correct recommendations per batch")
    plt.show()

Diagram futtatása 10 000 rangkéréshez

Futtassa a függvényt createChart .

createChart(count,rewards)

A diagram olvasása

Ez a diagram az aktuális alapértelmezett tanulási szabályzat modelljének sikerességét mutatja be.

Az ideális cél, hogy a vizsgálat végére a ciklus olyan sikerességi arányt átlagoz, amely közel 100%-os mínusz a feltárás. A feltárás alapértelmezett értéke 20%.

100-20=80

Ez a feltárási érték az Azure Portalon, a Personalizer-erőforrás konfigurációs oldalán található.

Annak érdekében, hogy jobb tanulási szabályzatot találhasson a Rank API-hoz tartozó adatok alapján, futtasson offline értékelést a portálon a Personalizer-ciklushoz.

Offline kiértékelés futtatása

1. Az Azure Portalon nyissa meg a Personalizer-erőforrás Kiértékelések lapját.

2. Válassza a Kiértékelés létrehozása lehetőséget.

3. Adja meg a kiértékelési név és a ciklus kiértékelésének dátumtartományát. A dátumtartománynak csak azokat a napokat kell tartalmaznia, amikor az értékelésre összpontosít.

   Az offline értékelés futtatásának célja annak megállapítása, hogy van-e jobb tanulási szabályzat az ebben a ciklusban használt funkciókhoz és műveletekhez. A jobb tanulási szabályzat megtalálásához győződjön meg arról, hogy az Optimalizálási felderítés be van kapcsolva.

4. A kiértékelés megkezdéséhez válassza az OK gombot.

5. Ez a Kiértékelések lap az új értékelést és annak aktuális állapotát sorolja fel. Attól függően, hogy mennyi adat áll rendelkezésére, ez a kiértékelés eltarthat egy ideig. Néhány perc múlva visszatérhet erre a lapra az eredmények megtekintéséhez.

6. Amikor az értékelés befejeződött, válassza ki az értékelést, majd válassza a különböző tanulási szabályzatok összehasonlítása lehetőséget. Ez megjeleníti a rendelkezésre álló tanulási szabályzatokat, és azt, hogy hogyan viselkednek az adatokkal.

7. Válassza ki a táblázat legfelülnézettebb tanulási szabályzatát, és válassza az Alkalmaz lehetőséget. Ez a legjobb tanulási szabályzatot alkalmazza a modellre és az újratanításokra.

Frissítési modell gyakoriságának módosítása 5 percre

1. Az Azure Portalon továbbra is a Personalizer erőforráson válassza a Konfiguráció lapot.
2. Módosítsa a modell frissítési gyakoriságát és a jutalom várakozási idejét 5 percre, és válassza a Mentés lehetőséget.

További információ a jutalom várakozási idejéről és a modellfrissítés gyakoriságáról.

#Verify new learning policy and times
get_service_settings()

Ellenőrizze, hogy a kimenet rewardWaitTimemodelExportFrequency 5 percre van-e állítva.

-----checking model
<Response [200]>
{'creationTime': '0001-01-01T00:00:00+00:00', 'lastModifiedTime': '0001-01-01T00:00:00+00:00'}
-----model updated: "0001-01-01T00:00:00+00:00"
-----checking service settings
<Response [200]>
{...learning policy...}
<Response [200]>
{'rewardWaitTime': '00:05:00', 'defaultReward': 0.0, 'rewardAggregation': 'earliest', 'explorationPercentage': 0.2, 'modelExportFrequency': '00:05:00', 'logRetentionDays': -1}
User count 4
Coffee count 4

Új tanulási szabályzat ellenőrzése

Térjen vissza az Azure Notebooks-fájlhoz, és folytassa ugyanazzal a ciklussal, de csak 2000 iteráció esetén. Rendszeresen frissítse a metrikák diagramját az Azure Portalon a szolgáltatás összes hívásának megtekintéséhez. Ha körülbelül 4000 hívása van, a ciklus egyes iterációihoz rang- és jutalomhívást kap, az iterációk befejeződnek.

# max iterations
num_requests = 2000

# check last mod date N% of time - currently 10%
lastModCheck2 = int(num_requests * .10)

jsonTemplate2 = rankactionsjsonobj

# main iterations
[count2, rewards2] = iterations(num_requests, lastModCheck2, jsonTemplate)

Diagram futtatása 2000 rangkéréshez

Futtassa a függvényt createChart .

createChart(count2,rewards2)

A második diagram áttekintése

A második diagramnak látható növekedést kell mutatnia a rangsor-előrejelzésekben a felhasználói beállításoknak megfelelően.

Clean up resources

Ha nem kívánja folytatni az oktatóanyag-sorozatot, törölje a következő erőforrásokat:

• Törölje az Azure Notebook-projektet.
• Törölje a Personalizer-erőforrást.

Következő lépések

Az ebben a mintában használt Jupyter-jegyzetfüzet és adatfájlok a Personalizer GitHub-adattárában érhetők el.