Python sklearn使用步骤

pip install -U scikit-learn -i https://pypi.tuna.tsinghua.edu.cn/simple

import sklearn

from sklearn.datasets import load_iris
iris = load_iris()
X, y = iris.data, iris.target

from sklearn.model_selection import train_test_split
X_train, X_test, y_train, y_test = train_test_split(X, y, test_size=0.2, random_state=42)

from sklearn.neighbors import KNeighborsClassifier
model = KNeighborsClassifier(n_neighbors=3)

model.fit(X_train, y_train)

y_pred = model.predict(X_test)

from sklearn.metrics import accuracy_score
print(f"Model accuracy: {accuracy_score(y_test, y_pred)}")

import joblib
# 保存模型
joblib.dump(model, 'model.pkl')
# 加载模型
loaded_model = joblib.load('model.pkl')

from sklearn.model_selection import GridSearchCV
param_grid = {'n_neighbors': [1, 3, 5, 7, 9]}
grid_search = GridSearchCV(model, param_grid, cv=5)
grid_search.fit(X_train, y_train)
print(f"Best parameters: {grid_search.best_params_}")

from sklearn.preprocessing import StandardScaler
import numpy as np
# 创建一个具有两个特征的样本数据集
X = np.array([[1, -1], [2, 0], [0, 1], [1, 1], [2, -1]])
scaler = StandardScaler()
X_scaled = scaler.fit_transform(X)
# 注意事项：
# - 在训练集上拟合标准化器，并使用相同的参数转换测试集。
# - 不要在测试集上调用 fit_transform()，应该只使用 transform()。

from sklearn.preprocessing import MinMaxScaler
scaler = MinMaxScaler()
X_scaled = scaler.fit_transform(X)
# 注意事项：
# - 与 StandardScaler 类似，不要在测试集上调用 fit_transform()。
# - MinMaxScaler 会将特征缩放到 [0, 1] 范围内，对于某些算法可能不适用。

from sklearn.preprocessing import OneHotEncoder
import numpy as np
# 示例数据：具有两个分类特征的二维数组
data = np.array([[0, 0], [1, 1], [2, 0], [0, 2]])
# 创建OneHotEncoder实例
encoder = OneHotEncoder(sparse=False)
# 训练并转换数据
encoded_data = encoder.fit_transform(data)
# 打印转换后的数据
print(encoded_data)
# 打印特征名称
print(encoder.get_feature_names_out())

[[1. 0. 0. 1.]
 [0. 1. 1. 0.]
 [0. 0. 1. 0.]
 [1. 0. 0. 0.]]
['x0_0', 'x0_1', 'x0_2', 'x1_0']

from sklearn.preprocessing import LabelEncoder
import numpy as np
# 示例数据：一个包含分类标签的数组
labels = np.array(['cat', 'dog', 'cat', 'dog', 'bird'])
# 创建LabelEncoder实例
label_encoder = LabelEncoder()
# 训练并转换数据
encoded_labels = label_encoder.fit_transform(labels)
# 打印转换后的数据
print(encoded_labels)
# 打印原始和转换后的标签
print(label_encoder.classes_)
print(label_encoder.transform(['bird', 'cat']))

[0 1 0 1 2]
['bird' 'cat' 'dog']
[1 0]

from sklearn.datasets import load_iris
from sklearn.feature_selection import SelectKBest
from sklearn.feature_selection import chi2
iris = load_iris()
X, y = iris.data, iris.target
# 选择两个最佳特征
selector = SelectKBest(score_func=chi2, k=2)
X_k_best = selector.fit_transform(X, y)
# 注意事项：
# - 选择特征的方法应该与数据类型和任务类型相匹配。
# - chi2 适用于分类任务的非负特征。

from sklearn.feature_selection import RFE
from sklearn.linear_model import LogisticRegression
# 使用逻辑回归模型和RFE选择特征
selector = RFE(estimator=LogisticRegression(), n_features_to_select=2)
X_rfe = selector.fit_transform(X, y)
# 注意事项：
# - RFE 需要一个基础估计器，通常是监督学习模型。
# - 选择的特征数量应该小于等于原始特征的数量。

from sklearn.model_selection import train_test_split
X_train, X_test, y_train, y_test = train_test_split(X, y, test_size=0.2, random_state=42)
# 注意事项：
# - random_state 参数用于确保可重复性。
# - 保持训练集和测试集的比例一致对于评估模型性能很重要。

from sklearn.metrics import accuracy_score
from sklearn.linear_model import LogisticRegression
# 训练模型
model = LogisticRegression()
model.fit(X_train, y_train)
y_pred = model.predict(X_test)
# 计算准确率
accuracy = accuracy_score(y_test, y_pred)
# 注意事项：
# - 准确率是分类问题中最常用的评估指标，但不总是最佳指标。
# - 在不平衡数据集上，准确率可能会误导。

from sklearn.cluster import KMeans
# 使用 KMeans 进行聚类
kmeans = KMeans(n_clusters=3)
kmeans.fit(X)
y_kmeans = kmeans.predict(X)
# 注意事项：
# - 需要预先指定聚类的数量（n_clusters）。
# - KMeans 对异常值敏感，可能需要预处理数据。

from sklearn.linear_model import LinearRegression
# 使用线性回归进行拟合
reg = LinearRegression()
reg.fit(X_train, y_train)
y_pred = reg.predict(X_test)
# 注意事项：
# - 线性回归假设特征之间是线性关系。
# - 确保数据没有多重共线性。

from sklearn.svm import SVC
# 使用支持向量机进行分类
svc = SVC(kernel='linear')
svc.fit(X_train, y_train)
y_pred = svc.predict(X_test)
# 注意事项：
# - 选择合适的核函数（kernel）对模型性能有很大影响。
# - 对于大型数据集，SVC 训练可能会很慢。

from sklearn import datasets
from sklearn.model_selection import train_test_split
from sklearn.preprocessing import StandardScaler
from sklearn.neighbors import KNeighborsClassifier
from sklearn.metrics import accuracy_score
# 加载数据集
iris = datasets.load_iris()
X, y = iris.data, iris.target
# 划分训练集和测试集
X_train, X_test, y_train, y_test = train_test_split(X, y, test_size=0.2, random_state=42)
# 标准化特征
scaler = StandardScaler()
X_train_scaled = scaler.fit_transform(X_train)
X_test_scaled = scaler.transform(X_test)
# 创建KNeighborsClassifier实例
knn = KNeighborsClassifier(n_neighbors=3)
# 训练模型
knn.fit(X_train_scaled, y_train)
# 进行预测
y_pred = knn.predict(X_test_scaled)
# 计算准确率
accuracy = accuracy_score(y_test, y_pred)
print(f'Accuracy of the KNeighborsClassifier: {accuracy:.2f}')

from sklearn.model_selection import GridSearchCV
# 参数网格
param_grid = {'C': [0.1, 1, 10], 'kernel': ['linear', 'rbf']}
grid_search = GridSearchCV(SVC(), param_grid, cv=5)
grid_search.fit(X_train, y_train)
# 注意事项：
# - GridSearchCV 可能非常耗时，尤其是在大型参数空间和大型数据集上。
# - 只对训练集进行网格搜索，以避免过拟合。

from sklearn.model_selection import RandomizedSearchCV
from scipy.stats import expon, randint
# 定义参数的分布
param_distributions = {
    'n_estimators': randint(100, 500),
    'max_depth': [5, 10, None],
    'learning_rate': expon(scale=1.0),
}
# 使用随机搜索交叉验证
random_search = RandomizedSearchCV(RandomForestRegressor(), param_distributions, n_iter=10, cv=5, random_state=42)
random_search.fit(X_train, y_train)
# 注意事项：
# - RandomizedSearchCV 对于大型参数空间更为高效，因为它不是尝试所有可能的组合。
# - `n_iter` 参数控制了随机搜索的迭代次数。
# - 随机搜索的结果可能因随机状态的不同而有所差异。

# 创建带有预处理和模型的管道
pipeline = Pipeline([
    ('scaler', StandardScaler()),
    ('svc', SVC())
])
# 定义参数网格
param_grid = {
    'svc__C': [0.1, 1, 10],
    'svc__kernel': ['linear', 'rbf']
}
# 在管道中使用网格搜索交叉验证
grid_search = GridSearchCV(pipeline, param_grid, cv=5)
grid_search.fit(X_train, y_train)
# 注意事项：
# - 参数名称需要包含步骤名称和参数名称，格式为 `step__parameter`。
# - 管道和网格搜索的结合可以同时优化预处理步骤和模型参数。

from sklearn import datasets
from sklearn.ensemble import RandomForestClassifier, VotingClassifier
from sklearn.linear_model import LogisticRegression
from sklearn.svm import SVC
from sklearn.model_selection import train_test_split
from sklearn.metrics import accuracy_score
# 加载数据集
iris = datasets.load_iris()
X, y = iris.data, iris.target
# 划分训练集和测试集
X_train, X_test, y_train, y_test = train_test_split(X, y, test_size=0.3, random_state=42)
# 创建不同的分类器
log_clf = LogisticRegression(max_iter=1000, random_state=42)
rnd_clf = RandomForestClassifier(n_estimators=100, random_state=42)
svm_clf = SVC(gamma='scale', probability=True, random_state=42)
# 创建VotingClassifier对象，这里使用硬投票
voting_clf = VotingClassifier(
    estimators=[('lr', log_clf), ('rf', rnd_clf), ('svc', svm_clf)],
    voting='hard'
)
# 训练VotingClassifier
voting_clf.fit(X_train, y_train)
# 进行预测
y_pred = voting_clf.predict(X_test)
# 计算准确率
accuracy = accuracy_score(y_test, y_pred)
print(f'Accuracy of the VotingClassifier: {accuracy:.2f}')

from sklearn.ensemble import AdaBoostClassifier
from sklearn.tree import DecisionTreeClassifier
# 使用决策树作为基础估计器
ada_clf = AdaBoostClassifier(
    DecisionTreeClassifier(max_depth=1),
    n_estimators=200,
    algorithm="SAMME.R",
    learning_rate=0.5
)
ada_clf.fit(X_train, y_train)
y_pred = ada_clf.predict(X_test)
# 注意事项：
# - AdaBoostClassifier 可以通过调整 `learning_rate` 来控制模型过拟合的风险。
# - 基础估计器通常是弱学习器，如决策树，其深度通常较小。