ราคาที่เหมาะสมเพื่อผลกำไรสูงสุดโดยใช้ Amazon SageMaker

นี่เป็นข้อความรับเชิญโดย Viktor Enrico Jeney วิศวกรอาวุโสด้าน Machine Learning ของ Adspert

โฆษณา เป็น ISV ในเบอร์ลินที่พัฒนาเครื่องมือการจัดการราคาเสนอที่ออกแบบมาเพื่อเพิ่มประสิทธิภาพแคมเปญการตลาดและการโฆษณาโดยอัตโนมัติ หลักการหลักของบริษัทคือการทำให้กำไรสูงสุดของการโฆษณาอีคอมเมิร์ซเป็นไปโดยอัตโนมัติด้วยความช่วยเหลือของปัญญาประดิษฐ์ การพัฒนาแพลตฟอร์มโฆษณาอย่างต่อเนื่องปูทางสู่โอกาสใหม่ๆ ซึ่ง Adspert เชี่ยวชาญในการใช้เพื่อความสำเร็จของลูกค้า

เป้าหมายหลักของ Adspert คือการลดความซับซ้อนของกระบวนการสำหรับผู้ใช้ในขณะที่เพิ่มประสิทธิภาพแคมเปญโฆษณาในแพลตฟอร์มต่างๆ ซึ่งรวมถึงการใช้ข้อมูลที่รวบรวมจากแพลตฟอร์มต่างๆ ที่สมดุลกับงบประมาณที่เหมาะสมที่สุดที่กำหนดไว้ในระดับที่สูงกว่าแต่ละแพลตฟอร์ม เป้าหมายของ Adspert คือการเพิ่มประสิทธิภาพการบรรลุเป้าหมายของลูกค้า ไม่ว่าจะใช้แพลตฟอร์มใดก็ตาม Adspert ยังคงเพิ่มแพลตฟอร์มตามความจำเป็นเพื่อให้ลูกค้าของเราได้เปรียบอย่างมาก

ในโพสต์นี้ เราแชร์วิธีที่ Adspert สร้างเครื่องมือกำหนดราคาตั้งแต่ต้นโดยใช้บริการต่างๆ ของ AWS เช่น อเมซอน SageMaker และวิธีที่ Adspert ร่วมมือกับ AWS Data Lab เพื่อเร่งโครงการนี้จากการออกแบบเพื่อสร้างในเวลาที่บันทึก

เครื่องมือกำหนดราคาจะปรับราคาสินค้าที่ผู้ขายเลือกใหม่ในตลาดอีคอมเมิร์ซโดยพิจารณาจากการมองเห็นและอัตรากำไรเพื่อเพิ่มผลกำไรสูงสุดในระดับผลิตภัณฑ์

ในฐานะผู้ขาย จำเป็นที่ผลิตภัณฑ์ของคุณจะมองเห็นได้เสมอเพราะจะทำให้ยอดขายเพิ่มขึ้น ปัจจัยที่สำคัญที่สุดในการขายอีคอมเมิร์ซก็คือการที่ลูกค้ามองเห็นข้อเสนอของคุณ แทนที่จะเป็นข้อเสนอของคู่แข่ง

แม้ว่าจะขึ้นอยู่กับแพลตฟอร์มอีคอมเมิร์ซที่เฉพาะเจาะจง แต่เราพบว่าราคาผลิตภัณฑ์เป็นหนึ่งในตัวเลขหลักที่สำคัญที่สุดที่อาจส่งผลต่อการมองเห็น อย่างไรก็ตาม ราคาเปลี่ยนแปลงบ่อยและรวดเร็ว ด้วยเหตุนี้เครื่องมือการกำหนดราคาจึงต้องดำเนินการในเวลาที่ใกล้เคียงเรียลไทม์เพื่อเพิ่มการมองเห็น

ภาพรวมของโซลูชัน

ไดอะแกรมต่อไปนี้แสดงสถาปัตยกรรมโซลูชัน

โซลูชันประกอบด้วยส่วนประกอบต่อไปนี้:

1. บริการฐานข้อมูลเชิงสัมพันธ์ของ Amazon (Amazon RDS) สำหรับ PostgreSQL เป็นแหล่งข้อมูลหลัก ซึ่งประกอบด้วยข้อมูลผลิตภัณฑ์ซึ่งจัดเก็บไว้ในฐานข้อมูล RDS สำหรับ Postgres
2. ข้อมูลการเปลี่ยนแปลงรายการผลิตภัณฑ์มาถึงในเวลาจริงใน บริการ Amazon Simple Queue (Amazon SQS) คิว
3. ข้อมูลผลิตภัณฑ์ที่จัดเก็บใน Amazon RDS จะถูกนำเข้ามาในเลเยอร์ดิบในเวลาที่เกือบจะเรียลไทม์โดยใช้รูปแบบการบันทึกการเปลี่ยนแปลง (CDC) ที่มีอยู่ใน บริการย้ายฐานข้อมูล AWS (AWS DMS)
4. การแจ้งเตือนรายการสินค้าที่มาจาก Amazon SQS จะได้รับการส่งผ่านข้อมูลในเลเยอร์ดิบในเวลาที่เกือบจะเรียลไทม์โดยใช้an AWS แลมบ์ดา ฟังก์ชัน
5. ข้อมูลต้นฉบับถูกเก็บไว้ใน บริการจัดเก็บข้อมูลอย่างง่ายของ Amazon (Amazon S3) บัคเก็ตเลเยอร์ดิบโดยใช้รูปแบบข้อมูล Parquet เลเยอร์นี้เป็นแหล่งความจริงเพียงแหล่งเดียวสำหรับ Data Lake การแบ่งพาร์ติชั่นที่ใช้ในที่เก็บข้อมูลนี้สนับสนุนการประมวลผลข้อมูลที่เพิ่มขึ้น
6. AWS กาว งานแยก แปลง และโหลด (ETL) ทำความสะอาดข้อมูลผลิตภัณฑ์ ลบรายการที่ซ้ำกัน และใช้การรวมข้อมูลและการแปลงทั่วไปที่ไม่เชื่อมโยงกับกรณีธุรกิจเฉพาะ
7. เลเยอร์ขั้นของ Amazon S3 ได้รับข้อมูลที่เตรียมไว้ซึ่งจัดเก็บไว้ในรูปแบบ Apache Parquet เพื่อการประมวลผลต่อไป การแบ่งพาร์ติชั่นที่ใช้บนสเตจสโตร์รองรับการประมวลผลข้อมูลที่เพิ่มขึ้น
8. งาน AWS Glue ที่สร้างขึ้นในเลเยอร์นี้ใช้ข้อมูลที่มีอยู่ในเลเยอร์ขั้นตอนของ Amazon S3 ซึ่งรวมถึงการใช้กฎเกณฑ์ทางธุรกิจเฉพาะกรณีการใช้งานและการคำนวณที่จำเป็น ข้อมูลผลลัพธ์จากงานเหล่านี้จัดเก็บไว้ในเลเยอร์การวิเคราะห์ของ Amazon S3
9. เลเยอร์การวิเคราะห์ของ Amazon S3 ใช้เพื่อจัดเก็บข้อมูลที่ใช้โดยโมเดล ML เพื่อวัตถุประสงค์ในการฝึกอบรม การแบ่งพาร์ติชั่นที่ใช้ในร้านค้าที่ดูแลจัดการจะขึ้นอยู่กับการใช้ข้อมูลที่คาดไว้ ซึ่งอาจแตกต่างไปจากการแบ่งพาร์ติชั่นที่ใช้กับเลเยอร์ของพื้นที่งาน
10. โมเดล ML ที่ปรับราคาใหม่คือการนำ Scikit-Learn Random Forest ไปใช้ในโหมด SageMaker Script ซึ่งได้รับการฝึกฝนโดยใช้ข้อมูลที่มีอยู่ในบัคเก็ต S3 (เลเยอร์การวิเคราะห์)
11. งานประมวลผลข้อมูล AWS Glue เตรียมข้อมูลสำหรับการอนุมานแบบเรียลไทม์ งานประมวลผลข้อมูลที่นำเข้าในบัคเก็ต S3 (เลเยอร์สเตจ) และเรียกใช้จุดสิ้นสุดการอนุมาน SageMaker ข้อมูลนี้จัดทำขึ้นเพื่อใช้โดยแบบจำลองการกำหนดราคาซ้ำของ SageMaker AWS Glue เป็นที่ต้องการของ Lambda เนื่องจากการอนุมานต้องการการดำเนินการประมวลผลข้อมูลที่ซับซ้อนที่แตกต่างกัน เช่น การรวมและฟังก์ชันหน้าต่างบนข้อมูลปริมาณมาก (ธุรกรรมหลายพันล้านรายการต่อวัน) ผลลัพธ์จากการเรียกใช้แบบจำลองการกำหนดราคาใหม่จะถูกเก็บไว้ในบัคเก็ต S3 (เลเยอร์การอนุมาน)
12. งานการฝึกอบรม SageMaker ถูกปรับใช้โดยใช้ตำแหน่งข้อมูล SageMaker ตำแหน่งข้อมูลนี้ถูกเรียกใช้โดยตัวประมวลผลการอนุมานของ AWS Glue ซึ่งสร้างคำแนะนำราคาที่เกือบจะเรียลไทม์เพื่อเพิ่มการมองเห็นผลิตภัณฑ์
13. การคาดคะเนที่สร้างโดยจุดสิ้นสุดการอนุมานของ SageMaker จะถูกจัดเก็บไว้ในเลเยอร์การอนุมานของ Amazon S3
14. ฟังก์ชันเครื่องมือเพิ่มประสิทธิภาพการคาดการณ์ของ Lambda จะประมวลผลคำแนะนำที่สร้างโดยจุดสิ้นสุดการอนุมานของ SageMaker และสร้างคำแนะนำราคาใหม่ที่มุ่งเน้นที่การเพิ่มผลกำไรของผู้ขายสูงสุด โดยใช้การแลกเปลี่ยนระหว่างปริมาณการขายและส่วนต่างของยอดขาย
15. คำแนะนำราคาที่สร้างโดยเครื่องมือเพิ่มประสิทธิภาพการคาดการณ์ของแลมบ์ดาจะถูกส่งไปยัง API การปรับราคา ซึ่งจะอัปเดตราคาผลิตภัณฑ์ในตลาดกลาง
16. คำแนะนำราคาที่อัปเดตที่สร้างโดยเครื่องมือเพิ่มประสิทธิภาพการคาดการณ์ของ Lambda จะถูกจัดเก็บไว้ในเลเยอร์การเพิ่มประสิทธิภาพ Amazon S3
17. งานตัวโหลดการคาดการณ์ของ AWS Glue จะโหลดการคาดคะเนที่สร้างโดยโมเดล ML ลงในแหล่งข้อมูล RDS สำหรับฐานข้อมูล Postgres SQL เพื่อวัตถุประสงค์ในการตรวจสอบและการรายงาน ใช้ AWS Glue Studio เพื่อใช้งานองค์ประกอบนี้ เป็นอินเทอร์เฟซแบบกราฟิกที่ช่วยให้สร้าง เรียกใช้ และตรวจสอบงาน ETL ใน AWS Glue ได้ง่าย

การเตรียมข้อมูล

ชุดข้อมูลสำหรับโมเดลการเปิดเผยของ Adspert สร้างขึ้นจากคิว SQS และนำเข้าไปยังเลเยอร์ข้อมูลดิบของ Data Lake แบบเรียลไทม์ด้วย Lambda หลังจากนั้น ข้อมูลดิบจะถูกล้างด้วยการแปลงข้อมูลอย่างง่าย เช่น การลบข้อมูลที่ซ้ำกัน กระบวนการนี้ถูกนำมาใช้ใน AWS Glue ผลลัพธ์จะถูกเก็บไว้ในชั้นการแสดงละครของ Data Lake ของเรา การแจ้งเตือนจะแจ้งราคาสินค้า ช่องทางการส่งสินค้า เวลาจัดส่ง และตัวแปรอื่นๆ ให้กับคู่แข่ง นอกจากนี้ยังจัดให้มีการวัดการมองเห็นที่ขึ้นกับแพลตฟอร์ม ซึ่งสามารถแสดงเป็นตัวแปรบูลีน (มองเห็นได้หรือมองไม่เห็น) เราได้รับการแจ้งเตือนทุกครั้งที่มีการเปลี่ยนแปลงข้อเสนอ ซึ่งเพิ่มได้หลายล้านกิจกรรมต่อเดือนสำหรับผลิตภัณฑ์ของลูกค้าทั้งหมดของเรา

จากชุดข้อมูลนี้ เราดึงข้อมูลการฝึกอบรมดังต่อไปนี้: สำหรับการแจ้งเตือนทุกครั้ง เราจับคู่ข้อเสนอที่มองเห็นได้กับทุกข้อเสนอที่มองไม่เห็น และในทางกลับกัน จุดข้อมูลทุกจุดแสดงถึงการแข่งขันระหว่างผู้ขายสองรายซึ่งมีผู้ชนะและผู้แพ้ที่ชัดเจน งานประมวลผลนี้ใช้งานในงาน AWS Glue กับ Spark ชุดข้อมูลการฝึกอบรมที่เตรียมไว้จะถูกส่งไปยังบัคเก็ต S3 การวิเคราะห์ที่จะใช้โดย SageMaker

ฝึกโมเดล

โมเดลของเราจัดประเภทสำหรับข้อเสนอแต่ละคู่ หากข้อเสนอนั้นปรากฏให้เห็น โมเดลนี้ช่วยให้เราสามารถคำนวณราคาที่ดีที่สุดสำหรับลูกค้าของเรา เพิ่มการมองเห็นตามการแข่งขัน และเพิ่มผลกำไรสูงสุด ยิ่งไปกว่านั้น รูปแบบการจัดหมวดหมู่นี้สามารถให้ข้อมูลเชิงลึกแก่เราเกี่ยวกับสาเหตุที่ทำให้รายชื่อของเราปรากฏหรือไม่ปรากฏให้เห็นได้ เราใช้คุณสมบัติดังต่อไปนี้:

• อัตราส่วนราคาของเราต่อราคาของคู่แข่ง
• ความแตกต่างในช่องทางการเติมเต็ม
• จำนวนข้อเสนอแนะสำหรับผู้ขายแต่ละราย
• คะแนนคำติชมของผู้ขายแต่ละราย
• ความแตกต่างของเวลาในการจัดส่งขั้นต่ำ
• ความแตกต่างของเวลาในการจัดส่งสูงสุด
• ความพร้อมจำหน่ายสินค้าของผู้ขายแต่ละราย

Adspert ใช้ SageMaker เพื่อฝึกและโฮสต์โมเดล เราใช้ Scikit-Learn Random Forest ใช้งานใน โหมดสคริปต์ SageMaker. เรายังรวมคุณสมบัติบางอย่างในการประมวลผลล่วงหน้าโดยตรงในไปป์ไลน์ Scikit-Learn ในสคริปต์การฝึกอบรม ดูรหัสต่อไปนี้:

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)

ฟังก์ชั่นการประมวลผลล่วงหน้าที่สำคัญที่สุดอย่างหนึ่งคือ transform_priceซึ่งหารราคาด้วยราคาต่ำสุดของคู่แข่งและคอลัมน์ราคาภายนอก เราพบว่าคุณลักษณะนี้มีผลกระทบต่อความถูกต้องของแบบจำลอง เรายังใช้ลอการิทึมเพื่อให้โมเดลตัดสินใจตามความแตกต่างของราคาที่สัมพันธ์กัน ไม่ใช่ความแตกต่างของราคาแบบสัมบูรณ์

ตัว Vortex Indicator ได้ถูกนำเสนอลงในนิตยสาร training_script.py สคริปต์ ขั้นแรกเราจะกำหนดวิธีการสร้าง Scikit-Learn ColumnTransformer เพื่อใช้หม้อแปลงที่ระบุกับคอลัมน์ของดาต้าเฟรม:

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

ในสคริปต์การฝึกอบรม เราโหลดข้อมูลจาก Parquet ลงใน dataframe ของ Pandas กำหนดไปป์ไลน์ของ ColumnTranformer และ RandomForestClassifierและฝึกโมเดล หลังจากนั้น โมเดลจะถูกจัดลำดับโดยใช้ 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'))

ในสคริปต์การฝึกอบรม เรายังต้องใช้ฟังก์ชันสำหรับการอนุมาน:

• input_fn – มีหน้าที่แยกวิเคราะห์ข้อมูลจากเนื้อความคำขอของ payload
• model_fn – โหลดและส่งคืนโมเดลที่ถูกทิ้งในส่วนการฝึกอบรมของสคริปต์
• ทำนาย_fn – มีการใช้งานของเราเพื่อขอคำทำนายจากแบบจำลองโดยใช้ข้อมูลจากเพย์โหลด
• ทำนาย_proba – ในการวาดเส้นโค้งการมองเห็นที่คาดการณ์ไว้ เราคืนค่าความน่าจะเป็นของคลาสโดยใช้ predict_proba ฟังก์ชัน แทนการทำนายเลขฐานสองของลักษณนาม

ดูรหัสต่อไปนี้:

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

รูปต่อไปนี้แสดงความสำคัญของคุณลักษณะตามสิ่งเจือปนที่ส่งคืนโดย ลักษณนามสุ่มป่า.

ด้วย SageMaker เราสามารถฝึกโมเดลด้วยข้อมูลจำนวนมาก (มากถึง 14 พันล้านธุรกรรมต่อวัน) โดยไม่ต้องโหลดอินสแตนซ์ที่มีอยู่ของเราหรือต้องตั้งค่าเครื่องแยกที่มีทรัพยากรเพียงพอ ยิ่งกว่านั้น เนื่องจากอินสแตนซ์จะปิดลงทันทีหลังจากงานฝึกอบรม การฝึกอบรมด้วย SageMaker จึงประหยัดต้นทุนได้อย่างมาก การปรับใช้โมเดลด้วย SageMaker ทำงานโดยไม่มีภาระงานเพิ่มเติม การเรียกใช้ฟังก์ชันเดียวใน Python SDK นั้นเพียงพอที่จะโฮสต์โมเดลของเราเป็นจุดสิ้นสุดการอนุมาน และสามารถขอได้อย่างง่ายดายจากบริการอื่นๆ โดยใช้ SageMaker Python SDK เช่นกัน ดูรหัสต่อไปนี้:

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

สิ่งประดิษฐ์ของโมเดลถูกจัดเก็บไว้ใน Amazon S3 โดยฟังก์ชัน fit ดังที่เห็นในโค้ดต่อไปนี้ สามารถโหลดโมเดลเป็น a SKLearnModel อ็อบเจ็กต์โดยใช้สิ่งประดิษฐ์ของโมเดล เส้นทางของสคริปต์ และพารามิเตอร์อื่นๆ หลังจากนั้น สามารถปรับใช้กับประเภทอินสแตนซ์ที่ต้องการและจำนวนอินสแตนซ์ได้

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
)

ประเมินแบบจำลองตามเวลาจริง

เมื่อใดก็ตามที่มีการส่งการแจ้งเตือนใหม่สำหรับผลิตภัณฑ์ใดผลิตภัณฑ์หนึ่งของเรา เราต้องการคำนวณและส่งราคาที่เหมาะสมที่สุด ในการคำนวณราคาที่เหมาะสม เราสร้างชุดข้อมูลการคาดการณ์ซึ่งเราเปรียบเทียบข้อเสนอของเรากับข้อเสนอของคู่แข่งแต่ละรายสำหรับช่วงราคาที่เป็นไปได้ จุดข้อมูลเหล่านี้จะถูกส่งต่อไปยังตำแหน่งข้อมูล SageMaker ซึ่งจะคืนค่าความน่าจะเป็นที่คาดการณ์ไว้ว่าจะมองเห็นได้กับคู่แข่งแต่ละรายในราคาที่กำหนด เราเรียกความน่าจะเป็นที่จะมองเห็นได้ การมองเห็นที่คาดการณ์ไว้. ผลลัพธ์สามารถแสดงให้เห็นเป็นเส้นโค้งสำหรับผู้แข่งขันแต่ละราย ซึ่งแสดงถึงความสัมพันธ์ระหว่างราคาของเรากับการมองเห็น ดังแสดงในรูปต่อไปนี้

ในตัวอย่างนี้ ทัศนวิสัยต่อคู่แข่ง 1 เกือบจะเป็นฟังก์ชันคงที่ทีละส่วน ซึ่งหมายความว่าเราต้องลดราคาให้ต่ำกว่าเกณฑ์ที่กำหนด ซึ่งเป็นราคาคร่าวๆ ของคู่แข่งเป็นหลักจึงจะมองเห็นได้ อย่างไรก็ตาม ทัศนวิสัยของคู่แข่ง 2 ไม่ได้ลดลงอย่างสูงชัน ยิ่งไปกว่านั้น เรายังคงมีโอกาส 50% ที่จะถูกมองเห็นได้แม้จะมีราคาสูงมากก็ตาม จากการวิเคราะห์ข้อมูลเข้าพบว่าผู้แข่งขันมีเรตติ้งน้อยซึ่งถือว่าแย่มาก โมเดลของเราได้เรียนรู้ว่าแพลตฟอร์มอีคอมเมิร์ซเฉพาะนี้ทำให้ผู้ขายเสียเปรียบที่มีคะแนนตอบรับไม่ดี เราค้นพบเอฟเฟกต์ที่คล้ายกันสำหรับคุณสมบัติอื่นๆ เช่น ช่องทางการเติมเต็มและเวลาในการจัดส่ง

การแปลงข้อมูลที่จำเป็นและการอนุมานเทียบกับตำแหน่งข้อมูล SageMaker ถูกนำไปใช้ใน AWS Glue งาน AWS Glue ทำงานเป็นไมโครแบตช์บนข้อมูลเรียลไทม์ที่นำเข้าจากแลมบ์ดา

สุดท้าย เราต้องการคำนวณเส้นโค้งการมองเห็นรวม ซึ่งเป็นการมองเห็นที่คาดการณ์ไว้สำหรับราคาที่เป็นไปได้แต่ละราคา ข้อเสนอของเราจะมองเห็นได้หากดีกว่าข้อเสนอของผู้ขายรายอื่นทั้งหมด สมมติว่ามีความเป็นอิสระระหว่างความน่าจะเป็นที่จะมองเห็นได้กับผู้ขายแต่ละรายจากราคาของเรา ความน่าจะเป็นที่จะถูกมองเห็นได้กับผู้ขายทุกรายเป็นผลจากความน่าจะเป็นตามลำดับ นั่นหมายความว่าเส้นโค้งการมองเห็นรวมสามารถคำนวณได้โดยการคูณเส้นโค้งทั้งหมด

ตัวเลขต่อไปนี้แสดงการมองเห็นที่คาดการณ์ไว้ซึ่งส่งคืนจากตำแหน่งข้อมูล SageMaker

รูปต่อไปนี้แสดงเส้นโค้งการมองเห็นรวม

ในการคำนวณราคาที่เหมาะสม ขั้นแรก เส้นโค้งการมองเห็นจะปรับให้เรียบก่อนแล้วจึงคูณด้วยมาร์จิ้น ในการคำนวณมาร์จิ้น เราใช้ต้นทุนสินค้าและค่าธรรมเนียม ต้นทุนของสินค้าที่ขายและค่าธรรมเนียมเป็นข้อมูลผลิตภัณฑ์คงที่ที่ซิงค์ผ่าน AWS DMS ตามฟังก์ชันกำไร Adspert จะคำนวณราคาที่เหมาะสมและส่งไปยังแพลตฟอร์มอีคอมเมิร์ซผ่าน API ของแพลตฟอร์ม

มีการใช้งานในเครื่องมือเพิ่มประสิทธิภาพการคาดการณ์ของ AWS Lambda

รูปต่อไปนี้แสดงความสัมพันธ์ระหว่างการมองเห็นที่คาดการณ์ไว้และราคา

รูปต่อไปนี้แสดงความสัมพันธ์ระหว่างราคาและกำไร

สรุป

วิธีการที่มีอยู่ของ Adspert ในการเพิ่มผลกำไรสูงสุดนั้นมุ่งเน้นไปที่การจัดการการเสนอราคาเพื่อเพิ่มผลตอบแทนจากการโฆษณา เพื่อให้ได้ประสิทธิภาพที่เหนือกว่าในตลาดอีคอมเมิร์ซ ผู้ขายต้องพิจารณาทั้งการโฆษณาและราคาที่แข่งขันได้ของผลิตภัณฑ์ของตน ด้วยโมเดล ML ใหม่นี้ในการคาดการณ์การมองเห็น เราสามารถขยายฟังก์ชันการทำงานของเราเพื่อปรับราคาของลูกค้าได้เช่นกัน

เครื่องมือกำหนดราคาใหม่จะต้องสามารถฝึกอบรมโมเดล ML อัตโนมัติกับข้อมูลจำนวนมากได้ เช่นเดียวกับการแปลงข้อมูลแบบเรียลไทม์ การคาดการณ์ และการปรับราคาให้เหมาะสม ในโพสต์นี้ เราได้อธิบายขั้นตอนหลักของกลไกการปรับราคาให้เหมาะสม และสถาปัตยกรรม AWS ที่เราดำเนินการร่วมกับ AWS Data Lab เพื่อให้บรรลุเป้าหมายเหล่านั้น

การนำแบบจำลอง ML จากแนวคิดไปสู่การผลิตมักจะซับซ้อนและใช้เวลานาน คุณต้องจัดการข้อมูลจำนวนมากเพื่อฝึกโมเดล เลือกอัลกอริธึมที่ดีที่สุดสำหรับการฝึก จัดการความสามารถในการประมวลผลขณะฝึก จากนั้นปรับใช้โมเดลในสภาพแวดล้อมการผลิต SageMaker ลดความซับซ้อนนี้ด้วยการทำให้สร้างและปรับใช้โมเดล ML ได้ตรงไปตรงมามากขึ้น หลังจากที่เราเลือกอัลกอริธึมและเฟรมเวิร์กที่เหมาะสมจากตัวเลือกที่มีอยู่มากมาย SageMaker จัดการโครงสร้างพื้นฐานพื้นฐานทั้งหมดเพื่อฝึกโมเดลของเราและปรับใช้กับการผลิต

หากคุณต้องการเริ่มทำความคุ้นเคยกับ SageMaker เวิร์กชอปวัน Immersion สามารถช่วยให้คุณได้รับความเข้าใจแบบ end-to-end เกี่ยวกับวิธีสร้างกรณีการใช้งาน ML จากวิศวกรรมคุณลักษณะ อัลกอริธึมในตัวต่างๆ และวิธีการฝึก ปรับแต่ง และปรับใช้โมเดล ML ในสถานการณ์ที่เหมือนกับการใช้งานจริง ซึ่งจะแนะนำให้คุณนำแบบจำลองของคุณเองมาใช้และดำเนินการยกระดับและเปลี่ยนปริมาณงาน ML ในสถานที่ไปยังแพลตฟอร์ม SageMaker นอกจากนี้ยังสาธิตแนวคิดขั้นสูง เช่น การดีบักโมเดล การตรวจสอบโมเดล และ AutoML และช่วยให้คุณประเมินปริมาณงาน ML ของคุณผ่านเลนส์ AWS ML Well-Architected

หากคุณต้องการความช่วยเหลือในการเร่งดำเนินการกรณีการใช้งานที่เกี่ยวข้องกับข้อมูล การวิเคราะห์ AI และ ML แบบไร้เซิร์ฟเวอร์ และการปรับคอนเทนเนอร์ให้ทันสมัย ​​โปรดติดต่อ AWS Data Lab.

เกี่ยวกับผู้แต่ง

วิคเตอร์ เอ็นริโก เจนีย์ เป็นวิศวกรแมชชีนเลิร์นนิ่งอาวุโสที่ Adspert ในกรุงเบอร์ลิน ประเทศเยอรมนี เขาสร้างโซลูชันสำหรับการทำนายและปัญหาการเพิ่มประสิทธิภาพเพื่อเพิ่มผลกำไรของลูกค้า Viktor มีพื้นฐานด้านคณิตศาสตร์ประยุกต์และรักการทำงานกับข้อมูล ในเวลาว่าง เขาชอบเรียนภาษาฮังการี ฝึกศิลปะการต่อสู้ และเล่นกีตาร์

เอนนิโอ ปาสตอเร่ เป็นสถาปนิกข้อมูลในทีม AWS Data Lab เขาเป็นคนกระตือรือร้นในทุกสิ่งที่เกี่ยวข้องกับเทคโนโลยีใหม่ที่มีผลกระทบเชิงบวกต่อธุรกิจและการดำรงชีวิตโดยทั่วไป Ennio มีประสบการณ์มากกว่า 9 ปีในด้านการวิเคราะห์ข้อมูล เขาช่วยบริษัทกำหนดและใช้แพลตฟอร์มข้อมูลในอุตสาหกรรมต่างๆ เช่น โทรคมนาคม การธนาคาร เกม การค้าปลีก และการประกันภัย