数据挖掘,计算机网络、操作系统刷题笔记55
2022找工作是学历、能力和运气的超强结合体,遇到寒冬,大厂不招人,可能很多算法学生都得去找开发,测开
测开的话,你就得学数据库,sql,oracle,尤其sql要学,当然,像很多金融企业、安全机构啥的,他们必须要用oracle数据库
这oracle比sql安全,强大多了,所以你需要学习,最重要的,你要是考网络警察公务员,这玩意你不会就别去报名了,耽误时间!
与此同时,既然要考网警之数据分析应用岗,那必然要考数据挖掘基础知识,今天开始咱们就对数据挖掘方面的东西好生讲讲
刷题系列文章
【1】Oracle数据库:刷题错题本,数据库的各种概念
【2】操作系统,计算机网络,数据库刷题笔记2
【3】数据库、计算机网络,操作系统刷题笔记3
【4】数据库、计算机网络,操作系统刷题笔记4
【5】数据库、计算机网络,操作系统刷题笔记5
【6】数据库、计算机网络,操作系统刷题笔记6
【7】数据库、计算机网络,操作系统刷题笔记7
【8】数据库、计算机网络,操作系统刷题笔记8
【9】操作系统,计算机网络,数据库刷题笔记9
【10】操作系统,计算机网络,数据库刷题笔记10
【11】操作系统,计算机网络,数据库刷题笔记11
【12】操作系统,计算机网络,数据库刷题笔记12
【13】操作系统,计算机网络,数据库刷题笔记13
【14】操作系统,计算机网络,数据库刷题笔记14
【15】计算机网络、操作系统刷题笔记15
【16】数据库,计算机网络、操作系统刷题笔记16
【17】数据库,计算机网络、操作系统刷题笔记17
【18】数据库,计算机网络、操作系统刷题笔记18
【19】数据库,计算机网络、操作系统刷题笔记19
【20】数据库,计算机网络、操作系统刷题笔记20
【21】数据库,计算机网络、操作系统刷题笔记21
【22】数据库,计算机网络、操作系统刷题笔记22
【23】数据库,计算机网络、操作系统刷题笔记23
【24】数据库,计算机网络、操作系统刷题笔记24
【25】数据库,计算机网络、操作系统刷题笔记25
【26】数据库,计算机网络、操作系统刷题笔记26
【27】数据库,计算机网络、操作系统刷题笔记27
【28】数据库,计算机网络、操作系统刷题笔记28
【29】数据库,计算机网络、操作系统刷题笔记29
【30】数据库,计算机网络、操作系统刷题笔记30
【31】数据库,计算机网络、操作系统刷题笔记31
【32】数据库,计算机网络、操作系统刷题笔记32
【33】数据库,计算机网络、操作系统刷题笔记33
【34】数据库,计算机网络、操作系统刷题笔记34
【35】数据挖掘,计算机网络、操作系统刷题笔记35
【36】数据挖掘,计算机网络、操作系统刷题笔记36
【37】数据挖掘,计算机网络、操作系统刷题笔记37
【38】数据挖掘,计算机网络、操作系统刷题笔记38
【39】数据挖掘,计算机网络、操作系统刷题笔记39
【40】数据挖掘,计算机网络、操作系统刷题笔记40
【41】数据挖掘,计算机网络、操作系统刷题笔记41
【42】数据挖掘,计算机网络、操作系统刷题笔记42
【43】数据挖掘,计算机网络、操作系统刷题笔记43
【44】数据挖掘,计算机网络、操作系统刷题笔记44
【45】数据挖掘,计算机网络、操作系统刷题笔记45
【46】数据挖掘,计算机网络、操作系统刷题笔记46
【47】数据挖掘,计算机网络、操作系统刷题笔记47
【48】数据挖掘,计算机网络、操作系统刷题笔记48
【49】数据挖掘,计算机网络、操作系统刷题笔记49
【50】数据挖掘,计算机网络、操作系统刷题笔记50
【51】数据挖掘,计算机网络、操作系统刷题笔记51
【52】数据挖掘,计算机网络、操作系统刷题笔记52
【53】数据挖掘,计算机网络、操作系统刷题笔记53
【54】数据挖掘,计算机网络、操作系统刷题笔记54
文章目录
- 数据挖掘,计算机网络、操作系统刷题笔记55
-
- 数据挖掘分析应用:模型评估评价方法
- 二分类模型评估
- 增益图与KS图
- 回归模型的评估
- 非监督学习的评估指标
- 整个数据挖掘分析应用,课程总结
- 大数据在未来有什么作用????
- 宽带城域网主要技术是基于数据传输速度为千兆网Mb/s 的 Fast Ethernet 的。( )
- Ethernet 标准采用的媒体访问控制方式为( )。
- 有关路由器和二层交换机的区别,下述错误的是?
- IPV6地址类型可以分为单播地址,组播地址,任播地址
- 提高设备接口的速率可以缩短下列哪项时延()。
- ping是ICMP协议,并不是通常所说的tcp/udp端口;ICMP不像tcp/udp有端口,但它确实含有两个域:类型type和代码code,而这些与端口作用不同。
- 国标规定接入网的维护管理接口应符合 ()接口标准
- 总结
文章目录
- 数据挖掘,计算机网络、操作系统刷题笔记55
- 数据挖掘分析应用:模型评估评价方法
- 二分类模型评估
- 增益图与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
四种数据集的聚类,看看效果如何
kmeans算法用罗阔系数来衡量是最合适的
基于密度的,
反正就知道就行了
整个数据挖掘分析应用,课程总结
认识数据,做预测,回归
多角度看看数据
大数据在未来有什么作用????
推荐系统的实力
大数据分析方法,跟上面我们学习的内容一模一样
而大数据唯一的区别就是工具,要快,要猛
主要就是并行,高速计算
宽带城域网主要技术是基于数据传输速度为千兆网Mb/s 的 Fast Ethernet 的。( )
Ethernet 标准采用的媒体访问控制方式为( )。
有关路由器和二层交换机的区别,下述错误的是?
集线器工作在物理层,所有端口在1个广播域和冲突域。交换机工作在1个广播域,有多少端口有多少冲突域。路由器每个端口都是广播域和冲突域。
广播域是指广播能到达的范围。冲突域是指同一物理线路上节点的集合。
IPV6地址类型可以分为单播地址,组播地址,任播地址
提高设备接口的速率可以缩短下列哪项时延()。
传输时延=A+C+D
ping是ICMP协议,并不是通常所说的tcp/udp端口;ICMP不像tcp/udp有端口,但它确实含有两个域:类型type和代码code,而这些与端口作用不同。
与端口无关
国标规定接入网的维护管理接口应符合 ()接口标准
总结
提示:重要经验:
1)
2)学好oracle,即使经济寒冬,整个测开offer绝对不是问题!同时也是你考公网络警察的必经之路。
3)笔试求AC,可以不考虑空间复杂度,但是面试既要考虑时间复杂度最优,也要考虑空间复杂度最优。