一、分类算法

from sklearn.linear_model import Ridge                    # 岭回归
from sklearn.linear_model import Lasso                    # 套索回归
from sklearn.linear_model import LinearRegression         # 线性回归
from sklearn.linear_model import LogisticRegression       # 逻辑斯蒂

from sklearn.tree import DecisionTreeClassifier           # 决策树--分类
from sklearn.tree import DecisionTreeRegressor            # 决策树--回归
from sklearn.ensemble import RandomForestClassifier       # 随机森林--分类
from sklearn.ensemble import RandomForestRegressor        # 随机森林--回归
from sklearn.ensemble import GradientBoostingClassifier   # GBDT--分类
from sklearn.ensemble import GradientBoostingRegressor    # GBDT--回归

import xgboost as gbt
from xgboost import XGBClassifier                         # XGBoost

import lightgbm as lgbm
from lightgbm import LGBMClassifier                       # LightGBM

from sklearn.svm import SVC                               # 支持向量机--分类
from sklearn.svm import SVR                               # 支持向量机--回归

from sklearn.neighbors import KNeighborsClassifier        # KNN--分类
from sklearn.neighbors import KNeighborsRegressor         # KNN--回归

from sklearn.neural_network import MLPClassifier          # 多层感知机

1.1、逻辑回归

1.1.1、示例&调参

from sklearn.linear_model import LogisticRegression         # 逻辑斯蒂（人为指定一个正则化系数）
from sklearn.linear_model import LogisticRegressionCV       # 逻辑斯蒂（使用交叉验证来选择正则化系数C，用法大致相同）
from sklearn.model_selection import GridSearchCV            # 网格搜索

clf_lr = LogisticRegression()       # 定义模型实例
clf_lr.fit(X, y)                    # 训练模型
clf_lr.predict(X)                   # 样本对应各个类别预测标签

param_grid = {"penalty":['l1', 'l2'],
             "C":[0.01, 0.1, 1, 10, 100]}

grid_search_lr = GridSearchCV(clf_lr, param_grid, cv=5, scoring='neg_log_loss')
grid_search_lr.fit(X, y)

grid_search_lr.best_score_   # 获取最高分
grid_search_lr.best_params_   # 获取被搜索的最好参数
grid_search_lr.best_estimator_   # 获取最佳估计器（带所有参数的值）

1.1.2、参数详解（部分）

clf_lr.fit(X, y)                    # 训练模型
clf_lr.get_params([deep])           # 获取模型参数
clf_lr.predict(X)                   # 样本对应各个类别预测标签
clf_lr.predict_proba(X)             # 样本对应各个类别的概率
clf_lr.predict_log_proba(X)         # 样本对应各个类别的概率的对数转化
clf_lr.score(X, y)                  # 模型预测得分（官方文档描述是accuracy准确率）

1.2、随机森林

1.2.1、示例&调参

from sklearn.ensemble import RandomForestClassifier       # 随机森林
from sklearn.model_selection import GridSearchCV          # 网格搜索

clf_rf = RandomForestClassifier()   # 定义模型实例
clf_rf.fit(X, y)                    # 训练模型
clf_rf.predict(X)                   # 样本对应各个类别预测标签
clf_lr.predict_proba(X)             # 样本对应各个类别的概率


param_grid = {'n_estimators':range(10,71,10),
							'max_features':range(3,11,2),
							'max_depth':range(3,14,2), 
							'min_samples_split':range(80,150,20), 
							'min_samples_leaf':range(10,60,10)}
grid_search_rf = GridSearchCV(clf_rf, param_grid = param_grid, scoring='roc_auc',cv=5)
grid_search_rf.fit(X,y)
grid_search_rf.best_score_   # 获取最高分
grid_search_rf.best_params_   # 获取被搜索的最好参数
grid_search_rf.best_estimator_   # 获取最佳估计器（带所有参数的值）

1.2.2、参数详解（部分）

1.3、GBDT

1.3.1、示例&调参

from sklearn.ensemble import GradientBoostingClassifier   # GBDT--分类
from sklearn.ensemble import GradientBoostingRegressor    # GBDT--回归
from sklearn.model_selection import GridSearchCV          # 网格搜索

clf_gbdt = GradientBoostingClassifier()   # 定义模型实例
clf_gbdt.fit(X, y)                        # 训练模型
clf_gbdt.predict(X)                       # 样本对应各个类别预测标签
clf_gbdt.predict_proba(X)                 # 样本对应各个类别的概率


param_grid = {'n_estimators':range(20,81,10),
							'learning_rate':[0.01, 0.05,0.1,0.5],
							'max_depth':range(3,14,2), 
							'min_samples_split':range(100,801,200),
							'min_samples_leaf':range(60,101,10),
							'max_features':range(3,11,2),
							'subsample':[0.6,0.7,0.75,0.8,0.85,0.9]}
grid_search_gbdt = GridSearchCV(clf_gbdt, param_grid = param_grid, scoring='roc_auc',cv=5)
grid_search_gbdt.fit(X,y)
grid_search_gbdt.best_score_   # 获取最高分
grid_search_gbdt.best_params_   # 获取被搜索的最好参数
grid_search_gbdt.best_estimator_   # 获取最佳估计器（带所有参数的值）

1.3.2、参数详解（部分）

1.4、XGBoost

1.5、LightGBM

1.5.1、接口调用

# 
import lightgbm as lgb
from lightgbm import plot_importance
from sklearn.datasets import load_iris
from sklearn.metrics import accuracy_score
from sklearn.model_selection import train_test_split

lightgbm.train(params, train_set, num_boost_round=100, valid_sets=None, valid_names=None, fobj=None, feval=None, init_model=None, feature_name='auto', categorical_feature='auto', early_stopping_rounds=None, evals_result=None, verbose_eval=True, learning_rates=None, keep_training_booster=False, callbacks=None)
"""
params：参数
train_set：训练数据，需要用特定方式转换，详见下文
num_boost_round：最大迭代次数，默认10
valid_sets：用于评估的数据及数据的名称，列表类型，
fobj：指定二阶可导的自定义目标函数
feval：自定义评估函数
categorical_feature：指定哪些是类别特征
early_stopping_rounds：指定迭代多少次没有得到优化则停止训练，默认值为None，表示不提前停止训练。
verbose_eval：可以是bool类型，也可以是整数类型。如果设置为整数，则每间隔verbose_eval次迭代就输出一次信息。
init_model：加载之前训练好的 lgb 模型，用于增量训练。
"""

# 加载鸢尾花数据集
iris = 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=123457)
# 构造训练集
dtrain = lgb.Dataset(X_train,y_train)
dtest = lgb.Dataset(X_test,y_test)

# 参数
params = {
    'booster': 'gbtree',
    'objective': 'multiclass',
    'num_class': 3,
    'num_leaves': 31,
    'subsample': 0.8,
    'bagging_freq': 1,
    'feature_fraction ': 0.8,
    'slient': 1,
    'learning_rate ': 0.01,
    'seed': 0
}
# xgboost模型训练
model = lgb.train(params,dtrain, num_boost_round=100, valid_sets=[dtrain, dtest], 
                  verbose_eval=100, early_stopping_rounds=30)
# 对测试集进行预测
y_pred = model.predict(X_test)
# 计算准确率
accuracy = accuracy_score(y_test, np.argmax(y_pred, axis=1))
print('accuarcy:%.2f%%'%(accuracy*100))
# 显示重要特征
plot_importance(model)

import matplotlib.pyplot as plt
from lightgbm import LGBMClassifier
from lightgbm import plot_importance
from sklearn.datasets import load_iris
from sklearn.metrics import accuracy_score
from sklearn.model_selection import train_test_split


# 加载样本数据集
iris = 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=12343)

crf_lgbm = LGBMClassifier(
    max_depth=3,
    learning_rate=0.1,
    n_estimators=200, # 使用多少个弱分类器
    objective='multiclass',
    num_class=3,
    booster='gbtree',
    min_child_weight=2,
    subsample=0.8,
    colsample_bytree=0.8,
    reg_alpha=0,
    reg_lambda=1,
    seed=0 # 随机数种子
)
crf_lgbm.fit(X_train,y_train, eval_set=[(X_train, y_train), (X_test, y_test)], 
          verbose=100, early_stopping_rounds=50)

# 对测试集进行预测
y_pred = crf_lgbm.predict(X_test)
y_proba = crf_lgbm.predict_proba(X_test)
#计算准确率
accuracy = accuracy_score(y_test,y_pred)
print('accuracy:%3.f%%'%(accuracy*100))

# 显示重要特征
plot_importance(model)
plt.show()

1.5.2、参数详解

1.5.3、调参实例

clf_lgbm = lgbm.LGBMClassifier(
                              boosting_type='gbdt',      # 第一步 根据场景固定部分参数
                              objective='binary',
                              metric='auc',
                              verbose=-1,
                              learning_rate=0.1,       # 第二步 学习率和迭代次数一起调   0.666700429456532
                              n_estimators=200,        
                              max_depth=5,            # 第三步调 {max_depth,num_leaves}, 0.6708004303847365
                              num_leaves=20,
                              min_data_in_leaf=50,     # 第四步调 min_data_in_leaf, 0.6728529685838128
                              bagging_fraction=0.7,    # 第五步调 {bagging_fraction,feature_fraction}, 0.6728529685838128
                              feature_fraction=1,
                            #   lambda_l1=1,             # 第六步调 {lambda_l1,lambda_l2}, 0.6714313656366919
                            #   lambda_l2=1,
                            #   learning_rate=0.1,       # 第七步调, learning_rate, 最佳0.1, 0.6714313656366919
                              )
param_grid = {
    # 'n_estimators': range(100,501 ,100),
    # 'max_depth': range(1, 6, 1),
    # 'num_leaves':range(15, 36, 5),
    # 'min_data_in_leaf': range(20, 80, 10),
    # 'feature_fraction': [0.7,0.8,0.9,1.0],
    # 'bagging_fraction': [0.7,0.8,0.9,1.0],
    'lambda_l1': [1e-5,1e-1,0.0,0.1,0.5,1.0],
    'lambda_l2': [1e-5,1e-1,0.0,0.1,0.5,1.0],
    # 'learning_rate': [0.01, 0.015, 0.025, 0.05, 0.1]
}
gs_lgbm = GridSearchCV(clf_lgbm, param_grid=param_grid, scoring='roc_auc')
gs_lgbm.fit(train_data_array, train_label)
print('最优参数组合:',gs_lgbm.best_params_)
print('最优参数分数:',gs_lgbm.best_score_)
# print(gs_lgbm.scorer_)

1.5.4、特征重要性

boost = clf_lgbm.booster_
pd.DataFrame({
        'column': train_data_value_all_df.columns,
        'importance': boost.feature_importance(),
    }).sort_values(by='importance')

1.5.5、参考文档

二、聚类算法

# 划分聚类
from sklearn.cluster import KMeans            # KMeans聚类
from sklearn.cluster import MiniBatchKMeans   # KMeans聚类大样本优化

# 层次聚类
from sklearn.cluster import Birch

# 密度聚类
from sklearn.cluster import DBSCAN
from sklearn.cluster import OPTICS

# 谱聚类
from sklearn.cluster import SpectralClustering

2.1、KMeans聚类

2.1.1、概述

2.1.2、示例&调参

from sklearn.cluster import KMeans
from sklearn import datasets

iris = datasets.load_iris()   # 加载数据
X = iris.data
y = iris.target
est = KMeans(n_clusters=3)   # 定义模型
y_pred = est.fit_predict(X)   # 聚类

"""
array([0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0,
       0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0,
       0, 0, 0, 0, 0, 0, 1, 1, 2, 1, 1, 1, 1, 1, 1, 1, 1, 1, 1, 1, 1, 1,
       1, 1, 1, 1, 1, 1, 1, 1, 1, 1, 1, 2, 1, 1, 1, 1, 1, 1, 1, 1, 1, 1,
       1, 1, 1, 1, 1, 1, 1, 1, 1, 1, 1, 1, 2, 1, 2, 2, 2, 2, 1, 2, 2, 2,
       2, 2, 2, 1, 1, 2, 2, 2, 2, 1, 2, 1, 2, 1, 2, 2, 1, 1, 2, 2, 2, 2,
       2, 1, 2, 2, 2, 2, 1, 2, 2, 2, 1, 2, 2, 2, 1, 2, 2, 1], dtype=int32)
"""

2.1.3、参数详解（部分）

2.1.4、大样本优化Mini Batch K-Means

from sklearn.cluster import MiniBatchKMeans
import numpy as np
X = np.array([[1, 2], [1, 4], [1, 0],
              [4, 2], [4, 0], [4, 4],
              [4, 5], [0, 1], [2, 2],
              [3, 2], [5, 5], [1, -1]])

# manually fit on batches
kmeans = MiniBatchKMeans(n_clusters=2,
                         random_state=0,
                         batch_size=6,
                         n_init="auto")
kmeans = kmeans.partial_fit(X[0:6,:])    # 增量学习
kmeans = kmeans.partial_fit(X[6:12,:])
kmeans.cluster_centers_

kmeans.predict([[0, 0], [4, 4]])   # 聚类

2.1.5、参考文章

2.2、BIRCH聚类

2.2.1、概述

2.2.2、示例&调参

from sklearn.cluster import Birch
X = [[0, 1], [0.3, 1], [-0.3, 1], [0, -1], [0.3, -1], [-0.3, -1]]
brc = Birch(n_clusters=None)
brc.fit(X)

brc.predict(X)

2.2.3、参数详解

2.2.4、参考文章：

2.3、DBSCAN聚类

2.3.1、概述

2.3.2、示例&调参

from sklearn.cluster import DBSCAN

y_pred = DBSCAN(eps=0.1, min_samples=10).fit_predict(X)

2.3.3、参数详解

2.3.4、OPTICS聚类

2.3.5、参考文章

2.4、谱聚类

2.4.1、概述

2.4.2、示例&调参

import numpy as np
from sklearn import datasets
X, y = datasets.make_blobs(n_samples=500, n_features=6, centers=5, cluster_std=[0.4, 0.3, 0.4, 0.3, 0.4], random_state=11)

from sklearn.cluster import SpectralClustering
y_pred = SpectralClustering().fit_predict(X)

from sklearn import metrics
print("Calinski-Harabasz Score", metrics.calinski_harabasz_score(X, y_pred))

for index, gamma in enumerate((0.01,0.1,1,10)):
    for index, k in enumerate((3,4,5,6)):
        y_pred = SpectralClustering(n_clusters=k, gamma=gamma).fit_predict(X)
        print("Calinski-Harabasz Score with gamma=", gamma, "n_clusters=", k,"score:", metrics.calinski_harabasz_score(X, y_pred))

2.4.3、参数详解

2.4.4、参考文章

2.5、聚类模型评估

2.5.1、CH评估

from sklearn import metrics
metrics.calinski_harabaz_score(X, y_pred)

2.5.2、轮廓系数

from sklearn import metrics
metrics.silhouette_samples(X, y_pred, etric='euclidean')
"""
metric  ： 计算要素阵列中实例之间的距离时使用的度量。默认是euclidean（欧氏距离）。
如果metric是字符串，则必须是允许的选项之一metrics.pairwise.pairwise_distances。如果X是距离数组本身，请使用metric="precomputed"。

"""

三、降维算法

from sklearn.decomposition import PCA
from sklearn.decomposition import KernelPCA
from sklearn.decomposition import IncrementalPCA
from sklearn.decomposition import SparsePCA
from sklearn.decomposition import MiniBatchSparsePCA

from sklearn.discriminant_analysis import LinearDiscriminantAnalysis

from sklearn.manifold import LocallyLinearEmbedding

from sklearn.manifold import TSNE

3.1、PCA主成分分析

3.1.1、概述

💡

算法流程：

3.1.2、示例

import numpy as np
import matplotlib.pyplot as plt
from mpl_toolkits import mplot3d
%matplotlib inline
from sklearn.datasets import make_blobs
# X为样本特征，Y为样本簇类别， 共1000个样本，每个样本3个特征，共4个簇
X, y = make_blobs(n_samples=10000, n_features=3, centers=[[3,3, 3], [0,0,0], [1,1,1], [2,2,2]], cluster_std=[0.2, 0.1, 0.2, 0.2], 
                  random_state =9)
fig = plt.figure()
ax = plt.axes(projection='3d')
ax.scatter(X[:, 0], X[:, 1], X[:, 2],marker='o')

from sklearn.decomposition import PCA
pca = PCA(n_components=3)       # 数据本来就是三维，如果降维后的维度也设置为3，则是单纯的对数据投影，可以通过此方法查看特征方差分布
pca.fit(X)

print(pca.explained_variance_ratio_)    # 各特征的方差值占比
print(pca.explained_variance_)          # 各特征的方差值

"""
[0.98318212 0.00850037 0.00831751]
[3.78521638 0.03272613 0.03202212]
"""

3.1.3、参数

3.1.4、PCA对比

3.2、LDA线性判别

import numpy as np
from sklearn.discriminant_analysis import LinearDiscriminantAnalysis
X = np.array([[-1, -1], [-2, -1], [-3, -2], [1, 1], [2, 1], [3, 2]])
y = np.array([1, 1, 1, 2, 2, 2])
lda = LinearDiscriminantAnalysis(n_components=1)
lda.fit(X, y)
X_new = lda.transform(X)

3.3、LLE局部线性嵌入

from sklearn.datasets import load_digits
from sklearn.manifold import LocallyLinearEmbedding
X, _ = load_digits(return_X_y=True)
X.shape

embedding = LocallyLinearEmbedding(n_components=2)
X_transformed = embedding.fit_transform(X[:100])
X_transformed.shape

3.4、tSNE T分布随机近邻嵌入

import numpy as np
from sklearn.manifold import TSNE
X = np.array([[0, 0, 0], [0, 1, 1], [1, 0, 1], [1, 1, 1]])
X_embedded = TSNE(n_components=2, learning_rate='auto',
                  init='random', perplexity=3).fit_transform(X)
X_embedded.shape

四、关联规则算法

4.1、Apriori

4.2、FP Tree

4.3、PrefixSpan