פייפליין למידת מכונה: פיתוח טרנספורמרים מותאמים אישית ב-Scikit-learn

פייפליינים של למידת מכונה הם חיוניים לבניית מודלים חזקים וניתנים לתחזוקה. Scikit-learn (או sklearn) מספקת מסגרת עוצמתית ליצירת פייפליינים אלה. מרכיב מפתח בכל פייפליין טוב הוא היכולת לבצע טרנספורמציות נתונים מותאמות אישית. מאמר זה סוקר את הפיתוח של טרנספורמרים מותאמים אישית ב-scikit-learn, ומספק מדריך מקיף למדעני נתונים ומהנדסי למידת מכונה ברחבי העולם.

מהו פייפליין למידת מכונה?

פייפליין למידת מכונה הוא רצף של רכיבי עיבוד נתונים המשורשרים יחד. רכיבים אלה כוללים בדרך כלל:

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

שימוש בפייפליין מציע מספר יתרונות, כולל:

• שחזוריות (Reproducibility): הבטחה שאותם שלבי עיבוד נתונים מיושמים באופן עקבי.
• מודולריות: פירוק תהליך עיבוד הנתונים לרכיבים רב-פעמיים.
• תחזוקתיות: הקלה על עדכון ותחזוקה של תהליך עיבוד הנתונים.
• פריסה פשוטה: ייעול תהליך הפריסה של מודלי למידת מכונה.

מדוע להשתמש בטרנספורמרים מותאמים אישית?

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

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

בניית טרנספורמר מותאם אישית

כדי ליצור טרנספורמר מותאם אישית ב-scikit-learn, עליכם ליצור מחלקה שיורשת מ-sklearn.base.BaseEstimator ו-sklearn.base.TransformerMixin. המחלקה שלכם חייבת לממש שתי מתודות:

• fit(self, X, y=None): מתודה זו לומדת את הפרמטרים הדרושים לטרנספורמציה. במקרים רבים, מתודה זו פשוט מחזירה self.
• transform(self, X): מתודה זו מיישמת את הטרנספורמציה על הנתונים.

הנה דוגמה בסיסית לטרנספורמר מותאם אישית שמוסיף ערך קבוע לכל תכונה:

            from sklearn.base import BaseEstimator, TransformerMixin
import numpy as np

class AddConstantTransformer(BaseEstimator, TransformerMixin):
    def __init__(self, constant=1):
        self.constant = constant

    def fit(self, X, y=None):
        return self

    def transform(self, X):
        return X + self.constant

            

              
                Copy
              
            
          

בואו נפרק את הדוגמה הזו:

• ייבוא ספריות נדרשות: BaseEstimator, TransformerMixin מ-sklearn.base ו-numpy לפעולות נומריות.
• הגדרת המחלקה: AddConstantTransformer יורשת מ-BaseEstimator ו-TransformerMixin.
• בנאי (__init__): מתודה זו מאתחלת את הטרנספורמר עם ערך constant (ברירת המחדל היא 1).
• מתודת fit: מתודה זו פשוט מחזירה self, מכיוון שטרנספורמר זה אינו צריך ללמוד פרמטרים כלשהם מהנתונים.
• מתודת transform: מתודה זו מוסיפה את הערך constant לכל איבר בנתוני הקלט X.

דוגמת שימוש

            from sklearn.pipeline import Pipeline
from sklearn.preprocessing import StandardScaler

X = np.array([[1, 2], [3, 4], [5, 6]])

pipeline = Pipeline([
    ('scaler', StandardScaler()),
    ('add_constant', AddConstantTransformer(constant=2))
])

X_transformed = pipeline.fit_transform(X)

print(X_transformed)

            

              
                Copy
              
            
          

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

פיתוח טרנספורמרים מותאמים אישית למתקדמים

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

טיפול בתכונות קטגוריות

תכונות קטגוריות הן סוג נתונים נפוץ בלמידת מכונה. ניתן ליצור טרנספורמרים מותאמים אישית לביצוע פעולות שונות על תכונות קטגוריות, כגון קידוד One-Hot, קידוד תווית (label encoding), או גיבוב תכונות (feature hashing).

הנה דוגמה לטרנספורמר מותאם אישית המבצע קידוד One-Hot על עמודות שצוינו:

            import pandas as pd
from sklearn.preprocessing import OneHotEncoder

class CategoricalEncoder(BaseEstimator, TransformerMixin):
    def __init__(self, categorical_features=None):
        self.categorical_features = categorical_features
        self.encoder = None

    def fit(self, X, y=None):
        if self.categorical_features is None:
            self.categorical_features = X.select_dtypes(include=['object']).columns

        self.encoder = OneHotEncoder(handle_unknown='ignore', sparse_output=False)
        self.encoder.fit(X[self.categorical_features])
        return self

    def transform(self, X):
        X_encoded = self.encoder.transform(X[self.categorical_features])
        X_encoded = pd.DataFrame(X_encoded, index=X.index, columns=self.encoder.get_feature_names_out(self.categorical_features))
        X = X.drop(columns=self.categorical_features)
        X = pd.concat([X, X_encoded], axis=1)
        return X

            

              
                Copy
              
            
          

בדוגמה זו:

• הטרנספורמר מזהה עמודות קטגוריות באופן אוטומטי (אם לא צוינו).
• הוא משתמש ב-OneHotEncoder מ-scikit-learn לביצוע הקידוד.
• הוא מטפל בקטגוריות לא ידועות באמצעות handle_unknown='ignore'.
• התכונות המקודדות משורשרות חזרה ל-dataframe המקורי.

טיפול בערכים חסרים

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

הנה דוגמה לטרנספורמר מותאם אישית שמשלים ערכים חסרים באמצעות החציון:

            from sklearn.impute import SimpleImputer

class MissingValueImputer(BaseEstimator, TransformerMixin):
    def __init__(self, strategy='median', missing_values=np.nan):
        self.strategy = strategy
        self.missing_values = missing_values
        self.imputer = None

    def fit(self, X, y=None):
        self.imputer = SimpleImputer(strategy=self.strategy, missing_values=self.missing_values)
        self.imputer.fit(X)
        return self

    def transform(self, X):
        return self.imputer.transform(X)

            

              
                Copy
              
            
          

טרנספורמר זה משתמש ב-SimpleImputer מ-scikit-learn לביצוע ההשלמה. הוא מאפשר לכם לציין את אסטרטגיית ההשלמה ואת הערך המשמש לייצוג ערכים חסרים.

נרמול וסילום תכונות (Feature Scaling)

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

בעוד ש-scikit-learn מספקת טרנספורמרים כמו StandardScaler ו-MinMaxScaler, ייתכן שתצטרכו סקלר מותאם אישית עבור התפלגויות נתונים ספציפיות. לדוגמה, אם יש לכם נתונים עם התפלגות מוטה מאוד, PowerTransformer (שזמין גם הוא ב-scikit-learn) עשוי להיות מתאים יותר. עם זאת, ניתן לכמוס אותו בתוך טרנספורמר מותאם אישית כדי לנהל את הפרמטרים שלו ולשלבו בצורה חלקה בפייפליין שלכם.

            from sklearn.preprocessing import PowerTransformer

class SkewedDataTransformer(BaseEstimator, TransformerMixin):
    def __init__(self, method='yeo-johnson'):
        self.method = method
        self.transformer = None

    def fit(self, X, y=None):
        self.transformer = PowerTransformer(method=self.method)
        self.transformer.fit(X)
        return self

    def transform(self, X):
        return self.transformer.transform(X)

            

              
                Copy
              
            
          

שילוב טרנספורמציות מרובות

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

הנה דוגמה לטרנספורמר מותאם אישית המשלב קידוד One-Hot והשלמת ערכים חסרים:

            class CombinedTransformer(BaseEstimator, TransformerMixin):
    def __init__(self, categorical_features=None, missing_value_strategy='median'):
        self.categorical_features = categorical_features
        self.missing_value_strategy = missing_value_strategy
        self.categorical_encoder = None
        self.missing_value_imputer = None

    def fit(self, X, y=None):
        self.categorical_encoder = CategoricalEncoder(categorical_features=self.categorical_features)
        self.missing_value_imputer = MissingValueImputer(strategy=self.missing_value_strategy)
        self.categorical_encoder.fit(X)
        self.missing_value_imputer.fit(X)
        return self

    def transform(self, X):
        X = self.categorical_encoder.transform(X)
        X = self.missing_value_imputer.transform(X)
        return X

            

              
                Copy
              
            
          

טרנספורמר זה משתמש ב-CategoricalEncoder וב-MissingValueImputer מהדוגמאות הקודמות כדי לבצע הן קידוד One-Hot והן השלמת ערכים חסרים בשלב אחד.

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

הנה כמה שיטות עבודה מומלצות שכדאי לאמץ בעת פיתוח טרנספורמרים מותאמים אישית:

• שמרו על פשטות: כל טרנספורמר צריך לבצע משימה אחת, מוגדרת היטב.
• הפכו אותו לרב-פעמי: עצבו את הטרנספורמרים שלכם כך שיהיו כלליים ככל האפשר, כדי שניתן יהיה לעשות בהם שימוש חוזר בפייפליינים שונים.
• טפלו במקרי קצה: חשבו כיצד הטרנספורמר שלכם יתמודד עם מקרי קצה, כגון ערכים חסרים, חריגות וסוגי נתונים בלתי צפויים.
• כתבו בדיקות יחידה (unit tests): כתבו בדיקות יחידה כדי להבטיח שהטרנספורמר שלכם פועל כהלכה.
• תעדו את הקוד שלכם: תעדו את הקוד שלכם בצורה ברורה כדי שאחרים יוכלו להבין כיצד להשתמש בטרנספורמר.

דוגמאות מהעולם האמיתי

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

הנדסת תכונות מתאריכים

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

            class DateFeatureExtractor(BaseEstimator, TransformerMixin):
    def __init__(self, date_columns=None):
        self.date_columns = date_columns

    def fit(self, X, y=None):
        return self

    def transform(self, X):
        for col in self.date_columns:
            X[col + '_dayofweek'] = X[col].dt.dayofweek
            X[col + '_month'] = X[col].dt.month
            X[col + '_quarter'] = X[col].dt.quarter
        return X

            

              
                Copy
              
            
          

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

הנדסת תכונות מטקסט

בעבודה עם נתוני טקסט, לעתים קרובות שימושי לבצע הנדסת תכונות באמצעות טכניקות כמו TF-IDF או שיכוני מילים (word embeddings). ניתן ליצור טרנספורמרים מותאמים אישית לביצוע משימות אלו. לדוגמה, קחו בחשבון ביקורות לקוחות במספר שפות. ייתכן שתצטרכו טרנספורמר מותאם אישית שמתרגם את הביקורות לאנגלית לפני החלת וקטוריזציית TF-IDF.

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

            # Note: This example requires a translation service (e.g., Google Translate API) and API key
# from googletrans import Translator # Example library (install with pip install googletrans==4.0.0-rc1)

class TextFeatureExtractor(BaseEstimator, TransformerMixin):
    def __init__(self, text_column, language='en'):
        self.text_column = text_column
        self.language = language
        # self.translator = Translator() # Instantiate translator (requires setup)

    def fit(self, X, y=None):
        return self

    def transform(self, X):
        # Example: Translate to English (replace with actual translation logic)
        # X[self.text_column + '_translated'] = X[self.text_column].apply(lambda text: self.translator.translate(text, dest=self.language).text)
        # Dummy translation for demonstration purposes
        X[self.text_column + '_translated'] = X[self.text_column].apply(lambda text: "Translated: " + text)

        # Apply TF-IDF or other text vectorization techniques here
        return X

            

              
                Copy
              
            
          

הנדסת תכונות גיאומרחביות

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

שילוב עם ספריות קיימות

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

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

סיכום

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