Optimaalne hinnakujundus maksimaalse kasumi saamiseks Amazon SageMakeri abil

See on Adsperti masinõppe vaneminseneri Viktor Enrico Jeney külalispostitus.

Adspert on Berliinis asuv ISV, mis töötas välja pakkumiste haldamise tööriista, mis on loodud turundus- ja reklaamikampaaniate automaatseks optimeerimiseks. Ettevõtte põhiprintsiibiks on tehisintellekti abil automatiseerida e-kaubanduse reklaami kasumi maksimeerimist. Reklaamiplatvormide pidev areng sillutab teed uutele võimalustele, mida Adspert oma klientide edu nimel asjatundlikult ära kasutab.

Adsperti peamine eesmärk on lihtsustada protsessi kasutajate jaoks, optimeerides samal ajal reklaamikampaaniaid erinevatel platvormidel. See hõlmab erinevatelt platvormidelt kogutud teabe kasutamist, mis on tasakaalustatud igast platvormist kõrgemal tasemel seatud optimaalse eelarvega. Adspert keskendub kliendi eesmärgi saavutamise optimeerimisele, olenemata kasutatavast platvormist. Adspert jätkab platvormide lisamist vastavalt vajadusele, et anda oma klientidele olulisi eeliseid.

Selles postituses jagame, kuidas Adspert lõi hinnatööriista nullist, kasutades erinevaid AWS-i teenuseid, näiteks Amazon SageMaker ja kuidas Adspert koostööd tegi AWS-i andmelabor kiirendada seda projekti projekteerimisest ehitamiseni rekordajaga.

Hinnakujundustööriist hindab ümber müüja valitud toote e-kaubanduse turul nähtavuse ja kasumimarginaali alusel, et maksimeerida kasumit toote tasemel.

Müüjana on oluline, et teie tooted oleksid alati nähtavad, sest see suurendab müüki. Kõige olulisem tegur e-poe müügi puhul on lihtsalt see, kui konkurendi pakkumise asemel on klientidele nähtav sinu pakkumine.

Kuigi see sõltub kindlasti konkreetsest e-kaubanduse platvormist, oleme avastanud, et toote hind on üks olulisemaid võtmenäitajaid, mis võib nähtavust mõjutada. Hinnad muutuvad aga sageli ja kiiresti; Sel põhjusel peab hinnakujundustööriist nähtavuse suurendamiseks toimima peaaegu reaalajas.

Ülevaade lahendusest

Järgnev diagramm illustreerib lahenduse arhitektuuri.

Lahus sisaldab järgmisi komponente:

1. Amazon Relational Database Service (Amazon RDS) PostgreSQL-i jaoks on peamine andmeallikas, mis sisaldab tooteteavet, mis on salvestatud RDS for Postgres andmebaasi.
2. Tooteloendi muudatuste teave saabub reaalajas Amazoni lihtsa järjekorra teenus (Amazon SQS) järjekord.
3. Amazon RDS-i salvestatud tooteteave neelatakse peaaegu reaalajas töötlemata kihti, kasutades muudatuste andmete püüdmise (CDC) mustrit, mis on saadaval AWS-i andmebaasi migratsiooniteenus (AWS DMS).
4. Amazon SQS-ist pärinevad tooteloendi teatised neelatakse peaaegu reaalajas töötlemata kihti kasutades AWS Lambda funktsiooni.
5. Algsed lähteandmed salvestatakse Amazoni lihtne salvestusteenus (Amazon S3) töötlemata kihi kopp Parketi andmevormingus. See kiht on andmejärve ainus tõeallikas. Sellel salvestusruumil kasutatav jaotus toetab andmete järkjärgulist töötlemist.
6. AWS liim ekstrakti-, teisendus- ja laadimistööd (ETL) puhastavad tooteandmeid, eemaldavad duplikaadid ning rakendavad andmete konsolideerimist ja üldisi teisendusi, mis ei ole seotud konkreetse ärijuhtumiga.
7. Amazon S3 lavakiht võtab vastu ettevalmistatud andmed, mis salvestatakse edasiseks töötlemiseks Apache Parquet formaadis. Lavapoes kasutatav sektsioonimine toetab andmete järkjärgulist töötlemist.
8. Selles kihis loodud AWS-liimitööd kasutavad Amazon S3 etapikihis saadaolevaid andmeid. See hõlmab kasutusjuhtumipõhiste ärireeglite ja nõutavate arvutuste rakendamist. Nende tööde tulemuste andmed salvestatakse Amazon S3 analüütikakihis.
9. Amazon S3 analüütikakihti kasutatakse andmete salvestamiseks, mida ML mudelid kasutavad treeningutel. Kureeritud poes kasutatav jaotus põhineb eeldataval andmekasutusel. See võib erineda lavakihis kasutatavast partitsioonist.
10. Ümberhinnangu ML-mudel on Scikit-Learn Random Foresti rakendus SageMakeri skriptirežiimis, mida koolitatakse S3 ämbris (analüütikakiht) saadaolevate andmete põhjal.
11. AWS-liimi andmetöötlustöö valmistab andmed ette reaalajas järelduste tegemiseks. Töö töötleb S3 ämbris (etapikihis) neelatud andmeid ja kutsub esile SageMakeri järelduse lõpp-punkti. Andmed on ette valmistatud kasutamiseks SageMakeri ümberhinnangute mudelis. AWS Glue eelistati Lambdale, kuna järeldus nõuab erinevaid keerukaid andmetöötlustoiminguid, nagu liitmised ja aknafunktsioonid suurel andmemahul (miljardid igapäevased tehingud). Ümberhinnangu mudeli väljakutsete tulemus salvestatakse S3 ämbrisse (järelduskiht).
12. SageMakeri koolitustöö juurutatakse SageMakeri lõpp-punkti abil. Seda lõpp-punkti kasutab AWS Glue järeldusprotsessor, genereerides toote nähtavuse suurendamiseks peaaegu reaalajas hinnasoovitusi.
13. SageMakeri järelduse lõpp-punkti genereeritud ennustused salvestatakse Amazon S3 järelduskihti.
14. Lambda prognooside optimeerija funktsioon töötleb SageMakeri järelduse lõpp-punkti genereeritud soovitusi ja genereerib uue hinnasoovituse, mis keskendub müüja kasumi maksimeerimisele, rakendades müügimahu ja müügimarginaali vahelist kompromissi.
15. Lambda prognooside optimeerija genereeritud hinnasoovitused esitatakse ümberhinnangu API-le, mis värskendab toote hinda turul.
16. Lambda prognooside optimeerija loodud värskendatud hinnasoovitused salvestatakse Amazon S3 optimeerimiskihis.
17. AWS-i liimi ennustuslaaduri töö laadib ML-mudeli loodud ennustused uuesti Postgresi SQL-i andmebaasi lähte-RDS-i auditeerimise ja aruandluse jaoks. Selle komponendi rakendamiseks kasutati AWS Glue Studio; see on graafiline liides, mis muudab AWS Glue'i ETL-tööde loomise, käitamise ja jälgimise lihtsaks.

Andmete ettevalmistamine

Adsperti nähtavusmudeli andmestik luuakse SQS-i järjekorrast ja sisestatakse Lambda abil reaalajas meie andmejärve töötlemata kihti. Seejärel puhastatakse algandmed lihtsate teisenduste, näiteks duplikaatide eemaldamise teel. Seda protsessi rakendatakse AWS Glue'is. Tulemus salvestatakse meie andmejärve lavastuskihti. Teatised annavad konkurendid antud toote kohta koos nende hindade, täitmise kanalite, tarneaegade ja paljude muude muutujatega. Need pakuvad ka platvormist sõltuvat nähtavuse mõõdikut, mida saab väljendada Boole'i ​​muutujana (nähtav või mittenähtav). Saame teatise iga kord, kui pakkumise muudatus toimub, mis toob kokku kuni mitu miljonit sündmust kuus kõigi meie klientide toodete kohta.

Sellest andmekogumist eraldame koolitusandmed järgmiselt: iga teatise puhul seome nähtavad pakkumised iga mittenähtava pakkumisega ja vastupidi. Iga andmepunkt kujutab endast kahe müüja vahelist konkurentsi, milles on selge võitja ja kaotaja. See töötlemistöö on rakendatud Sparkiga AWS-liimitöös. Ettevalmistatud treeningandmestik lükatakse analüütika S3 ämbrisse, mida SageMaker kasutab.

Treeni modelli

Meie mudel klassifitseerib iga pakkumispaari, kui antud pakkumine on nähtav. See mudel võimaldab meil arvutada oma klientidele parima hinna, suurendada konkurentsil põhinevat nähtavust ja maksimeerida nende kasumit. Lisaks võib see klassifitseerimismudel anda meile sügavama ülevaate põhjustest, miks meie kirjed on nähtavad või mitte. Kasutame järgmisi funktsioone:

• Meie hinna suhe konkurentide hindadesse
• Täitmiskanalite erinevus
• Tagasiside hulk iga müüja kohta
• Iga müüja tagasiside hinnang
• Minimaalsete tarneaegade erinevus
• Erinevus maksimaalsetes tarneaegades
• Iga müüja toote saadavus

Adspert kasutab mudeli koolitamiseks ja hostimiseks SageMakerit. Kasutame Scikit-Learn Random Foresti juurutamist SageMakeri skriptirežiim. Lisame koolitusskripti ka mõned funktsioonide eeltöötlused otse Scikit-Learni konveierisse. Vaadake järgmist koodi:

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)

Üks olulisemaid eeltöötlusfunktsioone on transform_price, mis jagab hinna konkurendihinna ja välise hinnaveeru miinimumiga. Oleme leidnud, et sellel funktsioonil on oluline mõju mudeli täpsusele. Samuti rakendame logaritmi, et lasta mudelil otsustada suhteliste hinnaerinevuste, mitte absoluutsete hinnaerinevuste põhjal.

aasta training_script.py skripti, määratleme kõigepealt, kuidas Scikit-Learni luua ColumnTransformer määratud trafode rakendamiseks andmeraami veergudele:

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

Treeningskriptis laadime andmed Parquetist Pandase andmeraami, määratleme ColumnTranformer ja RandomForestClassifierja treenige modelli. Seejärel muudetakse mudel kasutades 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'))

Treeningskriptis peame järelduste tegemiseks rakendama ka funktsioone:

• sisend_fn – Vastutab kasuliku koormuse päringukeha andmete sõelumise eest
• mudel_fn – Laadib ja tagastab mudeli, mis on skripti koolitussektsioonis tõmmatud
• ennustada_fn – Sisaldab meie rakendust, et taotleda mudelilt ennustust, kasutades kasuliku koormuse andmeid
• ennusta_proba – Prognoositud nähtavuskõverate joonistamiseks tagastame klassi tõenäosuse, kasutades predict_proba funktsioon klassifikaatori binaarse ennustuse asemel

Vaadake järgmist koodi:

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

Järgmisel joonisel on näidatud lisanditepõhised funktsioonide tähtsused, mille tagastas Juhuslik metsa klassifikaator.

SageMakeriga saime mudelit treenida suurel hulgal andmetel (kuni 14 miljardit igapäevast tehingut), ilma et oleksime koormanud meie olemasolevaid eksemplare või pidanud seadistama eraldi masinat, millel oleks piisavalt ressursse. Pealegi, kuna eksemplarid suletakse kohe pärast koolitustööd, oli SageMakeriga treenimine äärmiselt kuluefektiivne. Mudeli juurutamine SageMakeriga toimis ilma täiendava töökoormuseta. Pythoni SDK ühest funktsioonikutsest piisab, et majutada meie mudelit järelduse lõpp-punktina ja seda saab hõlpsasti taotleda ka teistelt teenustelt, kasutades SageMaker Python SDK-d. Vaadake järgmist koodi:

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

Mudeli artefakt salvestatakse Amazon S3-sse sobitusfunktsiooni abil. Nagu järgmisest koodist näha, saab mudelit laadida kui a SKLearnModel objekti, kasutades mudeli artefakti, skripti teed ja mõnda muud parameetrit. Seejärel saab selle juurutada soovitud eksemplari tüübile ja arvule.

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
)

Hinnake mudelit reaalajas

Iga kord, kui mõne meie toote kohta saadetakse uus teade, tahame arvutada ja esitada optimaalse hinna. Optimaalsete hindade arvutamiseks loome ennustusandmestiku, milles võrdleme oma pakkumist iga konkurendi pakkumisega erinevate võimalike hindade jaoks. Need andmepunktid edastatakse SageMakeri lõpp-punktile, mis tagastab prognoositud tõenäosuse olla iga konkurendi suhtes nähtav iga antud hinna puhul. Nähtavaks olemise tõenäosust nimetame ennustatav nähtavus. Tulemust saab visualiseerida iga konkurendi kõverana, mis kujutab meie hinna ja nähtavuse vahelist suhet, nagu on näidatud järgmisel joonisel.

Selles näites on nähtavus konkurendi 1 suhtes peaaegu tükkhaaval konstantne funktsioon, mis viitab sellele, et nähtavaks saamiseks peame peamiselt alandama hinda alla teatud läve, ligikaudu konkurendi hinna. Siiski ei vähene nähtavus konkurendi 2 ees nii järsult. Lisaks on meil 50% tõenäosus olla nähtav ka väga kõrge hinnaga. Sisendandmeid analüüsides selgus, et konkurendi hinnanguid on vähe, mis juhtuvad olema väga kehvad. Meie mudel sai teada, et see konkreetne e-kaubanduse platvorm seab kehva tagasiside reitinguga müüjad ebasoodsasse olukorda. Avastasime sarnase efekti ka muude funktsioonide puhul, nagu täitmiskanal ja tarneajad.

Vajalikud andmete teisendused ja järeldused SageMakeri lõpp-punkti suhtes on rakendatud AWS Glue'is. AWS-i liimitöö töötab mikropartiidena Lambdast kogutud reaalajas andmete põhjal.

Lõpuks tahame arvutada nähtavuse koondkõvera, mis on iga võimaliku hinna prognoositav nähtavus. Meie pakkumine on nähtav, kui see on parem kõigi teiste müüjate pakkumistest. Eeldades meie hinna juures iga müüja suhtes nähtavaks olemise tõenäosuste sõltumatust, on tõenäosus olla nähtav kõigi müüjate suhtes vastavate tõenäosuste korrutis. See tähendab, et nähtavuse koondkõvera saab arvutada kõigi kõverate korrutamisega.

Järgmised joonised näitavad SageMakeri lõpp-punktist tagastatud prognoositavaid nähtavusi.

Järgmine joonis näitab koondatud nähtavuse kõverat.

Optimaalse hinna arvutamiseks silutakse esmalt nähtavuskõver ja korrutatakse seejärel marginaaliga. Marginaali arvutamiseks kasutame kaubakulusid ja tasusid. Müüdud kaupade maksumus ja tasud on AWS-i DMS-i kaudu sünkroonitud staatiline tooteteave. Kasumifunktsiooni alusel arvutab Adspert optimaalse hinna ja esitab selle platvormi API kaudu e-kaubanduse platvormile.

Seda rakendatakse AWS Lambda prognoosi optimeerijas.

Järgmine joonis näitab prognoositava nähtavuse ja hinna suhet.

Järgmine joonis näitab hinna ja kasumi suhet.

Järeldus

Adsperti olemasolev lähenemisviis kasumi maksimeerimisele on keskendunud pakkumiste haldamisele, et suurendada reklaamitulu. Suurema jõudluse saavutamiseks poodide turgudel peavad müüjad aga arvestama nii reklaamiga kui ka oma toodete konkurentsivõimelise hinnaga. Selle uue nähtavuse ennustamise ML-mudeliga saame laiendada oma funktsioone, et kohandada ka klientide hindu.

Uus hinnakujundustööriist peab olema suuteline ML-mudeli automatiseerimiseks suurel hulgal andmemahtudel, samuti reaalajas andmete teisendusi, prognoose ja hindade optimeerimist. Selles postituses käisime läbi meie hinna optimeerimise mootori põhietapid ja AWS-i arhitektuuri, mille rakendasime koostöös AWS Data Labiga nende eesmärkide saavutamiseks.

ML-mudelite viimine kontseptsioonist tootmiseni on tavaliselt keeruline ja aeganõudev. Mudeli treenimiseks peate haldama suuri andmemahtusid, valima selle treenimiseks parima algoritmi, haldama treenimise ajal arvutusvõimsust ja seejärel juurutama mudeli tootmiskeskkonda. SageMaker vähendas seda keerukust, muutes ML-mudeli loomise ja juurutamise palju lihtsamaks. Pärast seda, kui valisime paljude saadaolevate valikute hulgast õiged algoritmid ja raamistikud, haldas SageMaker kogu aluseks olevat infrastruktuuri, et koolitada meie mudel ja juurutada see tootmisse.

Kui soovite SageMakeriga tutvuma hakata, Keelekümbluspäeva töötuba aitab teil saada täielikku arusaama ML-i kasutusjuhtude loomisest funktsioonide projekteerimise, erinevate sisseehitatud algoritmide ja ML-i mudeli treenimise, häälestamise ja kasutuselevõtu kohta tootmisega sarnases stsenaariumis. See juhendab teid tooma oma mudeli ja teostama kohapealset ML-i töökoormuse tõstmist ja nihutamist SageMakeri platvormile. See demonstreerib veelgi täiustatud kontseptsioone, nagu mudelite silumine, mudeli jälgimine ja AutoML, ning aitab teil hinnata oma ML-i töökoormust läbi AWS ML hästiarhitekteeritud objektiivi.

Kui soovite abi andmete, analüütika, tehisintellekti ja ML-i, serverita ja konteinerite moderniseerimisega seotud kasutusjuhtude rakendamise kiirendamisel, võtke ühendust AWS-i andmelabor.

Autoritest

Viktor Enrico Jeney on Adsperti masinõppe vaneminsener, mis asub Berliinis, Saksamaal. Ta loob lahendusi prognoosimis- ja optimeerimisprobleemidele, et suurendada klientide kasumit. Viktoril on rakendusmatemaatika taust ja talle meeldib andmetega töötada. Vabal ajal meeldib talle õppida ungari keelt, harjutada võitluskunste ja mängida kitarri.

Ennio Pastore on AWS Data Labi meeskonna andmearhitekt. Ta on entusiast kõigest, mis on seotud uute tehnoloogiatega, millel on positiivne mõju ettevõtlusele ja üldisele toimetulekule. Enniol on üle 9-aastane andmeanalüütika kogemus. Ta aitab ettevõtetel määratleda ja juurutada andmeplatvorme erinevates tööstusharudes, nagu telekommunikatsioon, pangandus, hasartmängud, jaekaubandus ja kindlustus.