S31L02 – मान का उपयोग करके भविष्यवाणी

html
पाइथन और XGBoost के साथ मशीन लर्निंग मॉडल बनाने और तैनात करने के लिए व्यापक गाइड

डेटा विज्ञान के तेजी से विकसित हो रहे क्षेत्र में, मशीन लर्निंग मॉडल बनाने, मूल्यांकन करने, और तैनात करने की क्षमता एक महत्वपूर्ण कौशल है। चाहे आप मौसम पैटर्न की भविष्यवाणी कर रहे हों, ग्राहक व्यवहार का विश्लेषण कर रहे हों, या निर्णय-निर्माण प्रक्रियाओं को स्वचालित कर रहे हों, इन चरणों में महारत हासिल करने से आपके परियोजनाओं की प्रभावशीलता और स्केलेबिलिटी में काफी सुधार हो सकता है। यह गाइड पाइथन का उपयोग करके मशीन लर्निंग मॉडल बनाने और तैनात करने के लिए एक व्यापक, चरण-दर-चरण दृष्टिकोण प्रदान करती है, जिसमें शक्तिशाली XGBoost एल्गोरिदम पर ध्यान केंद्रित किया गया है। हम डेटा प्रीप्रोसेसिंग, फीचर चयन, मॉडल प्रशिक्षण, मूल्यांकन, और तैनाती में गहराई से जाएंगे, जो जुपिटर नोटबुक्स से व्यावहारिक कोड उदाहरणों द्वारा समर्थित हैं।

सामग्री की तालिका


  मशीन लर्निंग मॉडल तैनाती का परिचय
  डेटा तैयारी और प्रीप्रोसेसिंग
    
      लाइब्रेरी और डेटा आयात करना
      गायब मानों से निपटना
      श्रेणीबद्ध विशेषताओं को एन्कोड करना
    
  
  फीचर चयन
  मॉडल प्रशिक्षण और मूल्यांकन
    
      के-निकटतम पड़ोसी (KNN)
      लॉजिस्टिक रिग्रेशन
      गॉसियन नेव बेयस
      सपोर्ट वेक्टर मशीन (SVM)
      डिसीजन ट्री
      रैंडम फॉरेस्ट
      एडा-बूस्ट
      XGBoost
    
  
  पिकल के साथ मॉडल सहेजना और लोड करना
  तैनात मॉडल के साथ भविष्यवाणियाँ करना
  वेब एप्लिकेशन में मॉडल तैनात करना
  निष्कर्ष



1. मशीन लर्निंग मॉडल तैनाती का परिचय

मशीन लर्निंग मॉडल तैनात करना केवल मॉडल बनाने और प्रशिक्षण देने से परे कई महत्वपूर्ण चरणों को शामिल करता है। इसमें डेटा तैयार करना, सही फीचर्स का चयन करना, कई मॉडलों को प्रशिक्षित करना, उनके प्रदर्शन का मूल्यांकन करना, और अंततः, सबसे अच्छा प्रदर्शन करने वाले मॉडल को एक उत्पादन वातावरण में तैनात करना शामिल है जहाँ यह रियल-टाइम भविष्यवाणियाँ प्रदान कर सकता है। यह गाइड पाइथन और XGBoost का उपयोग करके, जो गति और सटीकता के लिए अनुकूलित एक उच्च-प्रदर्शन लाइब्रेरी है, इन प्रत्येक चरणों के माध्यम से आपको मार्गदर्शन करती है।


2. डेटा तैयारी और प्रीप्रोसेसिंग

लाइब्रेरी और डेटा आयात करना

किसी भी मशीन लर्निंग परियोजना में पहला कदम डेटा तैयारी है। इसमें आवश्यक लाइब्रेरी आयात करना और डेटासेट लोड करना शामिल है।





		
		
			
			
Java
			
			import pandas as pd
import seaborn as sns

# Load the dataset
data = pd.read_csv('weatherAUS - tiny.csv')
data.tail()
			
				
					
				
					1
2
3
4
5
6
				
						import pandas as pd
import seaborn as sns
 
# Load the dataset
data = pd.read_csv('weatherAUS - tiny.csv')
data.tail()
					
				
			
		



आउटपुट:





		
		
			
			
Java
			
			          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
			
				
					
				
					1
2
3
4
5
6
				
						          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 का उपयोग करके संख्यात्मक और श्रेणीबद्ध कॉलम दोनों में गायब मानों से निपटते हैं।





		
		
			
			
Java
			
			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
				
						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])
					
				
			
		



श्रेणीबद्ध विशेषताओं को एन्कोड करना

मशीन लर्निंग एल्गोरिदम को संख्यात्मक इनपुट की आवश्यकता होती है। इसलिए, हम श्रेणीबद्ध विशेषताओं को लेबल एन्कोडिंग और वन-हॉट एन्कोडिंग विधियों दोनों का उपयोग करके एन्कोड करते हैं।





		
		
			
			
Java
			
			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)
			
				
					
				
					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 फीचर्स का चयन किया जाता है।





		
		
			
			
Java
			
			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)
			
				
					
				
					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. मॉडल प्रशिक्षण और मूल्यांकन

डेटा तैयार होने के बाद, हम इसे प्रशिक्षण और परीक्षण सेटों में विभाजित करते हैं और कई वर्गीकरण मॉडल बनाते हैं ताकि यह निर्धारित किया जा सके कि कौन सा सबसे अच्छा प्रदर्शन करता है।

प्रशिक्षण-परीक्षण विभाजन





		
		
			
			
Java
			
			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)
			
				
					
				
					1
2
3
4
5
				
						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, जो इनपुट डेटा के स्केल के प्रति संवेदनशील हैं।





		
		
			
			
Java
			
			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)
			
				
					
				
					1
2
3
4
5
6
7
8
9
10
11
				
						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)





		
		
			
			
Java
			
			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
			
				
					
				
					1
2
3
4
5
6
7
8
9
10
				
						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
					
				
			
		



लॉजिस्टिक रिग्रेशन





		
		
			
			
Java
			
			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
			
				
					
				
					1
2
3
4
5
6
7
8
9
				
						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
					
				
			
		



गॉसियन नेव बेयस





		
		
			
			
Java
			
			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
			
				
					
				
					1
2
3
4
5
6
7
8
9
				
						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)





		
		
			
			
Java
			
			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
			
				
					
				
					1
2
3
4
5
6
7
8
9
				
						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
					
				
			
		



डिसीजन ट्री





		
		
			
			
Java
			
			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
			
				
					
				
					1
2
3
4
5
6
7
8
9
				
						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
					
				
			
		



रैंडम फॉरेस्ट





		
		
			
			
Java
			
			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
			
				
					
				
					1
2
3
4
5
6
7
8
9
				
						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
					
				
			
		



एडा-बूस्ट





		
		
			
			
Java
			
			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
			
				
					
				
					1
2
3
4
5
6
7
8
9
				
						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 अपनी दक्षता और प्रदर्शन के लिए प्रसिद्ध है, विशेष रूप से बड़े डेटासेट्स को संभालने में।





		
		
			
			
Java
			
			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
			
				
					
				
					1
2
3
4
5
6
7
8
9
				
						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 पैरामीटर को स्पष्ट रूप से सेट कर सकते हैं।





		
		
			
			
Java
			
			model_xgb = xgb.XGBClassifier(use_label_encoder=False, eval_metric='logloss')
			
				
					
				
					1
				
						model_xgb = xgb.XGBClassifier(use_label_encoder=False, eval_metric='logloss')
					
				
			
		




5. पिकल के साथ मॉडल सहेजना और लोड करना

एक बार जब आपने सबसे अच्छा प्रदर्शन करने वाला मॉडल पहचान लिया, तो इसे भविष्य में उपयोग के लिए सहेजना आवश्यक है। पाइथन की pickle लाइब्रेरी मॉडल के आसान सीरियलाइजेशन और डीसिरियलाइजेशन की अनुमति देती है।

मॉडल सहेजना





		
		
			
			
Java
			
			import pickle

# Save the XGBoost model
file_name = 'model_xgb.pkl'
pickle.dump(model_xgb, open(file_name, 'wb'))
			
				
					
				
					1
2
3
4
5
				
						import pickle
 
# Save the XGBoost model
file_name = 'model_xgb.pkl'
pickle.dump(model_xgb, open(file_name, 'wb'))
					
				
			
		



मॉडल लोड करना





		
		
			
			
Java
			
			# 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
			
				
					
				
					1
2
3
4
5
6
				
						# 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. तैनात मॉडल के साथ भविष्यवाणियाँ करना

मॉडल सहेजने के बाद, आप अब नए डेटा पर भविष्यवाणियाँ कर सकते हैं। यहाँ बताया गया है कि आप कैसे मॉडल को लोड कर सकते हैं और नए उदाहरणों की भविष्यवाणी करने के लिए इसका उपयोग कर सकते हैं।





		
		
			
			
Java
			
			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]
			
				
					
				
					1
2
3
4
5
6
7
8
9
10
11
12
				
						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 को लोड करें।
      भविष्यवाणी करें।
    
  
  प्रतिक्रिया: उपयोगकर्ता को भविष्यवाणी परिणाम प्रदर्शित करें।


नमूना पाइथन फ्लास्क कोड:





		
		
			
			
Java
			
			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)
			
				
					
				
					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 जैसी शक्तिशाली लाइब्रेरी और जुपिटर नोटबुक्स और फ्लास्क जैसे टूल्स का उपयोग करके इस प्रक्रिया को सरल बनाया जा सकता है, जिससे यह कुशल और स्केलेबल बन जाता है। इस व्यापक गाइड का पालन करके, आप मजबूत मशीन लर्निंग मॉडल विकसित कर सकते हैं और उन्हें प्रभावी ढंग से तैनात कर सकते हैं ताकि आप अपनी विशिष्ट आवश्यकताओं को पूरा कर सकें।

अतिरिक्त संसाधन


  Jupyter Notebooks:
    
      S31L02 - Prediction using value.ipynb *(नोटबुक का लिंक)*
      S31L02 - temp file, include in project files.ipynb *(नोटबुक का लिंक)*
    
  
  Dataset: Kaggle पर Weather AUS Dataset




इन प्रथाओं को एकीकृत करके और प्रदान किए गए कोड स्निपेट्स का उपयोग करके, आप अपने मशीन लर्निंग परियोजनाओं की सटीकता बढ़ा सकते हैं और मॉडलों को उत्पादन वातावरण में सहजता से तैनात कर सकते हैं।