Optimalne cene za največji dobiček z uporabo Amazon SageMaker

To je gostujoča objava Viktorja Enrica Jeneyja, višjega inženirja strojnega učenja pri Adspertu.

Adspert je ISV s sedežem v Berlinu, ki je razvil orodje za upravljanje ponudb, zasnovano za samodejno optimizacijo uspešnosti trženja in oglaševalskih kampanj. Osnovno načelo podjetja je avtomatizirati maksimiranje dobička oglaševanja v e-trgovini s pomočjo umetne inteligence. Nenehen razvoj oglaševalskih platform odpira pot novim priložnostim, ki jih Adspert strokovno izkorišča za uspeh svojih strank.

Primarni cilj Adsperta je poenostaviti postopek za uporabnike in hkrati optimizirati oglaševalske akcije na različnih platformah. To vključuje uporabo informacij, zbranih na različnih platformah, uravnoteženih z optimalnim proračunom, določenim na ravni nad vsako platformo. Adspert se osredotoča na optimizacijo doseganja strankinega cilja, ne glede na to, katero platformo uporablja. Adspert še naprej dodaja platforme, kot je potrebno, da svojim strankam zagotovi pomembne prednosti.

V tej objavi delimo, kako je Adspert iz nič ustvaril orodje za določanje cen z uporabo različnih storitev AWS, kot je npr Amazon SageMaker in kako je Adspert sodeloval z Podatkovni laboratorij AWS pospešiti ta projekt od zasnove do izgradnje v rekordnem času.

Orodje za določanje cen spremeni ceno izdelka, ki ga izbere prodajalec, na tržnici e-trgovine na podlagi prepoznavnosti in stopnje dobička, da poveča dobiček na ravni izdelka.

Kot prodajalec je bistveno, da so vaši izdelki vedno vidni, saj s tem povečate prodajo. Najpomembnejši dejavnik pri prodaji v e-trgovini je preprosto, če je vaša ponudba vidna strankam namesto ponudbe konkurence.

Čeprav je zagotovo odvisna od specifične platforme e-trgovine, smo ugotovili, da je cena izdelka ena najpomembnejših ključnih številk, ki lahko vpliva na prepoznavnost. Cene pa se spreminjajo pogosto in hitro; zato mora orodje za določanje cen delovati v skoraj realnem času, da poveča prepoznavnost.

Pregled rešitve

Naslednji diagram prikazuje arhitekturo rešitev.

Rešitev vsebuje naslednje komponente:

1. Amazon Relational Database Service (Amazon RDS) za PostgreSQL je glavni vir podatkov, ki vsebuje informacije o izdelkih, ki so shranjene v zbirki podatkov RDS za Postgres.
2. Informacije o spremembah seznama izdelkov prispejo v realnem času v Storitev Amazon Simple Queue Service Čakalna vrsta (Amazon SQS).
3. Podatki o izdelku, shranjeni v Amazon RDS, se v skoraj realnem času vnesejo v surovo plast z uporabo vzorca za zajemanje podatkov o spremembi (CDC), ki je na voljo v Storitev za selitev baze podatkov AWS (AWS DMS).
4. Obvestila o seznamih izdelkov, ki prihajajo iz Amazon SQS, se vnesejo v skoraj realnem času v surovo plast z uporabo AWS Lambda Funkcija.
5. Izvorni izvorni podatki so shranjeni v Preprosta storitev shranjevanja Amazon (Amazon S3) vedro surovega sloja z uporabo formata podatkov Parquet. Ta plast je edini vir resnice za podatkovno jezero. Particioniranje, uporabljeno v tem pomnilniku, podpira inkrementalno obdelavo podatkov.
6. AWS lepilo opravila ekstrahiranja, preoblikovanja in nalaganja (ETL) čistijo podatke o izdelku, odstranjujejo dvojnike ter uporabljajo konsolidacijo podatkov in generične transformacije, ki niso vezane na določen poslovni primer.
7. Sloj stopnje Amazon S3 prejme pripravljene podatke, ki so shranjeni v formatu Apache Parquet za nadaljnjo obdelavo. Particioniranje, ki se uporablja v odrski shrambi, podpira inkrementalno obdelavo podatkov.
8. Opravila AWS Glue, ustvarjena v tem sloju, uporabljajo podatke, ki so na voljo v sloju stopnje Amazon S3. To vključuje uporabo poslovnih pravil in zahtevanih izračunov, specifičnih za primer uporabe. Podatki o rezultatih teh opravil so shranjeni v analitični plasti Amazon S3.
9. Analitični sloj Amazon S3 se uporablja za shranjevanje podatkov, ki jih uporabljajo modeli ML za namene usposabljanja. Particioniranje, uporabljeno v izbrani trgovini, temelji na pričakovani uporabi podatkov. To se lahko razlikuje od particioniranja, uporabljenega na sloju odra.
10. Model ML za ponovno določanje cen je implementacija Scikit-Learn Random Forest v skriptnem načinu SageMaker, ki se usposablja z uporabo podatkov, ki so na voljo v vedru S3 (plast analitike).
11. Opravilo za obdelavo podatkov AWS Glue pripravi podatke za sklepanje v realnem času. Opravilo obdela podatke, zaužite v vedru S3 (stopenjski sloj), in prikliče končno točko sklepanja SageMaker. Podatki so pripravljeni za uporabo v modelu ponovnega določanja cen SageMaker. AWS Glue je imel prednost pred Lambdo, ker sklepanje zahteva različne zapletene operacije obdelave podatkov, kot so združevanja in okenske funkcije za veliko količino podatkov (milijarde dnevnih transakcij). Rezultat klicev modela ponovnega določanja cen je shranjen v vedru S3 (plast sklepanja).
12. Učno opravilo SageMaker je uvedeno s končno točko SageMaker. To končno točko prikliče procesor sklepanja AWS Glue in generira cenovna priporočila v skoraj realnem času za povečanje vidnosti izdelka.
13. Napovedi, ki jih generira končna točka sklepanja SageMaker, so shranjene v sloju sklepanja Amazon S3.
14. Funkcija optimizatorja napovedi Lambda obdeluje priporočila, ki jih generira končna točka sklepanja SageMaker, in ustvari novo cenovno priporočilo, ki se osredotoča na maksimiranje dobička prodajalca z uporabo kompromisa med obsegom prodaje in prodajno maržo.
15. Priporočila za cene, ki jih ustvari optimizator napovedi Lambda, se predložijo API-ju za ponovno določanje cen, ki posodobi ceno izdelka na trgu.
16. Posodobljena cenovna priporočila, ki jih ustvari optimizator napovedi Lambda, so shranjena v plasti optimizacije Amazon S3.
17. Opravilo nalagalnika napovedi AWS Glue znova naloži v izvorno bazo podatkov RDS za Postgres SQL napovedi, ki jih ustvari model ML za namene revizije in poročanja. Za implementacijo te komponente je bil uporabljen AWS Glue Studio; to je grafični vmesnik, ki olajša ustvarjanje, izvajanje in spremljanje opravil ETL v AWS Glue.

Priprava podatkov

Nabor podatkov za Adspertov model vidnosti je ustvarjen iz čakalne vrste SQS in vstavljen v neobdelano plast našega podatkovnega jezera v realnem času z Lambdo. Nato se neobdelani podatki očistijo z izvajanjem preprostih transformacij, kot je odstranjevanje dvojnikov. Ta postopek je implementiran v AWS Glue. Rezultat je shranjen v uprizoritvenem sloju našega podatkovnega jezera. Obvestila zagotavljajo konkurente za določen izdelek z njihovimi cenami, kanali izpolnjevanja, časi pošiljanja in številnimi drugimi spremenljivkami. Zagotavljajo tudi merilo vidnosti, odvisno od platforme, ki se lahko izrazi kot logična spremenljivka (viden ali neviden). Vsakič, ko pride do spremembe ponudbe, prejmemo obvestilo, kar doda več milijonov dogodkov na mesec za vse izdelke naših strank.

Iz tega nabora podatkov ekstrahiramo podatke o usposabljanju na naslednji način: za vsako obvestilo združimo vidne ponudbe z vsako nevidno ponudbo in obratno. Vsaka podatkovna točka predstavlja tekmovanje med dvema prodajalcema, v katerem sta jasna zmagovalec in poraženec. To opravilo obdelave je implementirano v opravilu AWS Glue s Sparkom. Pripravljen nabor podatkov za usposabljanje je potisnjen v analitično vedro S3, da ga uporabi SageMaker.

Trenirajte model

Naš model razvršča za vsak par ponudb, če bo dana ponudba vidna. Ta model nam omogoča, da izračunamo najboljšo ceno za naše stranke, povečamo prepoznavnost na podlagi konkurence in maksimiziramo njihov dobiček. Poleg tega nam lahko ta klasifikacijski model omogoči globlji vpogled v razloge, zakaj so naši seznami vidni ali nevidni. Uporabljamo naslednje funkcije:

• Razmerje med našo ceno in cenami konkurentov
• Razlika v izpolnitvenih kanalih
• Količina povratnih informacij za vsakega prodajalca
• Ocena povratnih informacij vsakega prodajalca
• Razlika v minimalnem času dostave
• Razlika v najdaljših časih pošiljanja
• Razpoložljivost vsakega izdelka prodajalca

Adspert uporablja SageMaker za usposabljanje in gostovanje modela. Uporabljamo implementacijo Scikit-Learn Random Forest v Skriptni način SageMaker. Vključimo tudi nekaj predprocesiranja funkcij neposredno v cevovod Scikit-Learn v skriptu za usposabljanje. Oglejte si naslednjo kodo:

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)

Ena najpomembnejših funkcij predprocesiranja je transform_price, ki ceno deli z najnižjo ceno konkurenta in stolpcem zunanje cene. Ugotovili smo, da ta lastnost pomembno vpliva na točnost modela. Uporabimo tudi logaritem, da se model odloči na podlagi relativnih razlik v ceni, ne absolutnih razlik v ceni.

v training_script.py skripta, najprej definiramo, kako zgraditi Scikit-Learn ColumnTransformer za uporabo navedenih transformatorjev v stolpcih podatkovnega okvira:

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

V skripti za usposabljanje naložimo podatke iz Parquet v podatkovni okvir Panda, definiramo cevovod ColumnTranformer in RandomForestClassifierin usposobite model. Nato se model serializira z uporabo 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'))

V skripti za usposabljanje moramo implementirati tudi funkcije za sklepanje:

• input_fn – Odgovoren je za razčlenjevanje podatkov iz telesa zahteve tovora
• model_fn – Naloži in vrne model, ki je bil odložen v razdelku za usposabljanje skripta
• napoved_fn – Vsebuje našo izvedbo za zahtevo po napovedi iz modela z uporabo podatkov iz tovora
• napoved_proba – Za risanje predvidenih krivulj vidljivosti vrnemo verjetnost razreda z uporabo predict_proba namesto binarne napovedi klasifikatorja

Glej naslednjo kodo:

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

Naslednja slika prikazuje pomembnosti funkcij na podlagi nečistoč, ki jih vrne Klasifikator naključnih gozdov.

S SageMakerjem smo lahko usposobili model za veliko količino podatkov (do 14 milijard dnevnih transakcij), ne da bi obremenjevali naše obstoječe instance ali morali nastaviti ločen stroj z dovolj virov. Poleg tega je bilo usposabljanje s SageMakerjem izjemno stroškovno učinkovito, ker se primerki takoj zaprejo po izobraževalnem delu. Uvedba modela s SageMakerjem je delovala brez dodatne delovne obremenitve. En sam klic funkcije v SDK za Python zadostuje za gostovanje našega modela kot končne točke sklepanja, prav tako pa ga je mogoče preprosto zahtevati od drugih storitev z uporabo SDK za Python SageMaker. Oglejte si naslednjo kodo:

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

Artefakt modela je shranjen v Amazon S3 s funkcijo prileganja. Kot je razvidno iz naslednje kode, se lahko model naloži kot a SKLearnModel objekt z uporabo artefakta modela, poti skripta in nekaterih drugih parametrov. Nato ga je mogoče razmestiti v želeno vrsto instance in število instanc.

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
)

Ocenite model v realnem času

Vsakič, ko je poslano novo obvestilo za enega od naših izdelkov, želimo izračunati in oddati optimalno ceno. Za izračun optimalnih cen ustvarimo podatkovni niz napovedi, v katerem primerjamo lastno ponudbo s ponudbo posameznega konkurenta za vrsto možnih cen. Te podatkovne točke se posredujejo končni točki SageMaker, ki vrne predvideno verjetnost, da bo viden glede na vsakega konkurenta za vsako dano ceno. Verjetnost, da smo vidni, imenujemo predvidena vidljivost. Rezultat je mogoče vizualizirati kot krivuljo za vsakega konkurenta, ki prikazuje razmerje med našo ceno in prepoznavnostjo, kot je prikazano na naslednji sliki.

V tem primeru je vidnost v primerjavi s konkurentom 1 skoraj konstantna funkcija po delih, kar nakazuje, da moramo večinoma znižati ceno pod določen prag, približno ceno konkurenta, da postanemo vidni. Vendar se vidljivost proti Tekmovalcu 2 ne zmanjša tako strmo. Poleg tega imamo še vedno 50 % možnosti, da bomo vidni tudi z zelo visoko ceno. Analiza vhodnih podatkov je pokazala, da ima tekmovalec nizko število ocen, ki pa so zelo slabe. Naš model je ugotovil, da ta posebna platforma za e-trgovino postavlja prodajalce s slabimi povratnimi informacijami v slabši položaj. Podobne učinke smo odkrili za druge funkcije, kot sta kanal izpolnitve in čas pošiljanja.

Potrebne transformacije podatkov in sklepanja glede na končno točko SageMaker so implementirani v AWS Glue. Opravilo AWS Glue deluje v mikro serijah na podatkih v realnem času, ki jih zaužije Lambda.

Na koncu želimo izračunati agregirano krivuljo vidnosti, ki je predvidena vidnost za vsako možno ceno. Naša ponudba je vidna, če je boljša od ponudb vseh drugih prodajalcev. Ob predpostavki neodvisnosti med verjetnostmi, da smo vidni proti vsakemu prodajalcu glede na našo ceno, je verjetnost, da bomo vidni proti vsem prodajalcem, produkt zadevnih verjetnosti. To pomeni, da je agregirano krivuljo vidljivosti mogoče izračunati z množenjem vseh krivulj.

Naslednje slike prikazujejo predvidene vidnosti, ki jih vrne končna točka SageMaker.

Naslednja slika prikazuje agregirano krivuljo vidnosti.

Za izračun optimalne cene se krivulja vidnosti najprej zgladi in nato pomnoži z maržo. Za izračun marže uporabljamo stroške blaga in provizije. Stroški prodanega blaga in pristojbine so statične informacije o izdelku, sinhronizirane prek AWS DMS. Na podlagi profitne funkcije Adspert izračuna optimalno ceno in jo prek API-ja platforme posreduje platformi za e-trgovino.

To je implementirano v optimizatorju napovedi AWS Lambda.

Naslednja slika prikazuje razmerje med predvideno vidljivostjo in ceno.

Naslednja slika prikazuje razmerje med ceno in dobičkom.

zaključek

Adspertov obstoječi pristop k maksimiranju dobička je osredotočen na upravljanje ponudb za povečanje donosnosti oglaševanja. Da bi dosegli vrhunsko uspešnost na trgih e-trgovine, pa morajo prodajalci upoštevati oglaševanje in konkurenčne cene svojih izdelkov. S tem novim modelom ML za napovedovanje prepoznavnosti lahko razširimo našo funkcionalnost, da prilagodimo tudi cene strank.

Novo orodje za določanje cen mora biti sposobno avtomatiziranega učenja modela ML na veliki količini podatkov, pa tudi transformacije podatkov v realnem času, napovedi in optimizacije cen. V tej objavi smo se sprehodili skozi glavne korake našega mehanizma za optimizacijo cen in arhitekturo AWS, ki smo jo uvedli v sodelovanju z AWS Data Lab za doseganje teh ciljev.

Prenos modelov ML od koncepta do proizvodnje je običajno zapleten in dolgotrajen. Za usposabljanje modela morate upravljati z velikimi količinami podatkov, izbrati najboljši algoritem za njegovo usposabljanje, upravljati računalniško zmogljivost med usposabljanjem in nato razmestiti model v produkcijsko okolje. SageMaker je to kompleksnost zmanjšal tako, da je gradnjo in uvajanje modela ML naredil veliko enostavnejšo. Potem ko smo izbrali prave algoritme in ogrodja iz široke palete razpoložljivih izbir, je SageMaker upravljal vso osnovno infrastrukturo za usposabljanje našega modela in njegovo uvedbo v produkcijo.

Če se želite začeti seznanjati s SageMakerjem, Delavnica Immersion Day vam lahko pomaga pridobiti celovito razumevanje, kako zgraditi primere uporabe ML iz inženiringa funkcij, različnih vgrajenih algoritmov in kako usposobiti, prilagoditi in uvesti model ML v produkcijskem scenariju. Vodi vas, da prinesete svoj model in izvedete dvig in premik delovne obremenitve ML na mestu uporabe na platformo SageMaker. Nadalje prikazuje napredne koncepte, kot so razhroščevanje modela, spremljanje modela in AutoML, ter vam pomaga oceniti vašo delovno obremenitev ML prek leče AWS ML Well-Architected.

Če želite pomoč pri pospeševanju izvajanja primerov uporabe, ki vključujejo podatke, analitiko, AI in ML, posodobitev brez strežnika in vsebnika, se obrnite na Podatkovni laboratorij AWS.

O avtorjih

Viktor Enrico Jeney je višji inženir strojnega učenja pri Adspertu s sedežem v Berlinu v Nemčiji. Ustvarja rešitve za probleme napovedi in optimizacije z namenom povečanja dobička strank. Viktor ima izkušnje z uporabno matematiko in obožuje delo s podatki. V prostem času se rad uči madžarščine, ukvarja z borilnimi veščinami in igra kitaro.

Ennio Pastore je podatkovni arhitekt v ekipi AWS Data Lab. Je navdušenec nad vsem, kar je povezano z novimi tehnologijami, ki pozitivno vplivajo na podjetja in splošno preživetje. Ennio ima več kot 9 let izkušenj na področju podatkovne analitike. Podjetjem pomaga definirati in implementirati podatkovne platforme v panogah, kot so telekomunikacije, bančništvo, igre na srečo, maloprodaja in zavarovalništvo.