数据挖掘，计算机网络、操作系统刷题笔记55

最新推荐文章于 2024-08-23 17:37:15 发布

冰露可乐

最新推荐文章于 2024-08-23 17:37:15 发布

阅读量247

点赞数 1

分类专栏：数据挖掘操作系统计算机网络文章标签：数据挖掘计算机网络数据库国考省考刷题操作系统

本文链接：https://blog.csdn.net/weixin_46838716/article/details/129174014

版权

数据挖掘同时被 3 个专栏收录

86 篇文章 2 订阅

订阅专栏

计算机网络

73 篇文章 9 订阅

订阅专栏

操作系统

64 篇文章 4 订阅

订阅专栏

数据挖掘，计算机网络、操作系统刷题笔记55

文章目录

数据挖掘，计算机网络、操作系统刷题笔记55
@[TOC](文章目录)

数据挖掘分析应用：模型评估评价方法
二分类模型评估
增益图与KS图
回归模型的评估
非监督学习的评估指标
整个数据挖掘分析应用，课程总结
大数据在未来有什么作用？？？？
宽带城域网主要技术是基于数据传输速度为千兆网Mb/s 的 Fast Ethernet 的。（）
Ethernet 标准采用的媒体访问控制方式为( )。
有关路由器和二层交换机的区别，下述错误的是？
IPV6地址类型可以分为单播地址，组播地址，任播地址
提高设备接口的速率可以缩短下列哪项时延（）。
ping是ICMP协议，并不是通常所说的tcp/udp端口；ICMP不像tcp/udp有端口，但它确实含有两个域：类型type和代码code，而这些与端口作用不同。
国标规定接入网的维护管理接口应符合（）接口标准
总结

数据挖掘分析应用：模型评估评价方法

在这里插入图片描述
之前讲的都是其他内容，这波讲最后一个评估

在这里插入图片描述

二分类模型评估

1正类
0负类
比较预测值和真实值之间的差别
在这里插入图片描述
分为好几个qingk
正负–>正负
false negative 错误的假类
false positive 错误的正类

在这里插入图片描述
混淆矩阵

关键指标

对角线上的数字加起来，就是预测对了，美滋滋，这个占比就是正确率
accuracy

当负样本过多，导致正确率很高，但是一个正类都没有挖掘出来
在这里插入图片描述
充分考虑正类中，被分类正确的类那即是recall

再考虑整体的话，综合一波

在这里插入图片描述
牛的

咱们之前的案例，已经用过多次了这些

精准率
所有预测为正的过程中，正确的是精确率

在这里插入图片描述
AUC来了
FPR错误接受率
FRR错误拒绝率

有点区别

acc
recall
f1score
在这里插入图片描述

当p卡分阈值时，不同阈值，结果不同
ROC曲线出来了
在这里插入图片描述

代码演示

# 演示ann作图ROC
# 模型
def hr_modeling_all_ROC(features, label):
    from sklearn.model_selection import train_test_split
    # 切分函数
    #DataFrame
    feature_val = features.values
    label_val = label
    # 特征段
    feature_name = features.columns
    train_data, valid_data, y_train, y_valid = train_test_split(feature_val, label_val, test_size=0.2)  # 20%验证集
    train_data, test_data, y_train, y_test = train_test_split(train_data, y_train, test_size=0.25)  # 25%测试集
    print(len(train_data), len(valid_data), len(test_data))

    # KNN分类
    from sklearn.neighbors import NearestNeighbors, KNeighborsClassifier
    from sklearn.metrics import accuracy_score, recall_score, f1_score  # 模型评价
    from sklearn.naive_bayes import GaussianNB, BernoulliNB  # 高斯，伯努利，都是对特征有严格要求，离散值最好
    from sklearn.tree import DecisionTreeClassifier, export_graphviz  # 决策树
    from io import StringIO
    import pydotplus
    import os
    from sklearn.svm import SVC
    from sklearn.ensemble import RandomForestClassifier  # 随机森林
    from sklearn.ensemble import AdaBoostClassifier
    from sklearn.linear_model import LogisticRegression
    from keras.models import Sequential
    from keras.layers.core import Dense, Activation
    from tensorflow.keras.optimizers import SGD

    os.environ["PATH"] += os.pathsep+r'D:\Program Files\Graphviz\bin'

    models = []  # 申请模型，挨个验证好坏
    knn_clf = KNeighborsClassifier(n_neighbors=3)  # 5类
    bys_clf = GaussianNB()
    bnl_clf = BernoulliNB()
    DT_clf = DecisionTreeClassifier()
    SVC_clf = SVC()
    rdn_clf = RandomForestClassifier()
    adaboost_clf = AdaBoostClassifier(n_estimators=100)
    logi_clf = LogisticRegression(C=1000, tol=1e-10, solver="sag", max_iter=10000)

    # models.append(("KNN", knn_clf))  # 代码一个个模型测--放入的是元祖
    # models.append(("GaussianNB", bys_clf))  # 代码一个个模型测--放入的是元祖
    # models.append(("BernoulliNB", bnl_clf))  # 代码一个个模型测--放入的是元祖
    # models.append(("Decision Tree", DT_clf))  # 代码一个个模型测--放入的是元祖
    # models.append(("SVM classifier", SVC_clf))  # 代码一个个模型测--放入的是元祖
    # models.append(("Random classifier", rdn_clf))  # 代码一个个模型测--放入的是元祖
    # models.append(("adaboost classifier", adaboost_clf))  # 代码一个个模型测--放入的是元祖
    # models.append(("logistic classifier", logi_clf))  # 代码一个个模型测--放入的是元祖

    # 不同的模型，依次验证
    for modelName, model in models:
        print(modelName)
        model.fit(train_data, y_train)  # 指定训练集
        # 又集成化数据集
        data = [(train_data, y_train), (valid_data, y_valid), (test_data, y_test)]
        for i in range(len(data)):
            print(i)
            y_input = data[i][0]
            y_label = data[i][1]  # 输入输出预测
            y_pred = model.predict(y_input)
            print("acc:", accuracy_score(y_label, y_pred))
            print("recall:", recall_score(y_label, y_pred))
            print("F1:", f1_score(y_label, y_pred))
        print("\n")

    # 不考虑存储，你看看这个模型就会输出仨结果

    ann = Sequential()
    ann.add(Dense(50, input_dim=len(feature_val[0])))  # 隐藏层
    ann.add(Activation("sigmoid"))
    ann.add(Dense(2))  # 输出层
    ann.add(Activation("softmax"))
    sgd = SGD(lr=0.01)  # 优化器
    ann.compile(loss="mse", optimizer=sgd)  # 误差函数
    y_truth = np.array([[0,1] if t == 1 else [1,0] for t in y_train])  # Onehot编码
    ann.fit(train_data, y_truth, epochs=10, batch_size=2048)

    # 又集成化数据集
    data = [(train_data, y_train), (valid_data, y_valid), (test_data, y_test)]

    # 作图
    import matplotlib.pyplot as plt
    from sklearn.metrics import roc_curve, auc, roc_auc_score
    f = plt.figure()

    for i in range(len(data)):
        print(i)
        y_input = data[i][0]
        y_label = data[i][1]  # 输入输出预测
        y_pred = ann.predict(y_input)  # 连续值转化为独热编码
        print(y_pred)
        positive_y_pred = np.array(y_pred[:, 1]).reshape((1, -1))[0]  # 第0个

    print("\n")

if __name__ == '__main__':
    features, label = pre_processing(sl=True, le=True, npr=True, amh=True, wacc=True, pla=True, dep=False, sal=True,
       lower_d=False, ld_n=3)
    # print(features, label)

    # 灌入模型
    # hr_modeling_all_saveDT_SVM(features, label)
    # hr_modeling_all_saveDT_SVM_gbdt(features, label)
    hr_modeling_all_ROC(features, label)

    # 回归分析
    # regrfunc(features, label)

8999 3000 3000
2023-02-23 09:50:26.365761: I tensorflow/core/platform/cpu_feature_guard.cc:142] This TensorFlow binary is optimized with oneAPI Deep Neural Network Library (oneDNN) to use the following CPU instructions in performance-critical operations:  AVX AVX2
To enable them in other operations, rebuild TensorFlow with the appropriate compiler flags.
2023-02-23 09:50:27.226035: I tensorflow/core/common_runtime/gpu/gpu_device.cc:1510] Created device /job:localhost/replica:0/task:0/device:GPU:0 with 3994 MB memory:  -> device: 0, name: NVIDIA GeForce GTX 1660 SUPER, pci bus id: 0000:01:00.0, compute capability: 7.5
C:\ProgramData\Anaconda3\envs\AES\lib\site-packages\keras\optimizer_v2\optimizer_v2.py:356: UserWarning: The `lr` argument is deprecated, use `learning_rate` instead.
  "The `lr` argument is deprecated, use `learning_rate` instead.")
2023-02-23 09:50:27.549785: I tensorflow/compiler/mlir/mlir_graph_optimization_pass.cc:185] None of the MLIR Optimization Passes are enabled (registered 2)
Epoch 1/10
5/5 [==============================] - 1s 2ms/step - loss: 0.1859
Epoch 2/10
5/5 [==============================] - 0s 2ms/step - loss: 0.1856
Epoch 3/10
5/5 [==============================] - 0s 2ms/step - loss: 0.1854
Epoch 4/10
5/5 [==============================] - 0s 2ms/step - loss: 0.1852
Epoch 5/10
5/5 [==============================] - 0s 1ms/step - loss: 0.1850
Epoch 6/10
5/5 [==============================] - 0s 1ms/step - loss: 0.1848
Epoch 7/10
5/5 [==============================] - 0s 2ms/step - loss: 0.1847
Epoch 8/10
5/5 [==============================] - 0s 1ms/step - loss: 0.1846
Epoch 9/10
5/5 [==============================] - 0s 1ms/step - loss: 0.1845
Epoch 10/10
5/5 [==============================] - 0s 1ms/step - loss: 0.1844
0
[[0.70850194 0.291498  ]
 [0.7409873  0.25901273]
 [0.74286395 0.257136  ]
 ...
 [0.7635323  0.23646769]
 [0.67135936 0.32864067]
 [0.7015819  0.29841807]]
1
[[0.74752426 0.25247577]
 [0.7372727  0.26272735]
 [0.5784359  0.42156407]
 ...
 [0.72206247 0.27793753]
 [0.734357   0.265643  ]
 [0.77148694 0.22851308]]
2
[[0.7170777  0.28292227]
 [0.7623578  0.23764227]
 [0.8201074  0.17989264]
 ...
 [0.82093436 0.17906561]
 [0.7547596  0.2452404 ]
 [0.78885245 0.21114753]]



Process finished with exit code 0

直接输出是概率，咱们要看看预测为正类的概率是谁？


        positive_y_pred = np.array(y_pred[:, 1]).reshape((1, -1))[0]  # 第0个
        print(positive_y_pred)
[0.26407123 0.22625272 0.13863927 ... 0.24841325 0.21509019 0.19570823]

转化为行

在这里插入图片描述

# 演示ann作图ROC
# 模型
def hr_modeling_all_ROC(features, label):
    from sklearn.model_selection import train_test_split
    # 切分函数
    #DataFrame
    feature_val = features.values
    label_val = label
    # 特征段
    feature_name = features.columns
    train_data, valid_data, y_train, y_valid = train_test_split(feature_val, label_val, test_size=0.2)  # 20%验证集
    train_data, test_data, y_train, y_test = train_test_split(train_data, y_train, test_size=0.25)  # 25%测试集
    print(len(train_data), len(valid_data), len(test_data))

    # KNN分类
    from sklearn.neighbors import NearestNeighbors, KNeighborsClassifier
    from sklearn.metrics import accuracy_score, recall_score, f1_score  # 模型评价
    from sklearn.naive_bayes import GaussianNB, BernoulliNB  # 高斯，伯努利，都是对特征有严格要求，离散值最好
    from sklearn.tree import DecisionTreeClassifier, export_graphviz  # 决策树
    from io import StringIO
    import pydotplus
    import os
    from sklearn.svm import SVC
    from sklearn.ensemble import RandomForestClassifier  # 随机森林
    from sklearn.ensemble import AdaBoostClassifier
    from sklearn.linear_model import LogisticRegression
    from keras.models import Sequential
    from keras.layers.core import Dense, Activation
    from tensorflow.keras.optimizers import SGD

    os.environ["PATH"] += os.pathsep+r'D:\Program Files\Graphviz\bin'

    models = []  # 申请模型，挨个验证好坏
    knn_clf = KNeighborsClassifier(n_neighbors=3)  # 5类
    bys_clf = GaussianNB()
    bnl_clf = BernoulliNB()
    DT_clf = DecisionTreeClassifier()
    SVC_clf = SVC()
    rdn_clf = RandomForestClassifier()
    adaboost_clf = AdaBoostClassifier(n_estimators=100)
    logi_clf = LogisticRegression(C=1000, tol=1e-10, solver="sag", max_iter=10000)

    # models.append(("KNN", knn_clf))  # 代码一个个模型测--放入的是元祖
    # models.append(("GaussianNB", bys_clf))  # 代码一个个模型测--放入的是元祖
    # models.append(("BernoulliNB", bnl_clf))  # 代码一个个模型测--放入的是元祖
    # models.append(("Decision Tree", DT_clf))  # 代码一个个模型测--放入的是元祖
    # models.append(("SVM classifier", SVC_clf))  # 代码一个个模型测--放入的是元祖
    # models.append(("Random classifier", rdn_clf))  # 代码一个个模型测--放入的是元祖
    # models.append(("adaboost classifier", adaboost_clf))  # 代码一个个模型测--放入的是元祖
    # models.append(("logistic classifier", logi_clf))  # 代码一个个模型测--放入的是元祖

    # 不同的模型，依次验证
    for modelName, model in models:
        print(modelName)
        model.fit(train_data, y_train)  # 指定训练集
        # 又集成化数据集
        data = [(train_data, y_train), (valid_data, y_valid), (test_data, y_test)]
        for i in range(len(data)):
            print(i)
            y_input = data[i][0]
            y_label = data[i][1]  # 输入输出预测
            y_pred = model.predict(y_input)
            print("acc:", accuracy_score(y_label, y_pred))
            print("recall:", recall_score(y_label, y_pred))
            print("F1:", f1_score(y_label, y_pred))
        print("\n")

    # 不考虑存储，你看看这个模型就会输出仨结果

    ann = Sequential()
    ann.add(Dense(50, input_dim=len(feature_val[0])))  # 隐藏层
    ann.add(Activation("sigmoid"))
    ann.add(Dense(2))  # 输出层
    ann.add(Activation("softmax"))
    sgd = SGD(lr=0.01)  # 优化器
    ann.compile(loss="mse", optimizer=sgd)  # 误差函数
    y_truth = np.array([[0,1] if t == 1 else [1,0] for t in y_train])  # Onehot编码
    ann.fit(train_data, y_truth, epochs=10, batch_size=2048)

    # 又集成化数据集
    data = [(train_data, y_train), (valid_data, y_valid), (test_data, y_test)]

    # 作图
    import matplotlib.pyplot as plt
    from sklearn.metrics import roc_curve, auc, roc_auc_score
    f = plt.figure()

    for i in range(len(data)):  # 三种数据
        print(i)
        y_input = data[i][0]
        y_label = data[i][1]  # 输入输出预测
        y_pred = ann.predict(y_input)  # 连续值转化为独热编码
        # print(y_pred)
        positive_y_pred = np.array(y_pred[:, 1]).reshape((1, -1))[0]  # 第0个
        # print(positive_y_pred)

        # 绘制roc曲线
        f.add_subplot(1, 3, i+1)  # 每个数据，
        fpr, tpr, threshold = roc_curve(y_label, positive_y_pred)
        plt.plot(fpr, tpr)
        print("nn,auc:", auc(fpr, tpr))
        print("nn,auc_socre", roc_auc_score(y_label, positive_y_pred))

    print("\n")
    plt.show()

if __name__ == '__main__':
    features, label = pre_processing(sl=True, le=True, npr=True, amh=True, wacc=True, pla=True, dep=False, sal=True,
       lower_d=False, ld_n=3)
    # print(features, label)

    # 灌入模型
    # hr_modeling_all_saveDT_SVM(features, label)
    # hr_modeling_all_saveDT_SVM_gbdt(features, label)
    hr_modeling_all_ROC(features, label)

    # 回归分析
    # regrfunc(features, label)
8999 3000 3000
2023-02-23 09:56:47.450379: I tensorflow/core/platform/cpu_feature_guard.cc:142] This TensorFlow binary is optimized with oneAPI Deep Neural Network Library (oneDNN) to use the following CPU instructions in performance-critical operations:  AVX AVX2
To enable them in other operations, rebuild TensorFlow with the appropriate compiler flags.
2023-02-23 09:56:47.869019: I tensorflow/core/common_runtime/gpu/gpu_device.cc:1510] Created device /job:localhost/replica:0/task:0/device:GPU:0 with 3994 MB memory:  -> device: 0, name: NVIDIA GeForce GTX 1660 SUPER, pci bus id: 0000:01:00.0, compute capability: 7.5
C:\ProgramData\Anaconda3\envs\AES\lib\site-packages\keras\optimizer_v2\optimizer_v2.py:356: UserWarning: The `lr` argument is deprecated, use `learning_rate` instead.
  "The `lr` argument is deprecated, use `learning_rate` instead.")
2023-02-23 09:56:48.128300: I tensorflow/compiler/mlir/mlir_graph_optimization_pass.cc:185] None of the MLIR Optimization Passes are enabled (registered 2)
Epoch 1/10
5/5 [==============================] - 1s 2ms/step - loss: 0.5220
Epoch 2/10
5/5 [==============================] - 0s 1ms/step - loss: 0.4681
Epoch 3/10
5/5 [==============================] - 0s 1ms/step - loss: 0.4057
Epoch 4/10
5/5 [==============================] - 0s 2ms/step - loss: 0.3428
Epoch 5/10
5/5 [==============================] - 0s 1ms/step - loss: 0.2896
Epoch 6/10
5/5 [==============================] - 0s 1ms/step - loss: 0.2510
Epoch 7/10
5/5 [==============================] - 0s 1ms/step - loss: 0.2259
Epoch 8/10
5/5 [==============================] - 0s 1ms/step - loss: 0.2102
Epoch 9/10
5/5 [==============================] - 0s 1ms/step - loss: 0.2005
Epoch 10/10
5/5 [==============================] - 0s 1ms/step - loss: 0.1943
0
nn,auc: 0.5396860892781884
nn,auc_socre 0.5396860892781884
1
nn,auc: 0.5015238291861216
nn,auc_socre 0.5015238291861216
2
nn,auc: 0.5035119333086666
nn,auc_socre 0.5035119333086666

auc很小

反正好说
画图之后OK
在这里插入图片描述
把训练步骤重新调高


    ann.fit(train_data, y_truth, epochs=10000, batch_size=2048)
5/5 [==============================] - 0s 1ms/step - loss: 0.0724
0
nn,auc: 0.9453794032057896
nn,auc_socre 0.9453794032057896
1
nn,auc: 0.9366794357461877
nn,auc_socre 0.9366794357461877
2
nn,auc: 0.9364281188408267
nn,auc_socre 0.9364281188408267

再看看结果
在这里插入图片描述
情况好多了

增益图与KS图

在这里插入图片描述
当少量取数，结果发现很多人都是开挂的，那这游戏就没啥意思了

俩曲线的最大差距，是正类样本的区分度

回归模型的评估

找连续值的差距
在这里插入图片描述
mae绝对值和
残差和平均值
mae是没法求导的

残差平方和，这个好求导
在这里插入图片描述

可以代码看看

    # 回顾评估作图
def regrfunc_fig(features, label):
    df = features[["number_project", "average_montly_hours"]]
    y = features["last_evaluation"]
    # print(df, y)
    from sklearn.linear_model import LinearRegression, Ridge, Lasso
    from sklearn.linear_model import LogisticRegression

    reg_model = LinearRegression()
    ridge_model = Ridge(alpha=0.95)  # 参数

    reg_model.fit(df.values, y.values)
    ridge_model.fit(df.values, y.values)
    y_pred = reg_model.predict(df.values)
    y_pred_ridge = ridge_model.predict(df.values)

    print("coef", reg_model.coef_)
    print("coef", ridge_model.coef_)


    from sklearn.metrics import mean_squared_error, mean_absolute_error, r2_score
    print("reg mse:", mean_squared_error(y.values, y_pred))
    print("ridge mse:", mean_squared_error(y.values, y_pred_ridge))
    print("ridge mae:", mean_absolute_error(y.values, y_pred_ridge))
    print("ridge r2:", r2_score(y.values, y_pred_ridge))


if __name__ == '__main__':
    features, label = pre_processing(sl=True, le=True, npr=True, amh=True, wacc=True, pla=True, dep=False, sal=True,
       lower_d=False, ld_n=3)
    # print(features, label)

    # 灌入模型
    # hr_modeling_all_saveDT_SVM(features, label)
    # hr_modeling_all_saveDT_SVM_gbdt(features, label)
    # hr_modeling_all_ROC(features, label)

    # 回归分析
    # regrfunc(features, label)
    regrfunc_fig(features, label)

coef [0.25133773 0.23488103]
coef [0.25132597 0.23487106]
reg mse: 0.8324006384950512
ridge mse: 0.8324006388305498
ridge mae: 0.7640636726937647
ridge r2: 0.16759936116945018

Process finished with exit code 0

之前的代码，搞定它

非监督学习的评估指标

root mean score
类别正确与否？

轮廓系数，簇内距离近
簇间距离远

这样的话，差值越高越好
在这里插入图片描述
下面分母是归一化的

来瞅瞅轮廓系数的来评价那些聚类模型的实力



import numpy as np
import matplotlib.pyplot as plt
from sklearn.datasets import make_circles, make_blobs, make_moons
from sklearn.cluster import KMeans, DBSCAN, AgglomerativeClustering
from sklearn.metrics import silhouette_score  # 轮廓系数

def kmeans():
    n_samples = 1000  # 生成样本的个数
    circles = make_circles(n_samples=n_samples, factor=0.5, noise=0.05)  # factor俩圆之间的间距
    moons = make_moons(n_samples=n_samples, noise=0.05)
    blobs = make_blobs(n_samples=n_samples, random_state=8, center_box=(-1, 1), cluster_std=0.1)  # 避免位置变化,范围
    random_data = np.random.rand(n_samples, 2), None  # 标注不使用

    # print(circles)   # 样本点和标注，标注不需要
    colors = "bgrcmyk"
    data = [circles, moons, blobs, random_data]  # 四个数据集
    # 模型——随意添加
    models = [("None", None), ("Kmeans", KMeans(n_clusters=3)),
              ("DBSCAN", DBSCAN(min_samples=3, eps=0.1)) ,
              ("CengCi", AgglomerativeClustering(n_clusters=3, linkage="ward")) ]
    # n分2类

    f = plt.figure()  # 给不同模型下，不同数据集的聚类情况画图
    for index, clt in enumerate(models):
        clt_name, clt_entity = clt  # 前面是名字，后面是模型的实体
        for i, dataset in enumerate(data):
            X, Y = dataset  # 生成好的数据集，后面标注不用
            if not clt_entity:
                clt_res = [0 for item in range(len(X))]  # 数据中第一部分的维度
            else:
                # 有实体——拿着模型聚类去
                clt_entity.fit(X)  # 拟合
                clt_res = clt_entity.labels_.astype(np.int)  # 聚类之后，有自己的标签哦，拿出去展示，不同色

            # 然后拿着结果作图去
            f.add_subplot(len(models), len(data), index*len(data)+i+1)  # 不同模型，多个数据
            try:
                print(clt_name, i, silhouette_score(X, clt_res))  # 聚类结果
            except:
                pass
            [plt.scatter(X[p, 0], X[p, 1], edgecolors=colors[clt_res[p]]) for p in range(len(X))]
            # 每个数据都画出来
    plt.show()
        


if __name__ == '__main__':
    kmeans()
Kmeans 0 0.38925059028584474
Kmeans 1 0.4246503360601959
Kmeans 2 0.8260921886020176
Kmeans 3 0.3938499190238276

DBSCAN 0 0.034225726469269066
DBSCAN 1 0.13287622550288697
DBSCAN 2 0.7660416392364213

CengCi 0 0.3337788731118139
CengCi 1 0.4133540378962466
CengCi 2 0.8260921886020176
CengCi 3 0.3504936195698425