תמחור אופטימלי לרווח מרבי באמצעות Amazon SageMaker

זהו פוסט אורח מאת ויקטור אנריקו ג'ייני, מהנדס למידת מכונה בכיר ב-Adspert.

אדספרט הוא ISV מבוסס ברלין שפיתח כלי לניהול הצעות מחיר שנועד לבצע אופטימיזציה אוטומטית של קמפיינים שיווקיים ופרסומיים. עיקרון הליבה של החברה הוא לבצע אוטומציה של מקסום הרווח של פרסום מסחר אלקטרוני בעזרת בינה מלאכותית. הפיתוח המתמשך של פלטפורמות פרסום סולל את הדרך להזדמנויות חדשות, שאותן Adspert מנצלת במומחיות להצלחת לקוחותיה.

המטרה העיקרית של Adspert היא לפשט את התהליך עבור המשתמשים תוך אופטימיזציה של מסעות פרסום בפלטפורמות שונות. זה כולל שימוש במידע שנאסף על פני הפלטפורמות השונות מאוזן מול התקציב האופטימלי שנקבע ברמה מעל כל פלטפורמה. המיקוד של Adspert הוא לייעל את השגת היעד של הלקוח, ללא קשר לפלטפורמה שבה משתמשים. Adspert ממשיכה להוסיף פלטפורמות לפי הצורך כדי להעניק ללקוחותינו יתרונות משמעותיים.

בפוסט זה, אנו משתפים כיצד Adspert יצרה את כלי התמחור מאפס באמצעות שירותי AWS שונים כמו אמזון SageMaker וכיצד Adspert שיתפה פעולה עם מעבדת הנתונים של AWS להאיץ את הפרויקט הזה מתכנון לבנייה בזמן שיא.

כלי התמחור מתמחר מחדש מוצר שנבחר על ידי מוכר בשוק מסחר אלקטרוני בהתבסס על הנראות ושולי הרווח כדי למקסם את הרווחים ברמת המוצר.

כמוכר, חיוני שהמוצרים שלך יהיו גלויים תמיד כי זה יגדיל את המכירות. הגורם החשוב ביותר במכירות מסחר אלקטרוני הוא פשוט אם ההצעה שלך גלויה ללקוחות במקום הצעה של מתחרה.

למרות שזה בהחלט תלוי בפלטפורמת המסחר האלקטרוני הספציפית, גילינו שמחיר המוצר הוא אחד מנתוני המפתח החשובים ביותר שיכולים להשפיע על הנראות. עם זאת, המחירים משתנים לעתים קרובות ומהר; מסיבה זו כלי התמחור צריך לפעול כמעט בזמן אמת כדי להגביר את הנראות.

סקירה כללית של הפיתרון

התרשים הבא ממחיש את ארכיטקטורת הפתרונות.

הפתרון מכיל את הרכיבים הבאים:

1. שירות מסדי נתונים יחסיים של אמזון (Amazon RDS) עבור PostgreSQL הוא המקור העיקרי לנתונים, המכיל מידע על המוצר המאוחסן במסד נתונים RDS for Postgres.
2. מידע על שינויים ברישום מוצר מגיע בזמן אמת ב- שירות תורים פשוט של אמזון (אמזון SQS) תור.
3. מידע על המוצר המאוחסן ב-Amazon RDS נקלט כמעט בזמן אמת לתוך השכבה הגולמית באמצעות דפוס לכידת נתוני שינוי (CDC) הזמין ב שירות העברת מסדי נתונים של AWS (AWS DMS).
4. הודעות פרטי מוצר המגיעות מ-Amazon SQS נבלעות כמעט בזמן אמת לתוך השכבה הגולמית באמצעות א AWS למבדה פונקציה.
5. נתוני המקור המקוריים מאוחסנים ב- שירות אחסון פשוט של אמזון (Amazon S3) דלי שכבה גולמית בפורמט נתונים של פרקט. שכבה זו היא מקור האמת היחיד עבור אגם הנתונים. החלוקה המשמשת באחסון זה תומכת בעיבוד מצטבר של נתונים.
6. דבק AWS עבודות חילוץ, שינוי וטעינה (ETL) מנקות את נתוני המוצר, הסרת כפילויות והחלת איחוד נתונים ושינויים כלליים שאינם קשורים למקרה עסקי ספציפי.
7. שכבת השלב של Amazon S3 מקבלת נתונים מוכנים המאוחסנים בפורמט Apache Parquet להמשך עיבוד. החלוקה המשמשת בחנות הבמה תומכת בעיבוד מצטבר של נתונים.
8. עבודות הדבק של AWS שנוצרו בשכבה זו משתמשות בנתונים הזמינים בשכבת השלב של Amazon S3. זה כולל יישום של כללים עסקיים ספציפיים לשימוש במקרה וחישובים הנדרשים. נתוני התוצאות מעבודות אלה מאוחסנים בשכבת הניתוח של Amazon S3.
9. שכבת הניתוח של Amazon S3 משמשת לאחסון הנתונים המשמשים את דגמי ה-ML למטרות הדרכה. החלוקה המשמשת בחנות האצורה מבוססת על השימוש הצפוי בנתונים. זה עשוי להיות שונה מהמחיצה המשמשת בשכבת הבמה.
10. מודל התמחור של ML הוא יישום Scikit-Learn Random Forest במצב SageMaker Script, אשר מאומן באמצעות נתונים זמינים ב-S3 bucket (שכבת הניתוח).
11. עבודת עיבוד נתונים של AWS Glue מכינה נתונים להסקת מסקנות בזמן אמת. העבודה מעבדת נתונים שנקלטו בדלי S3 (שכבת שלב) ומפעילה את נקודת הסיום של SageMaker. הנתונים מוכנים לשימוש במודל התמחור מחדש של SageMaker. AWS Glue הועדף על למבדה, מכיוון שההסקה דורשת פעולות עיבוד נתונים מורכבות שונות כמו חיבורים ופונקציות חלונות על נפח נתונים גבוה (מיליארדי עסקאות יומיות). התוצאה מקריאת מודל התמחור מאוחסנת בדלי S3 (שכבת ההסקה).
12. עבודת ההדרכה של SageMaker נפרסת באמצעות נקודת קצה של SageMaker. נקודת קצה זו מופעלת על ידי מעבד ההסקת AWS Glue, ומייצר המלצות מחיר כמעט בזמן אמת כדי להגביר את נראות המוצר.
13. התחזיות שנוצרות על ידי נקודת הקצה של SageMaker מאוחסנות בשכבת ההסקה של Amazon S3.
14. פונקציית האופטימיזציה לחיזוי Lambda מעבדת את ההמלצות שנוצרות על ידי נקודת הסיום של SageMaker ומייצרת המלצת מחיר חדשה המתמקדת במקסום הרווח של המוכר, תוך החלת פשרה בין נפח מכירות לשולי מכירות.
15. המלצות המחיר שנוצרו על ידי מייעל חיזוי Lambda מוגשות ל-API לתמחור מחדש, אשר מעדכן את מחיר המוצר בשוק.
16. המלצות המחיר המעודכנות שנוצרו על ידי מייעל חיזוי Lambda מאוחסנות בשכבת האופטימיזציה של Amazon S3.
17. עבודת מטעין החיזוי של AWS Glue טוענת מחדש למסד הנתונים של המקור RDS עבור Postgres SQL את התחזיות שנוצרו על ידי מודל ה-ML למטרות ביקורת ודיווח. AWS Glue Studio שימש ליישם רכיב זה; זהו ממשק גרפי שמקל על יצירה, הפעלה וניטור של עבודות ETL ב-AWS Glue.

הכנת נתונים

מערך הנתונים עבור מודל הנראות של Adspert נוצר מתוך תור SQS ונבלע בשכבה הגולמית של אגם הנתונים שלנו בזמן אמת עם Lambda. לאחר מכן, הנתונים הגולמיים עוברים חיטוי על ידי ביצוע טרנספורמציות פשוטות, כמו הסרת כפילויות. תהליך זה מיושם ב-AWS Glue. התוצאה מאוחסנת בשכבת הבמה של אגם הנתונים שלנו. ההודעות מספקות למתחרים עבור מוצר נתון, את המחירים, ערוצי ההגשמה, זמני המשלוח, ומשתנים רבים נוספים. הם גם מספקים מדד נראות תלוי פלטפורמה, שיכול לבוא לידי ביטוי כמשתנה בוליאני (גלוי או לא גלוי). אנו מקבלים הודעה בכל פעם שמתרחש שינוי בהצעה, מה שמוסיף עד כמה מיליוני אירועים בחודש על כל מוצרי הלקוחות שלנו.

ממערך הנתונים הזה, אנו מחלצים את נתוני ההדרכה באופן הבא: עבור כל הודעה, אנו מצמידים את ההצעות הגלויות לכל הצעה שאינה גלויה, ולהיפך. כל נקודת נתונים מייצגת תחרות בין שני מוכרים, שבה יש מנצח ומפסיד ברור. עבודת עיבוד זו מיושמת בעבודת דבק של AWS עם Spark. מערך ההדרכה המוכן נדחף אל דלי ה-S3 של Analytics לשימוש על ידי 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, המחלק את המחיר במינימום של מחיר המתחרה ועמודת מחיר חיצוני. גילינו שלתכונה זו יש השפעה רלוונטית על דיוק הדגם. אנו גם מיישמים את הלוגריתם כדי לאפשר למודל להחליט על סמך הפרשי מחיר יחסיים, לא על הבדלי מחיר מוחלטים.

ב training_script.py תסריט, תחילה אנו מגדירים כיצד לבנות את ה-Skikit-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')

בסקריפט ההדרכה, אנו טוענים את הנתונים מפרקט לתוך מסגרת נתונים של 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 - אחראי על ניתוח הנתונים מגוף הבקשה של המטען
• model_fn – טוען ומחזיר את הדגם שהושלך בקטע ההדרכה של התסריט
• predict_fn – מכיל את היישום שלנו לבקשת חיזוי מהמודל באמצעות הנתונים מהמטען
• predict_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})

חפץ הדגם מאוחסן באמזון S3 על ידי פונקציית ההתאמה. כפי שניתן לראות בקוד הבא, ניתן לטעון את המודל כ 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 עובדת ב-micro-batchs על הנתונים בזמן אמת שנקלטו מלמבדה.

לבסוף, אנו רוצים לחשב את עקומת הראות המצטברת, שהיא הנראות החזויה עבור כל מחיר אפשרי. ההצעה שלנו גלויה אם היא טובה יותר מכל הצעות המוכרים האחרים. בהנחה של אי תלות בין ההסתברויות להיות גלוי מול כל מוכר בהינתן המחיר שלנו, ההסתברות להיות גלוי מול כל המוכרים היא מכפלה של ההסתברויות המתאימות. כלומר, ניתן לחשב את עקומת הראות המצטברת על ידי הכפלת כל העקומות.

האיורים הבאים מציגים את הנראות החזויה שהוחזרו מנקודת הקצה של SageMaker.

האיור הבא מציג את עקומת הראות המצטברת.

כדי לחשב את המחיר האופטימלי, תחילה מחליקים את עקומת הראות ולאחר מכן מוכפלים בשוליים. כדי לחשב את המרווח, אנו משתמשים בעלויות הסחורה ובעמלות. עלות הסחורה הנמכרת והעמלות הן מידע סטטי על המוצר המסונכרן באמצעות AWS DMS. בהתבסס על פונקציית הרווח, Adspert מחשבת את המחיר האופטימלי ומגישה אותו לפלטפורמת המסחר האלקטרוני דרך ה-API של הפלטפורמה.

זה מיושם בכלי האופטימיזציה של חיזוי AWS Lambda.

האיור הבא מציג את הקשר בין הנראות החזויה למחיר.

האיור הבא מציג את הקשר בין מחיר לרווח.

סיכום

הגישה הקיימת של Adspert למקסום רווחים מתמקדת בניהול הצעות מחיר כדי להגדיל את התשואות מהפרסום. עם זאת, כדי להשיג ביצועים מעולים בשוקי מסחר אלקטרוני, מוכרים צריכים לשקול גם פרסום וגם תמחור תחרותי של המוצרים שלהם. עם מודל ML חדש זה לניבוי נראות, אנו יכולים להרחיב את הפונקציונליות שלנו כדי להתאים גם את המחירים של הלקוח.

כלי התמחור החדש צריך להיות מסוגל להכשרה אוטומטית של מודל ה-ML על כמות גדולה של נתונים, כמו גם טרנספורמציות של נתונים בזמן אמת, תחזיות ואופטימיזציות של מחירים. בפוסט זה, עברנו על השלבים העיקריים של מנוע אופטימיזציית המחירים שלנו, וארכיטקטורת ה-AWS שיישמנו בשיתוף עם מעבדת הנתונים של AWS כדי להשיג את המטרות הללו.

העברת דגמי ML מהרעיון לייצור היא בדרך כלל מורכבת וגוזלת זמן. אתה צריך לנהל כמויות גדולות של נתונים כדי לאמן את המודל, לבחור את האלגוריתם הטוב ביותר להכשרתו, לנהל את קיבולת המחשוב תוך כדי הכשרתו, ולאחר מכן לפרוס את המודל בסביבת ייצור. SageMaker הפחית את המורכבות הזו על ידי הפיכתו להרבה יותר פשוט לבנות ולפרוס את מודל ה-ML. לאחר שבחרנו את האלגוריתמים והמסגרות הנכונות מתוך מגוון האפשרויות הרחב הזמינות, SageMaker ניהלה את כל התשתית הבסיסית כדי לאמן את המודל שלנו ולפרוס אותו לייצור.

אם תרצה להתחיל להכיר את SageMaker, ה סדנת יום הטבילה יכול לעזור לך לקבל הבנה מקצה לקצה כיצד לבנות מקרי שימוש ב-ML מהנדסת תכונות, האלגוריתמים השונים המובנים וכיצד לאמן, לכוונן ולפרוס את מודל ה-ML בתרחיש דמוי ייצור. זה מנחה אותך להביא דגם משלך ולבצע הרמת עומס עבודה ML מקומית לפלטפורמת SageMaker. זה מדגים עוד מושגים מתקדמים כמו איתור באגים במודל, ניטור מודלים ו-AutoML, ועוזר לך להעריך את עומס העבודה שלך ב-ML דרך העדשה של AWS ML Well-Architected.

אם תרצה עזרה בהאצת היישום של מקרי שימוש הכוללים נתונים, ניתוחים, AI ו-ML, ללא שרת ומודרניזציה של מיכלים, אנא צור קשר עם מעבדת הנתונים של AWS.

על המחברים

ויקטור אנריקו ג'ייני הוא מהנדס בכיר למידת מכונה ב-Adspert שבסיסה בברלין, גרמניה. הוא יוצר פתרונות לבעיות חיזוי ואופטימיזציה על מנת להגדיל את רווחי הלקוחות. לוויקטור יש רקע במתמטיקה שימושית ואוהב לעבוד עם נתונים. בזמנו הפנוי הוא נהנה ללמוד הונגרית, לתרגל אומנויות לחימה ולנגן בגיטרה.

אניו פסטור הוא ארכיטקט נתונים בצוות AWS Data Lab. הוא חובב מכל מה שקשור לטכנולוגיות חדשות שיש להן השפעה חיובית על העסקים והפרנסה הכללית. ל- Ennio יש למעלה מ-9 שנות ניסיון בניתוח נתונים. הוא עוזר לחברות להגדיר ולהטמיע פלטפורמות נתונים בין תעשיות, כגון טלקומוניקציה, בנקאות, משחקים, קמעונאות וביטוח.