降维PCA&LDA&数据预处理（preprocessing）

# pca 降维看效果
# decomposition分解
from sklearn.decomposition import PCA
# n_components=None 这个参数 可以是整数 也 可以是小数 整数表示保留几个特征 小数表示保留的比例
pca = PCA(n_components=2)
pca.fit(data)  # 这里只需要特征值 不需要目标值 (lda 既要特征值 也要 目标值 因为要计算各组 直接的做大差异)
pca_data = pca.transform(data)  # 转换

plt.scatter(pca_data[:,0],pca_data[:,1],c=target)
plt.scatter(data[:,0],data[:,1],c=target)

def cross_verify(data,target,model):
    scores = []
    for i in [0.1,0.2,0.3]:
        X_train,X_test,y_train,y_test = train_test_split(data,target,test_size=i)
        model.fit(X_train,y_train)
        score = model.score(X_test,y_test)
        scores.append(score)
    return np.array(scores).mean()

# 这里传入的是 pca降维后的数据
cross_verify(pca_data,target,KNeighborsClassifier())
# 降低了维度 准确率没有受到太大影响
# LDA discriminant_analysis判别分析
from sklearn.discriminant_analysis import LinearDiscriminantAnalysis
# n_components 指定保留的维度
lda = LinearDiscriminantAnalysis(n_components=2)

lda.fit(data,target)  # lda需要指定分组情况 才能找到各组直接中心距离最大的位置
# 所以 既要传入 特征值 也要 传入 目标值（和pca不同）
lda_data = lda.transform(data)

plt.scatter(lda_data[:,0],lda_data[:,1],c=target)

plt.scatter(pca_data[:,0],pca_data[:,1],c=target)

cross_verify(lda_data,target,KNeighborsClassifier())

# sklearn官网
# MinMaxScaler 区间归一化 (当前值-最小值)/(最大值-最小值)
# StandardScaler 标准化 (当前值-平均值)/标准差
# Normalizer 归一化 (当前值-平均值)/(最大值-最小值)
# Binarizer 二值化 （这里就不尝试了 主要用来处理图片）
from sklearn.preprocessing import MinMaxScaler,Normalizer,StandardScaler,Binarizer
# MinMaxScaler()
mms = MinMaxScaler()
mms.fit(data)
mms.transform(data)
minmax_data = MinMaxScaler().fit_transform(data)
normal_data = Normalizer().fit_transform(data)
standard_data = StandardScaler().fit_transform(data)

X_train1, X_test1, y_train1, y_test1 = train_test_split(data,target,test_size=0.25)  # 没有处理的数据
X_train2, X_test2, y_train2, y_test2 = train_test_split(minmax_data,target,test_size=0.25)
X_train3, X_test3, y_train3, y_test3 = train_test_split(normal_data,target,test_size=0.25)
X_train4, X_test4, y_train4, y_test4 = train_test_split(standard_data,target,test_size=0.25)

# 使用一些分类模型去尝试 knn lgc dtree nb svc
from sklearn.neighbors import KNeighborsClassifier
from sklearn.linear_model import LogisticRegression
from sklearn.tree import DecisionTreeClassifier
from sklearn.naive_bayes import GaussianNB
from sklearn.svm import SVC

knn = KNeighborsClassifier()
lgc = LogisticRegression()
dtree = DecisionTreeClassifier()
gnb = GaussianNB()
svc = SVC()

封装函数 使用各种模型 对 各种处理后的 数据 进行测试

选择 使用 哪一种 预处理方式

def select_preprocessor(model,name,X_train, X_test, y_train, y_test):
    model.fit(X_train,y_train)
    score = model.score(X_test,y_test)
    print("{}模型 {}处理的数据 得分是{}".format(model.__class__.__name__,name,score))

select_preprocessor(knn,'未',X_train1, X_test1, y_train1, y_test1 )
select_preprocessor(knn,'minmax',X_train2, X_test2, y_train2, y_test2 )
select_preprocessor(knn,'normal',X_train3, X_test3, y_train3, y_test3 )
select_preprocessor(knn,'standard',X_train4, X_test4, y_train4, y_test4 )

normal肯定是不用了 #其他方式都差不多 就可以不处理了

选择模型 选择模型是选择表现比较稳定的

使用不处理的 数据 对模型进行训练 看分数

def select_model(model,data,target,rate):
    X_train, X_test, y_train, y_test = train_test_split(data,target,test_size=rate)
    model.fit(X_train,y_train)
    score = model.score(X_test,y_test)
    print(model.__class__.__name__+':'+str(score))
    return score

# 传入一个列表 列表里面都是 各种模型
def select_model2(models,data,target):
    for model in models:
        score1 = select_model(model,data,target,0.1)
        score2 = select_model(model,data,target,0.2)
        score3 = select_model(model,data,target,0.3)
        # 主要想看的是 平均分 和 标准差
        nd = np.array([score1,score2,score3])
        print('平均分:%f 标准差:%f'%(nd.mean(),nd.std()))
        print('\n')   

select_model2([knn,lgc,dtree,gnb,svc],data,target)