sklearn-监督学习-分类与回归

一、分类模型
1.KNN算法
函数：KNeighborsClassifier()
思路：对k个最近的邻居进行拟合，调试出最佳n_neighbors的值，分别对训练集、验证集、测试集的标记值与预测值进行拟合，用参数accuracy_score \recall_score \f1_score 对拟合效果进行评定。

from sklearn.metrics import accuracy_score,recall_score,f1_score
from sklearn.neighbors import NearestNeighbors,KNeighborsClassifier
knn_clf = KNeighborsClassifier(n_neighbors=3)
knn_clf.fit(X_train,Y_train)
from sklearn.metrics import accuracy_score,recall_score,f1_score
print('Train')
Y_pred = knn_clf.predict(X_train)
print('ACC',accuracy_score(Y_train,Y_pred))
print('REC',recall_score(Y_train,Y_pred))
print('F-Score',f1_score(Y_train,Y_pred))
Y_pred = knn_clf.predict(X_validation)
print('Validation')
print('ACC',accuracy_score(Y_validation,Y_pred)) #准确率
print('REC',recall_score(Y_validation,Y_pred)) #召回率
print('F-Score',f1_score(Y_validation,Y_pred)) #F值
Y_pred = knn_clf.predict(X_test)
print('Test')
print('ACC',accuracy_score(Y_test,Y_pred))
print('REC',recall_score(Y_test,Y_pred))
print('F-Score',f1_score(Y_test,Y_pred))

2.朴素贝叶斯算法
函数：GaussianNB(), BernoulliNB()
思路：将上述代码进行优化，建立models的list，将模型以元组形式存入list，用classifier name 和 classifier循环遍历models，分类拟合得到分类数组和标签，然后建立训练集、验证集、测试集及其对应标记值的list；循环遍历每个xy_lst的元素，遍历过程中将数组与标签分开，并进行预测。最后通过评定参数accuracy_score、recall_score、f1_score，print预测值与标记值的准确率

from sklearn.metrics import accuracy_score,recall_score,f1_score
from sklearn.naive_bayes import GaussianNB,BernoulliNB
#用贝叶斯方法时，数据为离散值的情况下可能表现会更好一些
#高斯朴素贝叶斯（假设特征是高斯分布的），伯努利朴素贝叶斯（值是离散值用这个方法，如果是连续值要用伯努利进行二值化）
models = []
models.append(('GaussianNB',GaussianNB()))
models.append(('BernoulliNB',BernoulliNB()))

for clf_name,clf in models:
    clf.fit(X_train,Y_train)
    xy_lst = [(X_train,Y_train),(X_validation,Y_validation),(X_test,Y_test)]
    for i in range(len(xy_lst)):
        X_part = xy_lst[i][0]
        Y_part = xy_lst[i][1]
        Y_pred = clf.predict(X_part)
print(i)
print(clf_name,'--ACC',accuracy_score(Y_part,Y_pred))
print(clf_name,'--REC',recall_score(Y_part,Y_pred))
print(clf_name,'--F_score',f1_score(Y_part,Y_pred))

3.决策树
函数：DecisionTreeClassifier()
思路：决策树模型有两种方法，一个是用Gini系数，另一个是用entropy信息熵

from sklearn.tree import DecisionTreeClassifier,export_graphviz
from sklearn.externals.six import StringIO
models = []
models.append(('DecisionTreeGini',DecisionTreeClassifier(min_impurity_split=0.1)))  # min_impurity_split=0.1 最小不纯度，一种减枝方法
models.append(('DecisionTreeEntropy',DecisionTreeClassifier(criterion='entropy')))  # 信息增益方法的决策树
for clf_name,clf in models:
    clf.fit(X_train,Y_train)
    xy_lst = [(X_train,Y_train),(X_validation,Y_validation),(X_test,Y_test)]
    for i in range(len(xy_lst)):
        X_part = xy_lst[i][0]
        Y_part = xy_lst[i][1]
        Y_pred = clf.predict(X_part)
        print(i)
        print(clf_name,'--ACC',accuracy_score(Y_part,Y_pred))
        print(clf_name,'--REC',recall_score(Y_part,Y_pred))
        print(clf_name,'--F_score',f1_score(Y_part,Y_pred))
        dot_data = StringIO() #使用StringIO
        export_graphviz(clf,out_file=dot_data,
                            feature_names=f_names,
                            class_names=['NL','L'],
                            filled=True,
                            rounded=True,
                            special_characters=True)
        graph = pydotplus.graph_from_dot_data(dot_data.getvalue())
        graph.write_pdf('dt_tree2.pdf')

tree

4.支持向量机SVM算法
函数：SVC()
思路：先映射，再在低维空间计算，再用核函数扩维

from sklearn.svm import SVC
models.append(('SVM Classifier',SVC(C=1000))) #通过C可以控制计算的准确性

5.集成方法(ensemble)一随机森林算法(Bagging)
函数：RandomForestClassifier()
思想：每个决策树可以并不使用全部特征，不需要剪值，即可有效避免过拟合。通过对训练数据集进行随机采样，以重新组合成不同的数据集，利用弱学习算法对不同的新数据集进行学习，得到一系列的预测结果，对这些预测结果做平均或者投票做出最终的预测。

from sklearn.ensemble import RandomForestClassifier
models.append(('OriginalForest',RandomForestClassifier()))  #默认n_estimators=10, 特征自动选取
models.append(('RandomForest',RandomForestClassifier(max_features=None)))  #取全部特征

6.集成方法(ensemble)一Adaboost 算法(Boosting)
函数：AdaBoostClassifier()
思想：通过对样本进行不同的赋值，对错误学习的样本的权重设置的较大，这样在后续的学习中集中处理难学的样本，最终得到一系列的预测结果，每个预测结果有一个权重，较大的权重表示该预测效果较好。

from sklearn.ensemble import AdaBoostClassifier
# n_estimators 弱学习的分类器的数量，默认50；base_estimator 默认为决策树
models.append(('AdaBoost',AdaBoostClassifier(base_estimator=SVC(),n_estimators=100,algorithm='SAMME')))

二、回归模型
1.线性回归: LinearDiscriminantAnalysis()
2.岭回归: Ridge()
3.Lasso回归: Lasso()

from sklearn.linear_model import LinearRegression,Ridge,Lasso
regr = LinearRegression()
regr = Ridge(alpha=0.8)  #用岭回归可以得到控制参数规模的作用，但作用不是很明显
regr = Lasso(alpha=0.002) #通过控制参数的规模而达到一个更好的拟合效果
regr.fit(features.values,label.values)
Y_pred = regr.predict(features.values)
print('coef',regr.coef_)  #看下拟合过后的参数
from sklearn.metrics import mean_squared_error #平均平方误差
print('MSE',mean_squared_error(Y_pred,label.values))

4.逻辑回归： LogisticRegression()
主要用于线性可分的数据集

from sklearn.linear_model import LogisticRegression
models.append(('LogisticRegression',LogisticRegression(C=1000,tol=1e-10,solver="sag",max_iter=10000)))
# 如果效果不好，可以通过调参来优化；

5.人工神经网络: 用Keras进行实现
主要用于非线性数据，主要应用于图像识别，语音识别，自然语言处理等

from keras.models import Sequential # Sequential 人工神经网络的容器，而这个容器是序列化（层级化）的

from keras.layers.core import Dense,Activation # Dense 稠密层（神经网络层），Activation激活函数

from keras.optimizers import SGD # SGD是随机梯度下降算法

mdl = Sequential()

mdl.add(Dense(50,input_dim=len(f_v[0]))) # 先建一个稠密层表示输入层，在输入每一层的时候只需要表示输出就可以了，\

#只有在输入层的时候需要表示输入，输出代表下一个隐含神经元的个数，\

#先指定下一个隐含神经元的个数,eg:50；输入维度与输入数据维度保持一致

mdl.add(Activation('sigmoid'))

mdl.add(Dense(2)) # 输出维度设定

mdl.add(Activation('softmax'))

sgd = SGD(lr=0.05) #lr指的是学习率，也就是梯度下降里的α，学习率越大意味着很可能拟合不到最优点，所以lr不能取太大

mdl.compile(loss="mean_squared_error",optimizer="adam") # 编译过程（建立模型的过程），loss指的是最优化函数（损失函数）\

# 每个输出对应的输出值和要拟合的标注值，进行平方求和再开方得到的值，让它最小，就是loss的含义; \

# optimizer 表示用什么样的优化器去优化

mdl.fit(X_train,np.array([[0,1] if i == 1 else [1,0] for i in Y_train]),nb_epoch=20000,batch_size=8999)

# nb_epoch 表示迭代的次数，合理取值； batch_size 随机梯度算法每次选取的数量，由于本样本数据量不是很大，所以取全部训练集

# 结果不理想，可以调整迭代次数nb_epoch 或 增加样本数量batch_size；也可以调整学习率lr，比如从0.01调整到0.05;\

# 也可以通过更改优化器optimizer比如将sgd改为adam

xy_lst = [(X_train,Y_train),(X_validation,Y_validation),(X_test,Y_test)]

for i in range(len(xy_lst)):

    X_part = xy_lst[i][0]

    Y_part = xy_lst[i][1]

    Y_pred = mdl.predict_classes(X_part) #输出分类标注

    print(i)

    print("NN",'--ACC',accuracy_score(Y_part,Y_pred))

    print("NN",'--REC',recall_score(Y_part,Y_pred))

    print("NN",'--F_score',f1_score(Y_part,Y_pred))

return

6.GBDT，回归树和提升树: GradientBoostingClassifier()

from sklearn.ensemble import GradientBoostingClassifier
models.append(('GBDT',GradientBoostingClassifier(max_depth=6,n_estimators=100))) # max_depth 只是一个经验值
# 参数learn_rate 第二个分类器已经进行了衰减进行10%的衰减；criterion：mse