机器学习

最新推荐文章于 2023-07-14 17:37:18 发布

胖头鱼00

最新推荐文章于 2023-07-14 17:37:18 发布

阅读量285

点赞数

本文链接：https://blog.csdn.net/b806071099/article/details/93460762

版权

1.机器学习算法分类

1.1监督学习（预测）

目标值：类别-分类问题
相关算法：k-近邻算法，贝叶斯分类，决策树与随机森林，逻辑回归
目标值：连续性数据-回归问题
相关算法：线性回归，岭回归

1.2无监督学习

算法：聚类 k-means

1.3机器学习流程

获取数据
数据处理
特征工程
机器学习算法训练-模型
模型评估
应用

2.数据集

2.1 可用数据集

2.2 sklearn数据集
sklearn.datasets

load_* () 小规模数据集
sklearn.datasets.load_iris() 鸢尾花数据集
fetch_*(data_home=None) 大规模数据集
sklearn.datasets.fetch_20newsgroups(data_home=None)

from sklearn.datasets import load_iris
a = load_iris()
print(type(a),a)

2.3数据集的划分
测试集：20%-30%
训练集

from sklearn.datasets import load_iris
from sklearn.model_selection import train_test_split

iris = load_iris()
# print(type(iris),iris)
x_train,x_test,y_train,y_test = train_test_split(iris.data,iris.target,test_size=0.2, random_state=22)
# 训练集的特征值x_train，测试集的特征值x_test，训练集的目标值y_train，测试集目标值y_test
print(x_train,x_train.shape)

2.4特征值处理

数据是字典的时候，用one_hot转化，from sklearn.feature_extraction import DictVectorizer
数据是文本的时候，结巴分词，from sklearn.feature_extraction.text import TfidfTransformer
标准化的转换

3.具体算法代码

3.1 knn算法

根据你的邻居给你分类
k是个参数，可以使用网格搜索得到最佳值。

# knn算法例子
from sklearn.datasets import load_iris
from sklearn.model_selection import train_test_split
from sklearn.preprocessing import StandardScaler
from sklearn.model_selection import GridSearchCV
from sklearn.neighbors import KNeighborsClassifier

'''
1.获取数据
2.划分数据集
3.特征工程
4.预估器
5.模型评估
'''

def knn():
    iris = load_iris()
	# 划分训练集和测试集，random_state是随机数种子，设置固定值，获取固定结果。
    x_train,x_test,y_train,y_test = train_test_split(iris.data, iris.target,random_state=20)
	
    transfer = StandardScaler()
    transfer.fit_transform(x_train)
    transfer.fit(x_test)

    estimate = KNeighborsClassifier()
    estimate = GridSearchCV(estimate,param_grid={'n_neighbors':[1,3,5,7,9]},cv=3)
    estimate.fit(x_train,y_train)

    score = estimate.score(x_test,y_test)
    print('score is:',score)

    print(estimate.best_estimator_)
    print(estimate.best_score_)
if __name__ == '__main__':
    knn()

3.2朴素贝叶斯
朴素意思是各特征之间相互独立。
贝叶斯公式是概率公式，按照乘法法则:

P(A∩B)=P(A)*P(B|A)=P(B)*P(A|B)

如上公式也可变形为:

P(B|A)=P(A|B)*P(B)/P(A)

# 朴素贝叶斯算法例子
from sklearn.datasets import fetch_20newsgroups
from sklearn.model_selection import train_test_split
from sklearn.feature_extraction.text import TfidfTransformer
from sklearn.naive_bayes import MultinomialNB

'''
1.获取数据
2.划分数据集
3.特征工程
4.预估器
5.模型评估
'''

def nb_news():
    news = fetch_20newsgroups()

    x_train,x_test,y_train,y_test = train_test_split(news.data, news.target,random_state=20)

    transfer = TfidfTransformer()
    transfer.fit_transform(x_train)
    transfer.fit(x_test)

    estimate = MultinomialNB()
    estimate.fit(x_train,y_train)

    score = estimate.score(x_test,y_test)
    print('score is:',score)

if __name__ == '__main__':
    nb_news()

3.3 决策树
找到高效的决策顺序。
决策树的划分依据是信息增益(entroy)。
树的可视化网址：http://webgraphviz.com/
设置树的深度，防止过度拟合。


# 决策树算法例子
from sklearn.datasets import load_iris
from sklearn.model_selection import train_test_split
from sklearn.tree import DecisionTreeClassifier,export_graphviz

'''
1.获取数据
2.划分数据集
3.预估器
4.模型评估
5.可视化
'''

def tree_iris():
    iris = load_iris()

    x_train,x_test,y_train,y_test = train_test_split(iris.data, iris.target,random_state=20)


    estimate = DecisionTreeClassifier()
    estimate.fit(x_train,y_train)

    score = estimate.score(x_test,y_test)
    export_graphviz(estimate, out_file='1.dot',feature_names=iris.feature_names)
    print('score is:',score)

if __name__ == '__main__':
    tree_iris()

3.4 随机森林

森林：包含多个决策树的分类器
随机：训练集随机（bootstrap，随机有放回抽取）
随机：特征值随机（从M个特征中选择m个，切M>>m）

# 随机森林算法例子
from sklearn.datasets import load_iris
from sklearn.model_selection import train_test_split,GridSearchCV
from sklearn.preprocessing import StandardScaler
from sklearn.ensemble import RandomForestClassifier

'''
1.获取数据
2.划分数据集
3.特征处理
4.预估器
5.网格搜索
6.模型评估
'''


def Forest_iris():
    iris = load_iris()

    x_train,x_test,y_train,y_test = train_test_split(iris.data,iris.target)

    transfer = StandardScaler()
    transfer.fit_transform(x_train)
    transfer.transform(x_test)

    estimate = RandomForestClassifier()
    dict_1 = {'n_estimators':[120,300,500,800],'max_depth':[5,8,15,25]}
    estimate = GridSearchCV(estimate,param_grid=dict_1,cv=3)
    estimate.fit(x_train,y_train)

    score = estimate.score(x_test,y_test)
    print(score)
    print(estimate.best_score_)
    print(estimate.best_params_)

if __name__ == '__main__':
    Forest_iris()

3.5 回归问题
目标值是连续型的数据

线性回归：找到函数关系（特征值和目标值）
3.5.1 线性回归的损失和优化：

目标：求模型参数
过程：假设模型参数，计算损失函数（最小二乘法）
优化损失：1.正规方程（直接求出参数，用的比较少），原理是求矩阵的导数等于0.
优化损失：2.梯度下降（试错，改进，用的多）

# 线性回归(正规方程和梯度下降)算法例子
from sklearn.datasets import load_boston
from sklearn.model_selection import train_test_split
from sklearn.preprocessing import StandardScaler
from sklearn.linear_model import LinearRegression,SGDRegressor
from sklearn.metrics import mean_squared_error

'''
1.获取数据
2.划分数据集
3.特征处理
4.预估器
5.获得参数和偏置
6.模型评估
'''

def linear1():
    '''
    正规方程预测波士顿房价
    :return:
    '''
    iris = load_boston()

    x_train,x_test,y_train,y_test = train_test_split(iris.data, iris.target,random_state=10)

    transfer = StandardScaler()
    x_train = transfer.fit_transform(x_train)
    x_test = transfer.transform(x_test)

    estimate = LinearRegression()
    estimate.fit(x_train,y_train)

    print(estimate.coef_)
    print(estimate.intercept_)
    y_predict = estimate.predict(x_test)
    error = mean_squared_error(y_test, y_predict)
    print(error)
    
def linear2():
    '''
    梯度下降预测波士顿房价
    :return:
    '''
    iris = load_boston()

    x_train,x_test,y_train,y_test = train_test_split(iris.data, iris.target,random_state=10)

    transfer = StandardScaler()
    x_train = transfer.fit_transform(x_train)
    x_test = transfer.transform(x_test)

    estimate = SGDRegressor()
    estimate.fit(x_train,y_train)

    print(estimate.coef_)
    print(estimate.intercept_)
    y_predict = estimate.predict(x_test)
    error = mean_squared_error(y_test, y_predict)
    print(error)
    
if __name__ == '__main__':
    linear1()
    print('*'*30)
    linear2()

3.6 欠拟合和过拟合

欠拟合：学习到数据的特征过少
解决：增加数据的特征
过拟合：特征多，模型复杂
解决：正则化（L1和L2，L2更常用）
L1正则化表达式：损失函数+lambda*惩罚项（参数的绝对值之和）
L2正则化表达式：损失函数+lambda*惩罚项（参数平方的和）
正则力度（lambda）越大，惩罚项越小，权重系数越小

3.7 岭回归
L2正则化的使用
API（自己调参，优化损失。)

# 线性回归(岭回归)算法例子
from sklearn.datasets import load_boston
from sklearn.model_selection import train_test_split
from sklearn.preprocessing import StandardScaler
from sklearn.linear_model import LinearRegression,SGDRegressor,Ridge
from sklearn.metrics import mean_squared_error

'''
1.获取数据
2.划分数据集
3.特征处理
4.预估器
5.获得参数和偏置
6.模型评估
'''

def linear3():
    '''
    岭回归预测波士顿房价
    :return:
    '''
    iris = load_boston()

    x_train,x_test,y_train,y_test = train_test_split(iris.data, iris.target,random_state=10)

    transfer = StandardScaler()
    x_train = transfer.fit_transform(x_train)
    x_test = transfer.transform(x_test)

    estimate = Ridge()
    estimate.fit(x_train,y_train)

    print(estimate.coef_)
    print(estimate.intercept_)
    y_predict = estimate.predict(x_test)
    error = mean_squared_error(y_test, y_predict)
    print(error)


if __name__ == '__main__':
    linear3()

3.8 分类算法：逻辑回归（二分类问题）

线性回归的输出就是岭回归的输入。
损失函数：对数似然损失（分段函数合成一个函数）。
优化损失：梯度降低
激活函数：sigmoid函数 [0-1]

data.isnull().any()   # 查看是否存在缺失值
x = data.iloc[:,1:-1] 	# 筛选特征值
y= data['列名称'] 		# 筛选目标值

# 逻辑回归算法例子
from sklearn.datasets import load_iris
from sklearn.model_selection import train_test_split
from sklearn.preprocessing import StandardScaler
from sklearn.linear_model import LogisticRegression
from sklearn.metrics import mean_squared_error

'''
1.获取数据
2.划分数据集
3.特征处理
4.预估器
5.获得参数和偏置
6.模型评估
'''

def linear4():
    '''
    逻辑回归：二分类
    :return:
    '''
    iris = load_iris()

    x_train,x_test,y_train,y_test = train_test_split(iris.data, iris.target,random_state=10)

    transfer = StandardScaler()
    x_train = transfer.fit_transform(x_train)
    x_test = transfer.transform(x_test)

    estimate = LogisticRegression()
    estimate.fit(x_train,y_train)

    print(estimate.coef_)# 回归系数
    print(estimate.intercept_) # 偏置
    print(estimate.score(x_test,y_test))


if __name__ == '__main__':
    linear4()

3.8.1. 二分类的评估方法

混淆矩阵：

 1.真实为真，预测为真，真正例TP。
 2.真实为真，预测为假，伪反例FN。
 3.真实为假，预测为真，伪正例FP。
 4.真实为假，预测为假，真反例TN。

精确率与召回率

 精确率：预测为正例中，真实为正例的比例。
 召回率（常用，以恶性为正例）：真实为正例中，预测为正例的比例。

F1-score反映了模型的稳健性。
F1-score公式（2精确率召回率/精确率+召回率）

ROC曲线和AUC指标（结果范围 [0.5-1], 0.5为随机模型的结果）

 TPR（纵轴）:所有真实为1的样本中，预测为1的比例
 FPR（横轴）:所有真实为0的样本中，预测为1的比例
 AUC指标可以用于样本不均衡的情况。

3.9 模型的保存和加载

from sklearn.datasets import load_iris,load_boston
from sklearn.model_selection import train_test_split
from sklearn.preprocessing import StandardScaler
from sklearn.linear_model import LinearRegression,SGDRegressor,Ridge,LogisticRegression
from sklearn.metrics import mean_squared_error,roc_auc_score
from sklearn.externals import joblib

def linear3():
    '''
    逻辑回归预测波士顿房价
    :return:
    '''
    iris = load_boston()
    x_train, x_test, y_train, y_test = train_test_split(iris.data, iris.target, random_state=10)

    transfer = StandardScaler()
    x_train = transfer.fit_transform(x_train)
    x_test = transfer.transform(x_test)

    # estimate = Ridge()
    # estimate.fit(x_train, y_train)
    # # 保存模型
    # joblib.dump(estimate,'my_modle.pkl')
    # 加载模型
    estimate = joblib.load('my_modle.pkl')
    print(estimate.coef_)  # 回归系数
    print(estimate.intercept_)  # 偏置
    y_pre = estimate.predict(x_test)
    error = mean_squared_error(y_test, y_pre)
    print(error)
    if __name__ == '__main__':
		linear3()

4.无监督学习和K-means算法

4.1无监督含义和包含的算法

含义：没有目标值
算法：K-means和PCA降维

4.2 K-means聚类

先假设K个中心点。
计算每个点到中心点的距离，根据最小距离分类。
然后求出新中心点（平均数），重复步骤2和3。
新中心点和原来的中心点一致，停止运算。

4.2.1 模型评估

轮廓系数（高聚合，低耦合[-1,1]）

4.2.2 应用
用在分类之前，做个分类，以后使用


from sklearn.datasets import load_iris
from sklearn.preprocessing import StandardScaler
from sklearn.cluster import KMeans
from sklearn.metrics import silhouette_score

'''
1.获取数据
2.特征处理
3.预估器
4.得到结果
5.模型评估-轮廓系数
'''

def KMeans_boston():
    boston = load_iris()

    transfer = StandardScaler()
    boston = transfer.fit_transform(boston.data)

    estimate = KMeans(n_clusters=3)
    estimate.fit(boston)

    y_predict = estimate.predict(boston)
    print(y_predict)

    score = silhouette_score(boston.data,y_predict)
    print(score)
if __name__ == '__main__':
    KMeans_boston()

4.2 Xgboost算法（自适应增强）

打分，属于回归算法

迭代多个弱分类器，优化损失。
正则化解决过拟合。

调节的参数：

学习速率：一般小于0.1。
树的深度
弱分类器的个数

4.2 SVM算法，支持向量机（二分类）

求得边界的最大值
核函数（把数据转化到高维）


原始的GBDT算法基于经验损失函数的负梯度来构造新的决策树，只是在决策树构建完成后再进行剪枝。而XGBoost在决策树构建阶段就加入了正则项，

除了算法上的不同，XGBoost还在工程实现上做了大量的优化。总的来说，两者之间的区别和联系可以总结成以下几个方面。
(1)GBDT是机器学习算法，XGBoost是该算法的工程实现。
(2)在使用CART作为基分类器时，XGBoost显示地加入了正则项来控制模型的复杂度，有利于防止过拟合，从而提高模型的泛化能力。
(3)GBDT在模型训练时只使用了代价函数的一阶导数信息，XGBoost对代价函数进行二阶泰勒展开，可以同时使用一阶和二阶导数
(4)传统的GBDT采用CART作为基分类器，XGBoost支持多种类型的基分类器，比如线性分类器
(5)传统的GBDT在每轮迭代时使用全部数据，XGBoost则采用了与随机森林相似的策略，支持对数据进行采样。
(6)传统的GBDT没有设计对缺失值处理，XGBoost能够自动学习出缺失值的处理策略。

选取比较重要的变量：向前逐步法（statsmodles）

胖头鱼00

关注

0
点赞
踩
2

收藏

觉得还不错? 一键收藏
0
评论
机器学习

1.机器学习算法分类1.1监督学习（预测）目标值：类别-分类问题相关算法：k-近邻算法，贝叶斯分类，决策树与随机森林，逻辑回归目标值：连续性数据-回归问题相关算法：线性回归，岭回归1.2无监督学习算法：聚类 k-means1.3机器学习流程获取数据数据处理特征工程机器学习算法训练-模型模型评估应用2.数据集2.1 可用数据集sklearn. 点击跳转...
复制链接

扫一扫