html
पाइथन और XGBoost के साथ मशीन लर्निंग मॉडल बनाने और तैनात करने के लिए व्यापक गाइड
डेटा विज्ञान के तेजी से विकसित हो रहे क्षेत्र में, मशीन लर्निंग मॉडल बनाने, मूल्यांकन करने, और तैनात करने की क्षमता एक महत्वपूर्ण कौशल है। चाहे आप मौसम पैटर्न की भविष्यवाणी कर रहे हों, ग्राहक व्यवहार का विश्लेषण कर रहे हों, या निर्णय-निर्माण प्रक्रियाओं को स्वचालित कर रहे हों, इन चरणों में महारत हासिल करने से आपके परियोजनाओं की प्रभावशीलता और स्केलेबिलिटी में काफी सुधार हो सकता है। यह गाइड पाइथन का उपयोग करके मशीन लर्निंग मॉडल बनाने और तैनात करने के लिए एक व्यापक, चरण-दर-चरण दृष्टिकोण प्रदान करती है, जिसमें शक्तिशाली XGBoost एल्गोरिदम पर ध्यान केंद्रित किया गया है। हम डेटा प्रीप्रोसेसिंग, फीचर चयन, मॉडल प्रशिक्षण, मूल्यांकन, और तैनाती में गहराई से जाएंगे, जो जुपिटर नोटबुक्स से व्यावहारिक कोड उदाहरणों द्वारा समर्थित हैं।
सामग्री की तालिका
- मशीन लर्निंग मॉडल तैनाती का परिचय
- डेटा तैयारी और प्रीप्रोसेसिंग
- लाइब्रेरी और डेटा आयात करना
- गायब मानों से निपटना
- श्रेणीबद्ध विशेषताओं को एन्कोड करना
- फीचर चयन
- मॉडल प्रशिक्षण और मूल्यांकन
- के-निकटतम पड़ोसी (KNN)
- लॉजिस्टिक रिग्रेशन
- गॉसियन नेव बेयस
- सपोर्ट वेक्टर मशीन (SVM)
- डिसीजन ट्री
- रैंडम फॉरेस्ट
- एडा-बूस्ट
- XGBoost
- पिकल के साथ मॉडल सहेजना और लोड करना
- तैनात मॉडल के साथ भविष्यवाणियाँ करना
- वेब एप्लिकेशन में मॉडल तैनात करना
- निष्कर्ष
1. मशीन लर्निंग मॉडल तैनाती का परिचय
मशीन लर्निंग मॉडल तैनात करना केवल मॉडल बनाने और प्रशिक्षण देने से परे कई महत्वपूर्ण चरणों को शामिल करता है। इसमें डेटा तैयार करना, सही फीचर्स का चयन करना, कई मॉडलों को प्रशिक्षित करना, उनके प्रदर्शन का मूल्यांकन करना, और अंततः, सबसे अच्छा प्रदर्शन करने वाले मॉडल को एक उत्पादन वातावरण में तैनात करना शामिल है जहाँ यह रियल-टाइम भविष्यवाणियाँ प्रदान कर सकता है। यह गाइड पाइथन और XGBoost का उपयोग करके, जो गति और सटीकता के लिए अनुकूलित एक उच्च-प्रदर्शन लाइब्रेरी है, इन प्रत्येक चरणों के माध्यम से आपको मार्गदर्शन करती है।
2. डेटा तैयारी और प्रीप्रोसेसिंग
लाइब्रेरी और डेटा आयात करना
किसी भी मशीन लर्निंग परियोजना में पहला कदम डेटा तैयारी है। इसमें आवश्यक लाइब्रेरी आयात करना और डेटासेट लोड करना शामिल है।
|
import pandas as pd import seaborn as sns # Load the dataset data = pd.read_csv('weatherAUS - tiny.csv') data.tail() |
आउटपुट:
|
Date Location MinTemp MaxTemp Rainfall Evaporation Sunshine WindGustDir WindGustSpeed WindDir9am ... RainToday RISK_MM RainTomorrow 9994 04/01/2012 CoffsHarbour 19.6 28.6 0.0 7.4 10.0 NE 56.0 NNW ... No 0.6 No 9995 05/01/2012 CoffsHarbour 21.3 26.5 0.6 7.6 6.4 NNE 31.0 S ... No 0.0 No 9996 06/01/2012 CoffsHarbour 18.4 27.6 0.0 5.0 10.6 SSW 56.0 N ... No 0.0 No 9997 07/01/2012 CoffsHarbour 18.3 26.1 0.0 7.6 9.0 SW 28.0 SW ... No 0.0 No 9998 08/01/2012 CoffsHarbour 21.4 29.2 0.0 5.8 12.8 NNE 61.0 N ... No 2.0 Yes |
गायब मानों से निपटना
गायब डेटा से निपटना विश्वसनीय मॉडल बनाने के लिए महत्वपूर्ण है। यहाँ, हम Scikit-learn के SimpleImputer
का उपयोग करके संख्यात्मक और श्रेणीबद्ध कॉलम दोनों में गायब मानों से निपटते हैं।
|
import numpy as np from sklearn.impute import SimpleImputer # Handling missing numeric data imp_mean = SimpleImputer(missing_values=np.nan, strategy='mean') numerical_cols = list(np.where((X.dtypes == np.int64) | (X.dtypes == np.float64))[0]) imp_mean.fit(X.iloc[:, numerical_cols]) X.iloc[:, numerical_cols] = imp_mean.transform(X.iloc[:, numerical_cols]) # Handling missing categorical data string_cols = list(np.where((X.dtypes == np.object))[0]) imp_mode = SimpleImputer(missing_values=np.nan, strategy='most_frequent') imp_mode.fit(X.iloc[:, string_cols]) X.iloc[:, string_cols] = imp_mode.transform(X.iloc[:, string_cols]) |
श्रेणीबद्ध विशेषताओं को एन्कोड करना
मशीन लर्निंग एल्गोरिदम को संख्यात्मक इनपुट की आवश्यकता होती है। इसलिए, हम श्रेणीबद्ध विशेषताओं को लेबल एन्कोडिंग और वन-हॉट एन्कोडिंग विधियों दोनों का उपयोग करके एन्कोड करते हैं।
1 2 3 4 5 6 7 8 9 10 11 12 13 14 15 16 17 18 19 20 21 22 23 24 25 26 27 28 29 30 31 32 33 34
|
from sklearn import preprocessing from sklearn.compose import ColumnTransformer from sklearn.preprocessing import OneHotEncoder # Label Encoding function def LabelEncoderMethod(series): le = preprocessing.LabelEncoder() le.fit(series) print('Encoding values', le.transform(pd.unique(series))) return le.transform(series) # One Hot Encoding function def OneHotEncoderMethod(indices, data): columnTransformer = ColumnTransformer([('encoder', OneHotEncoder(), indices)], remainder='passthrough') return columnTransformer.fit_transform(data) # Encoding selection function def EncodingSelection(X, threshold=10): string_cols = list(np.where((X.dtypes == np.object))[0]) one_hot_encoding_indices = [] for col in string_cols: length = len(pd.unique(X[X.columns[col]])) if length == 2 or length > threshold: X[X.columns[col]] = LabelEncoderMethod(X[X.columns[col]]) else: one_hot_encoding_indices.append(col) X = OneHotEncoderMethod(one_hot_encoding_indices, X) return X # Apply encoding X = EncodingSelection(X) print(X.shape) # Output: (9999, 25) |
3. फीचर चयन
सही फीचर्स का चयन मॉडल के प्रदर्शन में सुधार करता है और गणनात्मक लागत को कम करता है। हम SelectKBest
का उपयोग करते हैं जिसमें Chi-Squared (chi2) सांख्यिकी परीक्षण के साथ शीर्ष 5 फीचर्स का चयन किया जाता है।
1 2 3 4 5 6 7 8 9 10 11 12 13 14 15 16 17
|
from sklearn.feature_selection import SelectKBest, chi2 from sklearn import preprocessing # Initialize SelectKBest and MinMaxScaler kbest = SelectKBest(score_func=chi2, k=10) MMS = preprocessing.MinMaxScaler() K_features = 5 # Fit and transform the features x_temp = MMS.fit_transform(X) x_temp = kbest.fit(x_temp, y) # Select top features best_features = np.argsort(x_temp.scores_)[-K_features:] features_to_delete = np.argsort(x_temp.scores_)[:-K_features] X = np.delete(X, features_to_delete, axis=1) print(X.shape) # Output: (9999, 5) |
4. मॉडल प्रशिक्षण और मूल्यांकन
डेटा तैयार होने के बाद, हम इसे प्रशिक्षण और परीक्षण सेटों में विभाजित करते हैं और कई वर्गीकरण मॉडल बनाते हैं ताकि यह निर्धारित किया जा सके कि कौन सा सबसे अच्छा प्रदर्शन करता है।
प्रशिक्षण-परीक्षण विभाजन
|
from sklearn.model_selection import train_test_split # Split the data X_train, X_test, y_train, y_test = train_test_split(X, y, test_size=0.20, random_state=1) print(X_train.shape) # Output: (7999, 5) |
फीचर स्केलिंग
फीचर्स को स्केल करना ऐसे एल्गोरिदम के लिए आवश्यक है जैसे KNN और SVM, जो इनपुट डेटा के स्केल के प्रति संवेदनशील हैं।
|
from sklearn import preprocessing # Initialize and fit the scaler sc = preprocessing.StandardScaler(with_mean=False) sc.fit(X_train) # Transform the data X_train = sc.transform(X_train) X_test = sc.transform(X_test) print(X_train.shape) # Output: (7999, 5) print(X_test.shape) # Output: (2000, 5) |
वर्गीकरण मॉडलों का निर्माण
के-निकटतम पड़ोसी (KNN)
|
from sklearn.neighbors import KNeighborsClassifier from sklearn.metrics import accuracy_score # Initialize and train KNN knnClassifier = KNeighborsClassifier(n_neighbors=3) knnClassifier.fit(X_train, y_train) # Make predictions y_pred = knnClassifier.predict(X_test) print(accuracy_score(y_pred, y_test)) # Output: 0.8455 |
लॉजिस्टिक रिग्रेशन
|
from sklearn.linear_model import LogisticRegression # Initialize and train Logistic Regression LRM = LogisticRegression(random_state=0, max_iter=200) LRM.fit(X_train, y_train) # Make predictions y_pred = LRM.predict(X_test) print(accuracy_score(y_pred, y_test)) # Output: 0.869 |
गॉसियन नेव बेयस
|
from sklearn.naive_bayes import GaussianNB # Initialize and train GaussianNB model_GNB = GaussianNB() model_GNB.fit(X_train, y_train) # Make predictions y_pred = model_GNB.predict(X_test) print(accuracy_score(y_pred, y_test)) # Output: 0.822 |
सपोर्ट वेक्टर मशीन (SVM)
|
from sklearn.svm import SVC # Initialize and train SVC model_SVC = SVC() model_SVC.fit(X_train, y_train) # Make predictions y_pred = model_SVC.predict(X_test) print(accuracy_score(y_pred, y_test)) # Output: 0.87 |
डिसीजन ट्री
|
from sklearn.tree import DecisionTreeClassifier # Initialize and train Decision Tree model_DTC = DecisionTreeClassifier() model_DTC.fit(X_train, y_train) # Make predictions y_pred = model_DTC.predict(X_test) print(accuracy_score(y_pred, y_test)) # Output: 0.8335 |
रैंडम फॉरेस्ट
|
from sklearn.ensemble import RandomForestClassifier # Initialize and train Random Forest model_RFC = RandomForestClassifier(n_estimators=500, max_depth=5) model_RFC.fit(X_train, y_train) # Make predictions y_pred = model_RFC.predict(X_test) print(accuracy_score(y_pred, y_test)) # Output: 0.873 |
एडा-बूस्ट
|
from sklearn.ensemble import AdaBoostClassifier # Initialize and train AdaBoost model_ABC = AdaBoostClassifier() model_ABC.fit(X_train, y_train) # Make predictions y_pred = model_ABC.predict(X_test) print(accuracy_score(y_pred, y_test)) # Output: 0.8715 |
XGBoost
XGBoost अपनी दक्षता और प्रदर्शन के लिए प्रसिद्ध है, विशेष रूप से बड़े डेटासेट्स को संभालने में।
|
import xgboost as xgb # Initialize and train XGBoost model_xgb = xgb.XGBClassifier(use_label_encoder=False) model_xgb.fit(X_train, y_train) # Make predictions y_pred = model_xgb.predict(X_test) print(accuracy_score(y_pred, y_test)) # Output: 0.865 |
नोट: प्रशिक्षण के दौरान, आपको XGBoost में डिफ़ॉल्ट मूल्यांकन मीट्रिक के संबंध में एक चेतावनी मिल सकती है। आप इस चेतावनी को दबाने के लिए eval_metric
पैरामीटर को स्पष्ट रूप से सेट कर सकते हैं।
|
model_xgb = xgb.XGBClassifier(use_label_encoder=False, eval_metric='logloss') |
5. पिकल के साथ मॉडल सहेजना और लोड करना
एक बार जब आपने सबसे अच्छा प्रदर्शन करने वाला मॉडल पहचान लिया, तो इसे भविष्य में उपयोग के लिए सहेजना आवश्यक है। पाइथन की pickle
लाइब्रेरी मॉडल के आसान सीरियलाइजेशन और डीसिरियलाइजेशन की अनुमति देती है।
मॉडल सहेजना
|
import pickle # Save the XGBoost model file_name = 'model_xgb.pkl' pickle.dump(model_xgb, open(file_name, 'wb')) |
मॉडल लोड करना
|
# Load the saved model saved_model = pickle.load(open('model_xgb.pkl', 'rb')) # Verify the loaded model y_pred = saved_model.predict(X_test) print(accuracy_score(y_pred, y_test)) # Output: 0.865 |
6. तैनात मॉडल के साथ भविष्यवाणियाँ करना
मॉडल सहेजने के बाद, आप अब नए डेटा पर भविष्यवाणियाँ कर सकते हैं। यहाँ बताया गया है कि आप कैसे मॉडल को लोड कर सकते हैं और नए उदाहरणों की भविष्यवाणी करने के लिए इसका उपयोग कर सकते हैं।
|
import pickle import numpy as np # Load the model saved_model = pickle.load(open('model_xgb.pkl', 'rb')) # New data instance new_data = np.array([[0.02283472, 3.93934668, 1.95100361, 2.12694147, 0 ]]) # Make prediction prediction = saved_model.predict(new_data) print(prediction) # Output: [1] |
7. वेब एप्लिकेशन में मॉडल तैनात करना
अपने मशीन लर्निंग मॉडल को तैनात करने से अन्य लोग इसे वेब इंटरफ़ेस के माध्यम से इंटरैक्ट कर सकते हैं। मान लीजिए आप एक वेब एप्लिकेशन बनाते हैं जिसमें एक फॉर्म होता है जहाँ उपयोगकर्ता फीचर मान दर्ज कर सकते हैं। बैकेंड सहेजे हुए model_xgb.pkl
फ़ाइल को लोड कर सकता है, इनपुट प्रक्रिया कर सकता है, और भविष्यवाणी वापस कर सकता है।
उदाहरण कार्यप्रवाह:
- फ्रंटेंड: उपयोगकर्ता एक फॉर्म में फीचर मान दर्ज करते हैं।
- बैकेंड:
- इनपुट डेटा प्राप्त करें।
- डेटा को प्रीप्रोसेस करें (जैसे, स्केलिंग, एन्कोडिंग)।
pickle
का उपयोग करके model_xgb.pkl
को लोड करें।
- भविष्यवाणी करें।
- प्रतिक्रिया: उपयोगकर्ता को भविष्यवाणी परिणाम प्रदर्शित करें।
नमूना पाइथन फ्लास्क कोड:
1 2 3 4 5 6 7 8 9 10 11 12 13 14 15 16 17 18 19 20 21 22 23
|
from flask import Flask, request, jsonify import pickle import numpy as np app = Flask(__name__) # Load the trained model model = pickle.load(open('model_xgb.pkl', 'rb')) @app.route('/predict', methods=['POST']) def predict(): data = request.get_json(force=True) # Extract features from the request features = [data['feature1'], data['feature2'], data['feature3'], data['feature4'], data['feature5']] # Convert to numpy array final_features = np.array([features]) # Make prediction prediction = model.predict(final_features) # Return the result return jsonify({'prediction': int(prediction[0])}) if __name__ == '__main__': app.run(debug=True) |
यह फ्लास्क एप्लिकेशन एक API एंडपॉइंट /predict
बनाता है जो JSON डेटा के साथ POST अनुरोध स्वीकार करता है। यह इनपुट को प्रोसेस करता है, लोड किए गए XGBoost मॉडल का उपयोग करके एक भविष्यवाणी करता है, और परिणाम को JSON प्रारूप में लौटाता है।
8. निष्कर्ष
मशीन लर्निंग मॉडल बनाना और तैनात करना विधिपूर्वक चरणों की एक श्रृंखला शामिल करता है, डेटा प्रीप्रोसेसिंग और फीचर चयन से लेकर मॉडल प्रशिक्षण, मूल्यांकन, और तैनाती तक। XGBoost जैसी शक्तिशाली लाइब्रेरी और जुपिटर नोटबुक्स और फ्लास्क जैसे टूल्स का उपयोग करके इस प्रक्रिया को सरल बनाया जा सकता है, जिससे यह कुशल और स्केलेबल बन जाता है। इस व्यापक गाइड का पालन करके, आप मजबूत मशीन लर्निंग मॉडल विकसित कर सकते हैं और उन्हें प्रभावी ढंग से तैनात कर सकते हैं ताकि आप अपनी विशिष्ट आवश्यकताओं को पूरा कर सकें।
अतिरिक्त संसाधन
इन प्रथाओं को एकीकृत करके और प्रदान किए गए कोड स्निपेट्स का उपयोग करके, आप अपने मशीन लर्निंग परियोजनाओं की सटीकता बढ़ा सकते हैं और मॉडलों को उत्पादन वातावरण में सहजता से तैनात कर सकते हैं।