Optimale prijsstelling voor maximale winst met Amazon SageMaker

Dit is een gastpost van Viktor Enrico Jeney, Senior Machine Learning Engineer bij Adspert.

Advertentie is een in Berlijn gevestigde ISV die een tool voor biedingsbeheer heeft ontwikkeld die is ontworpen om automatisch prestatiemarketing en advertentiecampagnes te optimaliseren. Het kernprincipe van het bedrijf is om de winstmaximalisatie van e-commerce-advertenties te automatiseren met behulp van kunstmatige intelligentie. De voortdurende ontwikkeling van advertentieplatforms maakt de weg vrij voor nieuwe kansen, die Adspert vakkundig benut voor het succes van hun klanten.

Het primaire doel van Adspert is om het proces voor gebruikers te vereenvoudigen en tegelijkertijd advertentiecampagnes op verschillende platforms te optimaliseren. Dit omvat het gebruik van informatie die is verzameld over de verschillende platforms, afgewogen tegen het optimale budget dat is ingesteld op een niveau boven elk platform. De focus van Adspert is het optimaliseren van het bereiken van de doelen van een klant, ongeacht welk platform wordt gebruikt. Adspert blijft waar nodig platforms toevoegen om onze klanten aanzienlijke voordelen te bieden.

In dit bericht delen we hoe Adspert de prijstool helemaal opnieuw heeft gemaakt met behulp van verschillende AWS-services zoals: Amazon Sage Maker en hoe Adspert samenwerkte met de AWS-datalab om dit project van ontwerp tot bouw in recordtijd te versnellen.

De prijstool herprijst een door de verkoper geselecteerd product op een e-commercemarktplaats op basis van de zichtbaarheid en winstmarge om de winst op productniveau te maximaliseren.

Als verkoper is het essentieel dat uw producten altijd zichtbaar zijn, omdat dit de verkoop zal verhogen. De belangrijkste factor bij e-commerceverkoop is simpelweg of uw aanbieding zichtbaar is voor klanten in plaats van die van een concurrent.

Hoewel het zeker afhangt van het specifieke e-commerceplatform, hebben we ontdekt dat de productprijs een van de belangrijkste kerncijfers is die de zichtbaarheid kunnen beïnvloeden. Prijzen veranderen echter vaak en snel; om deze reden moet de prijstool in bijna realtime handelen om de zichtbaarheid te vergroten.

Overzicht van de oplossing

Het volgende diagram illustreert de oplossingsarchitectuur.

De oplossing bevat de volgende componenten:

1. Amazon Relational Database Service (Amazon RDS) voor PostgreSQL is de belangrijkste gegevensbron met productinformatie die is opgeslagen in een RDS voor Postgres-database.
2. Informatie over wijzigingen in productvermeldingen arriveert in realtime in een Amazon Simple Queue-service (Amazon SQS) wachtrij.
3. Productinformatie die is opgeslagen in Amazon RDS wordt in bijna realtime opgenomen in de onbewerkte laag met behulp van het change data capture-patroon (CDC) dat beschikbaar is in AWS-databasemigratieservice (AWS-DMS).
4. Meldingen met productvermeldingen afkomstig van Amazon SQS worden in bijna realtime opgenomen in de onbewerkte laag met behulp van een AWS Lambda functie.
5. De originele brongegevens worden opgeslagen in de Amazon eenvoudige opslagservice (Amazon S3) onbewerkte laagemmer met Parquet-gegevensformaat. Deze laag is de enige bron van waarheid voor het datameer. De partitionering die op deze opslag wordt gebruikt, ondersteunt de incrementele verwerking van gegevens.
6. AWS lijm Taken voor extraheren, transformeren en laden (ETL) ruimen de productgegevens op, verwijderen duplicaten en passen gegevensconsolidatie en generieke transformaties toe die niet gebonden zijn aan een specifieke businesscase.
7. De Amazon S3-podiumlaag ontvangt voorbereide gegevens die worden opgeslagen in Apache Parquet-formaat voor verdere verwerking. De partitionering die in de stage store wordt gebruikt, ondersteunt de incrementele verwerking van gegevens.
8. De AWS Glue-taken die in deze laag zijn gemaakt, gebruiken de gegevens die beschikbaar zijn in de Amazon S3-faselaag. Dit omvat toepassing van use case-specifieke bedrijfsregels en vereiste berekeningen. De resultaatgegevens van deze taken worden opgeslagen in de Amazon S3-analyselaag.
9. De Amazon S3-analyselaag wordt gebruikt om de gegevens op te slaan die door de ML-modellen worden gebruikt voor trainingsdoeleinden. De partitionering die in de beheerde winkel wordt gebruikt, is gebaseerd op het verwachte gegevensgebruik. Dit kan verschillen van de partitionering die op de podiumlaag wordt gebruikt.
10. Het herprijzende ML-model is een Scikit-Learn Random Forest-implementatie in SageMaker Script Mode, die wordt getraind met behulp van gegevens die beschikbaar zijn in de S3-bucket (de analyselaag).
11. Een AWS Glue-gegevensverwerkingstaak bereidt gegevens voor op de realtime gevolgtrekking. De taak verwerkt gegevens die zijn opgenomen in de S3-bucket (faselaag) en roept het SageMaker-inferentie-eindpunt aan. De gegevens zijn voorbereid om te worden gebruikt door het SageMaker-herprijzingsmodel. AWS Glue kreeg de voorkeur boven Lambda, omdat de inferentie verschillende complexe gegevensverwerkingsoperaties vereist, zoals joins en vensterfuncties op een grote hoeveelheid gegevens (miljarden dagelijkse transacties). Het resultaat van de aanroepingen van het prijsherzieningsmodel wordt opgeslagen in de S3-bucket (inferentielaag).
12. De SageMaker-trainingstaak wordt geïmplementeerd met behulp van een SageMaker-eindpunt. Dit eindpunt wordt aangeroepen door de AWS Glue-inferentieprocessor, die bijna-realtime prijsaanbevelingen genereert om de productzichtbaarheid te vergroten.
13. De voorspellingen die worden gegenereerd door het SageMaker-inferentie-eindpunt worden opgeslagen in de Amazon S3-inferentielaag.
14. De optimalisatiefunctie voor Lambda-voorspellingen verwerkt de aanbevelingen die zijn gegenereerd door het SageMaker-inferentie-eindpunt en genereert een nieuwe prijsaanbeveling die zich richt op het maximaliseren van de winst van de verkoper, waarbij een afweging wordt gemaakt tussen verkoopvolume en verkoopmarge.
15. De prijsaanbevelingen die door de Lambda-voorspellingsoptimalisatie worden gegenereerd, worden ingediend bij de API voor herprijzen, die de productprijs op de markt bijwerkt.
16. De bijgewerkte prijsaanbevelingen die door de Lambda-voorspellingsoptimalisatie worden gegenereerd, worden opgeslagen in de Amazon S3-optimalisatielaag.
17. De taak van de AWS Glue-voorspellingslader laadt de voorspellingen die door het ML-model zijn gegenereerd voor controle- en rapportagedoeleinden opnieuw in de bron-RDS voor Postgres SQL-database. AWS Glue Studio werd gebruikt om dit onderdeel te implementeren; het is een grafische interface waarmee u eenvoudig ETL-taken in AWS Glue kunt maken, uitvoeren en bewaken.

Data voorbereiding

De dataset voor het zichtbaarheidsmodel van Adspert wordt gemaakt op basis van een SQS-wachtrij en in realtime opgenomen in de onbewerkte laag van ons datameer met Lambda. Daarna worden de onbewerkte gegevens opgeschoond door eenvoudige transformaties uit te voeren, zoals het verwijderen van duplicaten. Dit proces is geïmplementeerd in AWS Glue. Het resultaat wordt opgeslagen in de staging-laag van ons datameer. De meldingen geven de concurrenten voor een bepaald product hun prijzen, uitvoeringskanalen, verzendtijden en nog veel meer variabelen. Ze bieden ook een platformafhankelijke zichtbaarheidsmaatstaf, die kan worden uitgedrukt als een Booleaanse variabele (zichtbaar of niet zichtbaar). We ontvangen een melding wanneer er een aanbiedingswijziging plaatsvindt, wat neerkomt op enkele miljoenen evenementen per maand voor alle producten van onze klanten.

Uit deze dataset halen we de trainingsgegevens als volgt: voor elke melding koppelen we de zichtbare aanbiedingen aan elke niet-zichtbare aanbieding en vice versa. Elk datapunt vertegenwoordigt een competitie tussen twee verkopers, waarin er een duidelijke winnaar en verliezer is. Deze verwerkingstaak wordt geïmplementeerd in een AWS Glue-taak met Spark. De voorbereide trainingsdataset wordt naar de Analytics S3-bucket gepusht om door SageMaker te worden gebruikt.

Train het model

Ons model classificeert voor elk paar aanbiedingen, of een bepaald aanbod zichtbaar zal zijn. Dit model stelt ons in staat om de beste prijs voor onze klanten te berekenen, de zichtbaarheid op basis van concurrentie te vergroten en hun winst te maximaliseren. Bovendien kan dit classificatiemodel ons dieper inzicht geven in de redenen waarom onze vermeldingen wel of niet zichtbaar zijn. Wij gebruiken de volgende functies:

• Verhouding van onze prijs tot de prijzen van concurrenten
• Verschil in afhandelingskanalen
• Hoeveelheid feedback voor elke verkoper
• Feedbackbeoordeling van elke verkoper
• Verschil in minimale verzendtijden
• Verschil in maximale verzendtijden
• Beschikbaarheid van het product van elke verkoper

Adspert gebruikt SageMaker om het model te trainen en te hosten. We gebruiken Scikit-Learn Random Forest-implementatie in SageMaker-scriptmodus. We nemen ook enkele voorbewerking van functies rechtstreeks op in de Scikit-Learn-pijplijn in het trainingsscript. Zie de volgende code:

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)

Een van de belangrijkste voorbewerkingsfuncties is: transform_price, die de prijs deelt door het minimum van de prijs van de concurrent en een externe prijskolom. We hebben geconstateerd dat deze functie een relevante invloed heeft op de nauwkeurigheid van het model. We passen ook de logaritme toe om het model te laten beslissen op basis van relatieve prijsverschillen, niet op absolute prijsverschillen.

In het training_script.py script, definiëren we eerst hoe de Scikit-Learn . te bouwen ColumnTransformer om de gespecificeerde transformatoren toe te passen op de kolommen van een dataframe:

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

In het trainingsscript laden we de gegevens van Parquet in een Pandas-dataframe, definiëren we de pijplijn van de ColumnTranformer en RandomForestClassifieren train het model. Daarna wordt het model geserialiseerd met behulp van 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'))

In het trainingsscript moeten we ook functies voor gevolgtrekking implementeren:

• invoer_fn – Is verantwoordelijk voor het ontleden van de gegevens van de aanvraagtekst van de payload
• model_fn - Laadt en retourneert het model dat is gedumpt in het trainingsgedeelte van het script
• voorspellen_fn – Bevat onze implementatie om een ​​voorspelling van het model op te vragen met behulp van de gegevens van de payload
• voorspellen_proba – Om voorspelde zichtbaarheidscurven te tekenen, retourneren we de klassekans met behulp van de predict_proba functie, in plaats van de binaire voorspelling van de classifier

Zie de volgende code:

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

De volgende afbeelding toont de op onzuiverheden gebaseerde functiebelangen die worden geretourneerd door de Willekeurige bosclassificatie.

Met SageMaker waren we in staat om het model te trainen op een grote hoeveelheid gegevens (tot 14 miljard dagelijkse transacties) zonder onze bestaande instanties te belasten of een aparte machine met voldoende middelen op te zetten. Bovendien was de training met SageMaker, omdat de instances direct na de trainingstaak worden afgesloten, zeer kostenefficiënt. De modelimplementatie met SageMaker werkte zonder extra werklast. Een enkele functieaanroep in de Python SDK is voldoende om ons model als een inferentie-eindpunt te hosten, en het kan ook eenvoudig worden aangevraagd bij andere services met behulp van de SageMaker Python SDK. Zie de volgende code:

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

Het modelartefact wordt opgeslagen in Amazon S3 door de fit-functie. Zoals te zien is in de volgende code, kan het model worden geladen als a SKLearnModel object met behulp van het modelartefact, het scriptpad en enkele andere parameters. Daarna kan het worden ingezet op het gewenste exemplaartype en aantal exemplaren.

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
)

Evalueer het model in realtime

Wanneer er een nieuwe melding wordt verzonden voor een van onze producten, willen we de optimale prijs berekenen en indienen. Om optimale prijzen te berekenen, creëren we een voorspellingsdataset waarin we ons eigen aanbod vergelijken met het aanbod van elke concurrent voor een reeks mogelijke prijzen. Deze gegevenspunten worden doorgegeven aan het SageMaker-eindpunt, dat de voorspelde waarschijnlijkheid retourneert om voor elke gegeven prijs zichtbaar te zijn voor elke concurrent. We noemen de kans om zichtbaar te zijn de voorspelde zichtbaarheid. Het resultaat kan worden gevisualiseerd als een curve voor elke concurrent, die de relatie tussen onze prijs en de zichtbaarheid weergeeft, zoals weergegeven in de volgende afbeelding.

In dit voorbeeld is de zichtbaarheid ten opzichte van concurrent 1 bijna een stuksgewijs constante functie, wat suggereert dat we vooral de prijs onder een bepaalde drempel, ruwweg de prijs van de concurrent, moeten verlagen om zichtbaar te worden. De zichtbaarheid tegen Competitor 2 neemt echter niet zo sterk af. Bovendien hebben we nog steeds 50% kans om zichtbaar te zijn, zelfs met een zeer hoge prijs. Analyse van de invoergegevens bracht aan het licht dat de concurrent een laag aantal beoordelingen heeft, die erg slecht zijn. Ons model heeft geleerd dat dit specifieke e-commerceplatform een ​​nadeel geeft aan verkopers met slechte feedbackbeoordelingen. We ontdekten vergelijkbare effecten voor de andere functies, zoals het afhandelingskanaal en de verzendtijden.

De nodige gegevenstransformaties en gevolgtrekkingen tegen het SageMaker-eindpunt worden geïmplementeerd in AWS Glue. De AWS Glue-taak werkt in microbatches op de realtime gegevens die zijn opgenomen uit Lambda.

Ten slotte willen we de geaggregeerde zichtbaarheidscurve berekenen, de voorspelde zichtbaarheid voor elke mogelijke prijs. Ons aanbod is zichtbaar als het beter is dan de aanbiedingen van alle andere verkopers. Uitgaande van onafhankelijkheid tussen de kansen om zichtbaar te zijn voor elke verkoper gezien onze prijs, is de kans om zichtbaar te zijn voor alle verkopers het product van de respectieve kansen. Dat betekent dat de geaggregeerde zichtbaarheidscurve kan worden berekend door alle curven te vermenigvuldigen.

De volgende afbeeldingen tonen de voorspelde zichtbaarheid die wordt geretourneerd door het SageMaker-eindpunt.

De volgende afbeelding toont de geaggregeerde zichtbaarheidscurve.

Om de optimale prijs te berekenen, wordt de zichtbaarheidscurve eerst afgevlakt en vervolgens vermenigvuldigd met de marge. Voor het berekenen van de marge gebruiken we de kosten van goederen en de erelonen. De kosten van verkochte goederen en vergoedingen zijn de statische productinformatie die wordt gesynchroniseerd via AWS DMS. Op basis van de winstfunctie berekent Adspert de optimale prijs en legt deze via de API van het platform voor aan het e-commerceplatform.

Dit is geïmplementeerd in de AWS Lambda-voorspellingsoptimalisatie.

De volgende afbeelding toont de relatie tussen voorspelde zichtbaarheid en prijs.

De volgende figuur toont de relatie tussen prijs en winst.

Conclusie

De bestaande benadering van Adspert voor winstmaximalisatie is gericht op biedingsbeheer om het rendement van advertenties te vergroten. Om superieure prestaties op e-commercemarktplaatsen te bereiken, moeten verkopers echter rekening houden met zowel advertenties als concurrerende prijzen van hun producten. Met dit nieuwe ML-model om zichtbaarheid te voorspellen, kunnen we onze functionaliteit uitbreiden om ook de prijzen van klanten aan te passen.

De nieuwe prijstool moet in staat zijn om het ML-model op een grote hoeveelheid gegevens geautomatiseerd te trainen, evenals realtime gegevenstransformaties, voorspellingen en prijsoptimalisaties. In dit bericht hebben we de belangrijkste stappen van onze prijsoptimalisatie-engine doorlopen en de AWS-architectuur die we hebben geïmplementeerd in samenwerking met het AWS Data Lab om die doelen te bereiken.

Het is doorgaans complex en tijdrovend om ML-modellen van concept tot productie te brengen. U moet grote hoeveelheden gegevens beheren om het model te trainen, het beste algoritme kiezen om het te trainen, de rekencapaciteit beheren tijdens het trainen en het model vervolgens implementeren in een productieomgeving. SageMaker verminderde deze complexiteit door het veel eenvoudiger te maken om het ML-model te bouwen en te implementeren. Nadat we de juiste algoritmen en frameworks hadden gekozen uit het brede scala aan beschikbare keuzes, beheerde SageMaker alle onderliggende infrastructuur om ons model te trainen en in productie te nemen.

Als u vertrouwd wilt raken met SageMaker, kunt u de Onderdompelingsdag workshop kan u helpen een end-to-end begrip te krijgen van hoe u ML-gebruiksscenario's kunt bouwen op basis van feature-engineering, de verschillende ingebouwde algoritmen, en hoe u het ML-model kunt trainen, afstemmen en implementeren in een productie-achtig scenario. Het begeleidt u bij het meenemen van uw eigen model en het uitvoeren van een on-premise ML-workload lift-and-shift naar het SageMaker-platform. Het demonstreert verder geavanceerde concepten zoals modelfoutopsporing, modelbewaking en AutoML, en helpt u uw ML-werklast te evalueren via de AWS ML Well-Architected-lens.

Neem contact op met de AWS-datalab.

Over de auteurs

Victor Enrico Jeney is een Senior Machine Learning Engineer bij Adspert in Berlijn, Duitsland. Hij creëert oplossingen voor voorspellings- en optimalisatieproblemen om de winst van klanten te vergroten. Viktor heeft een achtergrond in toegepaste wiskunde en werkt graag met data. In zijn vrije tijd leert hij graag Hongaars, beoefent hij vechtsporten en speelt hij gitaar.

Ennio Pastore is een data-architect in het AWS Data Lab-team. Hij is een liefhebber van alles wat te maken heeft met nieuwe technologieën die een positieve impact hebben op bedrijven en het algemeen levensonderhoud. Ennio heeft meer dan 9 jaar ervaring in data-analyse. Hij helpt bedrijven bij het definiëren en implementeren van dataplatforms in verschillende sectoren, zoals telecommunicatie, bankieren, gaming, detailhandel en verzekeringen.