机器学习-小白简单入门

边洛洛

已于 2023-11-15 21:49:22 修改

阅读量124

点赞数 1

分类专栏： python机器学习文章标签：机器学习人工智能

于 2023-10-26 17:29:20 首次发布

本文链接：https://blog.csdn.net/qq_45854695/article/details/133562246

版权

python机器学习专栏收录该内容

1 篇文章 0 订阅

订阅专栏

4.6.5 K-means对Instacart Market用户聚类

4.6.6 K-means性能评估指标

4.6.7 K-means总结

1.机器学习概述

1.1 什么是机器学习？

通过历史数据总结规律，预测未来结果
三要素：数据（特征值、目标值）模型预测

1.2 机器学习开发流程

①获取数据②数据处理③特征工程④机器学习算法训练⑤模型评估⑥应用

# 1）获取数据

# 2）划分数据集

# 3）特征工程

# 4）某算法预估器流程

# 5）模型评估

   # 方法1直接比对真实值和预测值

   # 方法2计算准确率

1.3 机器学习分类

①监督学习（有目标值）分类(连续性)、回归(离散性)
②无监督学习（无目标值）聚类

2.特征工程

2.1 数据集

2.1.1 可用的数据集

①sklearn

②kaggle Find Open Datasets and Machine Learning Projects | Kaggle

③UCI UCI Machine Learning Repository

2.1.2 sklearn数据集

sklearn.datasets

datasets.load_* # 获取小规模数据集
datasets.fetch_* # 获取大规模数据集

sklearn数据集返回值介绍

load和fetch返回的数据类型为datasets.base.Bunch(字典格式)
data:特征数据数组
target：标签数组
DESCR：数据描述
feature_names：特征名
target_names：标签名

2.1.3 数据集的划分

思考：为什么要进行数据集的划分？

答：因为不能将所得的所有数据进行训练一个模型，所以将数据集划分为两部分:

①训练数据 ②测试数据

数据集划分api

sklearn.model_selection.train_test_split(arrays,*options)

x 数据集的特征值
y 数据集的目标值
test_size 测试值的大小，一般为float,默认为0.25
random_state 随机数种子
return 训练集特征值，测试集特征值，训练集目标值，测试集目标值

2.2 特征工程介绍

特征工程：使用专业背景知识和技巧处理数据，使得特征能在机器学习算法上发挥更好的作用的过程。

sklearn：对于特征的处理提供接口
pandas：一个读取数据、处理数据的工具

特征工程内容：①特征抽取②特征预处理③特征降维

2.3 特征抽取

2.3.1 特征提取

1.特征提取api

sklearn.feature_extraction

2.将任意数据转换为可用于机器学习的数字特征

字典特征提取
文本特征提取
图像特征提取（深度学习）

2.3.2 字典特征提取

作用：对字典数据进行特征值化

sklearn.feature_extraction.DictVectorizer(sparse=True,...)

DictVectorizer.fit_transform(X) X:字典或者包含字典的迭代器返回值：返回sparse矩阵
DictVectorizer.inverse_transform(X) X:array数组或者sparse矩阵返回值：转换之前数据格式
DictVectorizer.get_feature_names_out() 返回类别名称

vector：向量

sparse：稀疏默认返回稀疏矩阵（稀疏矩阵：将非零值按位置表示出来，可以节省内存，提高加载效率）

def dict_demo():
    """
    字典特征抽取
    :return:
    """
    data = [{'city':'北京','temperature':10},{'city':'上海','temperature':20},{'city':'深圳','temperature':30}]
    # 1.实例化一个转换器类
    transfer = DictVectorizer(sparse=False)
    # 2.调用fit_transform()
    data_new = transfer.fit_transform(data)
    print("data_new:\n",data_new)
    print("特征名字：\n",transfer.get_feature_names_out())

    return None

2.3.3 文本特征提取

作用：对文本数据进行特征值化

CountVectorizer文本特征提取：

api: sklearn.feature_extraction.text.CountVectorizer(stop_words=[“a”],...)

CountVectorizer.fit_transform(X) X:文本或者包含文本字符串的可迭代对象返回值：返回sparse矩阵
CountVectorizer.inverse_transform(X) X:array数组或者sparse矩阵返回值：转换之前数据格式
CountVectorizer.get_feature_names_out() 返回值:单词列表

CountVectorizer作用：统计每个样本特征词出现的个数

stop_words：停用词

TfidVectorizer文本特征提取：

TF（词频）指的是一个词在文档中出现的频率。
IDF（逆文档频率）指的是一个词的常见程度。

TF-IDF的公式：TF-IDF = TF * IDF

其中，TF = (词在文档中的出现次数) / (文档中总的词数)

IDF = log((总的文档数量) / (包含该词的文档数量))

api: sklearn.feature_extraction.text.TfidVectorizer(stop_words=None,...)

TfidVectorizer.fit_transform(X) X:文本或者包含文本字符串的可迭代对象返回值：返回sparse矩阵
TfidVectorizer.inverse_transform(X) X:array数组或者sparse矩阵返回值：转换之前数据格式
TfidVectorizer.get_feature_names_out() 返回值:单词列表

fit_transform是fit和transform的结合，既包括了训练又包含了转换，而transform方法仅用于将数据按照已经拟合的转换器进行转换,都是对数据进行某种统一处理的方法。

注意:

在使用fit_transform方法时，必须先使用fit_transform(trainData)对训练数据进行拟合转换器的训练，然后再使用transform(testData)对测试数据进行转换，否则程序会报错。

2.4 特征预处理

2.4.1 特征预处理介绍

api ：sklearn.preprocessing
无量纲化：归一化、标准化

为什么进行归一化/标准化？某特征比其他特征数量级大得多，而几个特征同等重要，容易使得算法无法学习到这些数量级小的特征。

2.4.2 归一化

1.定义：通过对原始数据进行变换把数据映射到[0,1]之间

2.公式：X_norm = (X - X_min) / (X_max - X_min) 其中，X是原始数据，X_min是最小值，X_max是最大值。结果X_norm是缩放后的数据。

3.API：sklearn.preprocessing.MinMaxScaler(feature_range=(0,1)...)

MinMaxScaler.fit_transform(X) X:numpy array格式的数据[n_samples,n_features]
返回值：转换后的形状相同的array

4.缺点：最大值最小值是变化的，容易受异常点影响，所以该方法鲁棒性较差，只适合传统精确小数据场景

2.4.3 标准化

1.定义：通过对原始数据进行变换把数据变换到均值为0，标准差为1范围内的数据

2.公式：（作用于每一列，mean为平均值，σ为标准差）

3.API：sklearn.preprocessing.StandardScaler()

StandardScaler.fit_transform(X) X:numpy array格式的数据[n_samples,n_features]
返回值：转换后的形状相同的array

处理之后每列来说所有数据都聚集在均值0附近，标准差为1

4.总结:在已有样本足够多的情况下比较稳定，适合现在嘈杂大数据场景。

标准化和归一化：

归一化：若出现异常点，影响了最大值和最小值，那么结果显然会发生改变
标准化：若出现异常点，由于具有一定数据量，少量的异常点对于平均值的影响并不大，从而方差改变较小

2.5 特征降维

1.降维：在某些限定条件下，降低随机变量（特征）个数，得到一组“不相关”主变量的过程

2.降维的两种方式：①特征选择②主成分分析

3.特征选择:

方法：

Filter(过滤式)：探究特征本身特点、特征与特征和目标值之间关联
方差选择法：低方差特征过滤
相关系数
Embedded(嵌入式)：算法自动选择特征(特征与目标值之间的关联)
决策树：信息熵、信息增益
正则化：L1、L2
深度学习：卷积

模块：sklearn.feature_selection

4. 过滤式

1.低方差特征过滤

特征方差小：某个特征大多样本的值比较接近
特征方差大：某个特征大多样本的值都有差别

sklearn.feature_selection.VarianceThreshold(threshold = 0.0)

删除所有低方差特征
Variance.fit_transform(X)
X : numpy array格式的数据[n_samples,n_features]
返回值：训练集差异低于threshold的特征将被删除。默认值是保留所有非零方差特征，即删除所有样本中具有相同值的特征。

2.相关系数

皮尔逊相关系数：反映变量之间相关关系密切程度的统计指标
公式：
相关系数的值为 -1<= r <= +1
当r > 0,表示两变量正相关，r < 0,表示两变量负相关
当|r|=1，表示两变量为完全相关，当r=0，表示两变量无相关关系
当0<|r|<1时，表示两变量存在一定程度的相关。当|r|越接近1，两变量线性关系越密切；当|r|越接近0，两变量线性关系越弱
一般按三级划分：|r|<0.4为低度相关；0.4<=|r|<0.7为显著性相关；0.7<=|r|<1为高度线性相关

3.API

from scipy.stats import pearsonr
x:(N.)array_like
y:(N.)array_like Returns:(Pearson's correlation coefficient,p-value)

5. 思考

若得出特征与特征之间相关性很高，处理方法时：

①选取其中一个②加权求和③主成分分析

2.6 主成分分析（PCA）

定义：高维数据转化为低维数据的过程，在此过程中可能会舍弃原有数据、创造新的变量

作用：是数据维数压缩，尽可能降低原数据的维数（复杂度），损失少量信息。

应用：回归分析或者聚类分析当中

api

sklearn.decomposition.PCA(n_components=None)
将数据分解为较低维数空间
n_components:
小数：表示保留百分之多少的信息
整数：减少到多少特征
PCA.fit_transform(X):numpy array格式的数据 [n_samples,n_features]
返回值：转换后指定维度的array

3.分类算法

3.1 sklearn转换器和估计器

转换器

1.实例化一个转换器类transformer

2.调用fit_transform(对于文档建立分类词频矩阵，不能同时调用)

估计器：在sklearn中，估计器很重要，是一类实现算法的api

1.实例化一个转换器类estimator

2.调用estimator.fix(x_train,y_train) 计算 ——调用完毕，模型生成

3.模型评估：

1）直接对比真实值和预测值

y_predict = estimator.predict(x_test)

y_test == y_predict

2）计算准确率

accuracy = estimator.score(x_test,y_test)

1.用于分类的估计器

sklearn.neighbors k-近邻算法
sklearn.naive.bayes 贝叶斯
sklearn.linear_model.LogisticRegression 逻辑回归
sklearn.tree 决策树与随机森林

2.用于回归的估计器

sklearn.linear_model.LinearRegression 线性回归
sklearn.linear_model.Ridge 岭回归

3.用于无监督学习的估计器

sklearn.cluster.KMeans 聚类

3.2 K-近邻算法（knn）

3.2.1 认识knn算法

核心思想：根据你的“邻居”判断你的类别

knn原理
定义：如果一个样本在特征空间内的k个最相似的样本中的大多数属于某一个类别，则该样本也属于这个类别
距离公式（采用欧氏距离）
k值过小，受异常点影响，容错率低；k值过大，受样本不均衡影响，准确率低
api：sklearn.neighbors.KNeighborsClassifier(n_neighbors=5,algorithm='auto')
n_neighbors:int(默认为5) k_neighbors查询默认使用的邻居数
algorithm:('auto','ball-tree','kd_tree','brute')
优缺点：
优：简单、易于理解和实现，无需训练
缺：①必须指定k值，k值选择不当则分类精度不能保证

②懒惰算法，对测试样本分类时的计算量较大，内存开销大

使用场景:小数据场景（几千-几万样本）

3.2.2 knn-鸢尾花案例

from sklearn.datasets import load_iris  # 小数据集鸢尾花
from sklearn.model_selection import train_test_split  # 训练测试集分割
from sklearn.preprocessing import StandardScaler  # 导入标准化
from sklearn.neighbors import KNeighborsClassifier


def knn_iris():
    """
    用knn算法对鸢尾花进行分类
    :return:
    """
    # 1）获取数据
    iris = load_iris()

    # 2）划分数据集
    x_train, x_test, y_train, y_test = train_test_split(iris.data, iris.target, test_size=0.2, random_state=6)

    # 3）特征工程；标准化
    # 实列化转换器类
    transfer = StandardScaler()
    # 对训练集求平均值标准值最终做标准化
    x_train = transfer.fit_transform(x_train)
    # 测试集标准化 训练集做了什么工作测试集也应该做什么样的工作
    x_test = transfer.transform(x_test)
 
    # 4）knn算法预估器
    estimator = KNeighborsClassifier()  
    
    # 5）模型评估
    # 方法1直接比对真实值和预测值
    y_predict = estimator.predict(x_test)  # 对测试集进行预测结果
    print("y_predict:\n", y_predict)
    print("直接比对真实值和预测值：\n", y_test == y_predict)

    # 方法2计算准确率
    score = estimator.score(x_test, y_test)  # score方法会将x_test输入到模型中进行预测，并与y_test进行比较，计算预测正确的样本数量，然后除以总样本数量得到准确率。
    print("准确率：\n", score)
   
    return None


if __name__ == "__main__":
    knn_iris()

3.3 模型选择与调优

3.3.1 认识交叉验证

交叉验证：将拿到的训练数据，分为训练集和验证集

交叉验证目的：为了让被评估的模型更加准确可信

超参数搜索-网格搜索

超参数：需要手动指定的参数

每组超参数都采用交叉验证来进行评估，最后选出最优参数组合建立模型

3.3.2 模型选择与调优API

sklearn.model_selection.GridSearchCV(estimator,param_grid=None,cv=None)
对估计器的指定参数进行详尽搜索
estimator：估计器对象
param_grid：估计器参数(dict){"n=neighbors":[1,3,5]}
cv：指定几折交叉验证
fit()：输入训练数据
score()：准确率
结果分析：
最佳参数：best_params_
最佳结果：best_score_
最佳估计器：best_estimator_
交叉验证结果：cv_results_

3.3.3 knn调优-鸢尾花案例

from sklearn.datasets import load_iris  # 小数据集鸢尾花
from sklearn.model_selection import train_test_split  # 训练测试集分割
from sklearn.preprocessing import StandardScaler  # 导入标准化
from sklearn.neighbors import KNeighborsClassifier
from sklearn.model_selection import GridSearchCV


def knn_iris_gscv():
    """
    用knn算法对鸢尾花进行分类
    :return:
    """
    # 1）获取数据
    iris = load_iris()

    # 2）划分数据集
    x_train, x_test, y_train, y_test = train_test_split(iris.data, iris.target, test_size=0.2, random_state=6)

    # 3）特征工程；标准化
    # 实列化转换器类
    transfer = StandardScaler()
    # 对训练集求平均值标准值最终做标准化
    x_train = transfer.fit_transform(x_train)
    # 测试集标准化 训练集做了什么工作测试集也应该做什么样的工作
    x_test = transfer.transform(x_test)
   
    # 4）knn算法预估器
    estimator = KNeighborsClassifier()  # 创建了一个K最近邻（K-Nearest Neighbors）分类器的实例 k值为3
    # 加入网络搜索与交叉验证
    # 参数准备
    param_dict = {"n_neighbors": [1, 3, 5, 7, 9, 11, 13]}
    estimator = GridSearchCV(estimator, param_grid=param_dict, cv=10)
    estimator.fit(x_train, y_train)  

    # 5）模型评估
    # 方法1直接比对真实值和预测值
    y_predict = estimator.predict(x_test)  # 对测试集进行预测结果
    print("y_test;\n", y_test)
    print("y_predict:\n", y_predict)
    print("直接比对真实值和预测值：\n", y_test == y_predict)

    # 方法2计算准确率
    score = estimator.score(x_test, y_test)  # score方法会将x_test输入到模型中进行预测，并与y_test进行比较，计算预测正确的样本数量，然后除以总样本数量得到准确率。
    print("准确率：\n", score)

    print("最佳参数：\n", estimator.best_params_)
    print("最佳结果：\n", estimator.best_score_)
    print("最好估计器：\n", estimator.best_estimator_)
    print("交叉验证结果：\n", estimator.cv_results_)

    return None


if __name__ == "__main__":
    knn_iris_gscv()

3.4 朴素贝叶斯算法

3.4.1 认识朴素贝叶斯

朴素+贝叶斯：特征之间相互独立+贝叶斯公式

概率P(X):取值[0,1]

api：sklearn.naive_bayes.MultinomialNB(alpha = 1.0)
拉普拉斯平滑系数
优点:
朴素贝叶斯模型发源于古典数学理论，有稳定的分类效果
对缺失数据不太敏感，算法简单，常用于文本分类
分类准确度高，速度快
缺点:
样本使用属性独立性假设，特征属性有关联时效果不好

3.4.2 朴素贝叶斯-新闻分类案例

from sklearn.datasets import fetch_20newsgroups
from sklearn.model_selection import train_test_split
from sklearn.feature_extraction.text import TfidfVectorizer
from sklearn.naive_bayes import MultinomialNB

def nb_new():
    """
    用朴素贝叶斯算法对新闻进行分类
    :return:
    """
    # 1）获取数据
    news = fetch_20newsgroups(subset="all")

    # 2)划分数据集
    x_train,x_test,y_train,y_test = train_test_split(news.data,news.target)

    # 3）特征工程：文本特征抽取-tfidf
    transfer = TfidfVectorizer()
    x_train = transfer.fit_transform(x_train)
    x_test = transfer.fit_transform(x_test)

    # 4）朴素贝叶斯算法预估器流程
    estimator = MultinomialNB()
    estimator.fit(x_train,y_train)  # 将训练集的特征值和目标值fit，开始训练

    # 5）模型评估
    # 方法1直接比对真实值和预测值
    y_predict = estimator.predict(x_test)  # 对测试集进行预测结果
    print("y_predict:\n", y_predict)
    print("直接比对真实值和预测值：\n", y_test == y_predict)
    # 方法2计算准确率
    score = estimator.score(x_test, y_test)  # score方法会将x_test输入到模型中进行预测，并与y_test进行比较，计算预测正确的样本数量，然后除以总样本数量得到准确率。
    print("准确率：\n", score)


if __name__ == "__main__":
    nb_new()

3.5 决策树

3.5.1 认识决策树

先看一个例子

女儿：多大年纪了？ (年龄)

母亲：26。

女儿：长的帅不帅？ (长相)

母亲：挺帅的。

女儿：收入高不？ (收入情况)

母亲：不算很高，中等情况。

女儿：是公务员不？ (是否公务员)

母亲：是，在税务局上班呢。

女儿：那好，我去见见。

根据对话所画出了决策树如下

决策树是一种基本的分类与回归方法。

决策树模型呈树形结构，在分类问题中，表示基于特征对实例进行分类的过程。

它利用了if-then分支结构，是定义在特征空间与类空间上的条件概率分布。

3.5.2 决策树分类原理

思考：如何高效的进行决策？要看特征的先后顺序。那么如何合适的选择特征的先后呢？这就是决策树要解决的问题了。

信息论基础

1）信息:消除随机不确定性的东西

2）信息的衡量-> 信息量-信息熵

3）信息熵：衡量信息的混乱程度，

熵值越大，信息越混乱
熵值随概率p变化的曲线如下图：

当p=0或p=1时，H(p)=0，随机变量完全没有不确定性

4）信息增益：衡量特征选择对于训练数据集的分类能力

公式 : g(D,A)=H(D)-H(D|A)

其中:H(D|A)是条件熵

计算方式如图：

3.5.3 API

sklearn.tree.DecisionTreeClassifier(criterion='gini',max_depth=None,random_state=None)

决策树分类器
criterion：默认是‘gini’系数，也可选信息增益的熵‘entropy’
max_depth:树的深度大小
random_state:随机数种子

3.5.4 决策树可视化

保存树的结构到dot文件

api:sklearn.tree.export_graphviz() # 该函数能够到处dot格式

tree.export_graphviz(estimator, out_file='iris.tree.dot'，feature_names=[' ', ' '])

第一个参数：预估器对象
第二个参数：指定导出样本格式
第三个参数：特征名字

生成的dot文件不能展示树结构，可利用一个可视化网站来显示

网址：Graphviz Online

3.5.5 决策树-鸢尾花案例

from sklearn.datasets import load_iris  # 小数据集鸢尾花
from sklearn.model_selection import train_test_split  # 训练测试集分割
from sklearn.tree import DecisionTreeClassifier,export_graphviz


def tree():
    """
    用决策树对鸢尾花进行分类
    :return:
    """
    # 1）获取数据
    iris = load_iris()

    # 2)划分数据集
    x_train, x_test, y_train, y_test = train_test_split(iris.data, iris.target,random_state=22)

    # 4）决策树算法预估器流程
    estimator = DecisionTreeClassifier(criterion='entropy')
    estimator.fit(x_train, y_train)  # 将训练集的特征值和目标值fit，开始训练

    # 5）模型评估
    # 方法1直接比对真实值和预测值
    y_predict = estimator.predict(x_test)  # 对测试集进行预测结果
    print("y_predict:\n", y_predict)
    print("直接比对真实值和预测值：\n", y_test == y_predict)

    # 方法2计算准确率
    score = estimator.score(x_test, y_test)  # score方法会将x_test输入到模型中进行预测，并与y_test进行比较，计算预测正确的样本数量，然后除以总样本数量得到准确率。
    print("准确率：\n", score)

    # 可视化决策树
    export_graphviz(estimator, out_file='iris.tree.dot', feature_names=iris.feature_names)


    return None



if __name__ == "__main__":
    tree()

生成的可视化决策树

3.6 集成学习方法之随机森林

3.6.1 集成学习方法

集成学习是通过建立几个模型组合来解决单一预测问题。

工作原理：生成多个分类器/模型，各自独立地学习和做出预测。

这些预测最后结合成组合预测，优于任何一个单分类所做出的预测

（简单说：就是三个臭皮匠，顶一个诸葛亮）

3.6.2 随机森林

随机森林是一个包含多个决策树的分类器，并且输出类别是由个别树输出的类别的众数而定。

（例如，你训练了5棵树，其中4棵树结果是True，1棵树结果是False，则最终结果是True）

随机：两个随机（若不随机，则多棵树的结果一样，无意义）

用N表示训练样本数，用M表示特征数目

①训练集随机 - N个样本中随机有放回的抽样N个

②特征随机 - M个特征中抽取m个特征 (M>>m,可达到降维的效果，每棵树特征不同，特征相关性强的树则脱颖而出)

注意：要采取BootStrap抽样（即随机有放回抽样）

3.6.3 API

sklearn.ensemble.RandomForestClassifier(n_estimators=10,criterion='gini',

max_depth=None.bootstrap=True,random_state=None,min_samples_split=2)

随机森林分类器
n_estimators：integer,optional(default=10) 森林里的树木数量
criterion：string，optional(default='gini') 分割特征的测量方法
max_depth：integer或None，optional(默认=无)
max_features='auto',每个决策树的最大特征数量
“auto”：max_features=sqrt(m_features)
“sqrt”：max_features=sqrt(m_features)
“log2”：max_features=log2(m_features)
None：max_features=m_features
bootstrap：boolean，optional(default=True) 是否在构建树时使用放回抽样
min_samples_split：节点划分最少样本数
min_samples_leaf：叶子节点的最小样本数

3.6.5 总结

在当前所有算法中，具有极好的准确率

能够有效地运行在大数据集上，处理具有高维特征的输入样本，而且不需要降维

能够评估各个特征在分类问题上的重要性

4.回归与聚类算法

4.1 线性回归

4.1.1 线性回归的原理

定义：利用回归方程(函数关系)对一个或多个自变量(特征值)和因变量(目标值)之间关系进行建模的一种分析方式。（即为特征值和目标值建立函数关系）

特点：只有一个自变量时-->单变量回归多个自变量时-->多元回归

公式： $h(w)=w_{1}x_{1}+w_{2}x_{2}+w_{3}x_{3}...+b=w^{T}x+b$ ，

其中w,x可理解为矩阵,

eg：期末成绩=0.7×考试成绩+0.3×平时成绩

线性模型分线性关系和非线性关系，

线性关系

单特征与目标值的关系呈直线关系，两个特征与目标值呈平面关系

非线性关系

分两种情况，①自变量一次 $y=w_{1}x_{1}+w_{2}x_{2}+w_{3}x_{3}...+b$

②参数一次 $y=w_{1}x_{1}+w_{2}x_{2}^{2}+w_{3}x_{3}^{3}...+b$

注意：线性关系一定是线性模型，线性模型不一定是线性关系

4.1.2 线性回归的损失和优化原理

线性回归目标：求模型参数，使模型参数能够预测准确

eg，假如我们知道衡量房价的真实关系式，而线性回归要做的假定特征值（相关特征）和目标值（房价）满足一个关系，通过不断地迭代更新权重和偏置，若求出来的模型参数接近真实关系，则成功了。那么如何衡量真实值和预测值之间的差距，则提出了损失函数。

损失函数：

其中 $y_{_{i}}$ 是第 i 个训练样本的真实值
$h_{_{w}}(x_{i})$ 是第 i 个训练样本特征值组合预测函数

优化算法：①正规方程②梯度下降

①正规方程（天才--直接求解W）

其中X为特征值矩阵，Y为目标值矩阵

缺点:特征过多过复杂时，求解速度太慢且得不到结果

②梯度下降（勤奋努力的普通人--不断试错、改进）

对比：

梯度下降 正规方程
需要选择学习率不需要
需要迭代求解一次运算得出
特征数量较大可以使用（>100K）需要计算方程，时间复杂度o(n3)

4.1.3 线性回归API

sklearn.linear_model.LinearRegression(fit_intercept=True)
通过正规方程优化
fit_intercept：是否计算偏置
LinearRegression.coef_：回归系数
LinearRegression.intercept_：偏置
sklearn.linear_model.SGDRegressor(loss='squared_loss', fit_intercept=True, learning_rate='invscaling', eta0=0.01)
SGDRegressor类实现了随机梯度下降学习，它支持不同的loss函数和正则化惩罚项来拟合线性回归模型
loss：损失类型； loss='squared_loss'：普通最小二乘法
fit_intercept：是否计算偏置
learning_rate：string，optional
学习率填充
‘constant’：eta = eta0
‘optional’：eta = 1.0 / （α * （t+t0）)[default]
'invscaling'：eta = eta0 / pow（t，power_t）
power_t = 0.25：存在父类当中
对于一个常数值的学习率来说，可以使用learning_rate='constant',并使用eta0来指定学习率。
SGDRegressor.coef_：回归系数
SGDRegressor.intercept_：偏置

4.2 欠拟合和过拟合

4.2.1 什么是欠拟合与过拟合

欠拟合：学习到的特征少，训练集和测试集效果都差

过拟合：学习到的特征多，训练集效果好，测试集效果差

4.2.2 原因以及解决办法

欠拟合
原因：学习到数据的特征过少
解决办法：增加数据的特征数量
过拟合
原因：学习到数据的特征过多，存在一些嘈杂特征，模型过于复杂，模型尝试去兼顾各个测试数据点 eg：学习到天鹅是白色的，而天鹅也有黑色的
解决办法：正则化

正则化

L2正则化（更常用）

作用：使其中一些w变小，接近于0，削弱某个特征的影响

Ridge回归

计入L2正则化后的损失函数：原损失函数+ 入*惩罚项

L1正则化

作用：使其中一些w直接为0，删除某个特征的影响

LASSO回归

4.3 线性回归的改进-岭回归

API

sklearn.linear_model.Ridge(alpha=1.0,fit_intercept=True,solver='auto',normalize=False)

具有L2正则化的线性回归
alpha：正则化力度，也叫入
入取值：0-1 1-10
solver：会根据数据自动选择优化方法
sag：若数据集、特征较大，选择该随机梯度下降优化
normalize：数据是否进行标准化
normalize=False：可以在fit之前调用preprocessing.StandardScaler标准化数据
Ridge.coef_：回归权重
Ridge.intercept_：回归偏置

如图，从左到右，正则化力度alpha越小，权重系数weights越大

4.4 分类算法-逻辑回归与二分类

4.4.1 逻辑回归的应用场景

广告是否被点击

是否患病

是否为垃圾邮件

是否为金融诈骗

4.4.2 逻辑回归的原理

1. 输入： $h(w)=w_{1}x_{1}+w_{2}x_{2}+w_{3}x_{3}...+b=w^{T}x+b$

（逻辑回归的输入是线性回归的输出）

2. 激活函数

sigmoid函数
分析
回归的结果输入到sigmoid函数中

输出结果：[0,1]区间中的一个概率值，默认阈值为0.5

3. 损失函数

逻辑回归的损失称为对数似然函数，公式

即

举个例子

优化：使用梯度下降优化算法，减少损失函数的值，更新权重参数，提升原本属于1类别的概率

4.4.3 逻辑回归API

sklearn.linear_model.LogisticRegression(solver='liblinear',penalty='12',C=1.0)

solver：优化求解方式参数值sag：随即平均梯度下降
penalty：正则化的种类
C：正则化力度

4.4.4 癌症预测案例

import pandas as pd
import numpy as np
from sklearn.model_selection import train_test_split
from sklearn.preprocessing import StandardScaler
from sklearn.linear_model import LogisticRegression

def cancer_demo():
    """
    用逻辑回归进行乳腺癌预测
    :return:
    """

    # 1）获取数据
    column_name = ['Sample code number', 'Clump Thickness', 'Uniformity of Cell Size', 'Uniformity of Cell Shape',
                   'Marginal Adhesion', 'Single Epithelial Cell Size', 'Bare Nuclei', 'Bland Chromatin',
                   'Normal Nucleoli', 'Mitoses', 'Class']
    data = pd.read_csv(
        "https://archive.ics.uci.edu/ml/machine-learning-databases/breast-cancer-wisconsin/breast-cancer-wisconsin.data",
        names=column_name)

    # 2）处理数据 -处理缺失值
    data = data.replace(to_replace="?", value=np.nan)  # 将"?"替换成nan
    # 将缺失样本删除,inplace指在原数据上进行操作
    data.dropna(inplace=True)   # 等价于data = data.dropna()

    # 3）数据集划分
    # 先筛选特征值和目标值
    x = data.iloc[:, 1:-1]  # data里面所有的行，第一列到倒数第二列
    y = data["Class"]  # data里面class那一列

    x_train, x_test, y_train, y_test = train_test_split(x, y, random_state=22)

    # 4）特征工程：标准化
    transfer = StandardScaler()
    x_train = transfer.fit_transform(x_train)
    x_test = transfer.transform(x_test)

    # 5）逻辑回归预估器
    estimator = LogisticRegression()
    estimator.fit(x_train, y_train)

    # 得出模型
    print("逻辑回归-权重系数:\n", estimator.coef_)
    print("逻辑回归-偏置为：\n", estimator.intercept_)

    # 6）模型评估
    # 方法1直接比对真实值和预测值
    y_predict = estimator.predict(x_test)  # 对测试集进行预测结果
    print("y_predict:\n", y_predict)
    print("直接比对真实值和预测值：\n", y_test == y_predict)

    # 方法2计算准确率
    score = estimator.score(x_test, y_test)  # score方法会将x_test输入到模型中进行预测，并与y_test进行比较，计算预测正确的样本数量，然后除以总样本数量得到准确率。
    print("准确率：\n", score)


if __name__ == "__main__":
    cancer_demo()

4.4.5 分类的评估方法

1. 精确率与召回率

思考：以上的模型评估方法，能做到的是癌症预测率，但是我们更关注的是一个真的得了癌症，是否能检测出来，所以引入了以下的评估方法。

①混淆矩阵

② 认识精确率与召回率

精确率：预测结果为正例样本中真实为正例的比例

（eg 预测患癌症的人群中，真正患癌的比例）

召回率：真实为正例的样本中预测结果为正例的比例

（eg 真正患癌症的人群中，正确检测出其患癌症的比例）

F1-score 反映了模型的稳健性

③ API

sklearn.metrics.classification_report(y_true, y_pred, labels=[], target_names=None)

y_true：真实目标值
y_pred：估计器预测目标值
labels：指定类别对应的数字
target_names：目标类别名称
return：每个类别精确率与召回率

2 ROC曲线与AUC指标

思考：为什么又引入了此评估指标？

举个例子，假如有100个人，其中有99人患癌，1人不患癌。假设全部预测为正例（默认患癌为正例），

则准确率:99%；精确率:99%；召回率:100%；F1-score:(2*99%*100%)/199%=99.497%

从此例看出，以上几个指标均不能解决这种样本分布不均匀的问题，所以引入新指标。

① 认识TPR与FPR

TPR=TP/(TP+FN) 所有真实类别为1的样本中，预测类别为1的比例（召回率）
FPR=FP/(FP+TN) 所有真实类别为0的样本中，预测类别为1的比例

②ROC曲线

横坐标：FPRate，纵坐标：TPRate

当二者相等（图中红色虚线），意思是分类器预测为1的概率是相等的，此时AUC=0.5

③AUC指标

AUC的概率意义是随机取一对正负样本，正样本>负样本的概率
AUC的取值[0.5,1]，越接近1越好
AUC=1时是完美分类器，采用这个预测模型时，不管设定什么阈值都能得出完美预测

④API

sklearn.metrics.roc_auc_score(y_true,y_score)

计算ROC曲线面积，即AUC值
y_true：每个样本的真实类别，必须为0（反例）、1（正例）标记
y_score：预测得分

⑤总结

回到一开始局的例子，TPR=100% FPR=1/1=100% -->AUC=0.5（最差）

AUC只能用来评估二分类

AUC适合评价样本不平衡中的分类器性能

4.5 模型保存和加载

API

import joblib

保存：joblib.dump(estimator,"test.pkl")

加载：estimator = joblib.load('test.pkl')

4.6 无监督学习- K-means算法

4.6.1 什么是无监督学习

简单说，就是没有目标值

比如，我们想将以下一群人分类，但我们并不知道有哪些类别，解决这类问题就叫做无监督学习

4.6.2 无监督学习包含算法

聚类 - K-means

降维 - PCA

4.6.3 K-means原理

1.K-means的聚类效果图如下

2.K-means聚类步骤

①随机设置K个特征空间内的点作为初始的聚类中心

②对于其他每个点计算到K个中心的距离，未知的点选择最近的一个聚类中心点作为标记类别

③接着对着标记的聚类中心之后，重新计算每个聚类的新中心点(平均值)
④如果计算出的新中心点与原中心点一样，则结束，否则进行第②步骤

4.6.4 K-meansAPI

sklearn.cluster.KMeans(n_cluster=8, init='k-means++')

n_cluster：开始的聚类中心数量，有几簇
init：初始化方法，默认为‘k-means++'
label_：默认标记的类型，可以和真实值比较

4.6.5 K-means对Instacart Market用户聚类

4.6.6 K-means性能评估指标

1 轮廓系数

其中 $b_{i}$ 是某样本到其它族群的所有样本的最小距离， $a_{i}$ 是某样本到本族群所有样本的平均距离

若 $b_{i}$ >> $a_{i}$ , SCj = 1 好

若 $b_{i}$ << $a_{i}$ , SCj = -1 差

轮廓系数取值范围[-1,1]

2 API

sklearn.metrics.silhouette_score(X,labels)

计算所有样本的平均轮廓系数
X：特征值
labels：被聚类标记的目标值

3 用户聚类结果评估
silhouette_score(data,predict)

4.6.7 K-means总结

特点：采用迭代式算法，直观易懂

缺点：容易收敛到局部最优解，通过多次聚类避免这种问题

注意：聚类一般在分类之前做

边洛洛

关注

1
点赞
踩
0

收藏

觉得还不错? 一键收藏
0
评论
机器学习-小白简单入门

特征工程：使用专业背景知识和技巧处理数据，使得特征能在机器学习算法上发挥更好的作用的过程。sklearn：对于特征的处理提供接口pandas：一个读取数据、处理数据的工具特征工程内容：①特征抽取②特征预处理③特征降维无量纲化：归一化、标准化为什么进行归一化/标准化？某特征比其他特征数量级大得多，而几个特征同等重要，容易使得算法无法学习到这些数量级小的特征。在当前所有算法中，具有极好的准确率能够有效地运行在大数据集上，处理具有高维特征的输入样本，而且不需要降维。
复制链接

扫一扫

专栏目录

梯度下降	正规方程
需要选择学习率	不需要
需要迭代求解	一次运算得出
特征数量较大可以使用（>100K）	需要计算方程，时间复杂度o(n3)

机器学习-小白简单入门

1.机器学习概述

1.1 什么是机器学习？

1.2 机器学习开发流程

1.3 机器学习分类

2.特征工程

2.1 数据集

2.1.1 可用的数据集

2.1.2 sklearn数据集

2.1.3 数据集的划分

2.2 特征工程介绍

2.3 特征抽取

2.3.1 特征提取

2.3.2 字典特征提取

2.3.3 文本特征提取

2.4 特征预处理

2.4.1 特征预处理介绍

2.4.2 归一化

2.4.3 标准化

2.5 特征降维

2.6 主成分分析（PCA）

3.分类算法

3.1 sklearn转换器和估计器

3.2 K-近邻算法（knn）

3.2.1 认识knn算法

3.2.2 knn-鸢尾花案例

3.3 模型选择与调优

3.3.1 认识交叉验证

3.3.2 模型选择与调优API

3.3.3 knn调优-鸢尾花案例

3.4 朴素贝叶斯算法

3.4.1 认识朴素贝叶斯

3.4.2 朴素贝叶斯-新闻分类案例

3.5 决策树

3.5.1 认识决策树

3.5.2 决策树分类原理

3.5.3 API

3.5.4 决策树可视化

3.5.5 决策树-鸢尾花案例

3.6 集成学习方法之随机森林

3.6.1 集成学习方法

3.6.2 随机森林

3.6.3 API

3.6.5 总结

4.回归与聚类算法

4.1 线性回归

4.1.1 线性回归的原理

4.1.2 线性回归的损失和优化原理

4.1.3 线性回归API

4.2 欠拟合和过拟合

4.2.1 什么是欠拟合与过拟合

4.2.2 原因以及解决办法

4.3 线性回归的改进-岭回归

4.4 分类算法-逻辑回归与二分类

4.4.1 逻辑回归的应用场景

4.4.2 逻辑回归的原理

4.4.3 逻辑回归API

4.4.4 癌症预测案例

4.4.5 分类的评估方法

4.5 模型保存和加载

4.6 无监督学习- K-means算法

4.6.1 什么是无监督学习

4.6.2 无监督学习包含算法

4.6.3 K-means原理

4.6.4 K-meansAPI

4.6.5 K-means对Instacart Market用户聚类

4.6.6 K-means性能评估指标

4.6.7 K-means总结

“相关推荐”对你有帮助么？