函数型数据分析代码实现

文章目录

• 3.2.3 Python 标志转换
• 3.3.4 Python 数据降维
• 3.3.7 Python 处理共线性问题
• 3.6.4 Python 数据抽样
• 3.8.3 Python 相关性分析
• 4.1.6 Python 聚类分析
• 4.2.6 Python 回归分析
• 4.3.6 Python 分类分析
• 4.5.5 Python 异常检测分析

3.2.3 Python 标志转换

import pandas as pd

用字符表示的顺序|序列数据

df = pd.DataFrame({'id': [3566841, 6541227, 3512441],
                   'sex': ['male', 'Female', 'Female'],
                   'level': ['high', 'low', 'middle']})
df  # 打印输出原始数据框

最简单的方法pd.get_dummies

df_new=df[['id']].join(pd.get_dummies(df[['sex','level']]))
de_new

但是对于用数值表示的标签不适用

df2 = pd.DataFrame({'id': [3566841, 6541227, 3512441],
                    'sex': [1, 2, 2],
                    'level': [3, 1, 2]})
df2

需要用到sklearn包二值化工具

from sklearn.preprocessing import OneHotEncoder#独热标签

id_data = df2.values[:, :1]  # 获得ID列  id_data=df2['id'].values
transform_data = df2.values[:, 1:]  # 指定要转换的列 transform_data=df2.iloc[:,1:].values

enc = OneHotEncoder()  # 建立模型对象
df2_new = enc.fit_transform(transform_data).toarray()  # 标志转换

df2_all = pd.concat((pd.DataFrame(id_data), pd.DataFrame(df2_new)), axis=1)  # 组合为数据框

df2_all  # 打印输出转换后的数据框

注意：这里列的顺序不一定按照预先的逻辑，但不会影响数据建模

3.3.4 Python 数据降维

《data1.txt》有10个特征，最后一列是标签

导入库

import numpy as np
from sklearn.tree import DecisionTreeClassifier
from sklearn.decomposition import PCA

数据准备

#读取数据
data=np.loadtxt('chapter3/data1.txt')
X=data[:,:-1]#二维矩阵
y=data[:,-1]#目标数组
#print(X[0],y[0])

使用决策树分类判断特征重要性

dtc=DecisionTreeClassifier(random_state=0)#初始化模型
dtc.fit(X,y)#训练模型
f_importance=dtc.feature_importances_#获得特征的重要性得分
print(f_importance)

【explain】:第4/5/7三个变量的重要性最高， 分别约为0.12、 0.48、 0.17， 三者得分之和约等于77%， 这意味着仅仅这3个变量已经具有非常显著的并且足以代表所有变量参与模型计算的能力。 因此， 可以选择这3个变量参与后续模型计算

使用PCA进行维度转换

pca=PCA()#初始化模型
pca.fit_transform(X)#数据投入并转换
components=pca.components_#获得转换后的所有主成分
components_var=pca.explained_variance_#各主成分的方差
components_var_ratio=pca.explained_variance_ratio_#各主成分的方差占比
print (components[:2]) # 打印输出前2个主成分
print (components_var[:2]) # 打印输出前2个主成分的方差
print (components_var_ratio) # 打印输出所有主成分的方差占比

【explain】:所有主成分的方差占比是选择主成分数量的关键， 因为PCA降维的基本思想是根据方差占比来选择主成分的数量。 通过该结果可以看出， 前6项主成分的方差占比之和components_var_ratio[:5].sum（ ） 约等于77%， 取前6项主成分基本可以作为转换后的主成分参与后续模型计算。

3.3.7 Python 处理共线性问题

前9列是自变量，最后一列是因变量。

导入库

# 导入相关库
import numpy as np
from sklearn.linear_model import Ridge
from sklearn.decomposition import PCA
from sklearn.linear_model import LinearRegression

读取数据

# 读取数据
data = np.loadtxt('data5.txt', delimiter='\t') # 读取数据文件
x = data[:, :-1] # 切分自变量
y = data[:, -1] # 切分预测变量

使用岭回归算法进行回归分析

model_ridge = Ridge(alpha=1.0) # 建立岭回归模型对象
model_ridge.fit(x, y) # 输入x/y训练模型
print (model_ridge.coef_) # 打印输出自变量的系数
print (model_ridge.intercept_) # 打印输出截距

这样就可以写出一个岭回归方程，9个自变量分别是x₁,x₂,…x₉,因变量是y

y=85.016436x₁+(-0.001183301 86)x₂+0.000980792921x₃

+(-0.000854201056)x₄+0.0000210489064x₅+0.000220180449x₆

+(-0.00000300990875)x₇+(-0.0000093008424)x₈

+(-0.0000000284498824)x₉

-7443.98652868

使用PCA主成分分析建立模型，应用数据后，根据累计方差，筛选在指定阈值之间的成分，再用线型回归获得回归模型

model_pca = PCA() # 建立PCA模型对象
data_pca = model_pca.fit_transform(x) # 将x进行主成分分析

#累计方差占比
ratio_cumsm = np.cumsum(model_pca.explained_variance_ratio_) # 得到所有主成分方差占比的累积数据
print (ratio_cumsm) # 打印输出所有主成分方差占比累积

可以看到第一个主成分的占比已经达到了90%以上

rule_index = np.where(ratio_cumsm > 0.8) # 获取方差占比超过0.8的所有索引值
min_index = rule_index[0][0] # 获取最小索引值
data_pca_result = data_pca[:, :min_index + 1] # 根据最小索引值提取主成分

其实由上一步结果可知，从第一个主成分已经开始达到了阈值条件，这里只选取一个主成分，也就是第一个主成分

model_liner = LinearRegression() # 建立回归模型对象
model_liner.fit(data_pca_result, y) # 输入主成分数据和预测变量y并训练模型
print (model_liner.coef_) # 打印输出自变量的系数
print (model_liner.intercept_) # 打印输出截距

这样就可以写出一个回归方程

y=0.0000126262171*α₁+1058.52726

α₁是第一个主成分，而非之前原始数据的第一个自变量

3.6.4 Python 数据抽样

《data3》

简单随机抽样

#简单随机抽样1  random.sample(population, k)
data=np.loadtxt('chapter3/data3.txt')# 导入普通数据文件
data_list=data.tolist()#array转list
data_sample_list = random.sample(data_list, 2000) # 随机抽取2000个样本
data_sample=np.array(data_sample_list)#list转array
print (data_sample[:2])# 打印输出前2条数据
print (len(data_sample)) # 打印输出抽样样本量

#简单随机抽样2 df.sample()
df=pd.read_table('chapter3/data3.txt',sep=' ',header=None)
df_sample=df.sample(2000)
df_sample.head()

等距抽样:找到间距，索引递增

# 等距抽样
sample_count = 2000  # 指定抽样数量
record_count = data.shape[0]  # 获取最大样本量
width = int(record_count / sample_count ) # 计算抽样间距

data_sample = []  # 初始化空白列表，用来存放抽样结果数据
i = 0  # 自增计数以得到对应索引值

while len(data_sample) <= sample_count and i * width <= record_count-1: # 当样本量小于等于指定抽样数量并且矩阵索引在有效范围内时
    data_sample.append(data[i * width])  # 新增样本
    i += 1  # 自增长

《data2》

分层抽样：定义分层，对每个分层抽取样本

# 导入有标签的数据文件
data2 = np.loadtxt('chapter3/data2.txt') # 导入带有分层逻辑的数据
each_sample_count = 200 # 定义每个分层的抽样数量
label_data_unique = np.unique(data2[:, -1]) # 定义分层值域（最后一列只有两种值 0 和1，这两个值就是分层依据）

sample_list = [] # 定义空列表， 用于存放临时分层数据
sample_data = [] # 定义空列表， 用于存放最终抽样数据
sample_dict = {} # 定义空字典， 用来显示各分层样本数量
for label_data in label_data_unique:  # 遍历每个分层标签
    for data_tmp in data2:  # 读取每条数据
        if data_tmp[-1] == label_data:  # 如果数据最后一列等于标签
            sample_list.append(data_tmp)  # 将数据加入到分层数据中
    each_sample_data = random.sample(sample_list, each_sample_count)  # 对每层数据都随机抽样
    sample_data.extend(each_sample_data)  # 将抽样数据追加到总体样本集
    sample_dict[label_data] = len(each_sample_data)  # 样本集统计结果添加到字典


print (sample_dict)  # 打印输出样本集统计结果

《data4》

整群抽样：从全部分层中抽取分层，选中分层的所有样本

data3 = np.loadtxt('chapter3/data4.txt')  # 导入已经划分好整群的数据集
label_data_unique = np.unique(data3[:, -1])  # 定义整群标签值域
print (label_data_unique)  # 打印输出所有整群标签

sample_label = random.sample(label_data_unique.tolist(), 2)  # 随机抽取2个整群
print (sample_label)  # 打印输出样本整群标签

sample_data = []  # 定义空列表，用来存储最终抽样数据
for each_label in sample_label:  # 遍历每个整群标签值域
    for data_tmp in data3:  # 遍历每个样本
        if data_tmp[-1] == each_label:  # 判断样本是否属于抽样整群
            sample_data.append(data_tmp)  # 样本添加到最终抽样数据集

print (len(sample_data))  # 打印输出总抽样数据记录条数

3.8.3 Python 相关性分析

《data5》前9列是自变量

相关系数矩阵

import numpy as np
data = np.loadtxt('chapter3/data5.txt', delimiter='\t') # 读取数据文件
x = data[:, :-1] # 切分自变量
correlation_matrix = np.corrcoef(x, rowvar=0) # 相关性分析
print (correlation_matrix.round(2)) # 打印输出相关性结果

4.1.6 Python 聚类分析

《cluster.txt》前两列是特征，最后一列是标签

导入库

import numpy as np # 导入Numpy库
import matplotlib.pyplot as plt # 导入Matplotlib库
from sklearn.cluster import KMeans # 导入sklearn聚类模块
from sklearn import metrics # 导入sklearn效果评估模块

数据准备

raw_data = np.loadtxt('cluster.txt') # 导入数据文件
X = raw_data[:, :-1] # 分割要聚类的数据,二维矩阵
y_true = raw_data[:, -1]#目标数组

训练聚类模型

n_clusters = 3 # 设置聚类数量
model_kmeans = KMeans(n_clusters=n_clusters, random_state=0) # 建立聚类模型对象
model_kmeans.fit(X) # 训练聚类模型
y_pre = model_kmeans.predict(X) # 预测聚类模型

模型效果指标评估

n_samples, n_features = X.shape # 总样本量,总特征数
inertias = model_kmeans.inertia_ # 样本距离最近的聚类中心的总和
adjusted_rand_s = metrics.adjusted_rand_score(y_true, y_pre) # 调整后的兰德指数
mutual_info_s = metrics.mutual_info_score(y_true, y_pre) # 互信息
adjusted_mutual_info_s = metrics.adjusted_mutual_info_score(y_true, y_pre) # 调整后的互信息
homogeneity_s = metrics.homogeneity_score(y_true, y_pre) # 同质化得分
completeness_s = metrics.completeness_score(y_true, y_pre) # 完整性得分
v_measure_s = metrics.v_measure_score(y_true, y_pre) # V-measure得分
silhouette_s = metrics.silhouette_score(X, y_pre, metric='euclidean') # 平均轮廓系数
calinski_harabaz_s = metrics.calinski_harabaz_score(X, y_pre) # Calinski和Harabaz得分
print ('samples: %d \t features: %d' % (n_samples, n_features)) # 打印输出样本量和特征数量
print (70 * '-') # 打印分隔线
print ('ine\tARI\tMI\tAMI\thomo\tcomp\tv_m\tsilh\tc&h') # 打印输出指标标题
print ('%d\t%.2f\t%.2f\t%.2f\t%.2f\t%.2f\t%.2f\t%.2f\t%d' % (
inertias, adjusted_rand_s, mutual_info_s, adjusted_mutual_info_s, homogeneity_s, complete
silhouette_s, calinski_harabaz_s)) # 打印输出指标值
print (70 * '-') # 打印分隔线
print ('short name \t full name') # 打印输出缩写和全名标题
print ('ine \t inertias')
print ('ARI \t adjusted_rand_s')
print ('MI \t mutual_info_s')
print ('AMI \t adjusted_mutual_info_s')
print ('homo \t homogeneity_s')
print ('comp \t completeness_s')
print ('v_m \t v_measure_s')
print ('silh \t silhouette_s')
print ('c&h \t calinski_harabaz_s')

模型效果可视化

centers = model_kmeans.cluster_centers_ # 各类别中心
colors = ['#4EACC5', '#FF9C34', '#4E9A06'] # 设置不同类别的颜色
plt.figure() # 建立画布
for i in range(n_clusters): # 循环读类别
    index_sets = np.where(y_pre == i) # 找到相同类的索引集合
    cluster = X[index_sets] # 将相同类的数据划分为一个聚类子集
    plt.scatter(cluster[:, 0], cluster[:, 1], c=colors[i], marker='.',s = 100,label='Cluster %s'%i) # 展示聚类子集内的样本点
    plt.plot(centers[i][0], centers[i][1], 'o', markerfacecolor=colors[i], markeredgecolor='k', markersize=6) # 展示各聚类子集的中心
plt.legend()#显示图例
plt.show() # 展示图像

模型应用

#样本（[-0.8, 0.5]）投入模型
new_X = np.array([-0.8, 0.5])[np.newaxis,:]
cluster_label = model_kmeans.predict(new_X)
print ('cluster of new data point is: %d' % cluster_label)#输出预测的类标签

4.2.6 Python 回归分析

前13列是特征列，自变量，最后一列是因变量

分别建立5种回归模型（贝叶斯岭回归、普通线性回归、弹性网络回归、支持向量机回归、梯度增强回归），每种回归模型都进行6次交叉验证，得到6次交叉验证分，应用数据后，分别用4个评估指标（解释方差得分、平均绝对误差、均方误差、判定系数得分）来评价，选择一个最优的模型，来预测新数据。

导入库

# 导入库
import numpy as np  # numpy库
import pandas as pd  # 导入pandas
import matplotlib.pyplot as plt  # 导入图形展示库

from sklearn.linear_model import BayesianRidge, LinearRegression, ElasticNet  # 批量导入贝叶斯岭回归、普通线性回归、弹性网络回归算法
from sklearn.svm import SVR  # 支持向量机中的回归算法
from sklearn.ensemble.gradient_boosting import GradientBoostingRegressor  # 集成算法-梯度增强回归
from sklearn.model_selection import cross_val_score  # 交叉检验
from sklearn.metrics import explained_variance_score, mean_absolute_error, mean_squared_error, r2_score  # 批量导入指标算法:解释方差得分、平均绝对误差、均方误差、判定系数

数据准备

# 数据准备
raw_data = np.loadtxt('regression.txt')  # 读取数据文件
X = raw_data[:, :-1]  # 分割自变量
y = raw_data[:, -1]  # 分割因变量

建立5个回归模型

model_br = BayesianRidge()  # 建立贝叶斯岭回归模型对象
model_lr = LinearRegression()  # 建立普通线性回归模型对象
model_etc = ElasticNet()  # 建立弹性网络回归模型对象
model_svr = SVR()  # 建立支持向量机回归模型对象
model_gbr = GradientBoostingRegressor()  # 建立梯度增强回归模型对象

交叉验证并应用数据获得预测值

model_names = ['BayesianRidge', 'LinearRegression', 'ElasticNet', 'SVR', 'GBR']  # 不同模型的名称列表
model_dic = [model_br, model_lr, model_etc, model_svr, model_gbr]  # 不同回归模型对象的集合
cv_score_list = []  # 交叉检验结果列表
pre_y_list = []  # 各个回归模型预测的y值列表

for model in model_dic:  # 读出每个回归模型对象
    scores = cross_val_score(model, X, y, cv=6)  # 将每个回归模型导入交叉检验模型中做训练检验
    cv_score_list.append(scores)  # 将交叉检验结果存入结果列表
    pre_y_list.append(model.fit(X, y).predict(X))  # 将回归训练中得到的预测y存入列表

查看这5个模型6次的交叉验证分

df1 = pd.DataFrame(cv_score_list, index=model_names)  # 建立交叉检验的数据框
df1

使用预测值和实际值，用4个指标评估模型效果

# 模型效果指标评估
model_metrics_name = [explained_variance_score, mean_absolute_error, mean_squared_error, r2_score]  # 回归评估指标对象集
model_metrics_list = []  # 回归评估指标列表
for i in range(5):  # 循环每个模型索引
    tmp_list = []  # 每个内循环的临时结果列表
    for m in model_metrics_name:  # 循环每个指标对象
        tmp_score = m(y, pre_y_list[i])  # 计算每个回归指标结果
        tmp_list.append(tmp_score)  # 将结果存入每个内循环的临时结果列表
    model_metrics_list.append(tmp_list)  # 将结果存入回归评估指标列表

查看评估结果

df2 = pd.DataFrame(model_metrics_list, index=model_names, columns=['ev', 'mae', 'mse', 'r2'])  # 建立回归指标的数据框
df2

ev和r2越接近1，mae和mse越小，越好。因此可见GBR模型效果最好，且交叉验证分稳定。

可视化模型效果

# 模型效果可视化
plt.figure(figsize=(15,5))  # 创建画布
plt.plot(np.arange(X.shape[0]), y, color='k', label='true y')  # 画出原始值的曲线
color_list = ['r', 'b', 'g', 'y', 'c']  # 颜色列表
linestyle_list = ['-', '.', 'o', 'v', '*']  # 样式列表
for i, pre_y in enumerate(pre_y_list):  # 读出通过回归模型预测得到的索引及结果
    plt.plot(np.arange(X.shape[0]), pre_y_list[i], color_list[i], label=model_names[i])  # 画出每条预测结果线
    
plt.title('regression result comparison')  # 标题
plt.legend(loc='upper right')  # 图例位置
plt.ylabel('real and predicted value')  # y轴标题
plt.show()  # 展示图像

由图可见，GRB与实际数据线也最贴合。

使用GRB模型预测新数据结果

print ('regression prediction')
new_point_set = [[1.05393, 0., 8.14, 0., 0.538, 5.935, 29.3, 4.4986, 4., 307., 21., 386.85, 6.58],
                 [0.7842, 0., 8.14, 0., 0.538, 5.99, 81.7, 4.2579, 4., 307., 21., 386.75, 14.67],
                 [0.80271, 0., 8.14, 0., 0.538, 5.456, 36.6, 3.7965, 4., 307., 21., 288.99, 11.69],
                 [0.7258, 0., 8.14, 0., 0.538, 5.727, 69.5, 3.7965, 4., 307., 21., 390.95, 11.28]]  # 要预测的新数据集
for i, new_point in enumerate(new_point_set):  # 循环读出每个要预测的数据点
    new_pre_y = model_gbr.predict(np.array(new_point).reshape(1,-1))  # 使用GBR进行预测
    print ('predict for new point %d is:  %.2f' % (i + 1, new_pre_y))  # 打印输出每个数据点的预测信息

4.3.6 Python 分类分析

《classification.csv》前4列是特征，最后一列是分类标签

导入库

import numpy as np  # 导入numpy库
from sklearn.model_selection import train_test_split  # 数据分区库
from sklearn import tree  # 导入决策树库
from sklearn.metrics import accuracy_score, auc, confusion_matrix, f1_score, precision_score, recall_score, roc_curve  # 导入指标库
import prettytable  # 导入表格库
import pydotplus  # 导入dot插件库
import matplotlib.pyplot as plt  # 导入图形展示库

训练分类模型

model_tree = tree.DecisionTreeClassifier(random_state=0)  # 建立决策树模型对象
model_tree.fit(X_train, y_train)  # 训练决策树模型
pre_y = model_tree.predict(X_test)  # 使用测试集做模型效果检验

输出模型概况

n_samples, n_features = X.shape  # 总样本量,总特征数
print ('samples: %d \t features: %d' % (n_samples, n_features))  # 打印输出样本量和特征数量
print (70 * '-')  # 打印分隔线

混淆矩阵

confusion_m = confusion_matrix(y_test, pre_y)  # 获得混淆矩阵
confusion_matrix_table = prettytable.PrettyTable()  # 创建表格实例
confusion_matrix_table.add_row(confusion_m[0, :])  # 增加第一行数据
confusion_matrix_table.add_row(confusion_m[1, :])  # 增加第二行数据
print ('confusion matrix')
print (confusion_matrix_table)  # 打印输出混淆矩阵

核心评估指标

y_score = model_tree.predict_proba(X_test)  # 获得决策树的预测概率
fpr, tpr, thresholds = roc_curve(y_test, y_score[:, 1])  # ROC
auc_s = auc(fpr, tpr)  # AUC
accuracy_s = accuracy_score(y_test, pre_y)  # 准确率
precision_s = precision_score(y_test, pre_y)  # 精确度
recall_s = recall_score(y_test, pre_y)  # 召回率
f1_s = f1_score(y_test, pre_y)  # F1得分
core_metrics = prettytable.PrettyTable()  # 创建表格实例
core_metrics.field_names = ['auc', 'accuracy', 'precision', 'recall', 'f1']  # 定义表格列名
core_metrics.add_row([auc_s, accuracy_s, precision_s, recall_s, f1_s])  # 增加数据
print ('core metrics')
print (core_metrics)  # 打印输出核心评估指标

模型效果可视化

names_list = ['age', 'gender', 'income', 'rfm_score']  # 分类模型维度列表
color_list = ['r', 'c', 'b', 'g']  # 颜色列表
plt.figure(figsize=(10,5))  # 创建画布
# 子网格1：ROC曲线
plt.subplot(1, 2, 1)  # 第一个子网格
plt.plot(fpr, tpr, label='ROC')  # 画出ROC曲线
plt.plot([0, 1], [0, 1], linestyle='--', color='k', label='random chance')  # 画出随机状态下的准确率线
plt.title('ROC')  # 子网格标题
plt.xlabel('false positive rate')  # X轴标题
plt.ylabel('true positive rate')  # y轴标题
plt.legend(loc=0)
# 子网格2：指标重要性
feature_importance = model_tree.feature_importances_  # 获得指标重要性
plt.subplot(1, 2, 2)  # 第二个子网格
plt.bar(np.arange(feature_importance.shape[0]), feature_importance, tick_label=names_list, color=color_list)  # 画出条形图
plt.title('feature importance')  # 子网格标题
plt.xlabel('features')  # x轴标题
plt.ylabel('importance')  # y轴标题
plt.suptitle('classification result')  # 图形总标题
plt.show()  # 展示图形

保存决策树规则图为PDF文件

dot_data = tree.export_graphviz(model_tree, out_file=None, max_depth=5, feature_names=names_list, filled=True, rounded=True)  # 将决策树规则生成dot对象
graph = pydotplus.graph_from_dot_data(dot_data)  # 通过pydotplus将决策树规则解析为图形
graph.write_pdf("tree.pdf")  # 将决策树规则保存为PDF文件

tree.export_graphviz(model_tree,out_file='model_tree.dot',max_depth=5,feature_names=names_list, filled=True,rounded=True)#导出成graphviz格式
#cmd 命令转化成png
from IPython.display import Image
Image('G:\\scripts\\tree.png')

模型应用

X_new = [[40, 0, 55616, 0], [17, 0, 55568, 0], [55, 1, 55932, 1]]
print ('classification prediction')
for i, data in enumerate(X_new):
   y_pre_new = model_tree.predict(np.array(data).reshape(1,-1))
   print ('classification for %d record is: %d' % (i + 1, y_pre_new))

4.5.5 Python 异常检测分析

5列全是特征，没有标签列，取前900个样本作为训练集，对后100个样本预测异常值

导入库

from sklearn.svm import OneClassSVM#一类支持向量机
import numpy as np
import matplotlib.pyplot as plt
from mpl_toolkits.mplot3d import Axes3D#3D样式库

准备数据

raw_data=np.loadtxt('chapter4/outlier.txt',delimiter=' ')#导入数据
train_set=raw_data[:900,:]#训练集
test_set=raw_data[:100,:]#测试集

异常数据检测

ocsvm=OneClassSVM(nu=0.1,kernel='rbf',random_state=0)#初始化模型
ocsvm.fit(train_set)#训练模型
pre_test=ocsvm.predict(test_set)#测试集结果预测

异常数据统计

#拼接测试集数据和预测结果
test_total=np.hstack((test_set, pre_test.reshape(test_set.shape[0],1)))
normal_test=test_total[test_total[:,-1]==1]#测试集中的正常数据
outlier_test=test_total[test_total[:,-1]==-1]#测试集中的异常数据

n_outlier_test=outlier_test.shape[0]#异常样本数量
n_test_total=test_total.shape[0]#总测试集样本量

print ('outliers: {0}/{1}'.format(n_outlier_test, n_test_total))  # 输出异常的结果数量
print ('{:*^60}'.format(' all result data (limit 5) '))  # 打印标题
print (test_total[:5])  # 打印输出前5条合并后的数据集

异常检测结果展示

plt.style.use('ggplot')#使用ggplot样式表
fig=plt.figure()#创建画布
ax=Axes3D(fig)#将画布转换为3D模型
#正常样本点(只展示前3个维度)
s1=ax.scatter(normal_test[:,0],normal_test[:,1],normal_test[:,2],s=100,edgecolors='k',c='g',marker='o')
#异常样本点(只展示前3个维度)
s2=ax.scatter(outlier_test[:,0],outlier_test[:,1],outlier_test[:,2],s=100,edgecolors='k',c='r',marker='o')

ax.w_xaxis.set_ticklabels([])  # 隐藏x轴标签，只保留刻度线
ax.w_yaxis.set_ticklabels([])  # 隐藏y轴标签，只保留刻度线
ax.w_zaxis.set_ticklabels([])  # 隐藏z轴标签，只保留刻度线
ax.legend([s1, s2], ['normal points', 'outliers'], loc=0)  # 设置两类样本点的图例
plt.title('novelty detection')  # 设置图像标题
plt.show()  # 展示图像