import numpy as np
 
 
def f(Z):
    """
    映射函数, 时间复杂度 O(n^2)?
    """
    Z1 = Z ** 2
    Z_shape = np.shape(Z)[1] - 1
    Z0 = []
    for i in range(Z_shape, 0, -1):
        for j in range(i - 1, -1, -1):
            xy = Z[0, i] * Z[0, j] * 2 ** 0.5
            Z0.append(xy)
    Z2 = np.array(Z0).reshape(1, -1)
    Z3 = Z * 2 ** 0.5
    return np.hstack((Z1 ,Z2, Z3, [[1]]))
 
 
X = np.array([[1,2,3,4]])  # 4 维行向量
Y = np.array([[5,6,7,8]])
# 使用多项式核函数计算
XY_poly = (X.dot(Y.T) + 1) ** 2
print("使用多项式核函数计算的结果为：", XY_poly)
# 使用映射的计算
X1 = f(X)
Y1 = f(Y)
print("使用映射计算的结果为：", X1.dot(Y1.T))
print("输出 X 的映射值为：\n",X1)
print("输出 Y 的映射值为：\n",Y1)
print("原输入空间的维度为：", np.shape(X)[1])
print("映射后特征空间的维度为：", np.shape(X1)[1])

import numpy as np
from sklearn.svm import SVC  # 导入 SVC 模型
import matplotlib.pyplot as plt
import matplotlib as mpl
 
# 导入数据
train_x = np.array([[4, 3], [3, 3], [1, 1]])
train_y = np.array([1, 1, -1])  # 写出对应的类别
print("训练集(最右一列为标签):\n", np.hstack((x, y.reshape(3, 1))))
 
# 调用 SVC, 训练算法
model = SVC(kernel="linear")  # 实例化, 设置的核函数为线性核函数
model.fit(x, y)  # 用训练集数据训练模型, 和上一句配合使用
 
# 预测数据
test_x = np.array([[4, 5], [0, 0], [1, 3]])
test_y = model.predict(test_x)
print("预测数据[4, 5], [0, 0], [1, 3]的类型值分别是", test_y)
 
# 相关方法和返回值
w = model.coef_[0]  # 获取 w
a = -w[0] / w[1]  # 斜率
b = model.intercept_
print("支持向量：\n",model.support_vectors_)  # 打印支持向量
print("支持向量的标号：",model.support_)  # 打印支持向量的标号
print("每类支持向量的个数：",model.n_support_)  # 每类支持向量的个数
print("数据集 X 到分类超平面的距离：",model.decision_function(x))
print("参数（法向量）w =", w)
print("分类线的斜率 a =", a)
print("分类平面截距 b：", b)  # 超平面的截距值（常数值）。
print("系数",model.coef_)  # 每个特征系数（重要性），只有 LinearSVC 核函数可用
print("超平面方程为{}x + {}y {} = 0".format(w[0], w[1], b[0]))
 
# 绘图
mpl.rcParams["font.sans-serif"] = ["Microsoft YaHei"]
mpl.rcParams['axes.unicode_minus'] = False
plt.figure()
plt.axis("equal")
for i in range(0, len(train_x)):
    plt.scatter(train_x[i][0], train_x[i][1], color="red", marker=["x", "o"][int(train_y[i] * 0.5 + 0.5)])
for i in range(0, len(test_x)):
    plt.scatter(test_x[i][0], test_x[i][1], color="blue", marker=["x", "o"][int(test_y[i] * 0.5 + 0.5)])
plt.plot(np.linspace(0, 4, 2), a * np.linspace(0, 4, 2) - b / w[1])
l1 = plt.scatter(0, 0, color="red")  # 设置图例
l2 = plt.scatter(0, 0, color='red')
plt.legend(handles=[plt.scatter(0, 0, color="red", marker="o"), plt.scatter(0, 0, color="red", marker="x"),
                    plt.scatter(0, 0, color="blue", marker="o"), plt.scatter(0, 0, color="blue", marker="x")],
           labels=['训练集正例点', '训练集负例点', '测试集正例点', '测试集负例点'] , loc='best')  # 显示图例
plt.show()

#调用相关的库：
import numpy as np
from sklearn.svm import SVC
import matplotlib.pyplot as plt
from sklearn.datasets import make_circles  # 画圆圈的库
import matplotlib as mpl
 
mpl.rcParams['font.sans-serif'] = ['SimHei']

def plot_decision_boundary (model, X, y, h=0.03, draw_SV=True, title='decision_boundary'):
    """
    画分类数据集
    :param model:
    :param X:
    :param y:
    :param h: 步长
    :param draw_SV:
    :param title: 标题
    """
    X_min, X_max = X[:,0].min() - 1, X[:,0].max() + 1
    y_min, y_max = X[:,1].min() - 1, X[:, 1].max() + 1
    # 画决策边界，需要有网格，利用 np.meshgrid()生成一个坐标矩阵
    """
    语法：X,Y = numpy.meshgrid(x, y)
    输入的 x，y，就是网格点的横纵坐标列向量（非矩阵）
    输出的 X，Y，就是坐标矩阵。
    """
    xx, yy = np.meshgrid(np.arange(X_min, X_max, h),np.arange(y_min, y_max, h))
    # 预测坐标矩阵中每个点所属的类别
    label_predict = model.predict(np.stack((xx.flat, yy.flat), axis=1))       
    # 将结果放入彩色图中
    label_predict = label_predict.reshape(xx.shape)   # 使之与输入的形状相同
    plt.title(title)
    plt.xlim(xx.min(), xx.max())
    plt.ylim(yy.min(), yy.max())
    plt.xticks(())  # 隐藏坐标轴
    plt.yticks(())
    # contour 和 contourf 都是画三维等高线图的，不同点在于 contour() 是绘制轮廓线，contourf()会填充轮廓。
    plt.contourf(xx, yy, label_predict, alpha=0.5)  # 用 contourf()函数为坐标矩阵中不同类别填充不同颜色    
    markers = ['x', '^', 'o']
    colors = ['b', 'r', 'c'] # 蓝, 红, 青
    # 对于一维数组或者列表，unique 函数去除其中重复的元素，
    # 并按元素由大到小返回一个新的无元素重复的元组或者列表
    classes = np.unique(y)
    # 画出每一类数据的散点图
    for label in classes:
        plt.scatter(X[y == label][:, 0], X[y == label][:, 1], 
                    c=colors[label], s=60, marker=markers[label])
    # 标记出支持向量，将两类支持向量机用不同颜色表示出来
    if draw_SV:
        SV = model.support_vectors_  # 获取支持向量
        n = model.n_support_[0]  # 第一类支持向量个数
        plt.scatter(SV[:n, 0],SV[:n, 1], s=15, c='black', marker='o')
        plt.scatter(SV[n:, 0],SV[n:, 1], s=15, c='g', marker='o')

"""
make_circles: 
    n_samples：int，optional（默认值= 100）
生成的总点数。如果是奇数，则内圆将比外圆具有一个点。
    shuffle：bool，optional（默认值= True）
是否洗牌样品。
    noise：双倍或无（默认=无）
高斯噪声的标准偏差加到数据上。
    random_state：int，RandomState 实例或 None（默认）
确定数据集重排和噪声的随机数生成。传递一个 int，用于跨多个函数调用的可重现输出。见术语表。
    factor：0  < double < 1（默认值= .8）
内圈和外圈之间的比例因子。
"""
X, y = make_circles(200,factor=0.1,noise=0.1) # 产生样本点
plt.scatter(X[y == 0, 0], X[y == 0, 1], c='b', s=20, marker = 'x')  # 第一类
plt.scatter(X[y == 1, 0], X[y == 1, 1], c='r', s=20, marker = '^')  # 第二类
plt.xticks(())
plt.yticks(())
plt.title('数据集')
plt.show()  # 画出数据集

plt.figure(figsize=(12, 10), dpi=200)
# 使用线性核函数进行分类
model_linear = SVC(C=1.0, kernel='linear')  # 实例化，设置的核函数为线性核函数
model_linear.fit(X, y)  # 用训练集数据训练模型，和上一句配合使用
 
# 画出使用线性核函数的分类边界
plt.subplot(2, 2, 1)
plot_decision_boundary(model_linear, X, y, title='线性核函数')  # 调用画图函数
print("采用线性核函数生成的支持向量个数：", model_linear.n_support_)
 
# 使用多项式核函数进行分类
model_poly = SVC(C=1.0, kernel='poly', degree=3, gamma="auto") # 实例化，设置的核函数为多项式核函数
model_poly.fit(X, y)  # 用训练集数据训练模型
# 画出使用多项式核函数的分类边界
plt.subplot(2, 2, 2)
plot_decision_boundary(model_poly, X, y, title='多项式核函数')  # 调用画图函数
print("采用多项式函数生成的支持向量个数：", model_poly.n_support_)
plt.show()

plt.figure(figsize=(12, 10), dpi=200)
# enumerate() 函数用于将一个可遍历的数据对象(如列表、元组或字符串)组合为一个索引序列，
# 同时列出数据和数据下标，一般用在 for 循环当中。
for j, gamma in enumerate((10, 1, 0.1, 0.01)):
    plt.subplot(2, 2, j+1)
    model_rtf= SVC(C=1.0, kernel='rbf', gamma=gamma)
    model_rtf.fit(X,y)  # 高斯核函数
    #调用画图函数
    plot_decision_boundary(model_rtf, X, y, title='rbf 函数，'
                                                  '参数 gamma='+str(gamma))
    print("rbf 函数，参数 gamma=",str(gamma),"支持向量个数：",model_rtf.n_support_)
plt.show()

from sklearn.model_selection import GridSearchCV
 
tuned_parameters = [{'kernel': ['rbf'], 'gamma': [1, 0.1, 0.01],'C': [0.1, 1, 10]},
                 {'kernel': ['linear'], 'C': [0.1, 1, 10]},
                 {'kernel': ['poly'],'gamma': [1, 0.1, 0.01],
                  'C': [0.1, 1, 10]}]
"""
GridSearchCV()函数能实现自动调参, 把参数输进去, 就能给出最优的结果和参数
https://blog.csdn.net/weixin_41988628/article/details/83098130
"""
model_grid = GridSearchCV(SVC(), tuned_parameters, cv=5)
model_grid.fit(X, y)
print("The best parameters are %s with a score of %0.2f"
      % (model_grid.best_params_, model_grid.best_score_))

import numpy as np
from sklearn import svm
from sklearn.svm import SVC  # 导入 SVM 模型
from sklearn.model_selection import train_test_split  # 导入测试库
from sklearn.datasets import load_wine  # 导入 wine 数据集
from time import time

wine = load_wine()
wine_data = wine.data
wine_label = wine.target
wine_data, wine_label

from sklearn.preprocessing import StandardScaler
 
wine_data = StandardScaler().fit_transform(wine_data)  # 对数据进行标准化
wine_data

wine_train, wine_test, wine_train_label, wine_test_label = \
train_test_split(wine_data, wine_label, test_size=0.2, random_state=100)

time0 = time()
model = SVC()
model.fit(wine_train, wine_train_label)
time1 = time()

def result_show_analyse(test,test_label):
    """
    预测结果并进行分析
    """
    from datetime import datetime
    
    # 1、预测结果
    print("---------测试集的结果--------")
    test_pred = model.predict(test)
    print("测试集的真实结果为：\n", test_label)
    print("测试集的预测结果为：\n", test_pred)
    # 求出预测和真实一样的数目
    true = np.sum(test_pred == test_label)
    print("预测对的结果数目为：", true)
    print("预测错的结果数目为：", test_label.shape[0] - true)
    print("训练时间：", datetime.fromtimestamp(time1-time0).strftime("%M:%S:%f"))
    # 2、结果分析，给出准确率、精确率、召回率、F1 值、Cohen’s Kappa 系数
    print("---------测试集的结果分析--------")
    print("使用 SVM 预测 wine 数据的准确率是：%f"
              % (accuracy_score(test_label, test_pred)))
    print("使用 SVM 预测 wine 数据的精确率是：%f"
              % (precision_score(test_label, test_pred, average="macro")))
        # 对多分类要加 average="macro"
    print("使用 SVM 预测 wine 数据的召回率是：%f"
              % (recall_score(test_label, test_pred, average="macro")))
    print("使用 SVM 预测 wine 数据的 F1 值是：%f"
              % (f1_score(test_label, test_pred, average="macro")))
    print("使用 SVM 预测 wine 数据的 Cohen’s Kappa 系数是：%f"
              % (cohen_kappa_score(test_label, test_pred)))
    print("使用 SVM 预测 wine 数据的分类报告为：\n",
              classification_report(test_label, test_pred))
    # 3、画出预测结果和真实结果对比的图
    print("---------测试集的结果图--------")
    plt.plot(test_pred,'bo', label="预测")
    plt.plot(test_label,'r*', label="真实")
    plt.xlabel(r'测试集样本',color='r', fontsize=18)
    plt.ylabel(r'类别标签',color='r', fontsize=18, rotation=360)
    plt.legend(bbox_to_anchor=(1.05, 1), loc=2, borderaxespad=0.)
    plt.title('测试集的实际分类和预测分类图', fontsize=18)
    plt.show()
    
    
# 调用结果函数
# 调用相关库
from sklearn.metrics import accuracy_score,precision_score, \
        recall_score,f1_score,cohen_kappa_score
from sklearn.metrics import classification_report
import matplotlib.pyplot as plt
 
# 图表中显示中文
from pylab import *
 
mpl.rcParams['font.sans-serif'] = ['SimHei']
mpl.rcParams['axes.unicode_minus'] = False
result_show_analyse(wine_test,wine_test_label)  # 调用结果模块

from sklearn import metrics
 
 
def cm_plot(y,yp):
    conf_mx = metrics.confusion_matrix(y, yp) # 模型对于测试集的混淆矩阵
    print("测试集的混淆矩阵：\n",conf_mx)
    # 画混淆矩阵图，配色风格使用 cm.Greens
    # (太丑了, 我要用 Oranges, https://blog.csdn.net/weixin_51111267/article/details/122605388)
    plt.matshow(conf_mx,cmap=plt.cm.Oranges)
    plt.colorbar()# 颜色标签
    for x in range(len(conf_mx)):
        for y in range(len(conf_mx)):
            plt.annotate(conf_mx[x,y],xy=(x,y),horizontalalignment='center',
                         verticalalignment='center')
            plt.ylabel('True label')# 坐标轴标签
            plt.xlabel('Predicted label')# 坐标轴标签
    return plt
 
 
wine_test_pred=model.predict(wine_test)
cm_plot(wine_test_label, wine_test_pred).show()

#取不同 gamma 值得到的准确率
score = []
gamma_range = np.logspace(-10, 1, 50) # 得到不同的 gamma 值即对数刻度上均匀间隔的数
for i in gamma_range:
    model = SVC(kernel="rbf",gamma = i, cache_size=5000)
    model.fit(wine_train, wine_train_label)
    score_gamma = model.score(wine_test, wine_test_label)
    score.append(score_gamma)
print("最大的准确率为：",max(score))
print("对应的 gamma 值", gamma_range[score.index(max(score))])
plt.xlabel("gamma 取值")
plt.ylabel("准确率")
plt.title("gamma 的学习曲线")
plt.plot(gamma_range,score)
plt.show()

from itertools import cycle
from sklearn.metrics import roc_curve, auc
from sklearn.model_selection import train_test_split
from sklearn.preprocessing import label_binarize
from numpy import interp
 
 
def plot_roc(test, test_label, test_pred):
    """
    :param test: 测试样本的数据
    :param test_label: 测试样本的标签
    :param test_pred: 测试样本的预测值
    """
    class_num = sum(unique(test_label))  # 类别数
    Y_pred = test_pred
    # 对输出进行二值化
    # Y_label 样例真实标签，Y_pred 学习器预测的标签
    Y_label = label_binarize(test_label, classes=[i for i in range(class_num)])
    Y_pred = label_binarize(Y_pred, classes=[i for i in range(class_num)])
    # 计算每一类的 ROC
    # dict() 用于创建一个字典
    fpr = dict()  # 假正例率（False Positive Rate , FPR）
    tpr = dict()  # 真正例率（True Positive Rate , TPR）
    roc_auc = dict()  # ROC 曲线下方的面积
    for i in range(class_num):
        fpr[i], tpr[i], _ = roc_curve(Y_label[:, i], Y_pred[:, i])
        roc_auc[i] = auc(fpr[i], tpr[i])
    # 计算 micro-average ROC 曲线和 ROC 面积
    fpr["micro"], tpr["micro"], _ = roc_curve(Y_label.ravel(), Y_pred.ravel())
    roc_auc["micro"] = auc(fpr["micro"], tpr["micro"])
 
    # 计算 macro-average ROC 曲线 and ROC 面积
    # 第一步：汇总所有误报率 aggregate all false positive rates
    all_fpr = np.unique(np.concatenate([fpr[i] for i in range(class_num)]))
    
    # 第二步：在此点插值所有 ROC 曲线 interpolate all ROC curves at this points
    mean_tpr = np.zeros_like(all_fpr)
    for i in range(class_num):
        mean_tpr += interp(all_fpr, fpr[i], tpr[i])
    # 第三步：最后对其进行平均并计算 AUC Finally average it and compute AUC
    mean_tpr /= class_num
    fpr["macro"] = all_fpr
    tpr["macro"] = mean_tpr
    roc_auc["macro"] = auc(fpr["macro"], tpr["macro"])
    # 画出具体的某一类的 ROC 曲线，如第一类
    plt.figure()
    lw = 2
    plt.plot(fpr[1], tpr[2], color="darkorange",
             lw=lw, label="ROC curve (area = %0.2f)" % roc_auc[1])
    plt.plot([0, 1], [0, 1], color="navy", lw=lw, linestyle="--")
    plt.xlim([0.0, 1.0])
    plt.ylim([0.0, 1.05])
    plt.xlabel("假正例率 False Positive Rate（FPR）")
    plt.ylabel("真正例率 True Positive Rate（TPR）")
    plt.title("Receiver operating characteristic example")
    plt.legend(loc="lower right")
    plt.show()
 
    # 画出所有类的 ROC 曲线
    lw = 2  # line width
    plt.figure()
    plt.plot(fpr["micro"], tpr["micro"],
             label="micro-average ROC 曲线 (area = {0:0.2f})"
                   "".format(roc_auc["micro"]),
             color="deeppink", linestyle=":", linewidth=4)
 
    plt.plot(fpr["macro"], tpr["macro"],
             label="macro-average ROC 曲线 (area = {0:0.2f})"
                   "".format(roc_auc["macro"]),
             color="navy", linestyle=":", linewidth=4)
    colors = cycle(["aqua", "darkorange", "cornflowerblue"])
    for i, color in zip(range(class_num), colors):
        plt.plot(fpr[i], tpr[i], color=color, lw=lw,
                 label="ROC curve of class {0} (area = {1:0.2f})"
                       "".format(i, roc_auc[i]))
 
    plt.plot([0, 1], [0, 1], "k--", lw=lw)
    plt.xlim([0.0, 1.0])
    plt.ylim([0.0, 1.05])
    plt.xlabel("假正例率 False Positive Rate（FPR）")
    plt.ylabel("真正例率 True Positive Rate（TPR）")
    plt.title('Some extension of Receiver operating characteristic'
              'to multi-class')
    plt.legend(loc="lower right")
    plt.show()
 
 
# 调用画 ROC 曲线的函数
model = SVC()  # 实例化，设置模型参数
model.fit(wine_train, wine_train_label)
wine_test_pred = model.predict(wine_test)
plot_roc(wine_test, wine_test_label, wine_test_pred)

import numpy as np
from sklearn import svm
from sklearn.svm import SVC
from sklearn.model_selection import train_test_split
from sklearn.datasets import load_iris
from sklearn.preprocessing import StandardScaler
from sklearn.metrics import classification_report
import matplotlib.pyplot as plt
import matplotlib as mpl
from time import time
 
# (1) 读取数据集, 区分标签和数据
iris = load_iris()
iris_data = iris.data
iris_label = iris.target
# (2) 标准化数据集
iris_data = StandardScaler().fit_transform(iris_data)
# (3) 将数据集划分为训练集和测试集
iris_train, iris_test, iris_train_label, iris_test_label = \
train_test_split(iris_data, iris_label, test_size=0.2)
# (4) 构建 SVM 模型
model = SVC()
model.fit(iris_train, iris_train_label)
iris_test_pred = model.predict(iris_test)
# (5) 输出预测测试集结果, 评价分类模型性能, 输出测试报告
print(classification_report(iris_test_label, iris_test_pred))
mpl.rcParams['font.sans-serif'] = ['SimHei']
mpl.rcParams['axes.unicode_minus'] = False
print("---------测试集的结果图--------")
plt.plot(iris_test_pred,'bo', label="预测")
plt.plot(iris_test_label,'r*', label="真实")
plt.xlabel(r'测试集样本',color='r', fontsize=18)
plt.ylabel(r'类别标签',color='r', fontsize=18, rotation=360)
plt.legend(bbox_to_anchor=(1.05, 1), loc=2, borderaxespad=0.)
plt.title('测试集的实际分类和预测分类图', fontsize=18)
plt.show()