Optymalna cena dla maksymalnego zysku dzięki Amazon SageMaker

To jest gościnny post Viktora Enrico Jeneya, starszego inżyniera uczenia maszynowego w Adspert.

Reklamodawca to niezależny dostawca oprogramowania z siedzibą w Berlinie, który opracował narzędzie do zarządzania stawkami, które ma na celu automatyczną optymalizację efektywności kampanii marketingowych i kampanii reklamowych. Podstawową zasadą firmy jest automatyzacja maksymalizacji zysku z reklamy e-commerce za pomocą sztucznej inteligencji. Ciągły rozwój platform reklamowych toruje drogę do nowych możliwości, które Adspert umiejętnie wykorzystuje dla sukcesu swoich klientów.

Głównym celem Adspert jest uproszczenie procesu dla użytkowników przy jednoczesnej optymalizacji kampanii reklamowych na różnych platformach. Obejmuje to wykorzystanie informacji zebranych na różnych platformach w stosunku do optymalnego budżetu ustalonego na poziomie powyżej każdej platformy. Celem Adspert jest optymalizacja realizacji celów klienta, niezależnie od używanej platformy. Adspert kontynuuje dodawanie platform w miarę potrzeb, aby zapewnić naszym klientom znaczne korzyści.

W tym poście dzielimy się tym, jak Adspert stworzył od podstaw narzędzie do wyceny, korzystając z różnych usług AWS, takich jak Amazon Sage Maker i jak Adspert współpracował z Laboratorium danych AWS przyspieszyć ten projekt od projektu do budowy w rekordowym czasie.

Narzędzie wyceny dokonuje ponownej wyceny wybranego przez sprzedawcę produktu na rynku e-commerce w oparciu o widoczność i marżę zysku, aby zmaksymalizować zyski na poziomie produktu.

Jako sprzedawca ważne jest, aby Twoje produkty były zawsze widoczne, ponieważ zwiększy to sprzedaż. Najważniejszym czynnikiem w sprzedaży e-commerce jest po prostu to, czy Twoja oferta jest widoczna dla klientów, a nie oferta konkurencji.

Chociaż z pewnością zależy to od konkretnej platformy e-commerce, odkryliśmy, że cena produktu jest jedną z najważniejszych kluczowych wartości, które mogą wpływać na widoczność. Jednak ceny zmieniają się często i szybko; z tego powodu narzędzie wyceny musi działać w czasie zbliżonym do rzeczywistego, aby zwiększyć widoczność.

Przegląd rozwiązania

Poniższy schemat ilustruje architekturę rozwiązania.

Rozwiązanie zawiera następujące składniki:

1. Usługa relacyjnej bazy danych Amazon (Amazon RDS) dla PostgreSQL jest głównym źródłem danych, zawierającym informacje o produktach, które są przechowywane w bazie danych RDS dla Postgres.
2. Informacje o zmianach na liście produktów docierają w czasie rzeczywistym w Usługa Amazon Simple Queue (Amazon SQS) kolejka.
3. Informacje o produkcie przechowywane w Amazon RDS są przetwarzane w czasie zbliżonym do rzeczywistego do warstwy nieprzetworzonej przy użyciu wzorca przechwytywania zmian danych (CDC) dostępnego w Usługa migracji bazy danych AWS (AWS DMS).
4. Powiadomienia o liście produktów pochodzące z Amazon SQS są przetwarzane w czasie zbliżonym do rzeczywistego do warstwy nieprzetworzonej za pomocą AWS Lambda funkcja.
5. Oryginalne dane źródłowe są przechowywane w Usługa Amazon Simple Storage (Amazon S3) wiadro z surowymi warstwami w formacie danych Parquet. Ta warstwa jest jedynym źródłem prawdy dla jeziora danych. Partycjonowanie używane w tym magazynie obsługuje przyrostowe przetwarzanie danych.
6. Klej AWS zadania wyodrębniania, przekształcania i ładowania (ETL) czyszczą dane produktu, usuwają duplikaty oraz stosują konsolidację danych i ogólne przekształcenia niezwiązane z konkretnym przypadkiem biznesowym.
7. Warstwa sceniczna Amazon S3 otrzymuje przygotowane dane, które są przechowywane w formacie Apache Parquet do dalszego przetwarzania. Partycjonowanie używane w magazynie na scenie obsługuje przyrostowe przetwarzanie danych.
8. Zadania AWS Glue utworzone w tej warstwie wykorzystują dane dostępne w warstwie etapowej Amazon S3. Obejmuje to stosowanie reguł biznesowych specyficznych dla przypadku użycia i wymaganych obliczeń. Dane wyników z tych zadań są przechowywane w warstwie analitycznej Amazon S3.
9. Warstwa analityczna Amazon S3 służy do przechowywania danych wykorzystywanych przez modele ML do celów szkoleniowych. Partycjonowanie używane w wyselekcjonowanym magazynie jest oparte na oczekiwanym użyciu danych. Może się to różnić od partycjonowania używanego w warstwie stołu montażowego.
10. Model przeszacowania ML to implementacja Scikit-Learn Random Forest w trybie SageMaker Script Mode, która jest szkolona przy użyciu danych dostępnych w zasobniku S3 (warstwa analityczna).
11. Zadanie przetwarzania danych AWS Glue przygotowuje dane do wnioskowania w czasie rzeczywistym. Zadanie przetwarza dane pozyskiwane w zasobniku S3 (warstwa etapowa) i wywołuje punkt końcowy wnioskowania SageMaker. Dane są przygotowane do wykorzystania przez model przeszacowania SageMaker. AWS Glue był preferowany od Lambda, ponieważ wnioskowanie wymaga różnych złożonych operacji przetwarzania danych, takich jak łączenia i funkcje okien na dużej ilości danych (miliardy codziennych transakcji). Wynik wywołań modelu przeszacowania jest przechowywany w zasobniku S3 (warstwa wnioskowania).
12. Zadanie szkoleniowe SageMaker jest wdrażane przy użyciu punktu końcowego SageMaker. Ten punkt końcowy jest wywoływany przez procesor wnioskowania AWS Glue, generując rekomendacje cenowe w czasie zbliżonym do rzeczywistego w celu zwiększenia widoczności produktu.
13. Predykcje generowane przez punkt końcowy wnioskowania SageMaker są przechowywane w warstwie wnioskowania Amazon S3.
14. Funkcja optymalizatora prognoz Lambda przetwarza rekomendacje generowane przez punkt końcowy wnioskowania SageMaker i generuje nową rekomendację cenową, która koncentruje się na maksymalizacji zysku sprzedawcy, stosując kompromis między wielkością sprzedaży a marżą sprzedaży.
15. Rekomendacje cenowe generowane przez optymalizator prognoz Lambda są przesyłane do interfejsu API przecen, który aktualizuje cenę produktu na rynku.
16. Zaktualizowane rekomendacje cenowe generowane przez optymalizator prognoz Lambda są przechowywane w warstwie optymalizacji Amazon S3.
17. Zadanie ładujące prognozy AWS Glue ponownie ładuje do źródłowej bazy danych RDS dla Postgres SQL prognozy wygenerowane przez model ML do celów audytu i raportowania. Do zaimplementowania tego komponentu użyto AWS Glue Studio; jest to interfejs graficzny, który ułatwia tworzenie, uruchamianie i monitorowanie zadań ETL w AWS Glue.

Przygotowywanie danych

Zestaw danych dla modelu widoczności Adspert jest tworzony z kolejki SQS i pozyskiwany w nieprzetworzonej warstwie naszego jeziora danych w czasie rzeczywistym za pomocą Lambda. Następnie surowe dane są oczyszczane przez wykonanie prostych przekształceń, takich jak usuwanie duplikatów. Proces ten jest zaimplementowany w AWS Glue. Wynik jest przechowywany w warstwie tymczasowej naszego jeziora danych. Powiadomienia dostarczają konkurentów dla danego produktu, z ich cenami, kanałami realizacji, czasem wysyłki i wieloma innymi zmiennymi. Zapewniają również miarę widoczności zależną od platformy, która może być wyrażona jako zmienna logiczna (widoczna lub niewidoczna). Otrzymujemy powiadomienie za każdym razem, gdy nastąpi zmiana oferty, co w sumie daje kilka milionów zdarzeń miesięcznie we wszystkich produktach naszych klientów.

Z tego zbioru danych wyodrębniamy dane treningowe w następujący sposób: dla każdego powiadomienia łączymy widoczne oferty z każdą niewidoczną ofertą i na odwrót. Każdy punkt danych reprezentuje konkurencję między dwoma sprzedawcami, w której jest wyraźny zwycięzca i przegrany. To zadanie przetwarzania jest zaimplementowane w zadaniu AWS Glue za pomocą Spark. Przygotowany treningowy zestaw danych jest przekazywany do zasobnika analitycznego S3, który ma być używany przez SageMaker.

Trenuj model

Nasz model klasyfikuje dla każdej pary ofert, czy dana oferta będzie widoczna. Ten model pozwala nam obliczyć najlepszą cenę dla naszych klientów, zwiększyć widoczność w oparciu o konkurencję i zmaksymalizować ich zysk. Ponadto ten model klasyfikacji może dać nam głębszy wgląd w powody, dla których nasze aukcje są widoczne lub niewidoczne. Korzystamy z następujących funkcji:

• Stosunek naszej ceny do cen konkurencji
• Różnica w kanałach realizacji
• Ilość opinii dla każdego sprzedawcy
• Ocena w ramach opinii każdego sprzedawcy
• Różnica w minimalnym czasie wysyłki
• Różnica w maksymalnym czasie wysyłki
• Dostępność produktu każdego sprzedawcy

Adspert używa programu SageMaker do trenowania i hostowania modelu. Używamy implementacji Scikit-Learn Random Forest w Tryb SageMakera. Uwzględniamy również wstępne przetwarzanie niektórych funkcji bezpośrednio w potoku Scikit-Learn w skrypcie szkoleniowym. Zobacz następujący kod:

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)

Jedną z najważniejszych funkcji przetwarzania wstępnego jest transform_price, która dzieli cenę przez minimum ceny konkurenta i zewnętrzną kolumnę ceny. Odkryliśmy, że ta funkcja ma istotny wpływ na dokładność modelu. Stosujemy również logarytm, aby pozwolić modelowi decydować na podstawie względnych różnic cen, a nie bezwzględnych różnic cen.

W training_script.py skrypt, najpierw definiujemy, jak zbudować Scikit-Learn ColumnTransformer aby zastosować określone transformatory do kolumn ramki danych:

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

W skrypcie szkoleniowym ładujemy dane z Parquet do ramki danych Pandas, definiujemy potok ColumnTranformer oraz RandomForestClassifieri trenuj model. Następnie model jest serializowany przy użyciu 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'))

W skrypcie szkoleniowym musimy również zaimplementować funkcje do wnioskowania:

• wejście_fn – odpowiada za parsowanie danych z treści żądania ładunku
• model_fn – Wczytuje i zwraca model, który został zrzucony w sekcji szkoleniowej skryptu
• przewidywać_fn – Zawiera naszą implementację do żądania predykcji z modelu przy użyciu danych z ładunku
• przewidywać_proba – Aby narysować przewidywane krzywe widoczności, zwracamy prawdopodobieństwo klasy za pomocą predict_proba funkcji, zamiast binarnej predykcji klasyfikatora

Zobacz następujący kod:

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

Poniższy rysunek przedstawia ważność funkcji opartych na zanieczyszczeniach zwróconą przez Losowy klasyfikator lasu.

Dzięki SageMaker byliśmy w stanie trenować model na dużej ilości danych (do 14 miliardów codziennych transakcji) bez obciążania naszych istniejących instancji lub konieczności konfigurowania oddzielnej maszyny z wystarczającymi zasobami. Co więcej, ponieważ instancje są wyłączane natychmiast po zakończeniu szkolenia, szkolenie z SageMakerem było niezwykle opłacalne. Wdrożenie modelu za pomocą SageMaker działało bez dodatkowego obciążenia. Pojedyncze wywołanie funkcji w pakiecie Python SDK jest wystarczające do hostowania naszego modelu jako punktu końcowego wnioskowania i można go łatwo zażądać również z innych usług za pomocą pakietu SageMaker Python SDK. Zobacz następujący kod:

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 modelu jest przechowywany w Amazon S3 przez funkcję dopasowania. Jak widać w poniższym kodzie, model można załadować jako SKLearnModel obiekt przy użyciu artefaktu modelu, ścieżki skryptu i kilku innych parametrów. Następnie można go wdrożyć w żądanym typie instancji i liczbie instancji.

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
)

Oceń model w czasie rzeczywistym

Za każdym razem, gdy wysyłane jest nowe powiadomienie dotyczące jednego z naszych produktów, chcemy obliczyć i przedstawić optymalną cenę. Aby obliczyć optymalne ceny, tworzymy zestaw danych predykcyjnych, w którym porównujemy naszą własną ofertę z ofertą każdego konkurenta w zakresie możliwych cen. Te punkty danych są przekazywane do punktu końcowego SageMaker, który zwraca przewidywane prawdopodobieństwo bycia widocznym dla każdego konkurenta dla każdej podanej ceny. Prawdopodobieństwo bycia widocznym nazywamy przewidywana widoczność. Wynik można zwizualizować jako krzywą dla każdego konkurenta, przedstawiającą zależność między naszą ceną a widocznością, jak pokazano na poniższym rysunku.

W tym przykładzie widoczność w stosunku do konkurenta 1 jest prawie fragmentarycznie stałą funkcją, co sugeruje, że aby stać się widocznym, musimy głównie obniżyć cenę poniżej pewnego progu, mniej więcej cenę konkurenta. Jednak widoczność w stosunku do Konkurenta 2 nie spada tak gwałtownie. Co więcej, nadal mamy 50% szans na bycie widocznym nawet przy bardzo wysokiej cenie. Analiza danych wejściowych wykazała, że ​​konkurent ma niską liczbę ocen, które bywają bardzo słabe. Nasz model wykazał, że ta konkretna platforma e-commerce jest niekorzystna dla sprzedawców z niskimi ocenami opinii. Odkryliśmy podobne efekty w przypadku innych funkcji, takich jak kanał realizacji i czas dostawy.

Niezbędne przekształcenia danych i wnioski dotyczące punktu końcowego SageMaker są zaimplementowane w AWS Glue. Zadanie AWS Glue działa w mikro-partiach na danych w czasie rzeczywistym pozyskiwanych z Lambda.

Na koniec chcemy obliczyć zagregowaną krzywą widoczności, która jest przewidywaną widocznością dla każdej możliwej ceny. Nasza oferta jest widoczna, jeśli jest lepsza niż wszystkie oferty innych sprzedawców. Zakładając niezależność prawdopodobieństw bycia widocznym dla każdego sprzedawcy przy naszej cenie, prawdopodobieństwo bycia widocznym dla wszystkich sprzedawców jest iloczynem odpowiednich prawdopodobieństw. Oznacza to, że zagregowaną krzywą widoczności można obliczyć, mnożąc wszystkie krzywe.

Poniższe rysunki przedstawiają przewidywane widoczności zwrócone z punktu końcowego SageMaker.

Poniższy rysunek przedstawia zagregowaną krzywą widoczności.

Aby obliczyć optymalną cenę, krzywa widoczności jest najpierw wygładzana, a następnie mnożona przez marżę. Do obliczenia marży wykorzystujemy koszty towaru i opłaty. Koszt sprzedanych towarów i opłaty to statyczne informacje o produkcie synchronizowane przez AWS DMS. Na podstawie funkcji zysku Adspert oblicza optymalną cenę i przesyła ją do platformy e-commerce za pośrednictwem interfejsu API platformy.

Jest to zaimplementowane w optymalizatorze predykcji AWS Lambda.

Poniższy rysunek przedstawia zależność między przewidywaną widocznością a ceną.

Poniższy rysunek przedstawia relację między ceną a zyskiem.

Wnioski

Obecne podejście Adspert do maksymalizacji zysków koncentruje się na zarządzaniu stawkami w celu zwiększenia zysków z reklam. Aby jednak osiągnąć najwyższą wydajność na rynkach e-commerce, sprzedawcy muszą brać pod uwagę zarówno reklamę, jak i konkurencyjne ceny swoich produktów. Dzięki temu nowemu modelowi ML do przewidywania widoczności możemy rozszerzyć naszą funkcjonalność, aby dostosować również ceny klienta.

Nowe narzędzie do wyceny musi umożliwiać automatyczne trenowanie modelu ML na dużej ilości danych, a także transformacje danych w czasie rzeczywistym, predykcje i optymalizacje cen. W tym poście omówiliśmy główne kroki naszego silnika optymalizacji cen oraz architekturę AWS, którą wdrożyliśmy we współpracy z AWS Data Lab, aby osiągnąć te cele.

Przenoszenie modeli ML od koncepcji do produkcji jest zazwyczaj skomplikowane i czasochłonne. Musisz zarządzać dużymi ilościami danych, aby wytrenować model, wybrać najlepszy algorytm do uczenia go, zarządzać mocą obliczeniową podczas uczenia go, a następnie wdrożyć model w środowisku produkcyjnym. SageMaker zmniejszył tę złożoność, znacznie upraszczając budowanie i wdrażanie modelu ML. Po wybraniu odpowiednich algorytmów i frameworków z szerokiej gamy dostępnych opcji firma SageMaker zarządzała całą podstawową infrastrukturą, aby przeszkolić nasz model i wdrożyć go w środowisku produkcyjnym.

Jeśli chcesz zacząć zapoznawać się z programem SageMaker, Warsztaty Immersion Day może pomóc w uzyskaniu kompleksowego zrozumienia, jak tworzyć przypadki użycia ML na podstawie inżynierii funkcji, różnych wbudowanych algorytmów oraz jak trenować, dostrajać i wdrażać model ML w scenariuszu podobnym do produkcyjnego. Prowadzi Cię do wprowadzenia własnego modelu i wykonania lokalnego podnoszenia i przenoszenia obciążeń ML na platformę SageMaker. Ponadto demonstruje zaawansowane koncepcje, takie jak debugowanie modelu, monitorowanie modelu i AutoML, a także pomaga ocenić obciążenie pracą ML za pomocą dobrze zaprojektowanej soczewki AWS ML.

Jeśli potrzebujesz pomocy w przyspieszeniu wdrażania przypadków użycia, które obejmują dane, analitykę, sztuczną inteligencję i ML, bezserwerową i modernizację kontenerów, skontaktuj się z Laboratorium danych AWS.

O autorach

Wiktor Enrico Jeney jest starszym inżynierem uczenia maszynowego w Adspert z siedzibą w Berlinie w Niemczech. Tworzy rozwiązania problemów predykcji i optymalizacji w celu zwiększenia zysków klientów. Viktor ma doświadczenie w matematyce stosowanej i uwielbia pracować z danymi. W wolnym czasie lubi uczyć się węgierskiego, ćwiczyć sztuki walki i grać na gitarze.

Ennio Pastora jest architektem danych w zespole AWS Data Lab. Jest entuzjastą wszystkiego, co związane z nowymi technologiami, które mają pozytywny wpływ na biznes i ogólne życie. Ennio ma ponad 9-letnie doświadczenie w analityce danych. Pomaga firmom definiować i wdrażać platformy danych w różnych branżach, takich jak telekomunikacja, bankowość, gry, handel detaliczny i ubezpieczenia.