此文章只是简单的总结每个算法的API使用，和简单的理解，可作为收藏使用，便于以后的查找；
如果想要看具体算法原理等请自行查找。
目录
一、K近邻(KNN) API
二、朴素贝叶斯 API
三、决策树 API
四、随机森林 API
五、线性回归(正规方程，梯度下降优化方法）API
…
…
…
一、K近邻（KNN）API：
-
分类算法
-
优点：简单，易于理解，易于实现；
-
缺点：懒惰算法，测试样本计算量大，必须指定K值
-
使用场景：小数据场景
0.用到的库和方法
from sklearn.datasets import load_iris #鸢尾花数据 from sklearn.model_selection import train_test_split #划分数据集方法 from sklearn.neighbors import KNeighborsClassifier #KNN from sklearn.preprocessing import StandardScaler #特征工程-标准化 from sklearn.metrics import classification_report #分类型性能检测 from sklearn.model_selection import GridSearchCV #网格搜索优化1.获取数据
iris = load_iris()2.划分数据集，x_train,x_test,y_trin,y_test 注意顺序
x_train,x_test,y_train,y_test = train_test_split(iris.data,iris.target)3特征工程：标准化
ss = StandardScaler() #分别对训练数据和测试数据标准化 x_train = ss.fit_transform(x_train) x_test = ss.fit_transform(x_test)4.KNN算法模型
KNN = KNeighborsClassifier(n_neighbors=15) #k值取15 以离得最近的15个取值5加入网格优化和交叉验证
K = np.arange(10,25) # 0-24 dicts = {"n_neighbors":K} KNN = GridSearchCV(KNN,param_grid=dicts,cv=10) #KNN:KNN模型，param_grid：取值，cv交叉验证6.训练数据
KNN.fit(x_train,y_train)7.预测数据
y_ = KNN.predict(x_test) y_array([1, 1, 0, 0, 2, 2, 0, 1, 0, 0, 0, 1, 0, 0, 1, 1, 1, 2, 0, 0, 1, 1,
1, 0, 2, 1, 2, 1, 1, 2, 1, 0, 2, 2, 2, 2, 1, 2])
8查看准确率KNN.score(x_test,y_test)0.9736842105263158
9最佳K参数print(KNN.best_params_) #最佳参数 print(KNN.best_score_) #最佳结果 #print(KNN.estimator) #最佳估计器 #print(KNN.cv_results_) #交叉验证结果{‘n_neighbors’: 10}
0.9553571428571429
10.性能检测 precision准确率，recall召回率/查正率，f1-score精确率和召回率的调和平均数，support数量print(classification_report(y_true=y_test,y_pred=y_)) precision recall f1-score support 0 1.00 1.00 1.00 14 1 1.00 0.92 0.96 13 2 0.92 1.00 0.96 11 avg / total 0.98 0.97 0.97 38
二、朴素贝叶斯API：
-
分类算法，概率算法
-
朴素贝叶斯:特征与特征之间相互独立的贝叶斯公式
-
优点:对于缺失数据不敏感，算法简答，常用于文本分类
-
缺点:文本属性之间的关联性时效果不明显
-
应用场景:文本分类（单词概率）,情感分析
0.用到的库和方法from sklearn.datasets import fetch_20newsgroups #20新闻数据集 from sklearn.model_selection import train_test_split #划分数据集方法 from sklearn.feature_extraction.text import TfidfVectorizer #特征工程-文本抽取 from sklearn.naive_bayes import MultinomialNB #朴素贝叶斯算法 from sklearn.metrics import classification_report #性能检测1.获取数据
news = fetch_20newsgroups(subset="all") #subset='train'默认获取的是训练集，这里需要获取全部数据"all"2.划分数据
x_train,x_test,y_train,y_test = train_test_split(news.data,news.target)3.特征工程-文本特征抽取
TV = TfidfVectorizer() #抽取训练数据和测试数据 注意抽取的函数不一样 x_train = TV.fit_transform(x_train) x_test = TV.transform(x_test)4.贝叶斯算法模型
MNB = MultinomialNB() #参数：MultinomialNB(alpha=1.0, fit_prior=True, class_prior=None)5.训练数据
MNB.fit(x_train,y_train)MultinomialNB(alpha=1.0, class_prior=None, fit_prior=True)
6.测试数据y_ = MNB.predict(x_test)7.模型准确率
MNB.score(x_test,y_test)0.8380730050933786
8.性能检测print(classification_report(y_true=y_test,y_pred=y_)) precision recall f1-score support 0 0.88 0.77 0.82 208 1 0.84 0.71 0.77 238 2 0.82 0.86 0.84 234 3 0.75 0.81 0.78 250 4 0.85 0.86 0.86 219 5 0.94 0.77 0.85 262 6 0.94 0.64 0.76 255 7 0.82 0.94 0.88 225 8 0.97 0.96 0.96 251 9 0.97 0.96 0.97 257 10 0.94 0.97 0.95 262 11 0.68 0.99 0.80 236 12 0.89 0.75 0.82 240 13 0.96 0.91 0.93 245 14 0.90 0.94 0.92 254 15 0.60 0.97 0.74 264 16 0.71 0.97 0.82 228 17 0.88 0.99 0.93 225 18 0.98 0.51 0.68 208 19 1.00 0.17 0.28 151 avg / total 0.86 0.84 0.83 4712
三、决策树 API：
转：https://blog.csdn.net/weixin_44432311/article/details/89399854
-
这里以分类树来演示；
-
决策树可以可视化；
-
优点：既能分类，又能回归；
-
缺点：容易过拟合；
-
改进：减枝cart算法，随机森林；
-
使用场景：企业重要决策，在决策过程，选择特征；
-
from sklearn.tree import DecisionTreeClassifier #分类树API
-
from sklearn.tree import DecisionTreeRegressor #回归树API
-
criterion：默认"gini"也可以统一选择信息增益"entropy"
-
max_depth:树的宽度大小
-
random_state：随机种子
0.用到的库和方法from sklearn.datasets import load_iris #鸢尾花数据 from sklearn.model_selection import train_test_split #划分数据集方法 from sklearn.metrics import classification_report #性能检测 from sklearn.preprocessing import StandardScaler #特征工程-标准化 from sklearn.tree import DecisionTreeClassifier #分类树API from sklearn.tree import export_graphviz #决策树可视化1.获取数据
iris = load_iris()2.划分数据
x_train,x_test,y_train,y_test = train_test_split(iris.data,iris.target,random_state=22)3特征工程：标准化
ss = StandardScaler() #分别对训练数据和测试数据标准化 x_train = ss.fit_transform(x_train) x_test = ss.fit_transform(x_test)4.模型导入
tree = DecisionTreeClassifier() # 参数：DecisionTreeClassifier(criterion='gini', splitter='best', # max_depth=None, min_samples_split=2, # min_samples_leaf=1, min_weight_fraction_leaf=0.0, # max_features=None, random_state=None, max_leaf_nodes=None）5.训练数据
tree.fit(x_train,y_train)DecisionTreeClassifier(class_weight=None, criterion=‘gini’, max_depth=None,
max_features=None, max_leaf_nodes=None,
min_impurity_decrease=0.0, min_impurity_split=None,
min_samples_leaf=1, min_samples_split=2,
min_weight_fraction_leaf=0.0, presort=False, random_state=None,
splitter=‘best’)
6.测试数据y_ = tree.predict(x_test)7.模型准确率
tree.score(x_test,y_test)0.9210526315789473
8.性能检测print(classification_report(y_true=y_test,y_pred=y_)) precision recall f1-score support 0 1.00 1.00 1.00 11 1 0.81 1.00 0.90 13 2 1.00 0.79 0.88 14 avg / total 0.94 0.92 0.92 389.可视化决策树
export_graphviz(tree,out_file="iris_tree.dot") #在本地生成一个文件打开，内容如下： digraph Tree { node [shape=box] ; 0 [label="X[2] <= -0.706\ngini = 0.666\nsamples = 112\nvalue = [39, 37, 36]"] ; 1 [label="gini = 0.0\nsamples = 39\nvalue = [39, 0, 0]"] ; 0 -> 1 [labeldistance=2.5, labelangle=45, headlabel="True"] ; 2 [label="X[3] <= 0.74\ngini = 0.5\nsamples = 73\nvalue = [0, 37, 36]"] ; 0 -> 2 [labeldistance=2.5, labelangle=-45, headlabel="False"] ; 3 [label="X[2] <= 0.748\ngini = 0.142\nsamples = 39\nvalue = [0, 36, 3]"] ; 2 -> 3 ; 4 [label="X[0] <= -1.026\ngini = 0.054\nsamples = 36\nvalue = [0, 35, 1]"] ; 3 -> 4 ; 5 [label="X[2] <= 0.105\ngini = 0.5\nsamples = 2\nvalue = [0, 1, 1]"] ; 4 -> 5 ; 6 [label="gini = 0.0\nsamples = 1\nvalue = [0, 1, 0]"] ; 5 -> 6 ; 7 [label="gini = 0.0\nsamples = 1\nvalue = [0, 0, 1]"] ; 5 -> 7 ; 8 [label="gini = 0.0\nsamples = 34\nvalue = [0, 34, 0]"] ; 4 -> 8 ; 9 [label="X[3] <= 0.481\ngini = 0.444\nsamples = 3\nvalue = [0, 1, 2]"] ; 3 -> 9 ; 10 [label="gini = 0.0\nsamples = 2\nvalue = [0, 0, 2]"] ; 9 -> 10 ; 11 [label="gini = 0.0\nsamples = 1\nvalue = [0, 1, 0]"] ; 9 -> 11 ; 12 [label="X[2] <= 0.636\ngini = 0.057\nsamples = 34\nvalue = [0, 1, 33]"] ; 2 -> 12 ; 13 [label="gini = 0.0\nsamples = 1\nvalue = [0, 1, 0]"] ; 12 -> 13 ; 14 [label="gini = 0.0\nsamples = 33\nvalue = [0, 0, 33]"] ; 12 -> 14 ; }
四、随机森林 API：
- 集成学习算法;
- 是包含多个决策树的分类器;
- 特点：随机(训练集随机，特征随机),森林==>多个决策树,少数服从多数;
- 采用bootstrap随机有放回的抽样训练集;
- 下面数据采用kaggle下载，经过简单数据清洗的泰坦尼克号生还预测数据
- 优点:极好的准确率，适合大数据，处理高位特征，不需要降维
- 缺点:没几个算法比它好用了
- n_estimators:integer,optional(default=10) 森林里的树木数量
- max_features=“auto”，每个决策树的最大特征数量
- max_depth：每棵树的深度
- min_samples_split:节点划分最少样本数
- min_samples_leaf:叶子节点的最小样本数
0.需要的库和方法
from sklearn.ensemble import RandomForestClassifier #随机森林算法
import pandas as pd #利用pandas导入本地数据
from sklearn.model_selection import GridSearchCV #网格搜索优化方法
1.加载数据
train = pd.read_csv("../Project/Titanic/train")
test = pd.read_csv("../Project/Titanic/test")
gender = pd.read_csv("../Datas/Titanic/gender_submission.csv")
2.分离数据
x_train = train[["Pclass","Sex","Age","SibSp","Parch","Fare"]]
y_train = train["Survived"]
x_test = test
y_test = gender
3.建立随机森林算法模型
R_tree = RandomForestClassifier()
# 参数：RandomForestClassifier(n_estimators=10, criterion='gini',
# max_depth=None, min_samples_split=2, min_samples_leaf=1,
# min_weight_fraction_leaf=0.0, max_features='auto', max_leaf_nodes=None,
# min_impurity_decrease=0.0, min_impurity_split=None）
4.网格搜索：来调节n_estimators=10 树的数量,max_depth=None 树的深度
dicts = {
"n_estimators":[25,50,75,100,150,200,250,300,500,1000,2000],
"max_depth":[1,2,5,7,10]
}
R_tree = GridSearchCV(R_tree,param_grid=dicts,cv=3)
5.训练
R_tree.fit(x_train,y_train)
GridSearchCV(cv=3, error_score=‘raise’,
estimator=RandomForestClassifier(bootstrap=True, class_weight=None, criterion=‘gini’,
max_depth=None, max_features=‘auto’, max_leaf_nodes=None,
min_impurity_decrease=0.0, min_impurity_split=None,
min_samples_leaf=1, min_samples_split=2,
min_weight_fraction_leaf=0.0, n_estimators=10, n_jobs=1,
oob_score=False, random_state=None, verbose=0,
warm_start=False),
fit_params=None, iid=True, n_jobs=1,
param_grid={‘n_estimators’: [25, 50, 75, 100, 150, 200, 250, 300, 500, 1000, 2000], ‘max_depth’: [1, 2, 5, 7, 10]},
pre_dispatch=‘2*n_jobs’, refit=True, return_train_score=‘warn’,
scoring=None, verbose=0)
6.预测
y_ = R_tree.predict(x_test)
7.最佳参数
print(R_tree.best_params_) #最佳参数
print(R_tree.best_score_) #最佳结果
{‘max_depth’: 10, ‘n_estimators’: 200}
0.8327721661054994
五、线性回归(正规方程，梯度下降优化方法）API：
- 是其他算法的基础，如深度学习;
- 线性回归损失函数与优化;
- 回归问题:目标值 — 连续型数据(房价预测,金融贷款额度…);
- 损失函数 == 最小二乘法,使用优化算法找到最小损失对于的W值;
- 优化算法:
- 正规方程(直接矩阵运算求w权重,如果特征多求解速度慢,只能在线性回归总运用),
- 梯度下降(沿着切线向下的方向，递归迭代计算权重,广泛使用);
- 性能评估：使用均方误差；
- 适用场景：
- 小规模数据建议LinearRegression(不能解决过拟合问题)和岭回归;
- 大规模用SGDRegressor;
6.1使用正规方程优化算法的线性回归 API
from sklearn.linear_model import LinearRegression
fit_intercept=True :是否计算偏置,一般都需要True
LogisticRegression.coef_:查看回归系数函数
LogisticRegression.intercept_:查看偏置函数
0.导入相关库和方法
from sklearn.linear_model import LinearRegression #使用正规方程优化算法的线性回归模型
from sklearn.preprocessing import StandardScaler #特征工程-标准化
from sklearn.model_selection import train_test_split #划分数据集方法
from sklearn.datasets import load_boston #波士顿房价预测数据集
from sklearn.model_selection import GridSearchCV #网格搜索优化
from sklearn.metrics import mean_absolute_error #回归性能评估：均方误差
1.获取数据集
boston = load_boston()
2.划分数据
x_train,x_test,y_train,y_test = train_test_split(boston.data,boston.target,random_state=25)
3.标准化数据
ss = StandardScaler()
x_train = ss.fit_transform(x_train)
x_test = ss.fit_transform(x_test)
4.正规方程–线性回归算法
lr = LinearRegression()
# 参数：LogisticRegression(penalty='l2', dual=False, tol=0.0001,
# C=1.0, fit_intercept=True, intercept_scaling=1,
# class_weight=None, random_state=None, solver='liblinear',
# max_iter=100, multi_class='ovr', verbose=0, warm_start=False, n_jobs=1)
5.训练
lr.fit(x_train,y_train)
LinearRegression(copy_X=True, fit_intercept=True, n_jobs=1, normalize=False)
6.预测
y_ = lr.predict(x_test)
#准确率，在线性回归中因为数据都是离散型的所有准确率不建议参考
#lr.score(x_test,y_test) 去除
0.6649732240675921
7.回归性能评估
均方误差，越小越好
mean_absolute_error(y_test,y_)
3.358759924765199
6.2使用梯度下降优化算法的线性回归 API
- from sklearn.linear_model import SGDRegressor
- 支持loss函数(损失类型),和正则化惩罚项来拟合线性回归模型
- loss=‘squared_loss’:默认普通最小二乘法
- 可以用网络搜索算法来优化学习率和梯度迭代次数
- fit_intercept=True :是否计算偏置
- learning_rate=‘invscaling’:学习率
-
‘invscaling’：学习率算法 包含 “comstant”,“optimal”,‘invscaling’,
-
对于常数值的学习率可以使用**“comstant”**==0
-
- max_iter=None,梯度迭代次数
- SGDRegressor.coef_:查看回归系数函数
- SGDRegressor.intercept_:查看偏置函数
0.导入相关库和方法
from sklearn.linear_model import SGDRegressor #使用梯度下降优化算法的线性回归模型
from sklearn.preprocessing import StandardScaler #特征工程-标准化
from sklearn.model_selection import train_test_split #划分数据集方法
from sklearn.datasets import load_boston #波士顿房价预测数据集
from sklearn.model_selection import GridSearchCV #网格搜索优化
from sklearn.metrics import mean_absolute_error #回归性能评估：均方误差
1.获取数据集
boston = load_boston()
2.划分数据
x_train,x_test,y_train,y_test = train_test_split(boston.data,boston.target,random_state=25)
3.标准化数据
ss = StandardScaler()
x_train = ss.fit_transform(x_train)
x_test = ss.fit_transform(x_test)
4.梯度下降–线性回归算法
SR = SGDRegressor()
# SGDRegressor(loss='squared_loss', penalty='l2', alpha=0.0001, l1_ratio=0.15,
# fit_intercept=True, max_iter=None, tol=None, shuffle=True, verbose=0,
# epsilon=0.1, random_state=None, learning_rate='invscaling', eta0=0.01,
# power_t=0.25, warm_start=False, average=False, n_iter=None)
5.训练
SR.fit(x_train,y_train)
SGDRegressor(alpha=0.0001, average=False, epsilon=0.1, eta0=0.01,
fit_intercept=True, l1_ratio=0.15, learning_rate=‘invscaling’,
loss=‘squared_loss’, max_iter=None, n_iter=None, penalty=‘l2’,
power_t=0.25, random_state=None, shuffle=True, tol=None, verbose=0,
warm_start=False)
6.预测
y_ = SR.predict(x_test)
7.回归性能评估
mean_absolute_error(y_test,y_)
6.3两种回归算法比较:
权重系数比较：
print(lr.coef_)
print(SR.coef_)
[-0.88651447 1.22644009 0.42682549 0.1441588 -2.34008032 2.96578856
-0.08406877 -3.27303143 2.71758075 -2.4379212 -2.31150591 0.68305045
-3.48696915]
[-0.69358511 0.75295173 -0.22401474 0.23993892 -1.06677793 3.68294086
-0.28033633 -1.96210373 0.54436058 -0.65591289 -1.95834084 0.80112146
-3.00765014]
偏置比较:
print(lr.intercept_)
print(SR.intercept_)
22.604485488126688
[22.13622798]
五、支持向量机(SVM) API：
转：https://blog.csdn.net/weixin_44432311/article/details/89672597
- 经典的分类算法;
- 简而言之：支持向量机就是找到一个 分割界面，放到两个类别之间，把它们分开；二维上，是一条直线， 三维上就一个平面，四维上就是一个理论上三维的界面;
- 优点：可以解决高维问题，即大型特征空间；能够处理非线性特征的相互作用;
- 缺点：对参数及核函数的选择较敏感；如果不进行修改只适用于二分类问题；
- 适用场景：邮件系统中的垃圾邮件,入侵检测系统中的网络行为;
5980
被折叠的 条评论
为什么被折叠?
到【灌水乐园】发言
