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

最新推荐文章于 2024-05-21 14:54:17 发布

冰露可乐

最新推荐文章于 2024-05-21 14:54:17 发布

阅读量496

点赞数

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

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

版权

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

86 篇文章 2 订阅

订阅专栏

计算机网络

73 篇文章 8 订阅

订阅专栏

操作系统

64 篇文章 4 订阅

订阅专栏

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

文章目录

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

数据挖掘分析应用:分析建模，机器学习
机器学习的分类
训练集，测试集，验证集
监督学习：分类
K近邻分类算法，KNN
按照因特网的观点，用网桥连接起来的若干局域网仍为一个局域网，因此这些局域网都具有相同的网络号。请问这句话的说法是正确的吗？
计算机网络通信安全的目标是什么？（）
拥塞控制算法中，闭环控制是通过反馈机制来调整当前网络流量，使网络流量与网络可用资源和协调
那么当第4个RTT时间内发送的所有TCP段都得到肯定应答时，拥塞窗口大小是（）。
DCE（Data Communicate Equipment）数据通信设备
采用FDM技术进行多路复用时，复用后的信号的带宽通常( )。
计算机网络拓扑结构是通过网中结点与通信线路之间的集合关系来表示网络结构，它反映出网络中各实体的（）
B类地址默认子网掩码为255.255.0.0，其中后16位可作为主机地址
网络上所抓到的TCP数据报文段中，有一个字段RcvWindow，其含义和作用为（）
下面关于以太网的描述正确的是（）。
以下关于各种类型路由特点的说法，哪些是不正确的
10GB 的硬盘表示其存储容量为（）。
以下关于通道的说法错误的是（）：
进程对管道进行读操作和写操作都可能被阻塞
下列哪种说法不适于描述微内核操作系统（）？
总结

数据挖掘分析应用:分析建模，机器学习

在这里插入图片描述
数据建模并非最重要的过程
特征工程才是最重要的

算法只是在逼近数据中其他字段与特定字段的映射关系f(x)

只要数据好，模型随便搞

所以：近朱者赤近墨者黑，环境才是最重要的。

在这里插入图片描述
机器学习是动态的学习过程

机器学习的分类

提炼出x与y标注之间的映射关系

有标注：监督学习，离散和连续【分类和回归】
无标注：非监督学习，聚类和关联
俩混合
在这里插入图片描述

训练集，测试集，验证集

6:2:2
8:1:1

模型的参数是由训练集决定的
验证集来纠正偏差
调节参数的过程

测试，就是评价模型泛化能力的数据

在这里插入图片描述
面对未知，你能解决吗？
这就是泛化能力

8:2训验证
在这里插入图片描述
用代码切分数据集

我们用之前特征工程处理完的数据

然后我们来切分训练集和测试集

pd.set_option('display.max_columns', None) # 展示所有列
def pre_processing(sl=False, le=False, npr=False, amh=False, tsc=False,
       wacc=False, pla=False, dep=False, sal=False,
       lower_d=False, ld_n=1):
    # 处理HR表
    df = pd.read_csv('../HR_comma_sep.csv')
    # print(df)

    # 清洗数据，除去异常值，抽样啥的
    df = df.dropna(subset=['satisfaction_level', 'last_evaluation'])
    df = df[df['satisfaction_level']<=1][df['salary']!='nme']


    # 标注label就是离职率left——顺序放后面哦
    label = df['left']
    df = df.drop('left', axis=1)  # 删除left列，而不是行哦

    # 特征选择，之前我们见过，left与last_evaluetion，number_projection,是无关的
    # 特征处理
    # satisfaction_level处于0--1之间，这个可以保留不动，可以缩放到--1，可以标准化
    # sl为True时，minmax化，False时，standard 处理
    scalar_list = [sl, le, npr, amh, tsc, wacc, pla]
    column_list = ['satisfaction_level', 'last_evaluation', 'number_project', 'average_montly_hours',
                   'time_spend_company', 'Work_accident', 'promotion_last_5years']
    for i in range(len(scalar_list)):
        if not scalar_list[i]:
            df[column_list[i]] = MinMaxScaler().fit_transform(df[column_list[i]].values.reshape(-1, 1)).reshape(1, -1)[0]
            # 转换列--行，取0行
        else:
            df[column_list[i]] = StandardScaler().fit_transform(df[column_list[i]].values.reshape(-1, 1)).reshape(1, -1)[0]
            # 转换
    # last_evaluation和satisfaction类似，le为True时，minmax化，False时，standard 处理，自hi今儿上面列表里面加入即可
    # number_project不大于10，npr为True时，minmax化，False时，standard 处理，自hi今儿上面列表里面加入即可
    # time_spend_company不大于10，tsc为True时，minmax化，False时，standard 处理，自hi今儿上面列表里面加入即可
    # average_montly_hours范围很大，我们最好将其离散化，由于数据不大，最好保留
    # 当然也能处理，average_montly_hours，amh为True时，minmax化，False时，standard 处理，自hi今儿上面列表里面加入即可
    # Work_accident和promotion_last_5years是0-1的
    # Work_accident不大于10，wacc为True时，minmax化，False时，standard 处理，自hi今儿上面列表里面加入即可
    # promotion_last_5years不大于10，pla为True时，minmax化，False时，standard 处理，自hi今儿上面列表里面加入即可

    # department,将其数值化，dep,True：LabelEncoding，False:OneHotEncoding
    # salary,将其数值化，sal,True：LabelEncoding，False:OneHotEncoding
    scalar_list = [dep, sal]
    column_list = ['department', 'salary']
    for i in range(len(scalar_list)):
        if not scalar_list[i]:
            #建议salary是按照0 1 2低中去编码
            if column_list[i] == "salary":
                df[column_list[i]] = [map_salary(s) for s in df['salary'].values]  # 字段所有行都去遍历处理
            else:
                df[column_list[i]] = LabelEncoder().fit_transform(df[column_list[i]])  # department是按照字母排序编码
        else:
            df = pd.get_dummies(df, columns=[column_list[i]])  # 这是onehot编码

    # lower_d降维？
    if lower_d:
        df = PCA(n_components=ld_n).fit_transform(df.values)  # 对整个表降维
    return df, label

def map_salary(s):
    d = dict([('low', 0), ('medium', 1), ('high', 2)])
    return d.get(s, 0)  # 有s，就返回其value，否则返回默认0

# 模型
def hr_modeling(features, label):
    from sklearn.model_selection import train_test_split
    # 切分函数
    #DataFrame
    feature_val = features
    label_val = label
    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))


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

    # 灌入模型
    hr_modeling(features, label)

8999 3000 3000

Process finished with exit code 0

配合昨天数据预处理的代码
今天的模型测试集划分很简单

注意它首先返回的是训练集和验证集，后面跟了俩标签

懂？？？
比例你随便OK，6:2：2

监督学习：分类

在这里插入图片描述

K近邻分类算法，KNN

在这里插入图片描述

坐标长度差
最大的那项是闵式距离

在这里插入图片描述

我们来寻找x最近的邻居点

KD-树，树型结构
最开始，分俩部分
不断去另一个维度均分

在这里插入图片描述

大小不一的格子就画出来了

这样的话，x周围就会延伸出去
得到这样的一个树
在这里插入图片描述
比如，你要找这个黑点x的最近邻居

找x与哪根线距离更近，这个线挂接的节点就是x的邻居
其他的都不算近

K nearst neighbor
在这里插入图片描述
我们认为与x距离近的点，可以分为一类
这就是最近邻邻居分类方法

在这里插入图片描述

下面代码演示

sklearn的官网有用法

在这里插入图片描述
Parameters你可以去看看

在这里插入图片描述
那个kneighbor是返回的索引
第2和0个点最近哦

pd.set_option('display.max_columns', None) # 展示所有列
def pre_processing(sl=False, le=False, npr=False, amh=False, tsc=False,
       wacc=False, pla=False, dep=False, sal=False,
       lower_d=False, ld_n=1):
    # 处理HR表
    df = pd.read_csv('../HR_comma_sep.csv')
    # print(df)

    # 清洗数据，除去异常值，抽样啥的
    df = df.dropna(subset=['satisfaction_level', 'last_evaluation'])
    df = df[df['satisfaction_level']<=1][df['salary']!='nme']


    # 标注label就是离职率left——顺序放后面哦
    label = df['left']
    df = df.drop('left', axis=1)  # 删除left列，而不是行哦

    # 特征选择，之前我们见过，left与last_evaluetion，number_projection,是无关的
    # 特征处理
    # satisfaction_level处于0--1之间，这个可以保留不动，可以缩放到--1，可以标准化
    # sl为True时，minmax化，False时，standard 处理
    scalar_list = [sl, le, npr, amh, tsc, wacc, pla]
    column_list = ['satisfaction_level', 'last_evaluation', 'number_project', 'average_montly_hours',
                   'time_spend_company', 'Work_accident', 'promotion_last_5years']
    for i in range(len(scalar_list)):
        if not scalar_list[i]:
            df[column_list[i]] = MinMaxScaler().fit_transform(df[column_list[i]].values.reshape(-1, 1)).reshape(1, -1)[0]
            # 转换列--行，取0行
        else:
            df[column_list[i]] = StandardScaler().fit_transform(df[column_list[i]].values.reshape(-1, 1)).reshape(1, -1)[0]
            # 转换
    # last_evaluation和satisfaction类似，le为True时，minmax化，False时，standard 处理，自hi今儿上面列表里面加入即可
    # number_project不大于10，npr为True时，minmax化，False时，standard 处理，自hi今儿上面列表里面加入即可
    # time_spend_company不大于10，tsc为True时，minmax化，False时，standard 处理，自hi今儿上面列表里面加入即可
    # average_montly_hours范围很大，我们最好将其离散化，由于数据不大，最好保留
    # 当然也能处理，average_montly_hours，amh为True时，minmax化，False时，standard 处理，自hi今儿上面列表里面加入即可
    # Work_accident和promotion_last_5years是0-1的
    # Work_accident不大于10，wacc为True时，minmax化，False时，standard 处理，自hi今儿上面列表里面加入即可
    # promotion_last_5years不大于10，pla为True时，minmax化，False时，standard 处理，自hi今儿上面列表里面加入即可

    # department,将其数值化，dep,True：LabelEncoding，False:OneHotEncoding
    # salary,将其数值化，sal,True：LabelEncoding，False:OneHotEncoding
    scalar_list = [dep, sal]
    column_list = ['department', 'salary']
    for i in range(len(scalar_list)):
        if not scalar_list[i]:
            #建议salary是按照0 1 2低中去编码
            if column_list[i] == "salary":
                df[column_list[i]] = [map_salary(s) for s in df['salary'].values]  # 字段所有行都去遍历处理
            else:
                df[column_list[i]] = LabelEncoder().fit_transform(df[column_list[i]])  # department是按照字母排序编码
        else:
            df = pd.get_dummies(df, columns=[column_list[i]])  # 这是onehot编码

    # lower_d降维？
    if lower_d:
        df = PCA(n_components=ld_n).fit_transform(df.values)  # 对整个表降维
    return df, label

def map_salary(s):
    d = dict([('low', 0), ('medium', 1), ('high', 2)])
    return d.get(s, 0)  # 有s，就返回其value，否则返回默认0

# 模型
def hr_modeling(features, label):
    from sklearn.model_selection import train_test_split
    # 切分函数
    #DataFrame
    feature_val = features
    label_val = label
    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
    knn_clf = KNeighborsClassifier(n_neighbors=5)  # 5类
    knn_clf.fit(train_data, y_train)  # 指定训练集
    y_pred = knn_clf.predict(valid_data)  # 输入验证集，得到预测值，可以去计算loss
    from sklearn.metrics import accuracy_score, recall_score, f1_score  # 模型评价
    print("acc:", accuracy_score(y_valid, y_pred))
    print("recall:", recall_score(y_valid, y_pred))
    print("F1:", f1_score(y_valid, y_pred))



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

    # 灌入模型
    hr_modeling(features, label)


8999 3000 3000
acc: 0.915
recall: 0.8022130013831259
F1: 0.8197879858657243

Process finished with exit code 0

看看
经过fit拟合之后，得到了模型
模型预测
然后拿去评估
你可以发现，这准确率91.%
还是可以的

调整n_neighbor的个数，acc不同
选择一个合适的n即可

不够你需要同样的训练集的情况下，才能对比n的大小，因为数据集是随机切分的哦

再看看测试集呢

    #测试你
    y_pred = knn_clf.predict(test_data)  # 输入测试集，得到预测值，可以去计算loss
    print("acc:", accuracy_score(y_valid, y_pred))
    print("recall:", recall_score(y_valid, y_pred))
    print("F1:", f1_score(y_valid, y_pred))

8999 3000 3000
acc: 0.9196666666666666
recall: 0.8367911479944675
F1: 0.8339076498966231
acc: 0.6233333333333333
recall: 0.20193637621023514
F1: 0.20534458509142053

Process finished with exit code 0

我这的话，测试集一般般啊
说明泛化能力一般般啊

那就是过拟合gg

要么就是特征工程出错了

反正就是前面的数据+模型有问题

HR很多参数都是False

你看看别的归一化呢？

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

    # 灌入模型
    hr_modeling(features, label)
8999 3000 3000
acc: 0.9426666666666667
recall: 0.8874824191279888
F1: 0.8800557880055789
acc: 0.65
recall: 0.25316455696202533
F1: 0.2553191489361702

Process finished with exit code 0

还是严重的过拟合
看来模型gg

存储模型

    # U存储
    import joblib
    joblib.dump(knn_clf, filename="knn_clf")
    knn_clf2 = joblib.load(filename="knn_clf")
     #测试你
    y_pred = knn_clf2.predict(test_data)  # 输入测试集，得到预测值，可以去计算loss
    print("acc:", accuracy_score(y_valid, y_pred))
    print("recall:", recall_score(y_valid, y_pred))
    print("F1:", f1_score(y_valid, y_pred))


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=True, ld_n=3)
    # print(df, label)

    # 灌入模型
    hr_modeling(features, label)
8999 3000 3000
acc: 0.93
recall: 0.8780141843971632
F1: 0.8549723756906078
acc: 0.632
recall: 0.24822695035460993
F1: 0.2407152682255846
acc: 0.632
recall: 0.24822695035460993
F1: 0.2407152682255846

Process finished with exit code 0

存好了，读取好了

easy

按照因特网的观点，用网桥连接起来的若干局域网仍为一个局域网，因此这些局域网都具有相同的网络号。请问这句话的说法是正确的吗？

在这里插入图片描述

计算机网络通信安全的目标是什么？（）

加强防火墙是手段

在这里插入图片描述

拥塞控制算法中，闭环控制是通过反馈机制来调整当前网络流量，使网络流量与网络可用资源和协调

闭环控制在这里插入图片描述

那么当第4个RTT时间内发送的所有TCP段都得到肯定应答时，拥塞窗口大小是（）。

在这里插入图片描述

链接：https://www.nowcoder.com/questionTerminal/5b910f26cc1f4d9fa193bfe51a088697
来源：牛客网

在发生超时后，慢开始门限ssthresh变为16KB/2=8KB，拥塞窗口变为1KB。在接下来的3个RTT内，执行慢开始算法，拥塞窗口大小依次为2KB、4KB、8KB，由于慢开始门限ssthresh为8KB，因此之后转而执行拥塞避免算法，即拥塞窗口开始“加法增大”。因此第4个RTT结束后，拥塞窗口的大小为9KB。