Optimális árképzés a maximális profit érdekében az Amazon SageMaker használatával

Ez Viktor Enrico Jeney, az Adspert vezető gépi tanulási mérnökének vendégbejegyzése.

Adspert egy berlini székhelyű ISV, amely egy ajánlatkezelő eszközt fejlesztett ki a marketing és hirdetési kampányok teljesítményének automatikus optimalizálására. A cég alapelve, hogy mesterséges intelligencia segítségével automatizálja az e-kereskedelmi hirdetések profitmaximalizálását. A hirdetési platformok folyamatos fejlesztése új lehetőségek előtt nyitja meg az utat, amit az Adspert szakszerűen kamatoztat ügyfelei sikerei érdekében.

Az Adspert elsődleges célja, hogy leegyszerűsítse a folyamatot a felhasználók számára, miközben optimalizálja a hirdetési kampányokat a különböző platformokon. Ez magában foglalja a különböző platformokon gyűjtött információk felhasználását az egyes platformok feletti szinten beállított optimális költségvetéshez képest. Az Adspert arra törekszik, hogy optimalizálja az ügyfél céljainak elérését, függetlenül a használt platformtól. Az Adspert szükség szerint folyamatosan bővíti a platformokat, hogy ügyfeleinek jelentős előnyöket biztosítson.

Ebben a bejegyzésben megosztjuk, hogyan hozta létre az Adspert az árképzési eszközt a semmiből különböző AWS-szolgáltatások, például Amazon SageMaker és hogyan működött együtt az Adspert a AWS Data Lab hogy rekordidő alatt felgyorsítsa ezt a projektet a tervezéstől a kivitelezésig.

Az árképzési eszköz a láthatóság és a haszonkulcs alapján újraárazza az eladó által kiválasztott terméket egy e-kereskedelmi piacon, hogy maximalizálja a termékszintű nyereséget.

Eladóként elengedhetetlen, hogy termékei mindig láthatóak legyenek, mert ez növeli az eladásokat. Az e-kereskedelmi értékesítésben a legfontosabb tényező egyszerűen az, hogy az Ön ajánlata látható-e az ügyfelek számára a versenytárs ajánlata helyett.

Bár minden bizonnyal az adott e-kereskedelmi platformtól függ, azt találtuk, hogy a termék ára az egyik legfontosabb kulcsfontosságú tényező, amely befolyásolhatja a láthatóságot. Az árak azonban gyakran és gyorsan változnak; ezért az árképzési eszköznek közel valós időben kell működnie a láthatóság növelése érdekében.

A megoldás áttekintése

A következő ábra a megoldás architektúráját mutatja be.

Az oldat a következő összetevőket tartalmazza:

1. Amazon Relational Database Service (Amazon RDS) a PostgreSQL-hez az RDS for Postgres adatbázisban tárolt termékinformációkat tartalmazó fő adatforrás.
2. A terméklista változásaival kapcsolatos információk valós időben érkeznek meg egy Amazon Simple Queue Service (Amazon SQS) sor.
3. Az Amazon RDS-ben tárolt termékinformációk csaknem valós időben kerülnek a nyers rétegbe a változási adatrögzítési (CDC) minta segítségével AWS adatbázis-migrációs szolgáltatás (AWS DMS).
4. Az Amazon SQS-től érkező terméklista-értesítések közel valós időben kerülnek a nyers rétegbe egy AWS Lambda funkciót.
5. Az eredeti forrásadatokat a Amazon egyszerű tárolási szolgáltatás (Amazon S3) nyersréteg vödör parketta adatformátum használatával. Ez a réteg az egyetlen igazságforrás az adattó számára. Az ezen a tárolón használt particionálás támogatja az adatok növekményes feldolgozását.
6. AWS ragasztó A kibontási, átalakítási és betöltési (ETL) feladatok megtisztítják a termékadatokat, eltávolítják az ismétlődéseket, valamint adatkonszolidációt és általános átalakításokat alkalmaznak, amelyek nem kapcsolódnak egy adott üzleti esethez.
7. Az Amazon S3 színpadi réteg előkészített adatokat fogad, amelyeket Apache Parquet formátumban tárolnak további feldolgozás céljából. A színpadi tárolóban használt particionálás támogatja az adatok növekményes feldolgozását.
8. Az ebben a rétegben létrehozott AWS ragasztófeladatok az Amazon S3 fázisrétegben elérhető adatokat használják. Ez magában foglalja a használati eset-specifikus üzleti szabályok alkalmazását és a szükséges számításokat. Az ezekből a feladatokból származó eredményeket az Amazon S3 elemzési réteg tárolja.
9. Az Amazon S3 analitikai réteg az ML modellek által edzési célokra használt adatok tárolására szolgál. A kiválasztott tárolóban használt particionálás a várható adathasználaton alapul. Ez eltérhet a színpadi rétegen használt particionálástól.
10. Az átárazó ML-modell egy Scikit-Learn Random Forest megvalósítás SageMaker Script módban, amelyet az S3 tárolóban (az analitikai rétegben) elérhető adatok felhasználásával képeznek ki.
11. Egy AWS Glue adatfeldolgozási feladat előkészíti az adatokat a valós idejű következtetéshez. A feladat feldolgozza az S3 tárolóban (szakaszrétegben) bevitt adatokat, és meghívja a SageMaker következtetési végpontot. Az adatok a SageMaker átárazási modell általi felhasználásra készültek. Az AWS Glue-t előnyben részesítették a Lambdával szemben, mivel a következtetéshez különböző összetett adatfeldolgozási műveletek szükségesek, például összekapcsolások és ablakfunkciók nagy mennyiségű adaton (napi tranzakciók milliárdjai). Az átárazási modell meghívásainak eredménye az S3 vödörben (következtetési rétegben) tárolódik.
12. A SageMaker képzési feladat egy SageMaker-végpont használatával kerül telepítésre. Ezt a végpontot hívja meg az AWS Glue következtetési processzora, amely közel valós idejű árajánlatokat generál a termék láthatóságának növelése érdekében.
13. A SageMaker következtetési végpont által generált előrejelzéseket az Amazon S3 következtetési réteg tárolja.
14. A Lambda előrejelzések optimalizáló funkciója feldolgozza a SageMaker következtetési végpont által generált ajánlásokat, és új árajánlatot generál, amely az eladói nyereség maximalizálására összpontosít, kompromisszumot alkalmazva az értékesítési mennyiség és az értékesítési árrés között.
15. A Lambda előrejelzési optimalizáló által generált árjavaslatok elküldésre kerülnek az újraárazási API-hoz, amely frissíti a termék árát a piacon.
16. A Lambda előrejelzési optimalizáló által generált frissített árajánlások az Amazon S3 optimalizálási rétegben tárolódnak.
17. Az AWS Glue előrejelzési betöltő feladat újratölti a forrás RDS for Postgres SQL adatbázisba az ML modell által generált előrejelzéseket auditálási és jelentéskészítési célokra. Az AWS Glue Studio-t használták ennek az összetevőnek a megvalósításához; ez egy grafikus felület, amely megkönnyíti az ETL-feladatok létrehozását, futtatását és figyelését az AWS Glue-ban.

Adatok előkészítése

Az Adspert láthatósági modelljének adatkészlete egy SQS-sorból jön létre, és a Lambda segítségével valós időben bekerül az adattó nyers rétegébe. Ezt követően a nyers adatokat egyszerű átalakításokkal, például ismétlődések eltávolításával megtisztítják. Ez a folyamat az AWS Glue-ban van megvalósítva. Az eredményt az adattavunk állomásozó rétegében tároljuk. Az értesítések megadják a versenytársakat az adott termékhez, azok áraival, teljesítési csatornáival, szállítási idejével és még sok más változóval. Emellett platformfüggő láthatósági mérőszámot is biztosítanak, amely logikai változóként fejezhető ki (látható vagy nem látható). Minden alkalommal értesítést kapunk, amikor ajánlatmódosítás történik, ami havonta több millió eseményt tesz ki ügyfeleink termékeire vonatkozóan.

Ebből az adatkészletből a következőképpen vonjuk ki a képzési adatokat: minden értesítésnél a látható ajánlatokat minden nem látható ajánlattal párosítjuk, és fordítva. Minden adatpont két eladó versenyét jelenti, amelyben egyértelmű győztes és vesztes van. Ez a feldolgozási feladat a Spark AWS ragasztófeladatában van megvalósítva. Az előkészített képzési adatkészletet az analytics S3 tárolóba küldi, hogy a SageMaker használja.

Tanítsd meg a modellt

Modellünk minden ajánlatpárhoz osztályoz, ha egy adott ajánlat látható lesz. Ez a modell lehetővé teszi, hogy kiszámítsuk a legjobb árat ügyfeleink számára, növeljük a láthatóságot a verseny alapján, és maximalizáljuk profitjukat. Ráadásul ez az osztályozási modell mélyebb betekintést nyújthat a listáink láthatóságának vagy nem láthatóságának okaiba. A következő funkciókat használjuk:

• Áraink és versenytársaink árainak aránya
• Különbség a teljesítési csatornákban
• Az egyes eladók visszajelzéseinek mennyisége
• Az egyes eladók visszajelzései
• Különbség a minimális szállítási időkben
• Különbség a maximális szállítási időkben
• Minden eladó termékének elérhetősége

Az Adspert a SageMaker-t használja a modell betanításához és fogadásához. Scikit-Learn Random Forest implementációt használunk SageMaker Script mód. Néhány funkció-előfeldolgozást közvetlenül a Scikit-Learn folyamatban is tartalmazunk a betanítási szkriptben. Lásd a következő kódot:

import numpy as np

def transform_price(X):
    X = X.to_numpy()
    return np.log(
        X[:, 0] / np.nanmin([X[:, 1], X[:, 2]], axis=0),
    ).reshape(-1, 1)

def difference(X):
    X = X.to_numpy()
    return (X[:, 0] - X[:, 1]).reshape(-1, 1)

def fulfillment_difference(X):
    X = X.astype(int)
    return difference(X)

Az egyik legfontosabb előfeldolgozási funkció az transform_price, amely elosztja az árat a versenytárs árának minimumával és egy külső ároszloppal. Úgy találtuk, hogy ez a funkció jelentős hatással van a modell pontosságára. A logaritmust is alkalmazzuk, hogy a modell relatív árkülönbségek, nem pedig abszolút árkülönbségek alapján döntsön.

A training_script.py szkriptet, először meghatározzuk a Scikit-Learn felépítését ColumnTransformer a megadott transzformátorok alkalmazásához egy adatkeret oszlopaira:

import argparse
import os
from io import StringIO

import joblib
import numpy as np
import pandas as pd
from custom_transformers import difference
from custom_transformers import fulfillment_difference
from custom_transformers import transform_price
from sklearn.compose import ColumnTransformer
from sklearn.ensemble import RandomForestClassifier
from sklearn.pipeline import Pipeline
from sklearn.preprocessing import FunctionTransformer
from sklearn.preprocessing import OneHotEncoder

def make_preprocessor():
    return ColumnTransformer([
        ('price_by_smallest_cp', FunctionTransformer(transform_price),
         ['price', 'competitor_price', 'external_price']),
        (fulfillment_difference, FunctionTransformer(fulfillment_difference),
         ['fulfillment', 'competitor_'fulfillment']),
        ('feedback_count', 'passthrough',
         ['feedback_count', 'competitor_feedback_count']),
        ('feedback_rating', 'passthrough',
         ['feedback_rating', 'competitor_feedback_rating']),
        (
            'availability_type',
            OneHotEncoder(categories=[['NOW'], ['NOW']],
                          handle_unknown='ignore'),
            ['availability_type', 'competitor_availability_type'],
        ),
        ('min_shipping', FunctionTransformer(difference),
         ['minimum_shipping_hours', 'competitor_min_shipping_hours']),
        ('max_shipping', FunctionTransformer(difference),
         ['maximum_shipping_hours', 'competitor_max_shipping_hours']),
    ], remainder='drop')

A képzési szkriptben betöltjük a Parquet adatait egy Pandas adatkeretbe, meghatározzuk a folyamat folyamatát. ColumnTranformer és a RandomForestClassifier, és képezze ki a modellt. Ezt követően a modell szerializálódik a segítségével joblib:

if __name__ == '__main__':
    parser = argparse.ArgumentParser()
    parser.add_argument('--output-data-dir', type=str,
                        default=os.environ['SM_OUTPUT_DATA_DIR'])
    parser.add_argument('--model-dir', type=str,
                        default=os.environ['SM_MODEL_DIR'])
    parser.add_argument('--train', type=str,
                        default=os.environ['SM_CHANNEL_TRAIN'])

    args = parser.parse_args()

    # load training data
    input_files = [os.path.join(args.train, file)
                   for file in os.listdir(args.train)]
    if len(input_files) == 0:
        raise ValueError
    raw_data = [pd.read_parquet(file) for file in input_files]
    train_data = pd.concat(raw_data)

    # split data set into x and y values
    train_y = train_data.loc[:, 'is_visible']

    if train_y.dtype != 'bool':
        raise ValueError(f'Label 'is_visible' has to be dtype bool but is'
                         f' {train_y.dtype}')

    train_X = train_data.drop('is_visible', axis=1)

    # fit the classifier pipeline and store the fitted model
    clf = Pipeline([
        ('preprocessor', make_preprocessor()),
        ('classifier', RandomForestClassifier(random_state=1)),
    ])
    clf.fit(train_X, train_y)
    joblib.dump(clf, os.path.join(args.model_dir, 'model.joblib'))

A képzési szkriptben függvényeket is meg kell valósítanunk a következtetéshez:

• input_fn – Felelős a rakomány kérés törzséből származó adatok elemzéséért
• modell_fn – Betölti és visszaadja azt a modellt, amely a szkript betanítási szakaszába került
• előre_fn – Tartalmazza azt a megvalósításunkat, amely előrejelzést kér a modelltől a hasznos teherből származó adatok felhasználásával
• előre_proba – Az előrejelzett láthatósági görbék megrajzolásához az osztályvalószínűséget a segítségével adjuk vissza predict_proba függvényt, az osztályozó bináris előrejelzése helyett

Lásd a következő kódot:

def input_fn(request_body, request_content_type):
    """Parse input data payload"""
    if request_content_type == 'text/csv':
        df = pd.read_csv(StringIO(request_body))
        return df
    else:
        raise ValueError(f'{request_content_type} not supported by script!')


def predict_fn(input_data, model):
    """Predict the visibilities"""
    classes = model.classes_

    if len(classes) != 2:
        raise ValueError('Model has more than 2 classes!')

    # get the index of the winning class
    class_index = np.where(model.classes_ == 1)[0][0]

    output = model.predict_proba(input_data)
    return output[:, class_index]


def model_fn(model_dir):
    """Deserialized and return fitted model

    Note that this should have the same name as the serialized model in the
    main method
    """
    clf = joblib.load(os.path.join(model_dir, 'model.joblib'))
    return clf

A következő ábra a szennyeződés alapú jellemző fontosságait mutatja be Véletlenszerű erdőosztályozó.

A SageMaker segítségével nagy mennyiségű adatra (akár 14 milliárd napi tranzakcióra) tudtuk betanítani a modellt anélkül, hogy megterheltük volna meglévő példányainkat, vagy külön gépet kellett volna beállítani elegendő erőforrással. Sőt, mivel a példányokat a betanítási munka után azonnal leállítják, a SageMakerrel végzett képzés rendkívül költséghatékony volt. A SageMakerrel végzett modelltelepítés további munkaterhelés nélkül működött. Egyetlen függvényhívás a Python SDK-ban elegendő ahhoz, hogy a modellünket következtetési végpontként tároljuk, és könnyen lekérhető más szolgáltatásoktól is a SageMaker Python SDK használatával. Lásd a következő kódot:

from sagemaker.sklearn.estimator import SKLearn

FRAMEWORK_VERSION = "0.23-1"
script_path = 'training_script.py'
output_location = f's3://{bucket}/{folder}/output'
source_dir = 'source_dir'

sklearn = SKLearn(
    entry_point=script_path,
    source_dir=source_dir,
    framework_version=FRAMEWORK_VERSION,
    instance_type='ml.m5.large',
    role=role,
    sagemaker_session=sagemaker_session,
    output_path=output_location)

sklearn.fit({'train': training_path})

A modell műtermékét az Amazon S3 tárolja az illeszkedés funkcióval. Amint az a következő kódban látható, a modell betölthető a SKLearnModel objektumot a modellműtermék, a szkript elérési útja és néhány egyéb paraméter használatával. Ezt követően telepíthető a kívánt példánytípusra és példányszámra.

model = sagemaker.sklearn.model.SKLearnModel(
    model_data=f'{output_location}/sagemaker-scikit-learn-2021-02-23-11-13-30-036/output/model.tar.gz',
    source_dir=source_dir,
    entry_point=script_path,
    framework_version=FRAMEWORK_VERSION,
    sagemaker_session=sagemaker_session,
    role=role
)
ENDPOINT_NAME = 'visibility-model-v1'
model.deploy(
    initial_instance_count=1,
    instance_type='ml.m5.large',
    endpoint_name=ENDPOINT_NAME
)

Értékelje a modellt valós időben

Valahányszor új értesítést küldünk valamelyik termékünkről, szeretnénk kiszámítani és megadni az optimális árat. Az optimális árak kiszámításához egy előrejelzési adatkészletet készítünk, amelyben összehasonlítjuk saját ajánlatunkat az egyes versenytársak ajánlataival a lehetséges ártartományok tekintetében. Ezek az adatpontok a SageMaker végpontnak kerülnek átadásra, amely visszaadja annak előre jelzett valószínűségét, hogy minden egyes versenytársnál láthatóak legyenek minden adott ár esetén. A láthatóság valószínűségét a előre jelzett láthatóság. Az eredmény minden versenytársnál görbeként ábrázolható, ábrázolva az árunk és a láthatóság közötti kapcsolatot, ahogy az alábbi ábrán is látható.

Ebben a példában az 1. versenytárssal szembeni láthatóság szinte darabonként állandó függvény, ami azt sugallja, hogy az árat egy bizonyos küszöb alá, nagyjából a versenytárs ára alá kell csökkentenünk, hogy láthatóvá váljunk. A 2. versenytárssal szemben azonban a láthatóság nem csökken olyan meredeken. Ráadásul még nagyon magas ár mellett is 50% esélyünk van a láthatóságra. A bemeneti adatokat elemezve kiderült, hogy a versenytársnak alacsony az értékelései, amelyek történetesen nagyon rosszak. Modellünk megtanulta, hogy ez a speciális e-kereskedelmi platform hátrányt jelent a rossz visszajelzéssel rendelkező eladóknak. Hasonló hatásokat fedeztünk fel a többi funkciónál is, például a teljesítési csatornánál és a szállítási időnél.

A szükséges adatátalakítások és a SageMaker végponttal kapcsolatos következtetések az AWS Glue-ban valósulnak meg. Az AWS ragasztófeladata mikro-kötegelve működik a Lambdától bevitt valós idejű adatokon.

Végül ki akarjuk számítani az összesített láthatósági görbét, amely az egyes lehetséges árak előre jelzett láthatósága. Ajánlatunk akkor látható, ha jobb, mint az összes többi eladó ajánlata. Feltételezve az árunk alapján az egyes eladókkal szembeni láthatóság valószínűsége közötti függetlenséget, az összes eladóval szembeni láthatóság valószínűsége a megfelelő valószínűségek szorzata. Ez azt jelenti, hogy az összesített láthatósági görbe az összes görbe szorzásával kiszámítható.

A következő ábrák a SageMaker végpontból visszaadott várható láthatóságokat mutatják.

A következő ábra az összesített láthatósági görbét mutatja.

Az optimális ár kiszámításához először a láthatósági görbét simítják, majd megszorozzák a margóval. Az árrés kiszámításához az áruköltséget és a díjakat használjuk fel. Az eladott áruk költsége és a díjak az AWS DMS-en keresztül szinkronizált statikus termékinformációk. A profitfüggvény alapján az Adspert kiszámítja az optimális árat, és a platform API-ján keresztül elküldi az e-kereskedelmi platformnak.

Ezt az AWS Lambda előrejelzés optimalizálója valósítja meg.

A következő ábra a várható láthatóság és az ár közötti összefüggést mutatja.

A következő ábra az ár és a haszon összefüggését mutatja.

Következtetés

Az Adspert jelenlegi profitmaximalizálási megközelítése az ajánlatkezelésre összpontosít, hogy növelje a hirdetésekből származó megtérülést. Az e-kereskedelmi piacokon azonban kiváló teljesítmény elérése érdekében az eladóknak figyelembe kell venniük termékeik reklámozását és versenyképes árát. Ezzel az új ML-modellel a láthatóság előrejelzésére kibővíthetjük funkcionalitásunkat, hogy az ügyfelek árait is módosíthassuk.

Az új árképzési eszköznek képesnek kell lennie az ML modell automatizált betanítására nagy mennyiségű adaton, valamint valós idejű adattranszformációra, előrejelzésre és ároptimalizálásra. Ebben a bejegyzésben végigjártuk az ároptimalizáló motorunk főbb lépéseit, és az AWS-architektúrát, amelyet az AWS Data Laborral együttműködésben implementáltunk e célok elérése érdekében.

Az ML-modellek koncepciójától a gyártásig való elvitele jellemzően bonyolult és időigényes. A modell betanításához nagy mennyiségű adatot kell kezelnie, kiválasztania a legjobb algoritmust a betanításhoz, kezelnie kell a számítási kapacitást a betanítás során, majd üzembe kell helyeznie a modellt egy éles környezetben. A SageMaker csökkentette ezt a bonyolultságot azzal, hogy sokkal egyszerűbbé tette az ML modell felépítését és telepítését. Miután kiválasztottuk a megfelelő algoritmusokat és keretrendszereket a rendelkezésre álló lehetőségek széles skálájából, a SageMaker felügyelte az összes mögöttes infrastruktúrát, hogy betanítsa a modellünket és üzembe helyezze azt.

Ha szeretné megismerkedni a SageMakerrel, a Merítésnapi workshop segítségével átfogó ismereteket szerezhet arról, hogyan lehet ML használati eseteket felépíteni a funkciótervezésből, a különböző beépített algoritmusokból, és hogyan lehet betanítani, hangolni és üzembe helyezni az ML-modellt egy éles forgatókönyvben. Útmutatást ad, hogy hozza létre saját modelljét, és végezzen helyszíni ML munkaterhelés-emelést és -váltást a SageMaker platformra. Továbbá olyan fejlett koncepciókat mutat be, mint a modellhibakeresés, a modellfigyelés és az AutoML, és segít az ML munkaterhelés értékelésében az AWS ML jól felépített objektíven keresztül.

Ha segítségre van szüksége az adatokkal, analitikával, mesterséges intelligenciával és ML-vel, szerver nélküli és konténermodernizálással kapcsolatos használati esetek megvalósításának felgyorsításában, forduljon a AWS Data Lab.

A szerzőkről

Viktor Enrico Jeney az Adspert vezető gépi tanulási mérnöke Berlinben, Németországban. Megoldásokat készít előrejelzési és optimalizálási problémákra az ügyfelek profitjának növelése érdekében. Viktor alkalmazott matematikai múlttal rendelkezik, és szeret adatokkal dolgozni. Szabadidejében szívesen tanul magyarul, űzi a harcművészeteket és gitározik.

Ennio Pastore az AWS Data Lab csapatának adattervezője. Mindennek lelkes, ami az új technológiákkal kapcsolatos, amelyek pozitív hatással vannak a vállalkozásokra és az általános megélhetésre. Ennio több mint 9 éves tapasztalattal rendelkezik az adatelemzés terén. Segít a vállalatoknak adatplatformok meghatározásában és megvalósításában olyan iparágakban, mint a telekommunikáció, a banki szolgáltatások, a játék, a kiskereskedelem és a biztosítás.