S31L02 – 使用价值进行预测

html
使用 Python 和 XGBoost 构建和部署机器学习模型的全面指南

在迅速发展的数据科学领域中，构建、评估和部署机器学习模型的能力是一项关键技能。无论您是在预测天气模式、分析客户行为，还是自动化决策过程，精通这些步骤都能显著提升您的项目的有效性和可扩展性。本指南提供了一个全面的、循序渐进的方法，使用 Python 构建和部署机器学习模型，重点介绍强大的 XGBoost 算法。我们将深入探讨数据预处理、特征选择、模型训练、评估和部署，并辅以来自 Jupyter Notebooks 的实际代码示例。

目录


  机器学习模型部署简介
  数据准备与预处理
    
      导入库和数据
      处理缺失值
      编码分类特征
    
  
  特征选择
  模型训练与评估
    
      K-近邻算法 (KNN)
      逻辑回归
      高斯朴素贝叶斯
      支持向量机 (SVM)
      决策树
      随机森林
      AdaBoost
      XGBoost
    
  
  使用 Pickle 保存和加载模型
  使用已部署的模型进行预测
  在 Web 应用中部署模型
  结论



1. 机器学习模型部署简介

部署机器学习模型不仅仅涉及构建和训练模型，还包括一些关键步骤。它包括准备数据、选择合适的特征、训练多个模型、评估它们的性能，最后将性能最佳的模型部署到生产环境中，以提供实时预测。本指南将使用 Python 和 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. 特征选择

选择合适的特征可以提高模型性能并降低计算成本。我们使用具有卡方（chi2）统计检验的 SelectKBest 来选择前 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)
					
				
			
		



构建分类模型

K-近邻算法 (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
					
				
			
		



AdaBoost





		
		
			
			
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 保存和加载模型

一旦您确定了表现最佳的模型，保存它以备将来使用是必不可少的。Python 的 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. 在 Web 应用中部署模型

部署您的机器学习模型允许他人通过 Web 界面与其交互。假设您创建了一个带有表单的 Web 应用，用户可以在表单中输入特征值。后端可以加载保存的 model_xgb.pkl 文件，处理输入，并返回预测结果。

示例工作流程：


  前端： 用户在表单中输入特征值。
  后端：
    
      接收输入数据。
      预处理数据（例如，缩放、编码）。
      使用 pickle 加载 model_xgb.pkl。
      进行预测。
    
  
  响应： 将预测结果显示给用户。


示例 Python Flask 代码：





		
		
			
			
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)
					
				
			
		



此 Flask 应用程序创建了一个 API 端点 /predict，接受带有 JSON 数据的 POST 请求。它处理输入，使用加载的 XGBoost 模型进行预测，并以 JSON 格式返回结果。


8. 结论

构建和部署机器学习模型涉及一系列有条不紊的步骤，从数据预处理和特征选择到模型训练、评估和部署。利用像 XGBoost 这样的强大库以及 Jupyter Notebooks 和 Flask 等工具可以简化这一过程，使其高效且可扩展。通过遵循本全面指南，您可以开发出强大的机器学习模型并有效地部署它们，以满足您的特定需求。

附加资源


  Jupyter Notebooks：
    
      S31L02 - 使用 value 进行预测.ipynb *(链接到笔记本)*
      S31L02 - 临时文件，包含在项目文件中.ipynb *(链接到笔记本)*
    
  
  数据集： Kaggle 上的 Weather AUS 数据集




通过整合这些实践并利用提供的代码片段，您可以提高机器学习项目的准确性并将模型无缝部署到生产环境中。