机器学习代码

#应用中，一般来说，收集到的数据集会非常混乱，不同于深度学习，把数据清洗等步骤也加入到神经网络模型的执行中，而机器学习，数据往往不能直接用于
#模型的训练，需要对数据集进行数据预处理，数据清洗，填补缺失值，处理异常数据等
#可以先使用pandas模块进行数据集类型的转换，方便对数据集进行信息查询等
import pandas as pd     #导入pandas模块
data = pd.read_csv("./data.csv") #可以使用pandas直接读取数据集，会直接将数据集的类型转换为DtaeFream
data = pd.DateFream(data)     #也可以使用datefream将数据转换为数据框类型
#机器学习中分监督学习、无监督学习、半监督学习和强化学习，使用监督学习时，需要提高标签，所以一般需要划分特征数据X和标签数据Y
#可以使用loc,iloc等进行X，Y的提取
X = data.loc[:,:]        #使用loc进行提取时，只能识别列名称，行切片：列切片
X = data.iloc[:,:]       #使用iloc提取时，既可以识别列名称，也可以识别列级索引，行切片：列切片
data.describe([0.01,0.1,0.25,0.5,0.75,0.95,0.99]).T     #对数据进行各分布下的描述性统计，然后进行转置
#结果返回个特征count，std等，可以根据经验来处理(删除)数据集异常值
data.head()    #使用此代码查看数据框的前5行信息，默认
data.info()    #使用此代码查看数据框的所有列信息，即所有特征信息，有无缺失值等
#接下来可以根据查看到的特征信息，对有缺失值的数据进行处理
#由于某特征缺失的数据比较多时，或者该特征对于标签的贡献几乎没有时，可以直接将此特征进行删除，删除完一般需要重新恢复索引
data.drop(["Ticket"],inplace=True,axis=1)  #使用drop(),指定需要删除的特征的列级名称，inplace=True表示在原始数据集框上进行更改，axis=1指定删除列
data.index = range(data.shape[0])    #恢复索引
#当某些特征的缺失值比较少时，且特征比较重要，往往需要对其进行缺失值填补操作
data["Age"]=data["Age"].fillna(data["Age"].mean())   #将年龄的列的缺失值补上该列的均值，fillna()是填补缺失值的意思，括号里面可以输入自定义的数，也可以使用填补特征列的其它统计值来填补，例如最大值，最小值，众数，中位数等
#当某些数据集只是缺少少量的数据而已，而且数据集又比较庞大，也可以选择将所有缺失数据的行进行删除
data = data.dropna()   #删除带用缺少数据的行，dropna与drop不一样，无需指定删除的数据，默认axis=0，删除行，inplace= False，需要指定新的变量存储返回的新矩阵
#由于机器学习模型只能识别数字类型的数据集，所以需要将其它的数据类型的数据转换成int类型的数据
labels = data["Embarked"].unique().tolist()   #使用unique()可以将某特征中的所有数据进行无重复统计，tolist()将统计完的对象转换成列表
data["Embarked"] = data["Embarked"].apply(lambda x: labels.index(x))   #apply()对某列特征进行数据更新，labels.index()取出该列各数据在labels的索引值，并替换掉原来的数据
#当然，对于性别这种比较特殊的特征，由于只有俩种类别，所以可以使用bool值对应的int值更方便的将数据类型替换掉
data.loc[:,"Sex"] = (data["Sex"] == "male").astype("int")   #将性别数据类型改为int，‘==’可以返回bool系列，使用astype可以将数据类型转换成布尔值对应的int值，true=1，false=0
#当然，除了可以使用怕pandas自带的方法进行缺失值处理以及类型转换之外，还可以使用sklearn中的相关类来进行数据处理
from sklearn.impute import SimpleImputer     #导入缺失值填补的类
data = df.loc[:,"score"]                  #提取需要进行预处理的特征
import numpy as np                        #导入numpy模块
data = np.array(data)                     #使用array()将series转换成adarray类型
data = data.reshape(-1,1)                 #使用reshape(-1,1)对数据进行升维度，因为模型填补的是特征，所以需要二维及以上的数据
a = SimpleImputer()                                  #实例化，默认填补该列特征数据的均值
b = SimpleImputer(strategy="median")                 #实例化，用中位数填补空值
c = SimpleImputer(strategy="constant", fill_value=0) #实例化，用0填补空值
d = SimpleImputer(strategy="most_frequent")          #实例化，用众数填补空值
a = a.fit_transform(data)        #训练并返回结果
b = b.fit_transform(data)        #训练并返回结果
c = c.fit_transform(data)        #训练并返回结果
d = d.fit_transform(data)        #训练并返回结果
df.loc[:,"score"] = b            #根据所需，使用中位数填补完返回的结果替换掉原来的特征矩阵
#同样，可以使用sklearn中的类，将数据集的类型转换成数值类型
from sklearn.preprocessing import LabelEncoder        #导入标签转换成数值类型的类
da1.loc[:,"gender"] = LabelEncoder().fit_transform(da1.loc[:,"gender"]) 
#通过1行代码将实例化与输出结果，把结果传入原数据集一起实现，由于标签是1维矩阵，所以可以直接拿去训练，实现标签列编码
from sklearn.preprocessing import OrdinalEncoder   #导入编码的类
import numpy as np
data = np.array(df.loc[:,"gender"])          
data = data.reshape(-1,1)      #由于是特征列，需要二维以上矩阵，所以需要(-1,1)升维度
df.loc[:,"gender"] = OrdinalEncoder().fit_transform(data)  #使用编码，将特征进行0，1，2等编码
#性别男女是独立互不干扰的，所以之前的编码生成的数值型0和1等，存在大小以及数值运算等关系，对后面模型的算法运行以及训练存在干扰，
#所以更加适合使用哑变量来实现一列特征存在多个不同的类时，且它们之间不存在某种联系时使用，效果比较好
from sklearn.preprocessing import OneHotEncoder       #导入独热编码的类
data=(np.array(df3.loc[:,"gender"]f).reshape(-1,1)  #由于哑变量处理特征列的数值型转换，所以同样需要二维以上数据
s = OneHotEncoder(categories="auto").fit_transform(data).toarray() #生成的是稀疏矩阵，可以用toarray把它变成数组显示出来
#categories='auto',会根据特征下的类别自动的将数据划分为n类，独热编码表示为0，1，0类似格式，属于哪一类哪个位置置1
s.get_feature_names_out() #输出分类后的各列代表的类别，0是该特征在原来数据集，也就是数据框的列级索引
#当特征下的数据为数值类型时，且可以划分为俩个区间时，例如年龄，分数等，就可以使用二值化将数据缩减为俩类，有利于提高后续模型运行的效率
from sklearn.preprocecsing import Binarizer   #导入二值化的类
df.loc[:,"score"]=Binarizer(threshold=30).fit_transform(df.loc[:, "score"].values.reshape(-1,1))  #将分数以30分为界限分成两个区间，也就是两个类
#同样的，二值化也是对特征矩阵进行操作，所以需要进行升维度操作，使用values可以取出特征系列的所有值，再使用reshape(-1,1)对其进行数据升维
#有时，需要把特征下的数据进行多区间分类操作，则需要使用分箱的类，原理跟二值化类似，只不过是将数据进行多值化而已
from sklearn.preprocessing import KBinsDiscretizer   #导入特征数据分箱的类
data = df.loc[:,"score"].values.reshape(-1,1)      #同样，需要对数据进行升维度操作
s = KBinsDiscretizer(n_bins=3, encode="ordinal", strategy="quantile").fit_transform(data)   #使用等位分箱，采用编码
ss = KBinsDiscretizer(n_bins=3,encode="onehot", strategy="quantile").fit_transform(data)    #使用等位分箱，采用独热编码
sss = KBinsDiscretizer(n_bins=3,encode="onehot", strategy="uniform").fit_transform(data)    #使用等宽分箱，采用独热编码
ssss = KBinsDiscretizer(n_bins=3,encode="ordinal", strategy="uniform").fit_transform(data)  #使用等宽分箱，采用编码
#以上输出结果都可以使用toarray()进行转换成数组显示
#后续对返回的新的特征列，可以与之前一样直接放入原来的数据集中或替换原来的数据集中的特征列
#为了方便观察特征数据的发布规律，以及加快模型的训练效率，可以对数据进行归一化处理
from sklearn.preprocessing import MinMaxScaler           #导入数据归一化的类
a = MinMaxScaler()              #实例化，默认将数据归一到【0，1】之间
b = a.fit_transform(data)          #归一化并导出数据
a.inverse_transform(b)             # 将归一化后的结果逆转
c = MinMaxScaler(feature_range=(5,10))      #实例化，将数据归一到【0，1】以外的范围中
d = c.fit_transform(data)     #归一化并导出数据
c.inverse_transform(d)        #同样可以逆转结果，前提是实例化与归一化训练分开执行，一起执行则返回最终结果，无法调用实例化后的模型
#也可以将数据正则化操作，可以让多个服从正态分布的特征缩小到统一范围内的正态分布中
from sklearn.preprocessing import StandardScaler     #导入正则化的类
a = StandardScaler()                            #实例化
b = a.fit_transform(data)                   #导出结果，是一个数组，服从正态分布
a.inverse_transform(b)             #将标准化结果进行逆转
#往往在神经网络中数据标准化是比较好的选择
#虽然特征数据已经基本处理完，但是因为现实收集到的分类标签可能出现极度偏向某一类的结果，就需要对样本进行均衡处理
#下采样，对原始数据集进行随机采样
sample = df.sample(n=492)      #使用sample(),指定随机采样个数492，并返回样本到sample，一般对全数据集(含标签)进行采样，后续不用再利用索引找数据
#过采样，使用SMOTE对标签少的一类样本进行样本添加，使其与另一类样本数量一致，用于二分类
from imblearn.over_sampling import SMOTE     #导入过采样的类SMOTE
smoke = SMOTE()     #实例化
X_oversample, Y_oversample = smoke.fit_resample(X, Y)   #训练，并返回特征样本和标签样本，需要输入X,Y，因为要利用标签和特征生成新的特征
#一般使用过采样，可以处理样本间数据不平衡问题，如评分卡等
'''
数据归一化和数据标准化都是对数据特征下的数据进行压缩处理，可以使在模型训练过程中，加快收敛，使不同特征之间的取值范围差异不会过大，从而导致
特征的权重调整过慢;
缺失值处理可以把特征列缺失的数据进行填补，后面才可以调用模型进行训练，而标签列是不会有空值的，因为决策树和随机森林处理的是有监督学习，需要
所有样本的标签才可以进行模型训练;
编码和独热编码都是对特征下的数据，一般是非数值数据进行数值的转换，例如，性别的特征，使用编码，就可以用1跟0替换，这样子后续的模型才可以接受
这些数据进行训练；但是些数据，例如不同的性别，车次，不同的地点，其内在是没有关系的，准确来说，不像数值成绩一样，可以进行数值的加减乘除而改
变结果，就像男生不可能说加1就可以变成女生一样，是女不是男是男不是女，所有需要使用哑变量来进行数值替换会更加的靠谱，不容易对后续模型算法的运
算造成干扰;
数据二值化则是将特征列的数值以某个界限分开，划分成俩类，用0和1表示，可以是特征里的数据，用于出现某种特征或没有出现某种特征的场景，简化数据;
数据分箱与二值化原理一样，只是分箱可以将数据分成多个类，例如成绩的划分等，参数可以选择编码也可以选择独热编码，可以指定按照等宽或等位来划分
数据，等宽就是划分后的每组数据间的最大值间隔相等，等位则是将该特征的全部数据按照样本数量相等的个数划分出来;
总之，上述操作都是对特征下的数据进行处理，就是数据预处理的操作，而对各个特征之间的操作才是特征工程，例如合并某些特征，删除，选择某些特征作为
模型训练的特征等;
样本过采样感觉应该执行于数据归一化、标准化之前，数据编码，处理缺失值之后
'''
#对数据进行预处理完后，如果数据集非常大，模型训练就会非常慢，而且有对模型毫无贡献的特征，就需要去把它删除掉，所以还需要特征选择，对特征进行一定的筛选
#Filter过滤法，有方差过滤，卡方过滤，F检验过滤，互信息法过滤，需要自己对模型进行评估
#方差过滤，如果一个特征本身的方差很小，甚至为0，就表明该特征下的数据几乎是一模一样的，对模型的训练根本起不了一点的作用，就需要把这类特征删除掉
from sklearn.feature_selection import VarianceThreshold    #导入方差过滤的类
selector = VarianceThreshold()       #实例化，不填参数默认方差为0，即选出特征下所有数据全部一样的特征进行删除
X_var0 = selector.fit_transform(X)   #将特征矩阵放进去训练并返回新的特征矩阵
#也可以自定义方差训练，也可以统计样本所有特征方差的中位数进行训练，则会删除掉一半的特征
X_median = VarianceThreshold(np.median(X.var().values)).fit_transform(X)  #使用X.var()计算所有特征的方差，再用values取出所有方差的值，进行求中位数
#当特征是二分类时，也就是伯努利随机变量，这些变量的方差可以计算成P（P-1）
#假设P=0.8，则可以删除掉特征是二分类时，某种类的数量占比达到百分之80以上的特征
X_p = VarianceThreshold(.8*(1-.8)).fit_transform(X)    #实例化并删除有些数据量占比达到80%以上的特
#当方差设置的比较小时，对于模型的训练时间可能几乎没啥变化，对于模型的表现可能也变化不大，但当方差设置的比较大时，由于删除掉了大部分特征，所有模型的
#训练时间肯定会有所下降，但是如果删除了较多的噪音特征，则模型的表现能力会上升，如果删除掉的是有用的特征，则模型的表现能力可能会有所下降
#卡方过滤，专门处理分类模型
from sklearn.feature_selection import SelectKBest  #导入特征分数选择的类
from sklearn.feature_selection import chi2      #导入卡方检验的类
X = SelectKBest(chi2, k=300).fit_transform(x,y)   #实例化并导出新的特征矩阵，之所以要导入y，是因为卡方校验需要用到标签来计算特征与标签的关系
#但是，可能后续对新的特征矩阵进行模型训练后，模型效果并不好，那就是因为K的取值不好，可以通过划学习曲线来找出K的最优取值
#当然，还有另外一种方法，可以不画学习曲线，利用对卡方检验的结果P进行统计，可以知道最优的K的取值
K，P = chi2(x,y)     #对卡方检验输出结果进行分析，如果P小于0.05或0.01，则该特征与标签有相关性，不删除，通过计算该总数可以确定k的取值
#F检验，既可以用于分类，也可以用于回归,可以计算特征与标签之间的线性关系
from sklearn.feature_selection import f_classif       #导入F检验分类的类
from sklearn.feature_selection import f_regression     #导入F检验回归的类
F, P = f_classif(x,y)           #对F检验输出结果进行分析，同样，如果P小于0.05或0.01则该特征与标签具有线性相关，不删除，可以计算总数来确定k取值
#互信息法，用来捕捉每个特征与标签之间的任意关系的方法，包括线性与非线性关系，既可以用于分类也可以用于回归
from sklearn.feature_selection import mutual_info_classif    #导入互信息法分类的类
from sklearn.feature_selection import mutual_info_regression  #导入互信息法回归的类
result = mutual_info_classif(x,y)      #互信息法检验不返回K或F统计量，而是返回每个特征与目标之间的互信息量的估计，0表示独立，1表示完全相关，但要求特征数据取值大于0
#一般建议先使用方差过滤掉方差为0的特征，再用互信息法过滤，因为互信息法捕捉任意相关性，包括线性相关
#嵌入法，让算法自己决定使用哪些特征的方法，即特征选择和算法训练同时进行,但需要具体到每个算法
from sklearn.feature_selection import SelectFromModel    #导入嵌入法的类
from sklearn.ensemble import RandomForestClassifier as RFC  #导入随机森林回归的类
RFC_ = RFC(n_estimators=10,random_state=0)     #随机森林实例化
X_embedded = SelectFromModel(RFC_,threshold=0.005).fit_transform(x,y)    #嵌入法实例化，指定分类算法，设置阈值0.005，保留0.005的特征，进行训练并返回结果
#嵌入法返回的是新的特征矩阵，也看不到模型效果，所以得利用学习曲线，把阈值用来循环遍历，从随机森林的feature_importances来获取阈值取值范围，最后把新特征矩阵与y拿去交叉验证，看哪个阈值最优
#嵌入法选择的特征效果很好，过滤法计算远远快于嵌入法，虽然过滤法要考虑很多统计量，但是大型数据中还是会考虑过滤法，因为嵌入法运行太慢了
#包装法，也是特征选择和算法训练同时的方法，与嵌入法十分相似，但是是依赖某个专业的数据挖掘算法，专门用来选取特征，而不是随机森林等算法
from sklearn.feature_selection import RFE    #导入包装法的类
RFC_ = RFC(n_estimators=10,random_state=0)   #随机森林实例化
selector = RFE(RFC_, n_features_to_select=340,step=50).fit(x,y)     #实例化包装法，保留340特征，每次迭代删除50个特征
selector.support_.sum()    #返回所有的特征是否被选中的bool矩阵
selector.ranking_          #返回特征的按数次迭代中总合重要性排名
X_wrapper = selector.transform(x)    #返回包装法选择过后的新的特征矩阵
'''
过滤法更加快速，但比较粗糙
包装法和嵌入法更加的精确，你叫适合具体到算法去调整，但是计算量比较大，尤其是嵌入法
当数据量很大时，优先使用方差过滤和互信息法调整，使用逻辑回归时，优先使用嵌入法，使用支持向量机时，优先使用包装法
'''
#除了对数据集进行特征选择，还可以进行特征创造，特征选择是在原始数据集中选取并删除某些特征，而特征创造则是生成新的完全不一样的特征矩阵
#PCA，是将已存在的特征进行压缩，降维后的特征不是原本的特征矩阵中的任何一个特征，而是通过某些方式组合起来的新特征，如扭转特征空间，新特征矩阵不具有可读性
#PCA使用的信息量衡量指标就是样本方差，也称为可解释性方差，方差越大，特征所带的信息量就越多
from sklearn.decomposition import PCA         #导入PCA的类
pca = PCA(n_components=2).fit_transform(X)        #实例化并训练导出新的特征矩阵到变量pca，指定降维为2个特征
pca = PCA(n_components=2).fit(X)    #实例化
pca.explained_variance_             #输出各列新特征的方差
pca.explained_variance_ratio_       #输出各列新特征信息量在原来数据集所有特征的占比
pca.explained_variance_ratio_.sum()   #输出各列新特征信息量在原来数据集所有特征的占比总和
pca = PCA().fit(X)        #实例化，不加参数默认生成与原来特征数量相同的新的特征矩阵
pca = PCA(n_components='mle').fit_transform(X)    #指定mle可以最大似然估计法，模型自己选出最好的维度数
pca = PCA(n_components=0.97, svd_solver='full')   #选出信息量大于0.97的特征维度构成新的特征矩阵，必须指定svd_solver
#降维常用于人脸识别，使模型只识别几个重要特征就可以实现准确高效的识别人脸
'''
数据集的预处理已经基本完成，后续只需对数据放进各类模型进行训练以及调参评估就可以应用
'''
#现在，对模型进行训练前一般需要拆分训练集和测试集
from sklearn.model_selection import train_test_split      #导入拆分数据集的类
xtrain,xtest,ytrain,ytest = train_test_split(x,y,test_size=0.3)   #实例化，指定测试集的占比为30%，并返回结果
#当然，划分好训练集和测试集后，有时候还有必要进行交叉验证，来衡量我们拆分的数据集是否合理
from  sklearn.model_selection import cross_val_score  #导入交叉验证的类
score = cross_val_score(clf,x,y,cv=10)    #指定实例化好的模型，特征数据，标签，交叉验证次数10次，第一次第1份测试集，另外9份测试集，第二次第2份测试集，其它训练集，如此往复
#上面代码输出十次交叉验证的分数结果，求均值，如果发现输出的评估分数比模型本身低，证明拆分的数据集还行
#网格搜索可以用来搜索模型最优的超参数
from sklearn.model_selection import GridSeachCV    #导入网格搜索的类
parameters = {"criterion":("gini","entropy")       #定义网格搜索参数及取值范围
             ,"splitter":("best","random")
             ,"max_depth":[*range(1,10)]
             ,"min_samples_leaf":[*range(1,50,5)]
             }
clf = DecisionTreeClassifier(random_state=0)       #实例化决策树
gs = GridSearchCV(clf, parameters, cv=10)   #网格搜索，把实例化好的模型放进去，搜索参数，交叉迭代10次
gs = gs.fit(X,Y)     #训练
gs.best_params_    #输出最优参数
gs.best_score_     #输出最优参数结合的模型评估结果
#接下来，就是进行模型本身的训练，sklearn中有多种机器学习模型，用于处理分类和回归等
#决策树，分为分类树和回归树
from sklearn import tree      #导入tree模块，里面包含分类和回归的类
TC = tree.DecisionTreeClassifier()   #实例化，设置分类树训练的参数，默认是基尼系数(gini)
TC = clf.fit(Xtrain,Ytrain)          #设置训练集的数据，通过训练得到模型返回给变量TC
score = TC.score(Xtest,Ytest)        #设置测试集的数据，并将测试结果返回给变量score,一般返回准确率
TR = DecisionTreeRegressor(max_depth=2)    #实例化，设置回归树的深度为2  
score = TR.score(Xtest,Ytest)    #输入测试集进行模型测试
score = TR.predict(Xtest)    #输入测试集特征进行结果预测
#决策树实例化的参数有n_estimators（树的数量）
                    #max_depth（树的深度）
                    #min_samples_leaf（叶子上面的最少数量有多少才能保留分支）
                    #min_samples_split（分叉最少要有多少个样本才能进行分支）
                    #max_features（限制最大用于模型的特征数量）
                    #criterion（gini,entropy）基尼系数和信息增益
                    #min_impurity_split（设置最低的不纯度，低于该值不再进行分支）
                    #max_leaf_nodes（设置最大叶子节点数量，高于该值删除叶子节点）
#可以使用集成学习(袋装法就是集成学习)，利用多个模型共同预测结果,袋装法的典型代表是Bagging（袋装法）
#随机森林，为了提高模型预测的准确性，
from sklearn.ensemble import RandomForestClassifier     #导入随机森林分类的类
RC = RandomForestClassifier(random_state=0)     #实例化
RC = RC.fit(Xtrain,Ytrain)        #把测试集数据带入模型训练
source = rlf.score(Xtest,Ytest)   #输入测试集数据进行模型打分
from sklearn.ensemble import RandomForestRegressor    #导入随机森林回归器的类
rfr = RandomForestRegressor(n_estimators=100)    #实例化，生成100棵树
rfr = rfr.fit(Xtrain, Ytrain)   #把测试集数据带入模型训练 
#随机森林实例化的参数有n_estimators（树的数量）
                      #max_depth（树的深度）
                      #min_samples_leaf（叶子上面的最少数量有多少才能保留分支）
                      #min_samples_split（分叉最少要有多少个样本才能进行分支）
                      #max_features（限制最大用于模型的特征数量）
                      #criterion（gini,entropy）基尼系数和信息增益
#袋装法
rcf = RandomForestClassifier(bootstrap=True)   #使用随机抽样放回的参数训练模型，得划分训练集测试集,默认就是该参数
rcf.fit(Xtrain,Ytrain)
rcf.score(Xtest,Ytest)
rcf = RandomForestClassifier(random_state=1, oob_score=True)  #使用装外数据进行模型测试，所以不用划分训练集与测试集
rcf.fit(X, Y)
rcf.oob_score_             #使用袋装法落到袋外的数据集进行模型测试
rcf.predict(Xtest)
rcf.predict_proba(Xtest)    #返回预测的类别各个概率占比
#逻辑回归，分类
from sklearn.linear_model import LogisticRegression   #导入逻辑回归的类
LR1= LogisticRegression(penalty='l1',solver='liblinear',C=0.5,max_iter=1000)  #使用L1正则化，稀疏特征
LR2= LogisticRegression(penalty='l2',solver='liblinear',C=0.5,max_iter=1000)  #使用L2正则化，C是正则化强度，默认1，越小惩罚越强
L1 = LR1.fit(X,Y)
L2 = LR2.fit(X,Y)
#线性回归，处理连续数值
from sklearn.linear_model import LinearRegression  #导入线性回归的类
LR = LinearRegression(fit_intercept=True,normalize=False)   #实例化，fit_intercept=True指定需要计算线性回归中的截距，normalize=False训练样本会进行归一化处理
LR.fit(X,Y)      #训练
#KNN，有监督学习，既可以分类，也可以回归，K个最近的邻居分类靠近哪一类归为哪一类
from sklearn.neighbors import KNeighborsClassifier as KNN #导入KNN的类
KN = KNN()     #实例化，参数有n_neighbors,指定以多少个最近邻的属性来分类数据
KN.fit(X,Y)  #模型训练
#SVM，有监督学习，既可以分类，也可以回归，支持向量机
from sklearn import svc  #导入svc的模块
clf = svc.SVC()  #实例化
clf.fit(X,Y)  #训练
#Kmeans，无监督学习，聚类算法
from sklearn.cluster import KMeans   #导入Kmeans的类
KM = KMeans(n_clusters=3, random_state=0).fit(data)  #实例化，把数据聚成三类，fit返回结果
y_pred = KM.labels_    #查看数据集的分类结果
from sklearn.metrics import silhouette_score   #导入轮廓系数评价的类
score = silhouette_score(data,y_pred)   #输入数据集，聚类结果，输出轮廓系数，越接近1越好，范围-1到1
'''metrics是sklearn中用来衡量模型指标的模块'''
#混淆矩阵可以用来对分类模型预测结果进行评估，结合画图可以更加明显显示预测结果好坏TP,TN,FP,FN等
from sklearn.metrics import confusion_matrix  #导入混淆矩阵的类
matrix = confusion_matrix(Ytest,y_pred)   #输入真实结果和预测结果，输出混淆矩阵
#分类是机器学习中比较常见的任务，对于分类任务常见的评价指标有准确率（Accuracy）、精确率（Precision）、召回率（Recall）
#准确率是分类正确的样本占总样本个数的比例，即TP+TN/TP+TN+FP+FN
#准确率是分类问题中最简单直观的评价指标，但存在明显的缺陷,比如如果样本中有99%的样本为正样本，那么分类器只需要一直预测为正，就可以得到99%的准确率，
#但其实际性能是非常低下的,也就是说，当不同类别样本的比例非常不均衡时，占比大的类别往往成为影响准确率的最主要因素
from sklearn.metrics import accuracy_score   #导入准确性评估的类
print(accuracy_score(y_true, y_pred))   #输入真实的标签和预测的标签就可以输出准确率
#精确率指模型预测为正的样本中实际也为正的样本占被预测为正的样本的比例，即TP/TP+NP
from sklearn.metrics import precision_score    #导入精确率评估的类
print(precision_score(y_true, y_pred, average='macro'))  
print(precision_score(y_true, y_pred, average='micro')) 
print(precision_score(y_true, y_pred, average='weighted'))  
print(precision_score(y_true, y_pred, average=None))
#召回率指实际为正的样本中被预测为正的样本所占实际为正的样本的比例，即TP/TP+FN
from sklearn.metrics import recall_score  #导入召回率评估的类
print(recall_score(y_true, y_pred, average='macro'))  
print(recall_score(y_true, y_pred, average='micro'))  
print(recall_score(y_true, y_pred, average='weighted'))  
print(recall_score(y_true, y_pred, average=None))
#回归的评估指标
#MAE，平均绝对误差，Mean absolute error，预测值与真实值的绝对误差的平均值
#MSE，均方误差，Mean squared error，预测值与真实值的绝对平方误差的平均值
from sklearn.metrics import mean_absolute_error   #导入平均绝对误差的类
from sklearn.metrics import mean_squared_error    #导入均方误差的类
mean_absolute_erro(true, pred)   #输出MAE
mean_squared_error(true, pred)   #输出MSE