परिचय

सारणीबद्ध डेटा के लिए एक बाइनरी वर्गीकरण मॉडल का चयन करते समय, मैंने एक तेज़, गैर-गहन शिक्षण मॉडल को आज़माने का निर्णय लिया: ग्रेडिएंट बूस्टिंग डिसीजन ट्रीज़ (जीबीडीटी)। यह आलेख डेटा स्रोत के रूप में BigQuery और मॉडलिंग के लिए XGBoost एल्गोरिदम का उपयोग करके ज्यूपिटर नोटबुक स्क्रिप्ट बनाने की प्रक्रिया का वर्णन करता है।

पूरी स्क्रिप्ट

उन लोगों के लिए जो स्पष्टीकरण के बिना सीधे स्क्रिप्ट में कूदना पसंद करते हैं, यह यहां है। कृपया अपने प्रोजेक्ट में फिट होने के लिए प्रोजेक्ट_नाम, डेटासेट_नाम और टेबल_नाम को समायोजित करें।

import xgboost as xgb
from sklearn.model_selection import train_test_split, GridSearchCV
from sklearn.metrics import precision_score, recall_score, f1_score, log_loss
from google.cloud import bigquery

# Function to load data from BigQuery
def load_data_from_bigquery(query):
    client = bigquery.Client()
    query_job = client.query(query)
    df = query_job.to_dataframe()
    return df

def compute_metrics(labels, predictions, prediction_probs):
    precision = precision_score(labels, predictions, average='macro')
    recall = recall_score(labels, predictions, average='macro')
    f1 = f1_score(labels, predictions, average='macro')
    loss = log_loss(labels, prediction_probs)
    return {
        'precision': precision,
        'recall': recall,
        'f1': f1,
        'loss': loss
    }

# Query in BigQuery
query = """
SELECT *
FROM `..`
"""

# Loading data
df = load_data_from_bigquery(query)

# Target data
y = df["reaction"]

# Input data
X = df.drop(columns=["reaction"], axis=1)

# Splitting data into training and validation sets
X_train, X_val, y_train, y_val = train_test_split(X, y, test_size=0.2, random_state=1)

# Training the XGBoost model
model = xgb.XGBClassifier(eval_metric='logloss')

# Setting the parameter grid
param_grid = {
    'max_depth': [3, 4, 5],
    'learning_rate': [0.01, 0.1, 0.2],
    'n_estimators': [100, 200, 300],
    'subsample': [0.8, 0.9, 1.0]
}

# Initializing GridSearchCV
grid_search = GridSearchCV(estimator=model, param_grid=param_grid, cv=3, scoring='accuracy', verbose=1, n_jobs=-1)

# Executing the grid search
grid_search.fit(X_train, y_train)

# Displaying the best parameters
print("Best parameters:", grid_search.best_params_)

# Model with the best parameters
best_model = grid_search.best_estimator_

# Predictions on validation data
val_predictions = best_model.predict(X_val)
val_prediction_probs = best_model.predict_proba(X_val)

# Predictions on training data
train_predictions = best_model.predict(X_train)
train_prediction_probs = best_model.predict_proba(X_train)

# Evaluating the model (validation data)
val_metrics = compute_metrics(y_val, val_predictions, val_prediction_probs)
print("Optimized Validation Metrics:", val_metrics)

# Evaluating the model (training data)
train_metrics = compute_metrics(y_train, train_predictions, train_prediction_probs)
print("Optimized Training Metrics:", train_metrics)

स्पष्टीकरण

BigQuery से डेटा लोड हो रहा है

पहले, डेटा को क्लाउड स्टोरेज में CSV फ़ाइलों के रूप में संग्रहीत किया जाता था, लेकिन धीमी डेटा लोडिंग हमारी सीखने की प्रक्रियाओं की दक्षता को कम कर रही थी, जिससे तेज़ डेटा प्रबंधन के लिए BigQuery में बदलाव आया।

BigQuery क्लाइंट सेट करना

from google.cloud import bigquery
client = bigquery.Client()

यह कोड Google क्लाउड क्रेडेंशियल्स का उपयोग करके एक BigQuery क्लाइंट को प्रारंभ करता है, जिसे पर्यावरण चर या Google क्लाउड SDK के माध्यम से सेट किया जा सकता है।

डेटा को क्वेरी करना और लोड करना

def load_data_from_bigquery(query):
    query_job = client.query(query)
    df = query_job.to_dataframe()
    return df

यह फ़ंक्शन एक SQL क्वेरी निष्पादित करता है और परिणामों को पांडा में डेटाफ़्रेम के रूप में लौटाता है, जिससे कुशल डेटा प्रोसेसिंग की अनुमति मिलती है।

XGBoost के साथ मॉडल का प्रशिक्षण

XGBoost ग्रेडिएंट बूस्टिंग का उपयोग करने वाला एक उच्च-प्रदर्शन मशीन लर्निंग एल्गोरिदम है, जो वर्गीकरण और प्रतिगमन समस्याओं के लिए व्यापक रूप से उपयोग किया जाता है।

https://arxiv.org/pdf/1603.02754

मॉडल आरंभीकरण

import xgboost as xgb
model = xgb.XGBClassifier(eval_metric='logloss')

यहाँ, मूल्यांकन मीट्रिक के रूप में लॉग हानि का उपयोग करते हुए, XGBClassifier वर्ग को त्वरित किया गया है।

डेटा विभाजन

from sklearn.model_selection import train_test_split
X_train, X_val, y_train, y_val = train_test_split(X, y, test_size=0.2, random_state=1)

यह फ़ंक्शन डेटा को प्रशिक्षण और सत्यापन सेट में विभाजित करता है, जो मॉडल के प्रदर्शन का परीक्षण करने और ओवरफिटिंग से बचने के लिए महत्वपूर्ण है।

पैरामीटर अनुकूलन

from sklearn.model_selection import GridSearchCV
param_grid = {
    'max_depth': [3, 4, 5],
    'learning_rate': [0.01, 0.1, 0.2],
    'n_estimators': [100, 200, 300],
    'subsample': [0.8, 0.9, 1.0]
}
grid_search = GridSearchCV(estimator=model, param_grid=param_grid, cv=3, scoring='accuracy', verbose=1, n_jobs=-1)
grid_search.fit(X_train, y_train)

ग्रिडसर्चसीवी मॉडल के लिए मापदंडों का सर्वोत्तम संयोजन खोजने के लिए क्रॉस-सत्यापन करता है।

मॉडल मूल्यांकन

मॉडल के प्रदर्शन का मूल्यांकन सत्यापन डेटासेट पर सटीकता, रिकॉल, एफ1 स्कोर और लॉग लॉस का उपयोग करके किया जाता है।

def compute_metrics(labels, predictions, prediction_probs):
    from sklearn.metrics import precision_score, recall_score, f1_score, log_loss
    return {
        'precision': precision_score(labels, predictions, average='macro'),
        'recall': recall_score(labels, predictions, average='macro'),
        'f1': f1_score(labels, predictions, average='macro'),
        'loss': log_loss(labels, prediction_probs)
    }
val_metrics = compute_metrics(y_val, val_predictions, val_prediction_probs)
print("Optimized Validation Metrics:", val_metrics)

आउटपुट परिणाम

जब आप नोटबुक चलाते हैं, तो आपको सर्वोत्तम पैरामीटर और मॉडल मूल्यांकन मेट्रिक्स दिखाने वाला निम्नलिखित आउटपुट मिलेगा।

Best parameters: {'learning_rate': 0.2, 'max_depth': 5, 'n_estimators': 300, 'subsample': 0.9}
Optimized Validation Metrics: {'precision': 0.8919952583956949, 'recall': 0.753797304483842, 'f1': 0.8078981867164722, 'loss': 0.014006406471894417}
Optimized Training Metrics: {'precision': 0.8969556573175115, 'recall': 0.7681976753444204, 'f1': 0.8199353049298048, 'loss': 0.012475375680566196}

अतिरिक्त जानकारी

डेटा स्रोत के रूप में Google क्लाउड स्टोरेज का उपयोग करना

कुछ मामलों में, BigQuery के बजाय Google क्लाउड स्टोरेज से डेटा लोड करना अधिक उपयुक्त हो सकता है। निम्नलिखित फ़ंक्शन क्लाउड स्टोरेज से एक CSV फ़ाइल को पढ़ता है और इसे पांडा में डेटाफ़्रेम के रूप में लौटाता है, और इसे लोड_डेटा_फ्रॉम_बिगक्वेरी फ़ंक्शन के साथ परस्पर उपयोग किया जा सकता है।

from google.cloud import storage

def load_data_from_gcs(bucket_name, file_path):
    client = storage.Client()
    bucket = client.get_bucket(bucket_name)
    blob = bucket.blob(file_path)
    data = blob.download_as_text()
    df = pd.read_csv(io.StringIO(data), encoding='utf-8')
    return df

उपयोग का उदाहरण:

bucket_name = ''
file_path = ''

df = load_data_from_gcs(bucket_name, file_path)

लाइटजीबीएम के साथ एक मॉडल का प्रशिक्षण

यदि आप XGBoost के बजाय LightGBM का उपयोग करना चाहते हैं, तो आप बस उसी सेटअप में XGBClassifier को LGBMClassifier से बदल सकते हैं।

import lightgbm as lgb
model = lgb.LGBMClassifier()

निष्कर्ष

भविष्य के लेख प्रशिक्षण के लिए BigQuery ML (BQML) के उपयोग को कवर करेंगे।