Python深度学习基于Tensorflow（5）机器学习基础-阿里云开发者社区

机器学习的流程如下所示：

具体又可以分为以下五个步骤：

明确目标：在机器学习项目中，首先需要明确业务目标和机器学习目标。业务目标是指希望机器学习模型能够帮助实现的具体业务需求，例如提高销售额、降低风险等。机器学习目标则是指需要通过机器学习模型来解决的具体问题，例如分类、回归、聚类等。在明确了目标之后，需要根据目标来选择适当的机器学习任务和评估指标。
收集数据：在明确了目标之后，需要收集相关的数据用于机器学习模型的训练和测试。数据可以来自于各种来源，例如数据库、文本文件、网页等。在收集数据时，需要确保数据的质量和量，同时也需要考虑数据的可用性和合法性。
数据探索和数据预处理：在收集到数据之后，需要对数据进行探索和预处理。数据探索是指通过统计学和可视化等手段对数据进行分析，了解数据的特点和规律。数据预处理是指对数据进行清洗、转换、降维等操作，使其满足机器学习模型的要求。在这一步骤中，还需要对数据进行分割，将其分为训练集、验证集和测试集。
模型选择：在数据预处理之后，需要选择适合的机器学习模型来解决具体的问题。模型选择需要考虑多方面的因素，例如模型的复杂度、训练时间、预测精度等。在选择模型时，还需要考虑模型的可解释性和可扩展性。
模型评估：在选择好模型之后，需要对模型进行评估，以确定其在实际应用中的表现。模型评估需要使用适当的评估指标，例如准确率、精确率、召回率等。在评估模型时，还需要考虑模型的泛化能力和鲁棒性。通过对模型进行评估，可以进一步优化模型，提高其预测精度和可靠性。一般使用K折交叉验证来评估模型

根据问题类型选择损失函数

问题类型	损失函数	评估指标
回归模型	MSE	MSE，MAE
SVM	hinge	Accuracy，Precision，Recall
二分类模型	BinaryCrossentropy	Accuracy，Precision，Recall
多分类模型	CategoricalCrossentropy	TopKCategoricalCrossentropy

监督学习

监督学习通俗来讲指的就是有y的数据集

线性回归

线性回归是最简单，最普通的一种做法，机器学习中的线性回归非常简单和粗暴，不同于统计模型中有各个变量的P值什么的，机器学习中的线性回归只有一个 parameters 还有一个 score

线性回归公式非常简单： f ( x ) = w 1 x 1 + w 2 x 3 + ⋯ + w n x n + b f(x)=w_1x_1+w_2x_3+\dots+w_nx_n+b f(x)=w1x1+w2x3+⋯+wnxn+b

在sklearn导入：from sklearn.linear_model import LinearRegression

from sklearn.linear_model import LinearRegression
from sklearn.datasets import make_regression
## 这里使用 make_regression 创建回归数据集
X, y = make_regression(n_samples=1000, n_features=10, bias=1.2,  noise=10)
## 因为这里添加了bias，所以会有常数项，而LinearRegression默认包含常数项的 fit_intercept=True
linear_model = LinearRegression(fit_intercept=True)
## 训练
linear_model.fit(X, y)
## 得到模型的系数和常数
linear_model.coef_, linear_model.intercept_

要深入探究线性回归，可以对普通的loss做一些变换，得到不同的线性回归模型：Ridge，Lasso，ElasticNet

首先是 L 1 L_1 L1惩罚： L 1 ( w ) = ∣ ∣ w ∣ ∣ 1 = ∑ ∣ w i ∣ L_1(w) = ||w||_1=\sum|w_i| L1(w)=∣∣w∣∣1=∑∣wi∣

其次是 L 2 L_2 L2惩罚： L 2 ( w ) = ∣ ∣ w ∣ ∣ 2 = ∑ w i 2 L_2(w)=||w||_2=\sum w_i^2 L2(w)=∣∣w∣∣2=∑wi2

Ridge的loss L = ∑ ( f ( x i ) − y i ) 2 + α L 1 ( w 2 ) \mathcal{L}=\sum (f(x_i)-y_i)^2 + \alpha L_1(w_2) L=∑(f(xi)−yi)2+αL1(w2)

Lasso的loss L = ∑ ( f ( x i ) − y i ) 2 + α L 1 ( w 1 ) \mathcal{L}=\sum (f(x_i)-y_i)^2 + \alpha L_1(w_1) L=∑(f(xi)−yi)2+αL1(w1)

ElasticNet的loss L = ∑ ( f ( x i ) − y i ) 2 + α L 1 ( w ) + β L 2 ( w ) \mathcal{L}=\sum (f(x_i)-y_i)^2 + \alpha L_1(w) + \beta L_2(w) L=∑(f(xi)−yi)2+αL1(w)+βL2(w)

这里统计学的书籍会具体讲一下适用于哪些数据特征的模型，从损失函数中可以看到，主要是为了防止过拟合问题

逻辑回归

逻辑回归是用来处理二分类问题的模型，类似的模型还有Probit模型，不同的是逻辑回归使用sigmoid函数来处理概率，而Probit使用正态分布累计密度函数来处理概率模型。

sigmoid函数如下： f ( z ) = 1 1 + e − z f(z)=\frac{1}{1+e^{-z}} f(z)=1+e−z1

正态分布累计密度如下： f ( z ) = 1 2 π ∫ − ∞ z e − t 2 2 d t f(z)=\frac{1}{\sqrt{2\pi}}\int_{-\infty}^ze^{-\frac{t^2}{2}}dt f(z)=2π 1∫−∞ze−2t2dt

很明显，两个模型都是把值映射在0-1范围内，但prob涉及到积分，导致运算速度不如逻辑回归，所以逻辑回归更为通用。这里的 z z z 相当于线性回归中的 y y y 值。

这里loss涉及到了一种类似于期望处理方法，如下表所示：

loss	l a b e l t r u e = 0 label_{true}=0 labeltrue=0	l a b e l t r u e = 1 label_{true}=1 labeltrue=1
l a b e l p r e d = 0 label_{pred}=0 labelpred=0	0	α \alpha α
l a b e l p r e d = 1 label_{pred}=1 labelpred=1	β \beta β	0

由条件概率可得：

P ( l a b e l p r e d = 0 ) = P ( l a b e l p r e d = 0 ∣ l a b e l t r u e = 0 ) P ( l a b e l t r u e = 0 ) + P ( l a b e l p r e d = 0 ∣ l a b e l t r u e = 1 ) P ( l a b e l t r u e = 1 ) P(label_{pred}=0)=P(label_{pred}=0|label_{true}=0)P(label_{true}=0) + P(label_{pred}=0|label_{true}=1)P(label_{true}=1) P(labelpred=0)=P(labelpred=0∣labeltrue=0)P(labeltrue=0)+P(labelpred=0∣labeltrue=1)P(labeltrue=1)

由于 P ( l a b e l t r u e = 0 ) P(label_{true}=0) P(labeltrue=0)， P ( l a b e l t r u e = 1 ) P(label_{true}=1) P(labeltrue=1)只能等于 0，1，并且是已知的；所以 P ( l a b e l p r e d = 0 ) = P ( l a b e l p r e d = 0 ∣ l a b e l t r u e = 0 ) P(label_{pred}=0)=P(label_{pred}=0|label_{true}=0) P(labelpred=0)=P(labelpred=0∣labeltrue=0)，或者 P ( l a b e l p r e d = 0 ) = P ( l a b e l p r e d = 0 ∣ l a b e l t r u e = 1 ) P(label_{pred}=0)=P(label_{pred}=0|label_{true}=1) P(labelpred=0)=P(labelpred=0∣labeltrue=1)；同理 P ( l a b e l p r e d = 1 ) = P ( l a b e l p r e d = 1 ∣ l a b e l t r u e = 0 ) P(label_{pred}=1)=P(label_{pred}=1|label_{true}=0) P(labelpred=1)=P(labelpred=1∣labeltrue=0)，或者 P ( l a b e l p r e d = 1 ) = P ( l a b e l p r e d = 1 ∣ l a b e l t r u e = 1 ) P(label_{pred}=1)=P(label_{pred}=1|label_{true}=1) P(labelpred=1)=P(labelpred=1∣labeltrue=1)；

L = α P ( l a b e l p r e d = 0 ∣ l a b e l t r u e = 1 ) P ( l a b e l t r u e = 1 ) + β P ( l a b e l p r e d = 1 ∣ l a b e l t r u e = 0 ) P ( l a b e l t r u e = 0 ) = α [ 1 − P ( l a b e l p r e d = 0 ∣ l a b e l t r u e = 1 ) ] [ 1 − P ( l a b e l t r u e = 0 ) ] + β P ( l a b e l p r e d = 1 ∣ l a b e l t r u e = 0 ) P ( l a b e l t r u e = 0 ) = α ( 1 − y ) ( 1 − p ( x ) ) + β y p ( x ) \begin{align} \mathcal{L} &= \alpha P(label_{pred}=0|label_{true}=1)P(label_{true}=1) + \beta P(label_{pred}=1|label_{true}=0)P(label_{true}=0) \\ &=\alpha [1-P(label_{pred}=0|label_{true}=1)][1-P(label_{true}=0)] + \beta P(label_{pred}=1|label_{true}=0)P(label_{true}=0) \\ &= \alpha (1-y)(1-p(x)) + \beta yp(x) \end{align} L=αP(labelpred=0∣labeltrue=1)P(labeltrue=1)+βP(labelpred=1∣labeltrue=0)P(labeltrue=0)=α[1−P(labelpred=0∣labeltrue=1)][1−P(labeltrue=0)]+βP(labelpred=1∣labeltrue=0)P(labeltrue=0)=α(1−y)(1−p(x))+βyp(x)

很明显，当 α \alpha α 和 β \beta β 相等且为1的时候，惩罚为 L = ∑ y i p ( x i ) + ( 1 − y i ) p ( x i ) \mathcal{L}=\sum y_ip(x_i) +(1-y_i)p(x_i) L=∑yip(xi)+(1−yi)p(xi)

以上的公式很出名，但是在实际应用中，把这一类分为另一类，和把另一类分为这一类的损失是不同的，所以根据情况自定义；

在sklearn导入：from sklearn.linear_model import LogisticRegression

import numpy as np
from sklearn.linear_model import LogisticRegression
from sklearn.datasets import make_classification
## 这里使用 make_classification 创建分类数据集
X, y = make_classification(n_samples=1000, n_features=10, n_classes=2)
## 建立模型
log_reg = LogisticRegression()
## 模型训练
log_reg.fit(X, y)
## 得到模型的系数和常数
log_reg.intercept_, log_reg.coef_

决策树

决策树有三种出名的算法：ID3，C4.5，CART 太多了，详细可以看周志华老师的机器学习介绍，这里做一下代码使用实例

利用决策树来解决回归

from sklearn.datasets import load_diabetes
from sklearn.model_selection import cross_val_score
from sklearn.tree import DecisionTreeRegressor
## 导入数据
X, y = load_diabetes(return_X_y=True)
## 选择模型
regressor = DecisionTreeRegressor(random_state=0)
## 训练并使用交叉验证打分
cross_val_score(regressor, X, y, cv=10)

利用决策树来解决分类

from sklearn.datasets import load_diabetes
from sklearn.model_selection import cross_val_score
from sklearn.tree import DecisionTreeRegressor
## 导入数据
X, y = load_iris(return_X_y=True)
## 选择模型
clf = DecisionTreeClassifier(random_state=0)
## 训练并使用交叉验证打分
cross_val_score(clf, X, y, cv=10)

支持向量机

支持向量分类的核心思想：找一个超平面把两类数据尽可能给分割开来

支持向量回归的核心思想：找两个平行的超平面把数据尽可能靠拢

SVR

from sklearn.svm import SVR
from sklearn.pipeline import make_pipeline
from sklearn.preprocessing import StandardScaler
import numpy as np
n_samples, n_features = 10, 5
rng = np.random.RandomState(0)
y = rng.randn(n_samples)
X = rng.randn(n_samples, n_features)
regr = make_pipeline(StandardScaler(), SVR(C=1.0, epsilon=0.2))
regr.fit(X, y)

SVC

from sklearn.svm import SVC
from sklearn.pipeline import make_pipeline
from sklearn.preprocessing import StandardScaler
import numpy as np
X = np.array([[-1, -1], [-2, -1], [1, 1], [2, 1]])
y = np.array([1, 1, 2, 2])
clf = make_pipeline(StandardScaler(), SVC(gamma='auto'))
clf.fit(X, y)

朴素贝叶斯

朴素贝叶斯假设：属性条件独立，其核心思想 p ( c ∣ x ) = p ( x ∣ c ) p ( c ) p ( x ) p(c|x)=\frac{p(x|c)p(c)}{p(x)} p(c∣x)=p(x)p(x∣c)p(c)

其中 c c c 表示类别，利用计算 p ( x ∣ c ) p ( c ) p(x|c)p(c) p(x∣c)p(c) 的方式去计算 p ( c ∣ x ) p(c|x) p(c∣x) ，这里的 p ( x ) p(x) p(x) 由于做比较就可以忽略；

由于属性条件独立，有 p ( x ∣ c ) = p ( ( x 1 , x 2 , … , x m ) ∣ c ) = ∏ p ( x i ∣ c ) p(x|c)=p((x_1,x_2,\dots,x_m)|c)=\prod p(x_i|c) p(x∣c)=p((x1,x2,…,xm)∣c)=∏p(xi∣c)

最后判别类别有： a r g m a x p ( c ) ∏ p ( x i ∣ c ) argmax \ \ p(c)\prod p(x_i|c) argmax p(c)∏p(xi∣c)

import numpy as np
from sklearn.naive_bayes import CategoricalNB
rng = np.random.RandomState(1)
X = rng.randint(5, size=(6, 100))
y = np.array([1, 2, 3, 4, 5, 6])
clf = CategoricalNB()
clf.fit(X, y)

集成学习

集成学习思想类似于：三个臭皮匠顶一个诸葛亮，通过总结不同模型的输出结果得到一个最终的结果

集成学习有两种典型的算法：装袋算法(Bagging) 和 提升分类器(Boosting)

Boosting：个体学习器之间存在强依赖关系，必须串行生成的序列化方法。

Bagging：个体学习器之间存在弱依赖关系，可同时生成的并行化方法。

Bagging

采样：从原始数据集中，使用Bootstrap方法进行有放回的抽样，生成新的训练子集。这意味着每个子集都是通过随机选择原始数据集中的样本而创建的，且一个样本在一次抽样中可以被重复选中多次，而有些样本可能一次都不会被选中。通常，这些子集的大小与原始数据集相同。
训练：对于每一个由Bootstrap生成的子集，使用一个基础学习算法（如决策树、线性回归等）独立地训练一个模型。由于各个子集之间是独立的，这些模型的训练过程可以并行进行。
预测：对于分类任务，所有模型的预测结果将通过投票的方式汇总，即每个模型对测试样本的预测类别进行投票，最终得票最多的类别作为Bagging集成的预测结果。对于回归任务，所有模型的预测值将被简单平均（或加权平均），以得到最终的预测值。

Bagging通过结合多个模型的预测来减少单一模型可能引入的方差，从而提高整体模型的稳定性和泛化能力。这种方法特别有效于那些具有高方差的学习算法。通过上述步骤，Bagging能够有效地减少模型的过拟合风险，并在很多情况下显著提升模型的性能。随机森林（Random Forest）是Bagging思想的一个典型应用，它在构建决策树时不仅使用Bootstrap采样，还加入了特征随机选择的机制，进一步增强了模型的多样性与泛化能力。

Boosting

先从初始训练集训练处一个基学习器；
再根据基学习器的表现对训练样本分布进行调整，使得先前基学习器做错的样本在后续受到更多的关注；
基于调整后的样本分布来训练下一个基学习器；
一直重复上述步骤，直到基学习器的个数达到train前的指定数T，然后将这T个基学习器进行加权；

基于Boosting思想的算法主要有：AdaBoost，GBDT，XGBoost

无监督学习

主成分分析

主成分分析 PCA 是一种降维的算法，还有一种叫 TSNE

PCA的基本思想是通过旋转的方式，把轴转换到方差最大的方向，然后选取方差大小前面的几个轴

import numpy as np
from sklearn.decomposition import PCA
X = np.array([[-1, -1], [-2, -1], [-3, -2], [1, 1], [2, 1], [3, 2]])
pca = PCA(n_components=2)
pca.fit(X)

KMeans聚类

from sklearn.cluster import KMeans
import numpy as np
X = np.array([[1, 2], [1, 4], [1, 0],[10, 2], [10, 4], [10, 0]])
kmeans = KMeans(n_clusters=2, random_state=0, n_init="auto").fit(X)
## 查看x对应的label
kmeans.labels_

当数据量较大时，可以使用 MiniBatchKMeans 进行计算，这样不用带入所有数据

缺失值和分类数据处理

处理缺失数据

处理缺失数据主要在sklearn.impute这个包内，impute.SimpleImputer，impute.IterativeImputer，impute.MissingIndicator，impute.KNNImputer

import pandas as pd
from io import StringIO
import numpy as  np
from sklearn.impute import SimpleImputer
csv_data = '''A,B,C,D
1.0,2.0,3.0,4.0
5.0,6.0,,8.0
10.0,11.0,12.0,'''
## 读取数据
df = pd.read_csv(StringIO(csv_data))
## 观察每一列的缺失值数量
df.isnull().sum()
## 缺失值使用均值填充
imr = SimpleImputer(missing_values=np.nan, strategy='mean')
imputed_data = imr.fit_transform(df)
imputed_data

分类数据转化为OneHot编码

import pandas as pd
df = pd.DataFrame([
            ['green', 'M', 10.1, 'class1'], 
            ['red', 'L', 13.5, 'class2'], 
            ['blue', 'XL', 15.3, 'class1']])
df.columns = ['颜色', '型号', '价格', '类别']
size_mapping = {
           'XL': 3,
           'L': 2,
           'M': 1}
df['型号'] = df['型号'].map(size_mapping)
## 获取OneHot编码
pd.get_dummies(df[['价格', '颜色', '型号', '类别']], drop_first=True)

get_dummies 函数会把所有的字符变量都变成OneHot编码，但是很明显，n个维度只能有n-1个编码，否则会造成多重共线性，不可取，所以一般要使用 drop_first

葡萄酒数据集示例

准备数据，这里使用 sklearn.datasets 中的 wine 数据集

import pandas as pd
import numpy as np
from sklearn.datasets import load_wine
data = load_wine()
X, y, feature_names = data['data'], data['target'], data['feature_names']
df_wine = pd.DataFrame(np.c_[X, y], columns=feature_names + ['class'])

切分训练集和测试集，标准化

from sklearn.preprocessing import StandardScaler
from sklearn.model_selection import train_test_split
X_train, X_test, y_train, y_test = train_test_split(X, y, test_size=0.3, random_state=0)
stdsc = StandardScaler()
X_train_std = stdsc.fit_transform(X_train)
X_test_std = stdsc.transform(X_test)

这里使用逻辑回归尝试做一个模型，发现效果还不错，这里的C是惩罚系数的倒数

from sklearn.linear_model import LogisticRegression
lr = LogisticRegression(penalty='l1', C=0.1,solver='liblinear')
lr.fit(X_train_std, y_train)
print('Training accuracy:', lr.score(X_train_std, y_train))
print('Test accuracy:', lr.score(X_test_std, y_test))
# Training accuracy: 0.9838709677419355
# Test accuracy: 0.9814814814814815

接着通过更改惩罚系数，观察逻辑回归模型参数的变化过程

weights, params = [], []
for c in np.arange(-4, 6):
    lr = LogisticRegression(penalty='l1', C=10.**c, solver='liblinear')
    lr.fit(X_train_std, y_train)
    weights.append(lr.coef_[1])
    params.append(10.**c)
weights = np.array(weights)

画图，由于x轴是对数距离，所以需要放缩 plt.xscale('log')

import matplotlib.pyplot as plt
plt.rcParams['font.sans-serif']=['Microsoft YaHei']
plt.rcParams['axes.unicode_minus'] = False 
fig = plt.figure()
ax = plt.subplot(111)
    
colors = ['blue', 'green', 'red', 'cyan', 
         'magenta', 'yellow', 'black', 
          'pink', 'lightgreen', 'lightblue', 
          'gray', 'indigo', 'orange']
for column, color in zip(range(weights.shape[1]), colors):
    plt.plot(params, weights[:, column], label=df_wine.columns[column+1], color=color)
## 在y=0上画一根--
plt.axhline(0, color='black', linestyle='--', linewidth=3)
## 限制x轴为[10^-5, 10^5]
plt.xlim([10**(-5), 10**5])
plt.ylabel('权重系数')
plt.xlabel('C')
## !!! x轴的距离使用对数距离
plt.xscale('log')
## 设置pic的legend
plt.legend(loc='upper left')
ax.legend(loc='upper center', 
          bbox_to_anchor=(1.38, 1.03),
          ncol=1, fancybox=True)

最后进行特征选择，分值的方式有两种：AIC 和 BIC；选择的方式有三种： 前向选择，后向选择以及逐步选择。这里是根据score的分值，使用后向选择的方式对变量进行剔除。

from sklearn.base import clone
from itertools import combinations
import numpy as np
from sklearn.model_selection import train_test_split
from sklearn.metrics import accuracy_score
class SBS():
    def __init__(self, estimator, k_features, scoring=accuracy_score,
                 test_size=0.25, random_state=1):
        self.scoring = scoring
        self.estimator = clone(estimator)
        self.k_features = k_features
        self.test_size = test_size
        self.random_state = random_state
    def fit(self, X, y):
        
        X_train, X_test, y_train, y_test = \
                train_test_split(X, y, test_size=self.test_size, 
                                 random_state=self.random_state)
        dim = X_train.shape[1]
        self.indices_ = tuple(range(dim))
        self.subsets_ = [self.indices_]
        score = self._calc_score(X_train, y_train, 
                                 X_test, y_test, self.indices_)
        self.scores_ = [score]
        while dim > self.k_features:
            scores = []
            subsets = []
            for p in combinations(self.indices_, r=dim-1):
                score = self._calc_score(X_train, y_train, 
                                         X_test, y_test, p)
                scores.append(score)
                subsets.append(p)
            best = np.argmax(scores)
            self.indices_ = subsets[best]
            self.subsets_.append(self.indices_)
            dim -= 1
            self.scores_.append(scores[best])
        self.k_score_ = self.scores_[-1]
        return self
    def transform(self, X):
        return X[:, self.indices_]
    def _calc_score(self, X_train, y_train, X_test, y_test, indices):
        self.estimator.fit(X_train[:, indices], y_train)
        y_pred = self.estimator.predict(X_test[:, indices])
        score = self.scoring(y_test, y_pred)
        return score

接着使用KNN模型作为分类器

from sklearn.neighbors import KNeighborsClassifier
import matplotlib.pyplot as plt
knn = KNeighborsClassifier(n_neighbors=2)
# 选择特征
sbs = SBS(knn, k_features=1)
sbs.fit(X_train_std, y_train)
# 可视化特征子集的性能
k_feat = [len(k) for k in sbs.subsets_]
plt.plot(k_feat, sbs.scores_, marker='o')
plt.ylim([0.7, 1.1])
plt.ylabel('Accuracy')
plt.xlabel('Number of features')
plt.grid()
plt.tight_layout()
plt.show()

得到结果：

使用随机森林获取特征重要性

from sklearn.ensemble import RandomForestClassifier
feat_labels = feature_names
forest = RandomForestClassifier(n_estimators=1000,
                                random_state=0,
                                n_jobs=-1)
forest.fit(X_train, y_train)
importances = forest.feature_importances_
indices = np.argsort(importances)[::-1]
plt.title('Feature Importances')
plt.bar(range(X_train.shape[1]), 
        importances[indices],
        color='lightblue', 
        align='center')
plt.xticks(range(X_train.shape[1]), feat_labels, rotation=90)
plt.xlim([-1, X_train.shape[1]])
plt.tight_layout()
plt.show()

Python深度学习基于Tensorflow（5）机器学习基础