scikit-learn Plot classification probability

# 资料汇入
iris = datasets.load_iris()
X = iris.data[:, 0:2]  # we only take the first two features for visualization
y = iris.target  # 目标资料


# print(X.shape)  得到x的shape ，shape[0] 返回的是第一维度长度，shape[1] 返回第二维度长度
n_features = X.shape[1]  # 0,图像的高度 1，图像的宽度 2，图像的通道数

# print(iris.items())  {('data',array()),('target',array()),('target_name',array())}
# 看一下iris里面是个啥
for key,value in iris.items():
    try:
        print(key,value.shape)
    except:
        print(key)

'''
#输出： 
data (150, 4)   #有150个数据，共四种特征
target (150,)   #这150个数据各是哪一种鸢尾花
target_names (3,)  #共有三种鸢尾花 setosa, versicolor, virgin
DESCR   #文件之描述
feature_names  #四个特征代表的意义
filename  #文件名
 
#item()的用法：
#字典 items() 方法以列表返回可遍历的(键, 值) 元组数组
#例子：
dict = {'Name': 'Runoob', 'Age': 7}
for i,j in dict.items():
    print(i, ":\t", j)
 
#输出：
Name :   Runoob
Age :    7

'''

C = 10
# RBF 径向基函数核，平方指数核，他的参数是一个长度尺度
kernel = 1.0 * RBF([1.0, 1.0])  # for GPC  内核对象

# Create different classifiers.
'''
逻辑回归分类器
C : float, default: 1.0 正则强度逆或者叫做惩罚系数就是对误差的容忍度，值越高越不能容忍
penalty : str, ‘l1’ or ‘l2’, default: ‘l2’ 这个是l1 or l2正则化，一般选l2正则化对于逻辑回归分类算法
solver: 求解器，对于优化问题的算法，对于大数据集，使用'sag'和'saga'，对于多类问题对于多类问题，只有 'newton-cg'、'sag'、'saga' 和 'lbfgs' 处理多项式损失；'liblinear' 仅限于一对多的方案。 算法的选择取决于所选择的惩罚
multi_class 根据solver的选择确定值
max_iter: 求解器收敛的最大迭代次数
'''

# 选择了五种分类器，存入一个dict资料中
classifiers = {
    
      # LogisticRegression 逻辑回归分类器
    "L1 logistic": LogisticRegression(
                            C=C, penalty="l1",
                            solver="saga",
                            multi_class="multinomial",
                            max_iter=10000), # L1惩罚项
    "L2 logistic (Multinomial)": LogisticRegression(
                            C=C, penalty="l2",
                            solver="saga",
                            multi_class="multinomial",
                            max_iter=10000),
    "L2 logistic (OvR)": LogisticRegression(
                            C=C, penalty="l2",
                            solver="saga",
                            multi_class="ovr",
                            max_iter=10000),
    "Linear SVC": SVC(
                    kernel="linear",
                    C=C, probability=True,
                    random_state=0),
    "GPC": GaussianProcessClassifier(kernel),
}

n_classifiers = len(classifiers)

# figure(num=id号，figsize= 整数元祖，默认为长宽，dpi=整数，窗口分辨率，edgecolor=窗口的边框颜色，frameon=是否绘制窗口的图框)
plt.figure(figsize=(3 * 2, n_classifiers * 2))
# subplots_adjust(self,left,bottom,right,top,   wspace=,hsacpe=  子图间的横向间距、纵向间距分别与子图平均宽度、平均高度的比值)
plt.subplots_adjust(bottom=0.2, top=0.95)


'''
meshgrid 笛卡尔积
经过下列操作后，向量就产生了一个10000*2的二维向量
1.首先xx是长度为100的列向量，yy是长度为100的行向量
2.经过np.meshgrid （向量转成矩阵（数组）） xx向量的大小提供列数，yy的大小提供行数，
    可以这样理解，xx是一个x列的行向量，yy是一个y行的列向量，
    现在需要将向量转换成矩阵，就需要将xx这个行向量扩充行数，yy这个列向量扩列数
    xx扩充多少行由yy的大小决定，扩充的行向量就是xx
    yy扩充多少列有xx的大小决定，扩充的列向量就是yy
example： xx = array([3., 4., 5., 6., 7., 8., 9.])
          yy = array([1., 2., 3., 4., 5.])
          xx,yy = np.meshgrid(xx,yy)# 从坐标向量返回坐标矩阵
          xx.shape,yy.shape # (5,7)
          xx = array([[3., 4., 5., 6., 7., 8., 9.],
                      [3., 4., 5., 6., 7., 8., 9.],
                      [3., 4., 5., 6., 7., 8., 9.],
                      [3., 4., 5., 6., 7., 8., 9.],
                      [3., 4., 5., 6., 7., 8., 9.]])
          yy = array([[1., 1., 1., 1., 1., 1., 1.],
                      [2., 2., 2., 2., 2., 2., 2.],
                      [3., 3., 3., 3., 3., 3., 3.],
                      [4., 4., 4., 4., 4., 4., 4.],
                      [5., 5., 5., 5., 5., 5., 5.]])

'''
# np.linspace 返回一个等差数列（默认浮点数） 指定间隔内返回均匀间隔的数字 100个样本数
xx = np.linspace(3, 9, 100)
yy = np.linspace(1, 5, 100).T
# meshgrid 生成 网格点（每个交叉点） 坐标矩阵（描述这些网格点——横坐标矩阵X中的每个元素，与纵坐标矩阵Y中对应位置元素，共同构成一个点的完成坐标）
xx, yy = np.meshgrid(xx, yy)


'''
# python 的向量要看成列向量 向量：array = ([1,2,3]) shape(3,) 数组：array = ([[1,2,3]])shape(1,3)
    数组 --> 向量 array2vec = array.ravel()
    向量 --> 数组 
# np.r_ 按列连接两个矩阵，就是把两矩阵上下相加（不是+，是添加），要求列数相等，类似于pandas中的concat()
# np.c_是按行连接两个矩阵，就是把两矩阵左右相加，要求行数相等，类似于pandas中的merge()
xx.ravel() 按行遍历xx矩阵中的每一个元素、
np.c_ 取出xx一个元素，取出yy的一个元素，组成一个行向量，最终Xfull的shape为（10000,2）
'''
# ravel Return a flattened array. 遍历矩阵中每一个元素，将多维数组变一维 np.flattened() 和 np.ravel() 的区别在于f是copy（拷贝，不会改变原有的值）r是返回一个view（改变了原来的值）
Xfull = np.c_[xx.ravel(), yy.ravel()]

# enumerate 枚举
for index, (name, classifier) in enumerate(classifiers.items()):
    classifier.fit(X, y)  # X shape(150,2) 为训练样本 y为训练样本的标签
    y_pred = classifier.predict(X)   # y_pred(150,)
    accuracy = accuracy_score(y, y_pred) #0.8333333333333334
    print("Accuracy (train) for %s: %0.1f%% " % (name, accuracy * 100))

    # View probabilities:
    '''
    predict && predict_proba 都是用于模型的预测
        1.predict 是返回一个预测的值   
        2.predict_proba返回的是对于 预测为各个类别的概率
        例如：这个predict_proba在执行了下列的语句后返回的是一个（10000，3）的二维数组，每一列代表的是预测为此类别的概率
                类别为什么是3 呢？因为X这组数据只包含了3种类别
    '''
    probas = classifier.predict_proba(Xfull)
    # np.unique() 去除重复的数字
    n_classes = np.unique(y_pred).size # 得到了
    for k in range(n_classes):
        '''
        plt.subplot(*args,**kwargs) 简单来说 *unpack 一个元祖或者一串数字 分解为单个数字，** unpack一个dict
        args(nrows,ncols,index)
            nrows--有多少行
            ncols--有多少列
            index--索引，子图将以index的位置在一个有nrows行和ncols列的网格上。index 从左上角的1开始，向右增加
                        index也可以是个双元组，指定start 和 end 如fig.add_subplots(3,1,(1,2)) 制作一个子图，横跨图中图的上部2/3部分
        不理解python中 *，** 意思的转载 https://blog.csdn.net/callinglove/article/details/45483097?ops_request_misc=%257B%2522request%255Fid%2522%253A%2522163637908916780366546257%2522%252C%2522scm%2522%253A%252220140713.130102334.pc%255Fall.%2522%257D&request_id=163637908916780366546257&biz_id=0&utm_medium=distribute.pc_search_result.none-task-blog-2~all~first_rank_ecpm_v1~rank_v31_ecpm-1-45483097.pc_search_result_cache&utm_term=kwargs&spm=1018.2226.3001.4187
        
        subplot && subplots 之间的区别
        https://blog.csdn.net/sinat_35930259/article/details/80002213
        '''
        plt.subplot(n_classifiers, n_classes, index * n_classes + k + 1)
        plt.title("Class %d" % k)
        if k == 0:      # 在每一行的开始添加纵坐标名称
            plt.ylabel(name)

        imshow_handle = plt.imshow(
            probas[:, k].reshape((100, 100)), extent=(3, 9, 1, 5), origin="lower"
        )

        plt.xticks(())  # 将x轴和y轴删去小标
        plt.yticks(())
        idx = y_pred == k
        if idx.any():
            plt.scatter(X[idx, 0], X[idx, 1], marker="o", c="w", edgecolor="k")

ax = plt.axes([0.15, 0.04, 0.7, 0.05]) #（left,bottom,width,height）
plt.title("Probability")

# 给子图添加渐变条
# mappable 提供一个可以映射颜色的对象，这个对象就是之前做的图
# cax 用来指示colorbar（）获取到的渐变色条在哪里显示
# orientation="horizontal" 用来指示方向水平
plt.colorbar(imshow_handle, cax=ax, orientation="horizontal")

plt.show()