Harga optimal untuk keuntungan maksimum menggunakan Amazon SageMaker

Ini adalah posting tamu oleh Viktor Enrico Jeney, Senior Machine Learning Engineer di Adspert.

Iklan adalah ISV yang berbasis di Berlin yang mengembangkan alat pengelolaan tawaran yang dirancang untuk mengoptimalkan kinerja kampanye pemasaran dan iklan secara otomatis. Prinsip inti perusahaan adalah untuk mengotomatisasi maksimalisasi keuntungan dari iklan e-niaga dengan bantuan kecerdasan buatan. Pengembangan platform periklanan yang berkelanjutan membuka jalan bagi peluang baru, yang dimanfaatkan secara ahli oleh Adspert untuk kesuksesan pelanggan mereka.

Tujuan utama Adspert adalah untuk menyederhanakan proses bagi pengguna sambil mengoptimalkan kampanye iklan di berbagai platform. Ini termasuk penggunaan informasi yang dikumpulkan di berbagai platform yang seimbang dengan anggaran optimal yang ditetapkan pada tingkat di atas setiap platform. Fokus Adspert adalah mengoptimalkan pencapaian tujuan pelanggan, terlepas dari platform apa yang digunakan. Adspert terus menambahkan platform yang diperlukan untuk memberikan keuntungan yang signifikan kepada pelanggan kami.

Dalam posting ini, kami membagikan bagaimana Adspert membuat alat penetapan harga dari awal menggunakan berbagai layanan AWS seperti Amazon SageMaker dan bagaimana Adspert berkolaborasi dengan Lab Data AWS untuk mempercepat proyek ini dari desain untuk membangun dalam waktu singkat.

Alat penetapan harga menilai ulang produk pilihan penjual di pasar e-niaga berdasarkan visibilitas dan margin keuntungan untuk memaksimalkan keuntungan di tingkat produk.

Sebagai penjual, produk Anda harus selalu terlihat karena ini akan meningkatkan penjualan. Faktor terpenting dalam penjualan e-niaga adalah jika penawaran Anda terlihat oleh pelanggan, bukan penawaran pesaing.

Meskipun tentu saja tergantung pada platform e-niaga tertentu, kami telah menemukan bahwa harga produk adalah salah satu tokoh kunci terpenting yang dapat memengaruhi visibilitas. Namun, harga sering berubah dan cepat; untuk alasan ini, alat penetapan harga perlu bertindak hampir seketika untuk meningkatkan visibilitas.

Ikhtisar solusi

Diagram berikut menggambarkan arsitektur solusi.

Solusinya mengandung komponen-komponen berikut:

1. Amazon Relational Database Service (Amazon RDS) untuk PostgreSQL adalah sumber data utama, yang berisi informasi produk yang disimpan dalam RDS untuk database Postgres.
2. Informasi perubahan daftar produk tiba secara real time dalam Layanan Antrian Sederhana Amazon (Amazon SQS).
3. Informasi produk yang disimpan di Amazon RDS diserap hampir secara real-time ke dalam lapisan mentah menggunakan pola change data capture (CDC) yang tersedia di Layanan Migrasi Database AWS (WSDMS).
4. Pemberitahuan daftar produk yang berasal dari Amazon SQS diserap hampir secara real-time ke dalam lapisan mentah menggunakan AWS Lambda fungsi.
5. Data sumber asli disimpan di Layanan Penyimpanan Sederhana Amazon (Amazon S3) raw layer bucket menggunakan format data Parket. Lapisan ini adalah satu-satunya sumber kebenaran untuk danau data. Partisi yang digunakan pada penyimpanan ini mendukung pemrosesan data tambahan.
6. Lem AWS pekerjaan ekstrak, transformasi, dan muat (ETL) membersihkan data produk, menghapus duplikat, dan menerapkan konsolidasi data dan transformasi umum yang tidak terkait dengan kasus bisnis tertentu.
7. Lapisan tahapan Amazon S3 menerima data yang telah disiapkan yang disimpan dalam format Apache Parket untuk diproses lebih lanjut. Partisi yang digunakan pada stage store mendukung pemrosesan data tambahan.
8. Pekerjaan AWS Glue yang dibuat di lapisan ini menggunakan data yang tersedia di lapisan tahap Amazon S3. Ini termasuk penerapan aturan bisnis khusus kasus penggunaan dan perhitungan yang diperlukan. Data hasil dari pekerjaan ini disimpan di lapisan analitik Amazon S3.
9. Lapisan analitik Amazon S3 digunakan untuk menyimpan data yang digunakan oleh model ML untuk tujuan pelatihan. Partisi yang digunakan pada penyimpanan yang dikurasi didasarkan pada penggunaan data yang diharapkan. Ini mungkin berbeda dengan partisi yang digunakan pada layer stage.
10. Model ML repricing adalah implementasi Scikit-Learn Random Forest dalam SageMaker Script Mode, yang dilatih menggunakan data yang tersedia di bucket S3 (lapisan analitik).
11. Pekerjaan pemrosesan data AWS Glue menyiapkan data untuk inferensi waktu nyata. Tugas memproses data yang diserap dalam bucket S3 (lapisan tahapan) dan memanggil titik akhir inferensi SageMaker. Data disiapkan untuk digunakan oleh model penetapan harga SageMaker. AWS Glue lebih disukai daripada Lambda, karena inferensi memerlukan operasi pemrosesan data kompleks yang berbeda seperti fungsi gabungan dan jendela pada volume data yang tinggi (miliaran transaksi harian). Hasil dari pemanggilan model repricing disimpan dalam bucket S3 (lapisan inferensi).
12. Tugas pelatihan SageMaker diterapkan menggunakan titik akhir SageMaker. Titik akhir ini dipanggil oleh prosesor inferensi AWS Glue, menghasilkan rekomendasi harga yang mendekati waktu nyata untuk meningkatkan visibilitas produk.
13. Prediksi yang dihasilkan oleh titik akhir inferensi SageMaker disimpan di lapisan inferensi Amazon S3.
14. Fungsi pengoptimal prediksi Lambda memproses rekomendasi yang dihasilkan oleh titik akhir inferensi SageMaker dan menghasilkan rekomendasi harga baru yang berfokus pada memaksimalkan keuntungan penjual, menerapkan pertukaran antara volume penjualan dan margin penjualan.
15. Rekomendasi harga yang dihasilkan oleh pengoptimal prediksi Lambda dikirimkan ke API penetapan harga, yang memperbarui harga produk di pasar.
16. Rekomendasi harga terbaru yang dihasilkan oleh pengoptimal prediksi Lambda disimpan di lapisan pengoptimalan Amazon S3.
17. Tugas pemuat prediksi AWS Glue memuat ulang ke RDS sumber untuk database SQL Postgres, prediksi yang dihasilkan oleh model ML untuk tujuan audit dan pelaporan. AWS Glue Studio digunakan untuk mengimplementasikan komponen ini; ini adalah antarmuka grafis yang memudahkan untuk membuat, menjalankan, dan memantau pekerjaan ETL di AWS Glue.

Persiapan data

Kumpulan data untuk model visibilitas Adspert dibuat dari antrean SQS dan diserap ke dalam lapisan mentah data lake kami secara waktu nyata dengan Lambda. Setelah itu, data mentah dibersihkan dengan melakukan transformasi sederhana, seperti menghapus duplikat. Proses ini diimplementasikan di AWS Glue. Hasilnya disimpan di lapisan pementasan danau data kami. Pemberitahuan memberikan pesaing untuk produk tertentu, dengan harga, saluran pemenuhan, waktu pengiriman, dan banyak variabel lainnya. Mereka juga menyediakan ukuran visibilitas yang bergantung pada platform, yang dapat dinyatakan sebagai variabel Boolean (terlihat atau tidak terlihat). Kami menerima pemberitahuan setiap kali terjadi perubahan penawaran, yang menambahkan hingga beberapa juta acara per bulan untuk semua produk pelanggan kami.

Dari kumpulan data ini, kami mengekstrak data pelatihan sebagai berikut: untuk setiap notifikasi, kami memasangkan penawaran yang terlihat dengan setiap penawaran yang tidak terlihat, dan sebaliknya. Setiap titik data mewakili persaingan antara dua penjual, di mana ada pemenang dan pecundang yang jelas. Pekerjaan pemrosesan ini diimplementasikan dalam pekerjaan AWS Glue dengan Spark. Set data pelatihan yang disiapkan didorong ke bucket S3 analitik untuk digunakan oleh SageMaker.

Latih modelnya

Model kami mengklasifikasikan untuk setiap pasangan penawaran, jika penawaran yang diberikan akan terlihat. Model ini memungkinkan kami untuk menghitung harga terbaik bagi pelanggan kami, meningkatkan visibilitas berdasarkan persaingan, dan memaksimalkan keuntungan mereka. Selain itu, model klasifikasi ini dapat memberi kita wawasan yang lebih dalam tentang alasan cantuman kita terlihat atau tidak terlihat. Kami menggunakan fitur berikut:

• Rasio harga kami dengan harga pesaing
• Perbedaan dalam saluran pemenuhan
• Jumlah umpan balik untuk setiap penjual
• Peringkat umpan balik dari setiap penjual
• Perbedaan waktu pengiriman minimum
• Perbedaan waktu pengiriman maksimum
• Ketersediaan produk masing-masing penjual

Adspert menggunakan SageMaker untuk melatih dan meng-host model. Kami menggunakan implementasi Scikit-Learn Random Forest di Mode Skrip SageMaker. Kami juga menyertakan beberapa fitur preprocessing secara langsung di pipeline Scikit-Learn dalam skrip pelatihan. Lihat kode berikut:

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)

Salah satu fungsi preprocessing yang paling penting adalah transform_price, yang membagi harga dengan harga minimum pesaing dan kolom harga eksternal. Kami telah menemukan bahwa fitur ini memiliki dampak yang relevan pada akurasi model. Kami juga menerapkan logaritma untuk membiarkan model memutuskan berdasarkan perbedaan harga relatif, bukan perbedaan harga absolut.

Dalam majalah training_script.py script, pertama kita mendefinisikan bagaimana membangun Scikit-Learn ColumnTransformer untuk menerapkan transformator yang ditentukan ke kolom kerangka data:

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

Dalam skrip pelatihan, kami memuat data dari Parket ke dalam kerangka data Pandas, menentukan jalur pipa ColumnTranformer dan RandomForestClassifier, dan melatih model. Setelah itu, model diserialkan menggunakan 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'))

Dalam skrip pelatihan, kita juga harus mengimplementasikan fungsi untuk inferensi:

• masukan_fn – Bertanggung jawab untuk mengurai data dari badan permintaan payload
• model_fn – Memuat dan mengembalikan model yang telah dibuang di bagian pelatihan skrip
• prediksi_fn – Berisi implementasi kami untuk meminta prediksi dari model menggunakan data dari payload
• prediksi_proba – Untuk menggambar kurva visibilitas yang diprediksi, kami mengembalikan probabilitas kelas menggunakan predict_proba fungsi, alih-alih prediksi biner dari classifier

Lihat kode berikut:

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

Gambar berikut menunjukkan pentingnya fitur berbasis pengotor yang dikembalikan oleh Pengklasifikasi Hutan Acak.

Dengan SageMaker, kami dapat melatih model pada sejumlah besar data (hingga 14 miliar transaksi harian) tanpa membebani instans kami yang ada atau harus menyiapkan mesin terpisah dengan sumber daya yang cukup. Selain itu, karena instans segera ditutup setelah pekerjaan pelatihan, pelatihan dengan SageMaker sangat hemat biaya. Penerapan model dengan SageMaker bekerja tanpa beban kerja tambahan. Satu panggilan fungsi di Python SDK sudah cukup untuk meng-host model kami sebagai titik akhir inferensi, dan dapat dengan mudah diminta dari layanan lain menggunakan SageMaker Python SDK juga. Lihat kode berikut:

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

Artefak model disimpan di Amazon S3 oleh fungsi fit. Seperti yang terlihat pada kode berikut, model dapat dimuat sebagai: SKLearnModel objek menggunakan artefak model, jalur skrip, dan beberapa parameter lainnya. Setelah itu, dapat di-deploy ke jenis instance dan jumlah instance yang diinginkan.

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
)

Evaluasi model secara real time

Setiap kali pemberitahuan baru dikirim untuk salah satu produk kami, kami ingin menghitung dan mengirimkan harga optimal. Untuk menghitung harga optimal, kami membuat kumpulan data prediksi di mana kami membandingkan penawaran kami sendiri dengan penawaran masing-masing pesaing untuk kisaran harga yang memungkinkan. Titik data ini diteruskan ke titik akhir SageMaker, yang mengembalikan probabilitas prediksi untuk terlihat terhadap setiap pesaing untuk setiap harga yang diberikan. Kami menyebut kemungkinan terlihat sebagai visibilitas yang diprediksi. Hasilnya dapat divisualisasikan sebagai kurva untuk setiap pesaing, menggambarkan hubungan antara harga kami dan visibilitas, seperti yang ditunjukkan pada gambar berikut.

Dalam contoh ini, visibilitas terhadap Pesaing 1 hampir merupakan fungsi konstan sepotong-sepotong, menunjukkan bahwa kita terutama harus menurunkan harga di bawah ambang batas tertentu, kira-kira harga pesaing, agar terlihat. Namun, visibilitas melawan Pesaing 2 tidak berkurang secara drastis. Selain itu, kami masih memiliki peluang 50% untuk terlihat bahkan dengan harga yang sangat tinggi. Menganalisis data input mengungkapkan bahwa pesaing memiliki jumlah peringkat yang rendah, yang kebetulan sangat buruk. Model kami mengetahui bahwa platform e-niaga khusus ini memberikan kerugian bagi penjual dengan peringkat umpan balik yang buruk. Kami menemukan efek serupa untuk fitur lainnya, seperti saluran pemenuhan dan waktu pengiriman.

Transformasi data dan inferensi yang diperlukan terhadap titik akhir SageMaker diimplementasikan di AWS Glue. Pekerjaan AWS Glue bekerja dalam batch mikro pada data real-time yang diserap dari Lambda.

Terakhir, kami ingin menghitung kurva visibilitas agregat, yang merupakan prediksi visibilitas untuk setiap kemungkinan harga. Penawaran kami terlihat jika lebih baik dari semua penawaran penjual lainnya. Dengan asumsi independensi antara probabilitas terlihat terhadap setiap penjual dengan harga kami, probabilitas terlihat terhadap semua penjual adalah produk dari probabilitas masing-masing. Itu berarti kurva visibilitas agregat dapat dihitung dengan mengalikan semua kurva.

Gambar berikut menunjukkan perkiraan visibilitas yang dikembalikan dari titik akhir SageMaker.

Gambar berikut menunjukkan kurva visibilitas agregat.

Untuk menghitung harga optimal, kurva visibilitas terlebih dahulu dihaluskan kemudian dikalikan dengan margin. Untuk menghitung margin, kami menggunakan biaya barang dan biaya. Harga pokok penjualan dan biaya adalah informasi produk statis yang disinkronkan melalui AWS DMS. Berdasarkan fungsi profit, Adspert menghitung harga optimal dan mengirimkannya ke platform e-niaga melalui API platform.

Ini diimplementasikan dalam pengoptimal prediksi AWS Lambda.

Gambar berikut menunjukkan hubungan antara prediksi visibilitas dan harga.

Gambar berikut menunjukkan hubungan antara harga dan keuntungan.

Kesimpulan

Pendekatan Adspert yang ada untuk memaksimalkan keuntungan difokuskan pada manajemen tawaran untuk meningkatkan pengembalian dari iklan. Untuk mencapai kinerja yang unggul di pasar e-niaga, bagaimanapun, penjual harus mempertimbangkan iklan dan harga yang kompetitif dari produk mereka. Dengan model ML baru ini untuk memprediksi visibilitas, kami dapat memperluas fungsionalitas kami untuk juga menyesuaikan harga pelanggan.

Alat penetapan harga baru harus mampu melatih model ML secara otomatis pada sejumlah besar data, serta transformasi data waktu nyata, prediksi, dan pengoptimalan harga. Dalam postingan ini, kami membahas langkah-langkah utama mesin pengoptimalan harga kami, dan arsitektur AWS yang kami terapkan bekerja sama dengan AWS Data Lab untuk mencapai tujuan tersebut.

Mengambil model ML dari konsep ke produksi biasanya rumit dan memakan waktu. Anda harus mengelola data dalam jumlah besar untuk melatih model, memilih algoritme terbaik untuk melatihnya, mengelola kapasitas komputasi saat melatihnya, lalu menerapkan model ke lingkungan produksi. SageMaker mengurangi kerumitan ini dengan membuatnya jauh lebih mudah untuk membangun dan menerapkan model ML. Setelah kami memilih algoritme dan kerangka kerja yang tepat dari berbagai pilihan yang tersedia, SageMaker mengelola semua infrastruktur dasar untuk melatih model kami dan menerapkannya ke produksi.

Jika Anda ingin mulai membiasakan diri dengan SageMaker, Lokakarya Hari Perendaman dapat membantu Anda memperoleh pemahaman menyeluruh tentang cara membangun kasus penggunaan ML dari rekayasa fitur, berbagai algoritme bawaan, dan cara melatih, menyesuaikan, dan menerapkan model ML dalam skenario seperti produksi. Ini memandu Anda untuk membawa model Anda sendiri dan melakukan peningkatan dan pemindahan beban kerja ML di lokasi ke platform SageMaker. Ini lebih lanjut menunjukkan konsep lanjutan seperti debugging model, pemantauan model, dan AutoML, dan membantu Anda mengevaluasi beban kerja ML Anda melalui lensa AWS ML Well-Architected.

Jika Anda membutuhkan bantuan untuk mempercepat penerapan kasus penggunaan yang melibatkan data, analitik, AI dan ML, tanpa server, dan modernisasi container, silakan hubungi Lab Data AWS.

Tentang penulis

Viktor Enrico Jeney adalah Senior Machine Learning Engineer di Adspert yang berbasis di Berlin, Jerman. Dia menciptakan solusi untuk masalah prediksi dan optimasi untuk meningkatkan keuntungan pelanggan. Viktor memiliki latar belakang matematika terapan dan suka bekerja dengan data. Di waktu luangnya, ia senang belajar bahasa Hongaria, berlatih seni bela diri, dan bermain gitar.

Ennio Pastore adalah arsitek data di tim AWS Data Lab. Dia adalah penggemar segala sesuatu yang berkaitan dengan teknologi baru yang berdampak positif pada bisnis dan mata pencaharian umum. Ennio memiliki lebih dari 9 tahun pengalaman dalam analisis data. Dia membantu perusahaan mendefinisikan dan mengimplementasikan platform data di seluruh industri, seperti telekomunikasi, perbankan, game, ritel, dan asuransi.