scikit-learn在机器学习算法中的代码使用

简单线性回归的实现

zip()

>>>a = [1,2,3]
>>> b = [4,5,6]
>>> c = [4,5,6,7,8]
>>> zipped = zip(a,b)     # 打包为元组的列表
[(1, 4), (2, 5), (3, 6)]
>>> zip(a,c)              # 元素个数与最短的列表一致
[(1, 4), (2, 5), (3, 6)]
>>> a1, a2 = zip(*zipped)          # 与 zip 相反，*zipped 可理解为解压，返回二维矩阵式
>>> list(a1)
[1, 2, 3]
>>> list(a2)
[4, 5, 6]

划分数据样本

def train_test_split(X, y, test_ratio=0.2, seed=None):
    """将数据 X 和 y 按照test_ratio分割成X_train, X_test, y_train, y_test"""
    assert X.shape[0] == y.shape[0], \
        "the size of X must be equal to the size of y"
    assert 0.0 <= test_ratio <= 1.0, \
        "test_ration must be valid"

    if seed:
        np.random.seed(seed)

    shuffled_indexes = np.random.permutation(len(X))

    test_size = int(len(X) * test_ratio)
    test_indexes = shuffled_indexes[:test_size]
    train_indexes = shuffled_indexes[test_size:]

    X_train = X[train_indexes]
    y_train = y[train_indexes]

    X_test = X[test_indexes]
    y_test = y[test_indexes]

    return X_train, X_test, y_train, y_test

根据 test_ratio划分样本为80% 20%……

scikit-learn中的MSE和MAE

from sklearn.metrics import mean_squared_error
from sklearn.metrics import mean_absolute_error
 
mean_squared_error(y_test, y_predict)
mean_absolute_error(y_test, y_predict)

metrics 衡量指标

scikit-learn当中的 SGD

# 此处SGDRegressor只能用于  线性模型！
from sklearn.linear_model import SGDRegressor

sgd_reg = SGDRegressor(n_iter=100)  #n_iter是 默认为5！
%time sgd_reg.fit(X_train_standard, y_train)
sgd_reg.score(X_test_standard, y_test)

kNN计算技巧

Counter

topK_y = [y_train[neighbor] for neighbor in nearest[:k]]
topK_y  # 距离x最近的k个点的  类别y
>[1, 1, 1, 1, 1, 0]

from collections import Counter
votes = Counter(topK_y)
>Counter({0: 1, 1: 5})


votes.most_common(1)  # 找出票数最多的1个元素！  ‘1’
>[(1, 5)]

predict_y = votes.most_common(1)[0][0]
predict_y   # 最终预测的y的数值！

相关难点

np.argsort(distances)  # 数值排序  返回对应的索引，找最近的k个点
from collections import Counter
votes = Counter(topK_y)
>Counter({0: 1, 1: 5})

模仿scikit-learn对于 kNN的封装

class KNNClassifier:

    def __init__(self, k):  # 相当于 构造函数
        """初始化kNN分类器"""
        assert k >= 1, "k must be valid"
        self.k = k
        self._X_train = None            # 添加下划线，表示为私有变量
        self._y_train = None

# 断言 多维度kNN算法》 必须有： 预测值和 训练值的特征个数必须相同！
        assert X_predict.shape[1] == self._X_train.shape[1], \
                "the feature number of X_predict must be equal to X_train"

训练数据和 测试数据

#train_test_split
#分离出一部分数据做训练，另外一部分数据做测试。

shuffled_indexes = np.random.permutation(len(X))  # X个数个  索引的随机排列
test_ratio = 0.2
test_size = int(len(X) * test_ratio)

# 获得测试  和  训练数据集的索引下表————再使用 Fancy Indexing进行索引输出.
test_indexes = shuffled_indexes[:test_size]
train_indexes = shuffled_indexes[test_size:]

X_train = X[train_indexes]
y_train = y[train_indexes]

X_test = X[test_indexes]
y_test = y[test_indexes]

kNN准确度-模型选择 与 超参数

• 超参数：在算法运行前需要决定的参数
• 模型参数：算法过程中学习的参数

  注意：kNN没有模型参数，但是k是典型的超参数.

寻找好的超参数

领域知识： 在领域库添加（此处不用）
经验数值： k=5则是经验知识
实验搜索： 不断实验，搜索最好的
    找到10之后， 还是可以在8-20之中继续查找。

k近邻算法

增加 距离权重参数！（不仅仅通过 最近距离的投票方法。）

距离

1. 欧拉距离
2. 曼哈顿距离
3. 明可夫斯基距离

最终KNeighborsClassifier 的超参数有：

k, p, weights —— 两个两个的进行网格搜索，实验寻找最好的超参数。

网格搜索 和 更多kNN中的超参数

Grid Search

sklearn中使用方法

• from sklearn import datasets
• from sklearn.model_slection import train_test_split
• from sklearn.neighbors import KNeighborsClassifier
• sk_knn_clf = KNeighborsClassfier( n_neighbors = 3, weights=”uniform/distance”, p=1 )

  GridSearchCV—— 交叉验证

• from sklearn.model_selection import GridSearchCV
• grid_search = GridSearchCV( knn_clf, param_grid， n_jobs=-1, verbose = 2 )

  n_jobs自动进行核分配

  verbose = 2 整数值越大，输出的数值 越详细。

• grid_search.fit(X_train, y_train)
• grid_saerch.best_estimator_ #返回一个最佳的knn_clf() 对象！
• grid_search.best_score_
• grid_saerch.best_params_

更多的超参数

• KNeighborsClassifier 还有一个 metrics参数

  对应：

identifier	class name	args	distance function
“euclidean”	EuclideanDistance		sqrt(sum((x - y)^2))
“manhattan”	ManhattanDistance		sum(\	x - y\	)
“chebyshev”	ChebyshevDistance		max(\	x - y\	)
“minkowski”	MinkowskiDistance	p	sum(\	x - y\	^p)^(1/p)
“wminkowski”	WMinkowskiDistance	p, w	sum(\	w * (x - y)\	^p)^(1/p)
“seuclidean”	SEuclideanDistance	V	sqrt(sum((x - y)^2 / V))
“mahalanobis”	MahalanobisDistance	V or VI	sqrt((x - y)’ V^-1 (x - y))

数据归一化

如果不进行相应变量的参数归一化，很容易被 对应变量的大小进行主导
x: 1 5
y: 200 100 这样就被y主导，不能反应每一个变量的特征

sklearn使用 数据归一化

from sklearn.preprocessing import StandardScaler

standardScalar = StandardScaler()
standardScalar.fit( X_train )     # 获得自己的均值和方差
standardScalar.mean_
#standardScalar.std_

standardScalar.scale_#更换为  描述数据统计分布范围

#X_train/X_test 进行数据归一化处理
standardScalar.transform( X_train )
X_train = standardScalar.transform( X_train ) #这个样才行

X_test_standard = standardScalar.transform( X_test )

内部Scalar的 自我实现

def fit( self,X ):
    assert X.ndim == 2, "The dimension of X must be 2"
    #此处只是进行二维的 矩阵进行求解！

    # 对每一列进行均值求解
    self.mean_ = np.array([ np.mean( X[:,i] for i in range( X.shape[1] ) ) ])
    self.scale_ = np.array( [np.std( X[:,i] for i in range( X.shape[1] ) )] )
    return self
# 特别注意 每一列加上 `range()` 而且需要每一列进行计算。
def transform(self,X ):
    
    assert X.shape[1] == len( self.mean_ ),\
        "the feature number of X must be eqial to mean_ and std_"
    restX = np.empty( shape=X.shape, dtype=float )
    fof col in range( X.shape[1] ):
        restX[:, col] = ( X[:,col] - self.mean_[col] ) / self.scale_[col]
        return restX

同样也可以进行 MinMaxScalar的import
import sklearn.preprocessing import StandardScaler

scikit-learn中的 PCA

from sklearn.decomposition import PCA

pca = PCA(n_components=1)
pca.fit(X)

pca.components_  # 因为scikit learn中用的不是梯度上升法进行的求解，因此方向相反  不需要在意。

X_reduction = pca.transform(X)
X_restore = pca.inverse_transform(X_reduction)

PCA当中 我们应该，设置降维到多少 维度呢？

• pca.explained_variance_ratio_

  pca当中 每一个维度，占方差 贡献的重要程度—— 根据重要程度 进行分类！

通过绘制 折线图，查看前多少维度 贡献多少。

plt.plot([i for i in range(X_train.shape[1])], 
         [np.sum(pca.explained_variance_ratio_[:i+1]) for i in range(X_train.shape[1])])
plt.show()

scikit-learn 已经给我们封装

pca = PCA(0.95)  # n_components  不用传，直接传输贡献率
pca.fit(X_train)


X_train_reduction = pca.transform(X_train)
X_test_reduction = pca.transform(X_test)

%%time 
knn_clf = KNeighborsClassifier()
knn_clf.fit(X_train_reduction, y_train)

knn_clf.score(X_test_reduction, y_test)
# 降低到28维 看可； 权衡 是否想要 为了加快时间，而牺牲精度的方法
# 降低到2维， 方便进行图形的查看

降低到28维 看可； 权衡 是否想要 为了加快时间，而牺牲精度的方法

降低到2维， 方便进行图形的查看

MNIST数据集 进行更大量、更正规的 机器学习的方法应用

使用PCA进行降维 训练时间和预测时间都减少了

而且有可能因为 降维去除了噪音，有可能准确率更高了！

PCA降噪

平常有可能数据有噪音抖动，还有可能 测量过程中有了噪音。

作用：降低纬度 丢失信息 去除了噪音

sklearn中的数据 预处理方法

数据处理中一般处理方法：

1. 数据加载和预处理为标准的数组数据/方便进行获取和数组建立操作
2. 进行训练样本和测试样本的划分
3. 进行训练和测试 样本的数据归一化操作
4. 根据不同的 分类/回归任务，选用不同的方法 进行数据的再处理和加工
   • 多项式回归进行升维度
   • knn可以直接进行 k近邻分类

数据集划分

from sklearn.model_selection import train_test_split
X_train, X_test, y_train, y_test = train_test_split(iris.data, iris.target, test_size=0.2, random_state=666)

数据尺度 归一化

from sklearn.preprocessing import StandardScaler 
standardScalar = StandardScaler() 
standardScalar.fit(X_train)

standardScalar.transform(X_train)

多项式回归（8-2

from sklearn.preprocessing import PolynomialFeatures

poly = PolynomialFeatures(degree=2) #最多添加二次方
poly.fit(X)
X2 = poly.transform(X)

# 多项式回归 化为 线性回归进行测试
from sklearn.linear_model import LinearRegression

lin_reg2 = LinearRegression()
lin_reg2.fit(X2, y)
y_predict2 = lin_reg2.predict(X2)

plt.scatter(x, y)
plt.plot(np.sort(x), y_predict2[np.argsort(x)], color='r')
plt.show()

进行数据的升维，多项式回归的预处理方法

多项式特征 数据归一化 线性回归

使用 Pipeline

x = np.random.uniform(-3, 3, size=100)
X = x.reshape(-1, 1)
y = 0.5 * x**2 + x + 2 + np.random.normal(0, 1, 100)

from sklearn.pipeline import Pipeline
from sklearn.preprocessing import StandardScaler
from sklearn.linear_model import LinearRegression

poly_reg = Pipeline([
    ("poly", PolynomialFeatures(degree=2)),
    ("std_scaler", StandardScaler()),
    ("lin_reg", LinearRegression())
])


poly_reg.fit(X, y)
y_predict = poly_reg.predict(X)

plt.scatter(x, y)
plt.plot(np.sort(x), y_predict[np.argsort(x)], color='r')
plt.show()

new一个管道，传入相应的数据集； 数据集就能沿着管道依次进行 执行。得到最后的结果！
虽然 sklearn没有给我们封装 多项式回归方法，但是我们可以用Pipeline进行 多种方法封装，并进行操作。

评价标准

均方误差:

from sklearn.metrics import mean_squared_error

y_predict = lin_reg.predict(X)
mean_squared_error(y, y_predict)

岭回归

# 使用岭回归  不再是线性回归了.
from sklearn.linear_model import Ridge

def RidgeRegression(degree, alpha):
    return Pipeline([
        ("poly", PolynomialFeatures(degree=degree)),
        ("std_scaler", StandardScaler()),
        ("ridge_reg", Ridge(alpha=alpha))
    ])

ridge1_reg = RidgeRegression(20, 0.0001) # 因为theta很大，所以设置小店开始实验
ridge1_reg.fit(X_train, y_train)

y1_predict = ridge1_reg.predict(X_test)
mean_squared_error(y_test, y1_predict) # 原理：过拟合是的theta太大了，现在就是限制theta大小

由于上面的 alpha占比重小，所以 不太会考虑theta对于损失函数的影响，造成了 theta过大的问题。

# More:
ridge4_reg = RidgeRegression(20, 10000000)# 越大表明损失函数，对于theta大小所占比重考虑越多！所以越平滑。

LASSO回归

from sklearn.linear_model import Lasso

def LassoRegression(degree, alpha):
    return Pipeline([
        ("poly", PolynomialFeatures(degree=degree)),
        ("std_scaler", StandardScaler()),
        ("lasso_reg", Lasso(alpha=alpha))
    ])

train_test_split 改进——使用交叉验证进行 模型构建

使用三叠交叉验证( Cross Validation )

from sklearn.model_selection import cross_val_score

knn_clf = KNeighborsClassifier()
cross_val_score(knn_clf, X_train, y_train, cv=2)
# array([ 0.98895028,  0.97777778,  0.96629213])

best_k, best_p, best_score = 0, 0, 0
for k in range(2, 11):
    for p in range(1, 6):
        knn_clf = KNeighborsClassifier(weights="distance", n_neighbors=k, p=p)
        
        # 注意这里两行进行了修改
        scores = cross_val_score(knn_clf, X_train, y_train)
        score = np.mean(scores)
        if score > best_score:
            best_k, best_p, best_score = k, p, score
            
print("Best K =", best_k)
print("Best P =", best_p)
print("Best Score =", best_score)
#Best K = 2
#Best P = 2
#Best Score = 0.982359987401
best_knn_clf = KNeighborsClassifier(weights="distance", n_neighbors=2, p=2)
best_knn_clf.fit(X_train, y_train)
best_knn_clf.score(X_test, y_test)
# 最后再使用 测试数据集 进行最终模型性能的衡量标准。
# 0.98052851182197498

使用网格搜索——进行相应的 超参数的寻找

from sklearn.model_selection import GridSearchCV

param_grid = [
    {
        'weights': ['distance'],
        'n_neighbors': [i for i in range(2, 11)], 
        'p': [i for i in range(1, 6)]
    }
]

grid_search = GridSearchCV(knn_clf, param_grid, verbose=1)
grid_search.fit(X_train, y_train)

逻辑回归算法（Logistic Regression）

逻辑回归实际是分类问题
讲样本的特征和样本发生的概率联系起来，概率是一个数。又称为回归问题。

性能度量 泛化能力度量

# ./metrics
import numpy as np
from math import sqrt

# 进行分类准确度度量
def accuracy_score(y_true, y_predict):
    """计算y_true和y_predict之间的准确率"""
    assert len(y_true) == len(y_predict), \
        "the size of y_true must be equal to the size of y_predict"

    return np.sum(y_true == y_predict) / len(y_true)


def mean_squared_error(y_true, y_predict):
    """计算y_true和y_predict之间的MSE"""
    assert len(y_true) == len(y_predict), \
        "the size of y_true must be equal to the size of y_predict"

    return np.sum((y_true - y_predict)**2) / len(y_true)


def root_mean_squared_error(y_true, y_predict):
    """计算y_true和y_predict之间的RMSE"""

    return sqrt(mean_squared_error(y_true, y_predict))


def mean_absolute_error(y_true, y_predict):
    """计算y_true和y_predict之间的MAE"""
    assert len(y_true) == len(y_predict), \
        "the size of y_true must be equal to the size of y_predict"

    return np.sum(np.absolute(y_true - y_predict)) / len(y_true)

# 回归算法中，统一准确率 进行算法性能评估
def r2_score(y_true, y_predict):
    """计算y_true和y_predict之间的R Square"""

    return 1 - mean_squared_error(y_true, y_predict)/np.var(y_true)

逻辑回归，添加多项式 和 模型正则化

def PolynomialLogisticRegression(degree, C, penalty='l2'):
    return Pipeline([
        ('poly', PolynomialFeatures(degree=degree)),
        ('std_scaler', StandardScaler()),
        ('log_reg', LogisticRegression(C=C, penalty=penalty))
    ])

poly_log_reg4 = PolynomialLogisticRegression(degree=20, C=0.1, penalty='l1')
poly_log_reg4.fit(X_train, y_train)

逻辑回归当中进行 多分类操作

# OvR 多分类手段方法
# 默认是 ovr，即：默认scikitlearn 逻辑回归可以进行多分类问题。
log_reg = LogisticRegression(multi_class="ovr", solver="liblinear")
log_reg.fit(X_train, y_train)
log_reg.score(X_test, y_test)


# OvO 多分类手段方法
log_reg2 = LogisticRegression(multi_class="multinomial", solver="newton-cg")
log_reg2.fit(X_train, y_train)
log_reg2.score(X_test, y_test)

sklearn 封装了OVR和OVO

from sklearn.multiclass import OneVsRestClassifier
#from sklearn.multiclass import OneVsOneClassifier

ovr = OneVsRestClassifier(log_reg)
ovr.fit(X_train, y_train)
ovr.score(X_test, y_test)

以上可以传入所有的 二分类器进行，多分类 任务！～

分类中的评价方法

混淆矩阵

混淆矩阵相关的实现

def TP(y_true, y_predict):
    assert len(y_true) == len(y_predict)
    return np.sum((y_true == 1) & (y_predict == 1))

TP(y_test, y_log_predict)

def precision_score(y_true, y_predict):
    tp = TP(y_true, y_predict)
    fp = FP(y_true, y_predict)
    try:
        return tp / (tp + fp)
    except:
        return 0.0
    
precision_score(y_test, y_log_predict)

混淆矩阵 scikit-learn中的实现

# 混淆矩阵
from sklearn.metrics import confusion_matrix
confusion_matrix(y_test, y_log_predict)

# 精准率
from sklearn.metrics import precision_score
precision_score(y_test, y_log_predict)

# 召回率
from sklearn.metrics import recall_score
recall_score(y_test, y_log_predict)

混淆矩阵中的比较——学习器性能的好坏

分类评价方法在F1-score中的实现应用方法

from sklearn.metrics import confusion_matrix

from sklearn.metrics import precision_score
precision_score( y_test, y_predict )
from sklearn.metrics import recall_score 
recall_score( y_test, y_predict)   
from sklearn.metrics import f1_score
f1_score( y_test, y_predict )
# 全都是分别：第一个 y_treu；第二个 y_predict

更改阈值

decision_scores = log_reg.decision_function(X_test)
y_predict_2 = np.array(decision_scores >= 5, dtype='int')
confusion_matrix(y_test, y_predict_2)
precision_score(y_test, y_predict_2)    
recall_score(y_test, y_predict_2)

Precision-Recall 曲线

绘制

from sklearn.metrics import precision_recall_curve

precisions, recalls, thresholds = precision_recall_curve(y_test, decision_scores)

# 注意，p r最终数值为0&1 ，对应thresholds没有数值；即 thresholds少一个数值。

ROC曲线绘制

from sklearn.metrics import roc_curve
fprs, tprs, thresholds = roc_curve(y_test, decision_scores)


from sklearn.metrics import roc_auc_score
roc_auc_score(y_test, decision_scores)

注意对于 有偏的数据还是应该使用p-r对应查看；roc_auc_score对应用来查看 比较算法/超参数使用对于分类算法好坏孰优孰劣！

多分类问题 在scikit-learn中的应用

from sklearn.metrics import precision_score
precision_score(y_test, y_predict, average="micro")

from sklearn.metrics import confusion_matrix
confusion_matrix(y_test, y_predict)

# 绘制错误矩阵图像（灰度值进行显示）
cfm = confusion_matrix(y_test, y_predict)

row_sums = np.sum(cfm, axis=1)
err_matrix = cfm / row_sums
np.fill_diagonal(err_matrix, 0)

plt.matshow(err_matrix, cmap=plt.cm.gray)
plt.show()
# 相应进行 1-8  1-9犯错误更多，改进1-8 1-9进行阈值更改的改进！
# 真实环境中，有可能 是样本错误 或 算法细节问题：上一行问题。

MORE：TensorFlow初接触

TensorFlow数据流图和概念解析

怎样与开发者建立联系。

未来重复类型的工作都会交给人工智能进行操作。人类主要从事偏创造类和情感类的 工作。

支撑向量机

硬间隔SVM

与kNN类似都现需要进行 数据归一化

from sklearn.preprocessing import StandardScaler

standardScaler = StandardScaler()
standardScaler.fit(X)
X_standard = standardScaler.transform(X)


from sklearn.svm import LinearSVC

svc = LinearSVC(C=1e9)
svc.fit(X_standard, y)

# support vector classifier
from sklearn.svm import LinearSVC

svc = LinearSVC(C=1e9)
svc.fit(X_standard, y)

注意：上方引入的只是线性SVM进行分类的svm算法
注意 ：svc.coef_ 和 svc.intercept_ 对应 w0 * x0 + w1 * x1 + b = 0

软间隔SVM并 绘制超平面

w = model.coef_[0]
b = model.intercept_[0]

# w0*x0 + w1*x1 + b = 0
# => x1 = -w0/w1 * x0 - b/w1
plot_x = np.linspace(axis[0], axis[1], 200)
up_y = -w[0]/w[1] * plot_x - b/w[1] + 1/w[1]
down_y = -w[0]/w[1] * plot_x - b/w[1] - 1/w[1]

# 利用这个布尔数组 进行上面数组的筛选.
up_index = (up_y >= axis[2]) & (up_y <= axis[3])
down_index = (down_y >= axis[2]) & (down_y <= axis[3])

plt.plot(plot_x[up_index], up_y[up_index], color='black')
plt.plot(plot_x[down_index], down_y[down_index], color='black')

处理高度非线性特征分类-使用svm方法

使用多项式特征的SVM

from sklearn.preprocessing import PolynomialFeatures, StandardScaler
from sklearn.svm import LinearSVC
from sklearn.pipeline import Pipeline

def PolynomialSVC(degree, C=1.0):
    return Pipeline([
        ("poly", PolynomialFeatures(degree=degree)),
        ("std_scaler", StandardScaler()),
        ("linearSVC", LinearSVC(C=C))
    ])

poly_svc = PolynomialSVC(degree=3)
poly_svc.fit(X, y) # 不进行实际预测，所以不 “train_test_split"了！

使用多项式核函数的SVM

注意： SVM算法本身也是 带有多项式化方法的——核函数

from sklearn.svm import SVC

def PolynomialKernelSVC(degree, C=1.0):
    return Pipeline([
        ("std_scaler", StandardScaler()),
        ("kernelSVC", SVC(kernel="poly", degree=degree, C=C))
    ])

poly_kernel_svc = PolynomialKernelSVC(degree=3)
poly_kernel_svc.fit(X, y)

# 然后进行图像化展示，并不是为了进行预测！

高斯核函数讲解

l1, l2 = -1, 1

X_new = np.empty((len(x), 2))
# 将一维数据 映射到二维上面了，利用 高斯核函数.
for i, data in enumerate(x):
    X_new[i, 0] = gaussian(data, l1)
    X_new[i, 1] = gaussian(data, l2)

# enumerate( x ) 讲x的数值放入到data中，索引放入到i中.

使用高斯核函数（RBF）的sklearn方法

>

from sklearn.preprocessing import StandardScaler
from sklearn.pipeline import Pipeline
from sklearn.svm import SVC

def RBFKernelSVC(gamma):
    return Pipeline([
        ("std_scaler", StandardScaler()),
        ("svc", SVC(ke rnel="rbf", gamma=gamma))
    ])

svc = RBFKernelSVC(gamma=1)
svc.fit(X, y)

SVM思想解决回归问题

from sklearn.svm import LinearSVR
from sklearn.svm import SVR
from sklearn.preprocessing import StandardScaler
from sklearn.pipeline import Pipeline

def StandardLinearSVR(epsilon=0.1):
    return Pipeline([
        ('std_scaler', StandardScaler()),
        ('linearSVR', LinearSVR(epsilon=epsilon))
    ])

注意：SVR之于 前面的SVC相应的用法相似，但是参数不同.

决策树 在sklearn中的使用

决策树使用

from sklearn.tree import DecisionTreeClassifier

dt_clf = DecisionTreeClassifier(max_depth=2, criterion="entropy", random_state=42)
dt_clf.fit(X, y)

决策树其他参数

# 决策树中 至少需要多少个样本数据才能继续 拆分下去
dt_clf3 = DecisionTreeClassifier(min_samples_split=10)
dt_clf3.fit(X, y)
#　越高越不容易过拟合
# 越小越容易过拟合——拆分的很小——所以过拟合


# 对于叶子结点　至少要有几个样本
dt_clf4 = DecisionTreeClassifier(min_samples_leaf=6)
dt_clf4.fit(X, y)


#　决策树最大叶子结点个数
dt_clf5 = DecisionTreeClassifier(max_leaf_nodes=4)
dt_clf5.fit(X,y)
# 叶子节点个数越多——越复杂 越容易过拟合

• min_samples_split
• min_samples_leaf
• min_weight_fraction_leaf
• max_depth
• max_leaf_nodes
• min_features
• 更多scikit-learn决策树的参数和详细解释，相请参照这里.

决策树解决回归问题

叶子节点包含相应的数据，如果包含的是类别的话。

参数都一样，区别在于 叶子结点是分类结果、还是回归结果？

from sklearn.tree import DecisionTreeRegressor

dt_reg = DecisionTreeRegressor()
dt_reg.fit(X_train, y_train)


dt_reg.score(X_test, y_test)
## 0.58605479243964098

# 显然过拟合了！加入了自己本身的特征！
# 回归算法决策树很容易过拟合
dt_reg.score(X_train, y_train)
## 1.0

集成学习

进行多方面算法集成

kNN
逻辑回归
SVM
决策树
神经网络
贝叶斯

---

最后进行投票，少数服从多数
VotingClassifier

集成学习-投票集成使用：

from sklearn.ensemble import VotingClassifier

# 投票分类（参数为分类器）；voting='hard' —— 少数服从多数
voting_clf = VotingClassifier(estimators=[
    ('log_clf', LogisticRegression()), 
    ('svm_clf', SVC()),
    ('dt_clf', DecisionTreeClassifier(random_state=666))],
                             voting='hard')
                
# 可以在 把每个算法调节到最优之后，再进行集成！

voting_clf.fit(X_train, y_train)
voting_clf.score(X_test, y_test)

soft-classifier

更合理的投票，应该有权值—— 专家的话语应该权重更大！

voting_clf2 = VotingClassifier(estimators=[
    ('log_clf', LogisticRegression()), 
    ('svm_clf', SVC(probability=True)),
    ('dt_clf', DecisionTreeClassifier(random_state=666))],
                             voting='soft')
# 使用soft voting classifier必须要求集合中每个模型都能估计概率！


voting_clf2.fit(X_train, y_train)
voting_clf2.score(X_test, y_test)

入门完成

如何集成更多分类器，给我们更好地表现呢？
虽然有很多机器学习方法，但是从投票角度看，仍然不够多
我们需要创建更多的子模型！集成更多的子模型
子模型之间不能一致！子模型之间要有差异性！

创建差异性——没格子模型只看样本数据的一部分。
可以每个子模型只看100个样本数据！
每个子模型不需要太高的准确率（但是也不能太低！）

from sklearn.tree import DecisionTreeClassifier
from sklearn.ensemble import BaggingClassifier

# n_estimators 几个样本模型
# max_samples 每个模型要看几个样本
# bootstrap=True 放回取样
bagging_clf2 = BaggingClassifier(DecisionTreeClassifier(),
                           n_estimators=5000, max_samples=100,
                           bootstrap=True)
bagging_clf2.fit(X_train, y_train)
bagging_clf2.score(X_test, y_test)

# 训练使用对应参数进行  不放回取样和模型管理

OOB（OUT-of-bag）

使用那些为渠道的样本做测试和验证

from sklearn.tree import DecisionTreeClassifier
from sklearn.ensemble import BaggingClassifier

bagging_clf = BaggingClassifier(DecisionTreeClassifier(),
                               n_estimators=500, max_samples=100,
                               bootstrap=True, oob_score=True)
bagging_clf.fit(X, y)

bagging_clf.oob_score_ # 通过OOB使用计算出来—— 泛化能力、准确度的结果
# 讲OOB当做了 测试训练集

## 0.91800000000000004

由此看出 Bagging思路非常容易进行并行化处理的方法

• 增加参数—— n_jobs 使用多个核进行处理

  random_subspaces_clf = BaggingClassifier(DecisionTreeClassifier(),
                                 n_estimators=500, max_samples=500,
                                 bootstrap=True, oob_score=True,
                                 max_features=1, bootstrap_features=True)
  random_subspaces_clf.fit(X, y)
  random_subspaces_clf.oob_score_
  # 随机特征取样
  
  random_patches_clf = BaggingClassifier(DecisionTreeClassifier(),
                                 n_estimators=500, max_samples=100,
                                 bootstrap=True, oob_score=True,
                                 max_features=1, bootstrap_features=True)
  random_patches_clf.fit(X, y)
  random_patches_clf.oob_score_
  #随机特征+随机样本取样

随机森林

由多个树组成的森林叫做随机森林

简单使用

from sklearn.ensemble import RandomForestClassifier

# 也是使用Bagging进行随机取样的，所以可以有 决策树类似分类器
rf_clf = RandomForestClassifier(n_estimators=500, oob_score=True, random_state=666, n_jobs=-1)
rf_clf.fit(X, y)

rf_clf.oob_score_
## 0.89200000000000002

rf_clf2 = RandomForestClassifier(n_estimators=500, max_leaf_nodes=16, oob_score=True, random_state=666, n_jobs=-1)
rf_clf2.fit(X, y)
rf_clf2.oob_score_
## 0.90600000000000003

注意在sklearn中的使用，RF相当于是 结合了BaggingClassifier和 DecisionTreeClassifier 参数使用！都有用到！

MORE 使用ExtraTree进行 分类

from sklearn.ensemble import ExtraTreesClassifier

et_clf = ExtraTreesClassifier(n_estimators=500, bootstrap=True, oob_score=True, random_state=666, n_jobs=-1)
et_clf.fit(X, y)

et_clf.oob_score_

分类相应的对应有 回归方法——Regressor

from sklearn.ensemble import BaggingRegressor
from sklearn.ensemble import RandomForestRegressor
from sklearn.ensemble import ExtraTreesRegressor

Boosting

Ada Boosting

每次一步步赋予权重进行修正

from sklearn.tree import DecisionTreeClassifier
from sklearn.ensemble import AdaBoostClassifier

# 关键是学习算法（基学习器） 和 一步步赋予权重
ada_clf = AdaBoostClassifier(
    DecisionTreeClassifier(max_depth=2), n_estimators=500)
ada_clf.fit(X_train, y_train)

Gradient Boosting

>

from sklearn.ensemble import GradientBoostingClassifier

gb_clf = GradientBoostingClassifier(max_depth=2, n_estimators=30)
gb_clf.fit(X_train, y_train)

gb_clf.score(X_test, y_test)

Boosting解决回归问题

from sklearn.ensemble import AdaBoostRegressor
from sklearn.ensemble import GradientBoostingRegressor