机器学习之鸢尾花-逻辑回归

import seaborn as sns
import pandas as pd
import numpy as np
import matplotlib.pyplot as plt
from sklearn import datasets
from matplotlib.colors import ListedColormap

# --------------------------------------------------------------------
# sklearn中的数据集为多种格式类型，特征值，分类值，列标签都是分开的
# seaborn中的数据集为pandas格式要求
# 考虑到seaborn展示的方便性，用seaborn进行数据可视化探索
# 在此把sklearn中的数据集转换为seaborn格式要求，也算兼顾了对pandas的学习
# --------------------------------------------------------------------

# 鸢尾花数据集
iris = datasets.load_iris()

# 鸢尾花数据集键值
# iris.keys()
# dict_keys(['data', 'target', 'target_names', 'DESCR', 'feature_names', 'filename'])

# 鸢尾花数据集的特征矩阵
# iris['data']
# [[5.1 3.5 1.4 0.2]
#  [4.9 3.  1.4 0.2]
#  [4.7 3.2 1.3 0.2]
#  [4.6 3.1 1.5 0.2]}
# 鸢尾花数据集的分类值，即目标数组
# iris['target']
# [0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0
# 鸢尾花数据集的特征标签名称
# iris['feature_names']
# ['sepal length (cm)', 'sepal width (cm)', 'petal length (cm)', 'petal width (cm)']
# 鸢尾花数据集的分类标签名称
# iris['target_names']
# ['setosa' 'versicolor' 'virginica']
# 鸢尾花数据集的数据路径
# iris.filename
# C:\Python\Python37\lib\site-packages\sklearn\datasets\data\iris.csv

# sns自带的iris是个pandas数据集，包含表头和分类
# iris = sns.load_dataset("iris")
#      sepal_length  sepal_width  petal_length  petal_width    species
# 0             5.1          3.5           1.4          0.2     setosa
# 1             4.9          3.0           1.4          0.2     setosa
pd_iris_data = pd.DataFrame(iris['data'],columns=iris['feature_names'])
pd_iris_target = pd.DataFrame(iris['target'],columns=['category'])
pd_iris = pd.concat([pd_iris_data, pd_iris_target], axis=1)

def get_iris_target_name(x):
    if x['category']==0:
        return 'setosa'
    elif x['category']==1:
        return 'versicolor'
    else:
        return 'virginica'
# 函数式新增列判断
pd_iris['category_name']=pd_iris.apply(get_iris_target_name,axis=1)
# lambda式新增列推导
pd_iris['newcategory_name']=pd_iris['category'].apply(lambda x:'setosa' if x==0 else ('versicolor' if x==1 else 'virginica'))


# ---------------------seaborn的几种用法-----------------------
# seaborn.pairplot(data, hue=None, hue_order=None, palette=None, vars=None, x_vars=None, y_vars=None, kind='scatter', diag_kind='hist', markers=None, size=2.5, aspect=1, dropna=True, plot_kws=None, diag_kws=None, grid_kws=None)¶
# 数据参数
# vars : 与data使用，否则使用data的全部变量。参数类型：numeric类型的变量list。
# {x, y}_vars : 与data使用，否则使用data的全部变量。参数类型：numeric类型的变量list。
# dropna : 是否剔除缺失值。参数类型：boolean, optional
# 特殊参数
# kind : {‘scatter’, ‘reg’}, optional Kind of plot for the non-identity relationships.
# diag_kind : {‘hist’, ‘kde’}, optional。Kind of plot for the diagonal subplots.
# 基本参数
# size : 默认 6，图的尺度大小（正方形）。参数类型：numeric
# hue : 使用指定变量为分类变量画图。参数类型：string (变量名)
# hue_order : list of strings Order for the levels of the hue variable in the palette
# palette : 调色板颜色
# markers : 使用不同的形状。参数类型：list
# aspect : scalar, optional。Aspect * size gives the width (in inches) of each facet.
# {plot, diag, grid}_kws : 指定其他参数。参数类型：dicts

# # 设置并使用 seaborn 默认的主题、尺寸大小以及调色板。
# sns.set(style="ticks", color_codes=True)
# # 指定分类变量的，散点图
# # 两种方法指定x,y,hue列
# # 第一种是在x_vars,y_vars,hue中指定，data作为一个整体
# cols = ['sepal length (cm)', 'sepal width (cm)', 'petal length (cm)', 'petal width (cm)']
# sns.pairplot(pd_iris, hue='category_name',kind='scatter', diag_kind='hist',x_vars=cols,y_vars=cols)
# plt.show()
# # 第二种是在data中指定x,y,hue列，hue指定分组列
# # pandas中有多余的列，所以必须指定列，且hue列必须在前序的data列中
# cols = ['sepal length (cm)', 'sepal width (cm)', 'petal length (cm)', 'petal width (cm)','category_name']
# sns.pairplot(pd_iris[cols], hue='category_name',kind='scatter', diag_kind='hist')
# plt.show()

# data=sns.load_dataset('iris')
# 使用标准sns.pairplot进行设置
# 散点图 + KDE图
# sns.pairplot(data)
# 散点图 + 分类 + 直方图
# sns.pairplot(data, hue='species',kind='scatter', diag_kind='hist')
# 散点图 + 分类 + KDE图
# sns.pairplot(data, hue='species',kind='scatter', diag_kind="kde")
# 散点图 + KDE图 + 调色板
# sns.pairplot(data, hue="species", palette="husl")
# # 散点图 + KDE图 + 图标
# sns.pairplot(data, hue="species", markers=["o", "s", "D"])
# # 散点图 + KDE图 + 回归线
# sns.pairplot(data, hue="species", kind="reg")
# plt.show()

# # 通过定制化方式进行参数设置，更加灵活和定制
# g = sns.PairGrid(data, hue="species")
# # 全局性图表类型设置
# g = g.map(plt.scatter)
# # 对角线图表类型设置
# g = g.map_diag(plt.hist)
# # 非对角线图表类型设置
# g = g.map_offdiag(plt.scatter)
# # 右上角图表类型设置
# g = g.map_upper(sns.kdeplot, lw=3, legend=False)
# # 左下角图表类型设置
# g = g.map_lower(sns.kdeplot, cmap="Blues_d")
# # 加图例
# g = g.add_legend()
# plt.show()

from sklearn.model_selection import train_test_split
from sklearn.linear_model import LogisticRegression
from sklearn.metrics import accuracy_score

def load_data(datasets):
    # 将数据集拆分为训练集和测试集
    X_train, X_test, y_train, y_test = train_test_split(datasets.data, datasets.target, test_size=0.70, random_state=0)
    return X_train, X_test, y_train, y_test

# ----------------------------------------逻辑回归定义----------------------------------------------
# 逻辑模型是一种广泛使用的统计模型，在其基本形式中，使用逻辑函数来模拟二进制 因变量; 存在更复杂的扩展。
# 在回归分析中，逻辑回归是估计逻辑模型的参数; 它是二项式回归的一种形式。
# 在数学上，二元逻辑模型具有一个具有两个可能值的因变量，例如通过/失败，赢/输，活/死或健康/生病; 这些由指示符变量表示，其中两个值标记为“0”和“1”。
# 在逻辑模型中，对数比值（在对数的的可能性），用于标记为“1”的值是一个线性组合的一个或多个自变量（“预测”）;
# 自变量可以是二进制变量（两个类，由指示符变量编码）或连续变量（任何实际值）
# ----------------------------------------逻辑回归优缺点----------------------------------------------
# 优点：
#   实现简单，广泛的应用于工业问题上；
#   分类时计算量非常小，速度很快，存储资源低；
#   便利的观测样本概率分数；
#   对逻辑回归而言，多重共线性并不是问题，它可以结合L2正则化来解决该问题；
#   计算代价不高，易于理解和实现；
# 缺点：
#   当特征空间很大时，逻辑回归的性能不是很好；
#   容易欠拟合，一般准确度不太高
#   不能很好地处理大量多类特征或变量；
#   只能处理两分类问题（在此基础上衍生出来的softmax可以用于多分类），且必须线性可分；
#   对于非线性特征，需要进行转换
# ----------------------------------------逻辑回归参数详解----------------------------------------------
# 正则化选择参数 penalty : str, ‘l1’or ‘l2’, 默认: ‘l2’
#         在调参时如果我们主要的目的只是为了解决过拟合，一般penalty选择L2正则化就够了。
#         但是如果选择L2正则化发现还是过拟合，即预测效果差的时候，就可以考虑L1正则化。
#         另外，如果模型的特征非常多，我们希望一些不重要的特征系数归零，从而让模型系数稀疏化的话，也可以使用L1正则化。
#         penalty参数的选择会影响我们损失函数优化算法的选择。
# dual:bool 默认False ‘双配方仅用于利用liblinear解算器的l2惩罚。’
# tol: float, 默认: 1e-4 ‘公差停止标准’
# C:float 默认:1.0 正则化强度， 与支持向量机一样，较小的值指定更强的正则化。
#         C值大，对误分类的惩罚大，趋向于训练集全分对的情况，准确率高，泛化能力弱。C值小，惩罚小，允许容错，泛化能力强。
# fit_intercept: bool 默认:True 指定是否应将常量（a.k.a. bias或intercept）添加到决策函数中。
# intercept_scaling:float ,默认:1 仅在使用求解器“liblinear”且self.fit_intercept设置为True时有用。
#         在这种情况下，x变为[x，self.intercept_scaling]，即具有等于intercept_scaling的常数值的“合成”特征被附加到实例矢量。
#         截距变为intercept_scaling * synthetic_feature_weight
# class_weight: dict or ‘balanced’ 默认:None
#         与{class_label：weight}形式的类相关联的权重。
#                 如果没有给出，所有类都应该有一个权重。
#                         “平衡”模式使用y的值自动调整与输入数据中的类频率成反比的权重，如n_samples /（n_classes * np.bincount（y））。
#                 如果指定了sample_weight，这些权重将与sample_weight（通过fit方法传递）相乘。
# random_state:int,RandomState实例或None，可选，默认值：None
#         在随机数据混洗时使用的伪随机数生成器的种子。
#                 如果是int，则random_state是随机数生成器使用的种子;
#                 如果是RandomState实例，则random_state是随机数生成器; 如果为None，则随机数生成器是np.random使用的RandomState实例。
#                 在求解器=='sag'或'liblinear'时使用。
# solver:{‘newton-cg’,’lbfgs’,’liblinear’,’sag’,’saga’}
#         默认: ‘liblinear’ 在优化问题中使用的算法。
#         如果选择‘l1’的话就只能用‘liblinear’算法。
#         如果选择‘l2’，solver参数可以选择‘liblinear’、‘newton-cg’、‘sag’和‘lbfgs’这四种算法；
#                 a) liblinear：使用了开源的liblinear库实现，内部使用了坐标轴下降法来迭代优化损失函数，小型数据集。
#                 b) lbfgs：拟牛顿法的一种，利用损失函数二阶导数矩阵即海森矩阵来迭代优化损失函数。
#                 c) newton-cg：也是牛顿法家族的一种，利用损失函数二阶导数矩阵即海森矩阵来迭代优化损失函数。
#                 d) sag：即随机平均梯度下降，是梯度下降法的变种，和普通梯度下降法的区别是每次迭代仅仅用一部分的样本来计算梯度，适合于样本数据多的时候，SAG是一种线性收敛算法，这个速度远比SGD快
#         优劣势
#         正则化    算法  适用场景
#                 L1    liblinear   liblinear适用于小数据集；如果选择L2正则化发现还是过拟合，即预测效果差的时候，就可以考虑L1正则化；如果模型的特征非常多，希望一些不重要的特征系数归零，从而让模型系数稀疏化的话，也可以使用L1正则化。
#                 L2    liblinear   libniear只支持多元逻辑回归的OvR，不支持MvM，但MVM相对精确。
#                 L2    lbfgs/newton-cg/sag 较大数据集，支持one-vs-rest(OvR)和many-vs-many(MvM)两种多元逻辑回归。
#                 L2    sag 如果样本量非常大，比如大于10万，sag是第一选择；但不能用于L1正则化。
# max_iter: int 默认:100 仅适用于newton-cg，sag和lbfgs求解器。 求解器收敛的最大迭代次数。
# muti_class:str,{‘ovr’:’multinomial’},默认:’ovr’
#         多类选项可以是'ovr'或'multinomial'。
#         如果选择了ovr，则4种损失函数的优化方法liblinear，newton-cg, lbfgs和sag都可以选择。
#         但是如果选择了multinomial,则只能选择newton-cg, lbfgs和sag了
# verbose: int,默认:0 对于liblinear和lbfgs求解器，将verbose设置为任何正数以表示详细程度。
# warm_start:bool 默认:False
# n_jobs: int,默认:1
#         如果multi_class ='ovr'“，则在对类进行并行化时使用的CPU核心数。
#         无论是否指定'multi_class'，当``solver``设置为'liblinear'时，都会忽略此参数。 如果给定值-1，则使用所有核心。
# 使用LogisticRegression考察线性回归的预测能力
# ----------------------------------------逻辑回归参数详解----------------------------------------------
def test_LogisticRegression(X_train, X_test, y_train, y_test):
    # 选择逻辑回归模型，默认penalty='l2',solver='lbfgs',C=1.0,max_iter=100,
    model = LogisticRegression()
    # LogisticRegression(C=1.0, class_weight=None, dual=False, fit_intercept=True,
    #                    intercept_scaling=1, l1_ratio=None, max_iter=100,
    #                    multi_class='auto', n_jobs=None, penalty='l2',
    #                    random_state=None, solver='lbfgs', tol=0.0001, verbose=0,
    #                    warm_start=False)
    # 把数据交给模型训练
    model.fit(X_train, y_train)
    print("Coefficients:%s, intercept %s"%(model.coef_,model.intercept_))
    print("Residual sum of squares:%.4f" % np.mean((model.predict(X_test) - y_test) ** 2))
    print('Score: %.4f' % model.score(X_test, y_test))

# 使用LogisticRegression考察线性回归的预测能力
def test_LogisticRegression_C(X_train, X_test, y_train, y_test):
    # ---------------调整正则化强度 C参数设置----------------
    Cs=np.logspace(-2,4,num=100)
    scores_train=[]
    scores_test=[]
    for C in Cs:
        model = LogisticRegression(C=C,max_iter=1000)
        model.fit(X_train, y_train)
        scores_train.append(accuracy_score(model.predict(X_train), y_train))
        scores_test.append(accuracy_score(model.predict(X_test), y_test))
    # 绘图
    fig=plt.figure(figsize=(10, 6))
    ax=fig.add_subplot()
    # ax.plot(Cs, scores,label='score')
    ax.plot(Cs, scores_train, label='scores train')
    ax.plot(Cs, scores_test, label='scores test')
    ax.set_xlabel(r"C")
    ax.set_ylabel(r"score")
    ax.set_xscale('log')
    ax.set_title("LogisticRegression")
    ax.legend()
    plt.show()

def test_LogisticRegression_Cpenaltyssolvers(X_train, X_test, y_train, y_test):
    # ---------------调整C值、正则化参数和solver参数设置----------------
    Cs = np.logspace(-2, 4, num=100)
    labels=['l1 + liblinear','l2 + newton-cg', 'l2 + lbfgs','l2 + liblinear' , 'l2 + sag', 'l2 + saga']
    penaltys = ['l1','l2','l2','l2','l2','l2']
    solvers=['liblinear','newton-cg', 'lbfgs','liblinear' , 'sag', 'saga']
    fig = plt.figure(figsize=(10, 6))
    i=1
    for penalty,solver,label in zip(penaltys,solvers,labels):
        ax = fig.add_subplot(2,3,i)
        i=i+1
        scores_train=[]
        scores_test=[]
        for C in Cs:
            model = LogisticRegression(penalty=penalty,solver=solver ,max_iter=1000,C=C)
            model.fit(X_train, y_train)
            scores_train.append(accuracy_score(model.predict(X_train), y_train))
            scores_test.append(accuracy_score(model.predict(X_test), y_test))
        ax.plot(Cs, scores_train, '-',label= 'scores train')
        ax.plot(Cs, scores_test, ':',label='scores test')
        ax.set_xlabel(r"C")
        ax.set_ylabel(r"score")
        ax.set_xscale('log')
        ax.set_title(label+" LogisticRegression")
        ax.legend()
    # 绘图
    plt.show()

def test_LogisticRegression_Cmulti_classsolvers(X_train, X_test, y_train, y_test):
    # ---------------调整C值、multi_class参数和solver参数设置----------------
    Cs = np.logspace(-2, 4, num=100)
    labels = ['ovr + liblinear', 'ovr + newton-cg', 'ovr + lbfgs', 'ovr + sag', 'multinomial + newton-cg', 'multinomial + lbfgs', 'multinomial + sag']
    multi_classs = ['ovr', 'ovr', 'ovr', 'ovr', 'multinomial', 'multinomial', 'multinomial']
    solvers = ['liblinear', 'newton-cg', 'lbfgs', 'sag', 'newton-cg', 'lbfgs', 'sag']
    fig = plt.figure(figsize=(10, 6))
    i=1
    for multi_class,solver,label in zip(multi_classs,solvers,labels):
        ax = fig.add_subplot(2,4,i)
        i=i+1
        scores_train=[]
        scores_test=[]
        for C in Cs:
            model = LogisticRegression(multi_class=multi_class,solver=solver ,max_iter=1000,C=C)
            model.fit(X_train, y_train)
            scores_train.append(accuracy_score(model.predict(X_train), y_train))
            scores_test.append(accuracy_score(model.predict(X_test), y_test))
        ax.plot(Cs, scores_train, '-',label= 'scores train')
        ax.plot(Cs, scores_test, ':',label='scores test')
        ax.set_xlabel(r"C")
        ax.set_ylabel(r"score")
        ax.set_xscale('log')
        ax.set_title(label+" LogisticRegression")
        ax.legend()
    # 绘图
    plt.show()

def test_LogisticRegression_penaltyssolvers(X_train, X_test, y_train, y_test):
    # ---------------调整正则化参数和solver参数设置----------------
    labels = ['l1 + liblinear', 'l2 + newton-cg', 'l2 + lbfgs', 'l2 + liblinear', 'l2 + sag', 'l2 + saga']
    penaltys = ['l1', 'l2', 'l2', 'l2', 'l2', 'l2']
    solvers = ['liblinear', 'newton-cg', 'lbfgs', 'liblinear', 'sag', 'saga']
    # max_iter: int 默认:100 仅适用于newton-cg，sag和lbfgs求解器。 求解器收敛的最大迭代次数。
    fig = plt.figure(figsize=(10, 6))
    ax = fig.add_subplot()
    scores_train=[]
    scores_test=[]
    for penalty, solver in zip(penaltys, solvers):
        model = LogisticRegression(penalty=penalty, solver=solver, max_iter=1000, C=0.1)
        model.fit(X_train, y_train)
        scores_train.append(accuracy_score(model.predict(X_train), y_train))
        scores_test.append(accuracy_score(model.predict(X_test), y_test))
    print('scores_train = ',scores_train)
    print('scores_test = ', scores_test)
    # C=0.1
    # scores_train =  [0.8444444444444444, 0.9555555555555556, 0.9555555555555556, 0.9777777777777777, 0.9555555555555556, 0.9555555555555556]
    # scores_test =  [0.7714285714285715, 0.8666666666666667, 0.8666666666666667, 0.9619047619047619, 0.8666666666666667, 0.8666666666666667]
    # C=1
    # scores_train = scores_train =  [0.9555555555555556, 0.9777777777777777, 0.9777777777777777, 0.9777777777777777, 0.9777777777777777, 0.9555555555555556]
    # scores_test =  [0.9047619047619048, 0.9047619047619048, 0.9047619047619048, 0.9333333333333333, 0.9333333333333333, 0.9428571428571428]
    # C=10
    # scores_train =  [0.9777777777777777, 0.9777777777777777, 0.9777777777777777, 0.9777777777777777, 0.9777777777777777, 0.9777777777777777]
    # scores_test =  [0.9428571428571428, 0.9428571428571428, 0.9428571428571428, 0.9523809523809523, 0.9714285714285714, 0.9619047619047619]
    # C=100
    # scores_train = [0.9777777777777777, 0.9777777777777777, 0.9777777777777777, 0.9777777777777777, 0.9777777777777777, 0.9777777777777777]
    # scores_test = [0.9619047619047619, 0.9619047619047619, 0.9619047619047619, 0.9428571428571428, 0.9619047619047619, 0.9619047619047619]
    # C=1000
    # scores_train = [1.0, 1.0, 1.0, 0.9777777777777777, 0.9777777777777777, 0.9777777777777777]
    # scores_test = [0.9714285714285714, 0.9714285714285714, 0.9714285714285714, 0.9523809523809523, 0.9619047619047619, 0.9619047619047619]
    bar_width=0.4
    bar_x=np.arange(len(labels))
    bar1 = ax.bar(x=bar_x - bar_width / 2,height=scores_train, width=bar_width)
    bar2 = ax.bar(x=bar_x + bar_width / 2,height=scores_test, width=bar_width)
    ax.set_xlabel('group')
    ax.set_ylabel('score')
    ax.set_title('LogisticRegression score of different penalty and solver')
    ax.set_xticks(range(7))
    ax.set_xticklabels(labels)
    ax.set_yticklabels(np.arange(0, 1, 10))
    ax.legend((bar1, bar2), ('train score', 'test score'))
    plt.show()

def test_LogisticRegression_multi_classssolvers(X_train, X_test, y_train, y_test):
    # ---------------调整multi_class参数和solver参数设置----------------
    labels = ['ovr + liblinear', 'ovr + newton-cg', 'ovr + lbfgs', 'ovr + sag', 'multinomial + newton-cg',
              'multinomial + lbfgs', 'multinomial + sag']
    multi_classs = ['ovr', 'ovr', 'ovr', 'ovr', 'multinomial', 'multinomial', 'multinomial']
    solvers = ['liblinear', 'newton-cg', 'lbfgs', 'sag', 'newton-cg', 'lbfgs', 'sag']
    # max_iter: int 默认:100 仅适用于newton-cg，sag和lbfgs求解器。 求解器收敛的最大迭代次数。
    fig = plt.figure(figsize=(10, 6))
    ax = fig.add_subplot()
    scores_train=[]
    scores_test=[]
    for multi_class, solver, label in zip(multi_classs, solvers, labels):
        model = LogisticRegression(multi_class=multi_class, solver=solver, max_iter=1000, C=0.1)
        model.fit(X_train, y_train)
        scores_train.append(accuracy_score(model.predict(X_train), y_train))
        scores_test.append(accuracy_score(model.predict(X_test), y_test))
    print('scores_train = ',scores_train)
    print('scores_test = ', scores_test)
    # C=0.1
    # scores_train =  [0.9777777777777777, 0.9333333333333333, 0.9333333333333333, 0.9333333333333333, 0.9555555555555556, 0.9555555555555556, 0.9555555555555556]
    # scores_test =  [0.9619047619047619, 0.8476190476190476, 0.8476190476190476, 0.8476190476190476, 0.8666666666666667, 0.8666666666666667, 0.8666666666666667]
    # C=1
    # scores_train =  [0.9777777777777777, 0.9111111111111111, 0.9111111111111111, 0.9111111111111111, 0.9777777777777777, 0.9777777777777777, 0.9777777777777777]
    # scores_test =  [0.9333333333333333, 0.8666666666666667, 0.8666666666666667, 0.8952380952380953, 0.9047619047619048, 0.9047619047619048, 0.9333333333333333]
    # C=10
    # scores_train =  [0.9777777777777777, 0.9555555555555556, 0.9555555555555556, 0.9777777777777777, 0.9777777777777777, 0.9777777777777777, 0.9777777777777777]
    # scores_test =  [0.9523809523809523, 0.9238095238095239, 0.9238095238095239, 0.9523809523809523, 0.9428571428571428, 0.9428571428571428, 0.9714285714285714]
    # C=100
    # scores_train =  [0.9777777777777777, 0.9777777777777777, 0.9777777777777777, 0.9777777777777777, 0.9777777777777777, 0.9777777777777777, 0.9777777777777777]
    # scores_test =  [0.9428571428571428, 0.9428571428571428, 0.9428571428571428, 0.9619047619047619, 0.9619047619047619, 0.9619047619047619, 0.9619047619047619]
    # C=1000
    # scores_train =  [0.9777777777777777, 0.9777777777777777, 0.9777777777777777, 0.9777777777777777, 1.0, 1.0, 0.9777777777777777]
    # scores_test =  [0.9523809523809523, 0.9619047619047619, 0.9619047619047619, 0.9619047619047619, 0.9714285714285714, 0.9714285714285714, 0.9619047619047619]
    bar_width=0.4
    bar_x=np.arange(len(labels))
    bar1 = ax.bar(x=bar_x - bar_width / 2,height=scores_train, width=bar_width)
    bar2 = ax.bar(x=bar_x + bar_width / 2,height=scores_test, width=bar_width)
    ax.set_xlabel('group')
    ax.set_ylabel('score')
    ax.set_title('LogisticRegression score of different multi_class and solver')
    ax.set_xticks(range(8))
    ax.set_xticklabels(labels)
    ax.set_yticklabels(np.arange(0, 1, 10))
    ax.legend((bar1, bar2), ('train score', 'test score'))
    plt.show()

from sklearn.model_selection import GridSearchCV
def test_LogisticRegression_best(X_train, X_test, y_train, y_test):
    # multi_classs = ['ovr','multinomial']
    # solvers = ['liblinear', 'newton-cg', 'lbfgs', 'sag','saga']
    # penaltys = ['l1', 'l2']
    # Cs = [0.01,0.1,1,10,100,100]
    tuned_parameters=[{'penalty':['l1'],
                       'C':[0.01,0.1,1,10,100,1000],
                       'solver':['liblinear'],
                       'multi_class':['ovr','multinomial']},
                      {'penalty': ['l2'],
                       'C': [0.01, 0.1, 1, 10, 100, 1000],
                       'solver': [  'newton-cg', 'lbfgs', 'sag'],
                       'multi_class': [ 'multinomial']},
                      {'penalty': ['l2'],
                       'C': [0.01, 0.1, 1, 10, 100, 1000],
                       'solver': [ 'newton-cg', 'lbfgs', 'liblinear', 'sag'],
                       'multi_class': ['ovr']}
                      ]
    model = GridSearchCV(LogisticRegression(tol=1e-6), tuned_parameters, cv=10)
    model.fit(X_train, y_train)
    print('Best parameters set found:', model.best_params_)
    # Best parameters set found: {'C': 1, 'multi_class': 'multinomial', 'penalty': 'l2', 'solver': 'sag'}
    # 得分网格报告
    # print(model.cv_results_)
    model = LogisticRegression(C=1,multi_class='multinomial',penalty='l2', solver='sag')
    # 把数据交给模型训练
    model.fit(X_train, y_train)
    print("Coefficients:%s, intercept %s" % (model.coef_, model.intercept_))
    print("Residual sum of squares:%.4f" % np.mean((model.predict(X_test) - y_test) ** 2))
    print('Score: %.4f' % model.score(X_test, y_test))
    # Score: 0.9714
#      sepal_length  sepal_width  petal_length  petal_width    species
def draw_iris(dataset):

    # 基于sepal length (cm)和sepal width (cm)进行散点图绘制，2维 2D展示
    plt.plot(dataset[dataset['category'] == 0]['sepal length (cm)'], dataset[dataset['category'] == 0]['sepal width (cm)'], 'rs', label='setosa')
    plt.plot(dataset[dataset['category'] == 1]['sepal length (cm)'], dataset[dataset['category'] == 1]['sepal width (cm)'], 'bx', label='versicolor')
    plt.plot(dataset[dataset['category'] == 2]['sepal length (cm)'], dataset[dataset['category'] == 2]['sepal width (cm)'], 'go', label='virginica')
    plt.xlabel("sepal length (cm)")
    plt.ylabel("sepal width (cm)")
    plt.title("预测分类边界")
    plt.legend()
    plt.rcParams['font.sans-serif'] = 'SimHei'  # 消除中文乱码
    plt.show()

    from mpl_toolkits.mplot3d import Axes3D
    # 基于sepal length (cm)和sepal width (cm)、petal length (cm)进行散点图绘制，3维 3D展示
    fig = plt.figure()
    ax=Axes3D(fig)
    ax.scatter(dataset[dataset['category'] == 0]['sepal length (cm)'], dataset[dataset['category'] == 0]['sepal width (cm)'], dataset[dataset['category'] == 0]['petal length (cm)'],c='r',marker='o', label='setosa')
    ax.scatter(dataset[dataset['category'] == 1]['sepal length (cm)'], dataset[dataset['category'] == 1]['sepal width (cm)'], dataset[dataset['category'] == 0]['petal length (cm)'],c='b',marker='x', label='versicolor')
    ax.scatter(dataset[dataset['category'] == 2]['sepal length (cm)'], dataset[dataset['category'] == 2]['sepal width (cm)'], dataset[dataset['category'] == 0]['petal length (cm)'],c='g',marker='s', label='virginica')
    ax.set_xlabel("sepal length (cm)")
    ax.set_ylabel("sepal width (cm)")
    ax.set_ylabel("petal length (cm)")
    plt.title("预测分类边界")
    plt.legend()
    plt.rcParams['font.sans-serif'] = 'SimHei'  # 消除中文乱码
    plt.show()

    from mpl_toolkits.mplot3d import Axes3D
    # 基于sepal length (cm)和sepal width (cm) 、 'petal length (cm)', 'petal width (cm)'进行散点图绘制，4维 4D展示
    fig = plt.figure()
    ax=Axes3D(fig)
    ax.scatter3D(dataset[dataset['category'] == 0]['sepal length (cm)'], dataset[dataset['category'] == 0]['sepal width (cm)'], dataset[dataset['category'] == 0]['petal length (cm)'],s=dataset[dataset['category'] == 0]['petal width (cm)']*100,c='r',marker='o', label='setosa')
    ax.scatter3D(dataset[dataset['category'] == 1]['sepal length (cm)'], dataset[dataset['category'] == 1]['sepal width (cm)'], dataset[dataset['category'] == 0]['petal length (cm)'],s=dataset[dataset['category'] == 0]['petal width (cm)']*100,c='b',marker='x', label='versicolor')
    ax.scatter3D(dataset[dataset['category'] == 2]['sepal length (cm)'], dataset[dataset['category'] == 2]['sepal width (cm)'], dataset[dataset['category'] == 0]['petal length (cm)'],s=dataset[dataset['category'] == 0]['petal width (cm)']*100,c='g',marker='s', label='virginica')
    ax.set_xlabel("sepal length (cm)")
    ax.set_ylabel("sepal width (cm)")
    ax.set_ylabel("petal length (cm)")
    plt.title("预测分类边界")
    plt.legend()
    plt.rcParams['font.sans-serif'] = 'SimHei'  # 消除中文乱码
    plt.show()

    # Andrews曲线
    cols = ['sepal length (cm)', 'sepal width (cm)', 'petal length (cm)', 'petal width (cm)','category_name']
    pd.plotting.andrews_curves(dataset[cols], 'category_name')
    plt.show()

def draw_iris_boundry(dataset):

    cols = ['sepal length (cm)', 'sepal width (cm)']
    X=np.array(dataset[cols])
    y=np.array(dataset['category'])
    #逻辑回归模型
    lr = LogisticRegression(C=1000)
    lr.fit(X,y)

    # meshgrid函数生成两个网格矩阵
    # 获取的鸢尾花两列数据，对应为花萼长度和花萼宽度，每个点的坐标就是(x, y)。
    # 先取X二维数组的第一列（长度）的最小值、最大值和步长h（设置为0.02）生成数组，
    # 再取X二维数组的第二列（宽度）的最小值、最大值和步长h生成数组，
    # 最后用meshgrid函数生成两个网格矩阵xx和yy，
    h = .02
    x_min, x_max = X[:, 0].min() - .5, X[:, 0].max() + .5
    y_min, y_max = X[:, 1].min() - .5, X[:, 1].max() + .5
    xx, yy = np.meshgrid(np.arange(x_min, x_max, h), np.arange(y_min, y_max, h))

    # pcolormesh函数将xx,yy两个网格矩阵和对应的预测结果Z绘制在图片上
    Z = lr.predict(np.c_[xx.ravel(), yy.ravel()])
    Z = Z.reshape(xx.shape)

    cmap_light = ListedColormap(['#AAAAFF', '#AAFFAA', '#FFAAAA'])
    plt.figure(1, figsize=(8, 6))
    # 调用pcolormesh()函数将xx、yy两个网格矩阵和对应的预测结果Z绘制在图片上，可以发现输出为三个颜色区块，分布表示分类的三类区域。
    # cmap=ListedColormap表示绘图样式选择相应的色彩。
    plt.pcolormesh(xx, yy, Z, cmap=cmap_light)

    # 绘制散点图
    plt.plot(dataset[dataset['category'] == 0]['sepal length (cm)'], dataset[dataset['category'] == 0]['sepal width (cm)'], 'rs', label='setosa')
    plt.plot(dataset[dataset['category'] == 1]['sepal length (cm)'], dataset[dataset['category'] == 1]['sepal width (cm)'], 'bx', label='versicolor')
    plt.plot(dataset[dataset['category'] == 2]['sepal length (cm)'], dataset[dataset['category'] == 2]['sepal width (cm)'], 'go', label='virginica')

    plt.xlabel('Sepal length')
    plt.ylabel('Sepal width')
    plt.xlim(xx.min(), xx.max())
    plt.ylim(yy.min(), yy.max())
    plt.xticks(())
    plt.yticks(())
    plt.legend(loc=2)
    plt.show()

draw_iris(pd_iris)
draw_iris_boundry(pd_iris)
if __name__=='__main__':
    X_train,X_test,y_train,y_test=load_data(iris)
    # -----------------------逻辑回归--------------------------------
    test_LogisticRegression(X_train,X_test,y_train,y_test)
    test_LogisticRegression_C(X_train, X_test, y_train, y_test)
    test_LogisticRegression_Cpenaltyssolvers(X_train, X_test, y_train, y_test)
    test_LogisticRegression_Cmulti_classsolvers(X_train, X_test, y_train, y_test)
    test_LogisticRegression_penaltyssolvers(X_train, X_test, y_train, y_test)
    test_LogisticRegression_multi_classssolvers(X_train, X_test, y_train, y_test)
    test_LogisticRegression_best(X_train, X_test, y_train, y_test)


# ---------------------K近邻算法-----------------------

# ------------------高斯朴素贝叶斯-----------------------

# ---------------------决策树-----------------------

# ---------------------K Means聚类-----------------------

# ------------------高斯混合模型聚类-----------------------

# -------------------SVM支撑向量机-----------------------