sklearn决策树与随机森林 参数及规则提取 模型可视化（初体验）

最新推荐文章于 2023-02-10 07:56:49 发布
最新推荐文章于 2023-02-10 07:56:49 发布
阅读量3.4k 收藏 24
点赞数 1
分类专栏： 机器学习记录 # 树模型 文章标签： 机器学习
版权声明：本文为博主原创文章，遵循 CC 4.0 BY-SA 版权协议，转载请附上原文出处链接和本声明。
本文链接：https://blog.csdn.net/m0_37872998/article/details/104249074
版权

决策树

import os
import pandas as pd
import numpy as np
from sklearn import tree
from sklearn.tree import _tree
from sklearn.model_selection import train_test_split
from sklearn.feature_extraction import DictVectorizer
from sklearn.tree import DecisionTreeClassifier
from sklearn.metrics import classification_report
from sklearn.ensemble import RandomForestClassifier
from sklearn.metrics import confusion_matrix
import matplotlib.pyplot as plt
import pydotplus


def tree_to_code(tree, feature_names):    # 决策树规则提取
    tree_ = tree.tree_
    feature_name = [
        feature_names[i] if i != _tree.TREE_UNDEFINED else "undefined!"
        for i in tree_.feature
    ]
    print('feature_name:', feature_name)
    with open('code.txt', 'a+') as f:
        f.write("def tree({}):".format(", ".join(feature_names)))
        f.write('\n')
        f.close()

    def recurse(node, depth):
        indent = "  " * depth
        # print('tree_.feature:',tree_.feature)
        if tree_.feature[node] != _tree.TREE_UNDEFINED:
            # print('tree_.feature[node]:',tree_.feature[node])
            name = feature_name[node]
            threshold = tree_.threshold[node]
            with open('code.txt', 'a+') as f:
                f.write("{}if {} <= {}:".format(indent, name, threshold))
                f.write('\n')
                f.close()
            recurse(tree_.children_left[node], depth + 1)
            with open('code.txt', 'a+') as f:
                f.write("{}else:  # if {} > {}".format(indent, name, threshold))
                f.write('\n')
                f.close()
            recurse(tree_.children_right[node], depth + 1)
        else:
            with open('code.txt', 'a+') as f:
                f.write("{}return {} -- {}".format(indent, tree_.value[node],
                                                target_name[np.argmax(tree_.value[node])]))
                f.write('\n')
                f.close()

    recurse(0, 1)

pwd = os.getcwd()
titanic = pd.read_csv(pwd + '/ta.txt')
titanic['age'].fillna(titanic['age'].mean(), inplace=True) #  补充缺失值
# 选取一些特征作为我们划分的依据
x = titanic[['pclass', 'age', 'sex']]
y = titanic['survived']
labels = [0, 1]
target_name = ["deid", "survived"]

fea_name = ["sex", "age", "pclass"]
fea_name.sort()

x_train, x_test, y_train, y_test = train_test_split(x, y, test_size=0.3)  # 测试数据和训练数据的比例 数值为测数据/总体数据

dt = DictVectorizer(sparse=False)   #  sparse=False意思是不产生稀疏矩阵

x_train = dt.fit_transform(x_train.to_dict(orient="record"))

x_test = dt.fit_transform(x_test.to_dict(orient="record"))

# 使用决策树
dtc = DecisionTreeClassifier(                         # 使用默认的就行
                             # class_weight='balanced',   #  平衡数据集
                             # criterion='entropy',     # 划分标准使用gini还是信息熵  默认gini
                             # max_features='sqrt',   
                             )

dtc.fit(x_train, y_train)

dt_predict = dtc.predict(x_test)


tree_to_code(dtc, fea_name)  # 实现决策树的规则提取

print(dtc.score(x_test, y_test))  

print(classification_report(y_test, dt_predict, labels=labels, target_names=target_name))

# # 混淆矩阵并可视化
confmat = confusion_matrix(y_true=y_test, y_pred=rfc_y_predict, labels=labels)  # 输出混淆矩阵
print(confmat)

fig, ax = plt.subplots(figsize=(3, 3))
ax.matshow(confmat, cmap=plt.cm.Blues, alpha=0.3)
for i in range(confmat.shape[0]):
    for j in range(confmat.shape[1]):
        ax.text(x=j, y=i, s=confmat[i, j], va='center', ha='center')

plt.xticks(range(len(confmat)), labels)
plt.yticks(range(len(confmat)), labels)
plt.xlabel('predicted label')
plt.ylabel('true label')
plt.savefig('confusion_matrix.png')
plt.show()

# 可视化决策树

os.environ["PATH"] += os.pathsep + 'graphviz的bin路径'   #  在pycharm运行时 可能会出现找不到graphviz的情况，自己加环境
dot_data = tree.export_graphviz(dtc, out_file=None, feature_names=fea_name, class_names=target_name,
                                filled=True,
                                rounded=True,
                                )
graph = pydotplus.graph_from_dot_data(dot_data)
graph.write_pdf("descion_tree.pdf")

随机森林

# 之前的数据导入处理和决策树一样
# 使用随机森林

rfc = RandomForestClassifier(n_estimators=100, max_depth=6)  #  如果不设置n_estimators的值 在2.0版本会有警告提示 建议将其设置为2.02的默认值100

rfc.fit(x_train, y_train)

rfc_y_predict = rfc.predict(x_test)

print(rfc.score(x_test, y_test))

print(classification_report(y_test, rfc_y_predict, labels=labels, target_names=target_name))

if os.path.exists(pwd + '/forest/'):
    os.chdir(pwd + '/forest/')
else:
    os.mkdir(pwd + '/forest/')
    os.chdir(pwd + '/forest/')

for idx, estimator in enumerate(rfc.estimators_):
    # 导出dot文件
    filename = 'forest_' + str(idx) + '.pdf'
    dot_data = tree.export_graphviz(estimator,
                                    out_file=None,
                                    feature_names=fea_name,
                                    class_names=target_name,
                                    rounded=True,
                                    proportion=False,
                                    precision=2,
                                    filled=True)
                                    
    graph = pydotplus.graph_from_dot_data(dot_data)

    graph.write_pdf(filename)

本地文件ta的原始文件
性别 Pclass 分别做了数值处理

提取的规则代码块

def tree(age, pclass, sex):
  if sex <= 1.5:
    if age <= 10.0:
      if pclass <= 2.5:
        return [[ 0. 12.]] deid
      else:  # if pclass > 2.5
        if age <= 0.583299994468689:
          return [[1. 0.]] survived
        else:  # if age > 0.583299994468689
          if age <= 4.0:
            return [[0. 3.]] deid
          else:  # if age > 4.0
            if age <= 7.5:
              return [[2. 0.]] survived
            else:  # if age > 7.5
              return [[1. 2.]] deid
    else:  # if age > 10.0
      if pclass <= 1.5:
        if age <= 54.5:
          if age <= 29.0:
            if age <= 17.5:
              return [[0. 2.]] deid
            else:  # if age > 17.5
              if age <= 24.5:
                if age <= 20.0:
                  return [[2. 0.]] survived
                else:  # if age > 20.0
                  if age <= 23.5:
                    if age <= 21.5:
                      return [[0. 1.]] deid
                    else:  # if age > 21.5
                      if age <= 22.5:
                        return [[1. 0.]] survived
                      else:  # if age > 22.5
                        return [[0. 1.]] deid
                  else:  # if age > 23.5
                    return [[2. 0.]] survived
              else:  # if age > 24.5
                if age <= 26.0:
                  return [[1. 2.]] deid
                else:  # if age > 26.0
                  if age <= 27.5:
                    return [[0. 1.]] deid
                  else:  # if age > 27.5
                    return [[1. 2.]] deid
          else:  # if age > 29.0
            if age <= 33.5:
              if age <= 31.09709072113037:
                return [[4. 0.]] survived
              else:  # if age > 31.09709072113037
                if age <= 32.09709072113037:
                  return [[29. 10.]] survived
                else:  # if age > 32.09709072113037
                  return [[2. 0.]] survived
            else:  # if age > 33.5
              if age <= 36.5:
                if age <= 35.5:
                  return [[0. 2.]] deid
                else:  # if age > 35.5
                  return [[1. 4.]] deid
              else:  # if age > 36.5
                if age <= 47.5:
                  if age <= 38.5:
                    if age <= 37.5:
                      return [[1. 1.]] survived
                    else:  # if age > 37.5
                      return [[1. 1.]] survived
                  else:  # if age > 38.5
                    if age <= 45.5:
                      if age <= 41.5:
                        if age <= 39.5:
                          return [[3. 1.]] survived
                        else:  # if age > 39.5
                          return [[2. 0.]] survived
                      else:  # if age > 41.5
                        if age <= 43.0:
                          return [[2. 1.]] survived
                        else:  # if age > 43.0
                          if age <= 44.5:
                            return [[1. 0.]] survived
                          else:  # if age > 44.5
                            return [[3. 1.]] survived
                    else:  # if age > 45.5
                      if age <= 46.5:
                        return [[5. 0.]] survived
                      else:  # if age > 46.5
                        return [[3. 1.]] survived
                else:  # if age > 47.5
                  if age <= 48.5:
                    return [[1. 2.]] deid
                  else:  # if age > 48.5
                    if age <= 51.5:
                      if age <= 49.5:
                        return [[2. 1.]] survived
                      else:  # if age > 49.5
                        return [[3. 0.]] survived
                    else:  # if age > 51.5
                      if age <= 53.0:
                        return [[1. 1.]] survived
                      else:  # if age > 53.0
                        return [[1. 1.]] survived
        else:  # if age > 54.5
          return [[14.  0.]] survived
      else:  # if pclass > 1.5
        if age <= 29.5:
          if age <= 25.5:
            if age <= 23.5:
              if age <= 18.5:
                return [[17.  0.]] survived
              else:  # if age > 18.5
                if age <= 19.5:
                  if pclass <= 2.5:
                    return [[1. 0.]] survived
                  else:  # if pclass > 2.5
                    return [[4. 1.]] survived
                else:  # if age > 19.5
                  if age <= 20.5:
                    return [[8. 0.]] survived
                  else:  # if age > 20.5
                    if age <= 22.5:
                      if age <= 21.5:
                        if pclass <= 2.5:
                          return [[5. 0.]] survived
                        else:  # if pclass > 2.5
                          return [[4. 1.]] survived
                      else:  # if age > 21.5
                        if pclass <= 2.5:
                          return [[3. 1.]] survived
                        else:  # if pclass > 2.5
                          return [[3. 0.]] survived
                    else:  # if age > 22.5
                      return [[7. 0.]] survived
            else:  # if age > 23.5
              if age <= 24.5:
                if pclass <= 2.5:
                  return [[1. 1.]] survived
                else:  # if pclass > 2.5
                  return [[6. 1.]] survived
              else:  # if age > 24.5
                if pclass <= 2.5:
                  return [[4. 0.]] survived
                else:  # if pclass > 2.5
                  return [[4. 1.]] survived
          else:  # if age > 25.5
            return [[23.  0.]] survived
        else:  # if age > 29.5
          if age <= 45.5:
            if age <= 44.5:
              if age <= 32.5:
                if age <= 31.59709072113037:
                  if pclass <= 2.5:
                    if age <= 30.59709072113037:
                      return [[8. 0.]] survived
                    else:  # if age > 30.59709072113037
                      return [[32.  4.]] survived
                  else:  # if pclass > 2.5
                    if age <= 30.59709072113037:
                      return [[1. 1.]] survived
                    else:  # if age > 30.59709072113037
                      return [[220.  32.]] survived
                else:  # if age > 31.59709072113037
                  if pclass <= 2.5:
                    return [[3. 2.]] survived
                  else:  # if pclass > 2.5
                    return [[5. 0.]] survived
              else:  # if age > 32.5
                if age <= 35.5:
                  return [[11.  0.]] survived
                else:  # if age > 35.5
                  if age <= 36.5:
                    if pclass <= 2.5:
                      return [[1. 0.]] survived
                    else:  # if pclass > 2.5
                      return [[0. 1.]] deid
                  else:  # if age > 36.5
                    if pclass <= 2.5:
                      if age <= 40.5:
                        return [[3. 0.]] survived
                      else:  # if age > 40.5
                        if age <= 41.5:
                          return [[1. 1.]] survived
                        else:  # if age > 41.5
                          return [[3. 0.]] survived
                    else:  # if pclass > 2.5
                      return [[11.  0.]] survived
            else:  # if age > 44.5
              if pclass <= 2.5:
                return [[2. 0.]] survived
              else:  # if pclass > 2.5
                return [[1. 1.]] survived
          else:  # if age > 45.5
            return [[13.  0.]] survived
  else:  # if sex > 1.5
    if pclass <= 2.5:
      if pclass <= 1.5:
        if age <= 62.5:
          if age <= 36.5:
            if age <= 35.5:
              if age <= 24.5:
                return [[ 0. 19.]] deid
              else:  # if age > 24.5
                if age <= 26.0:
                  return [[1. 0.]] survived
                else:  # if age > 26.0
                  if age <= 31.09709072113037:
                    return [[0. 6.]] deid
                  else:  # if age > 31.09709072113037
                    if age <= 32.09709072113037:
                      return [[ 1. 23.]] deid
                    else:  # if age > 32.09709072113037
                      return [[0. 5.]] deid
            else:  # if age > 35.5
              return [[1. 3.]] deid
          else:  # if age > 36.5
            return [[ 0. 31.]] deid
        else:  # if age > 62.5
          if age <= 63.5:
            return [[1. 1.]] survived
          else:  # if age > 63.5
            return [[0. 1.]] deid
      else:  # if pclass > 1.5
        if age <= 17.5:
          return [[0. 9.]] deid
        else:  # if age > 17.5
          if age <= 22.5:
            if age <= 21.5:
              if age <= 18.5:
                return [[1. 3.]] deid
              else:  # if age > 18.5
                return [[0. 5.]] deid
            else:  # if age > 21.5
              return [[2. 0.]] survived
          else:  # if age > 22.5
            if age <= 26.5:
              return [[0. 5.]] deid
            else:  # if age > 26.5
              if age <= 27.5:
                return [[1. 1.]] survived
              else:  # if age > 27.5
                if age <= 29.5:
                  return [[0. 5.]] deid
                else:  # if age > 29.5
                  if age <= 30.5:
                    return [[1. 2.]] deid
                  else:  # if age > 30.5
                    if age <= 46.0:
                      if age <= 43.0:
                        if age <= 39.0:
                          if age <= 37.0:
                            if age <= 31.59709072113037:
                              if age <= 31.09709072113037:
                                return [[0. 2.]] deid
                              else:  # if age > 31.09709072113037
                                return [[ 3. 17.]] deid
                            else:  # if age > 31.59709072113037
                              return [[0. 9.]] deid
                          else:  # if age > 37.0
                            return [[1. 0.]] survived
                        else:  # if age > 39.0
                          return [[0. 4.]] deid
                      else:  # if age > 43.0
                        return [[1. 0.]] survived
                    else:  # if age > 46.0
                      return [[0. 5.]] deid
    else:  # if pclass > 2.5
      if age <= 19.5:
        if age <= 12.0:
          if age <= 5.5:
            if age <= 1.0833500027656555:
              return [[0. 1.]] deid
            else:  # if age > 1.0833500027656555
              if age <= 3.5:
                return [[1. 0.]] survived
              else:  # if age > 3.5
                return [[0. 1.]] deid
          else:  # if age > 5.5
            return [[2. 0.]] survived
        else:  # if age > 12.0
          if age <= 17.5:
            if age <= 15.5:
              return [[0. 1.]] deid
            else:  # if age > 15.5
              if age <= 16.5:
                return [[1. 3.]] deid
              else:  # if age > 16.5
                return [[0. 1.]] deid
          else:  # if age > 17.5
            if age <= 18.5:
              return [[2. 3.]] deid
            else:  # if age > 18.5
              return [[0. 1.]] deid
      else:  # if age > 19.5
        if age <= 21.5:
          return [[3. 0.]] survived
        else:  # if age > 21.5
          if age <= 23.5:
            if age <= 22.5:
              return [[1. 2.]] deid
            else:  # if age > 22.5
              return [[0. 1.]] deid
          else:  # if age > 23.5
            if age <= 32.5:
              if age <= 31.59709072113037:
                if age <= 25.5:
                  return [[1. 1.]] survived
                else:  # if age > 25.5
                  if age <= 29.0:
                    return [[2. 0.]] survived
                  else:  # if age > 29.0
                    if age <= 30.59709072113037:
                      return [[1. 1.]] survived
                    else:  # if age > 30.59709072113037
                      return [[75. 40.]] survived
              else:  # if age > 31.59709072113037
                return [[1. 0.]] survived
            else:  # if age > 32.5
              if age <= 37.0:
                return [[0. 3.]] deid
              else:  # if age > 37.0
                if age <= 42.5:
                  return [[2. 0.]] survived
                else:  # if age > 42.5
                  return [[1. 1.]] survived

混淆矩阵

结果图
在这里插入图片描述

牧牧牧牧牧
关注
专栏目录
决策树与规则提取原理与代码实战案例讲解
程序员光剑
07-22 956
决策树与规则提取原理与代码实战案例讲解 作者：禅与计算机程序设计艺术 / Zen and the Art of Computer Programming 1. 背景介绍 1.1 问题的由来 决策树是机器学习领域中一种重要的算
机器学习之决策树及随机森林（附案例代码）
最新发布
JustinMars的博客
11-28 1220
决策树是单个模型，具有易解释性和理解性，但容易过拟合。 随机森林是多个决策树的集成，引入了随机性和Bagging思想，通常具有更好的泛化能力和鲁棒性，适用于各种数据类型和复杂度不同的问题。
本人博客 sklearn决策树与随机森林 参数及规则提取 模型可视化（初体验）数据文件
03-17
本人博客 sklearn决策树与随机森林 参数及规则提取 模型可视化（初体验）数据文件
sklearn adaboost_sklearn之随机森林(1)
weixin_39805924的博客
11-23 101
我是谁？梦幻1 概述集成算法：考虑多个评估器的建模结果，汇总之后得到一个综合的结果，以此来获取比单个模型更好的回归或分类表现。有三类集成算法：装袋法（Bagging），提升法（Boosting）和stacking装袋法的核心思想是构建多个相互独立的评估器，然后对其预测进行平均或多数表决原则来决定集成评估器的结果，装袋法的代表模型就是随机森林；提升法中，基评估器是相关的，是按顺序一一构建的。其核心...
机器学习可解释性【随机森林规则提取】
Zane
05-14 3445
本文首先介绍了机器学习模型可解释性分为： 1. 事前可解释性建模 2. 事后可解释性分析 随机森林规则提取，既可做事前也可做事后分析。 本文主要针对事后可解释性分析，提出了先通过参数优化建立随机森林模型，然后提取规则集，再将规则集去重，通过误差、频率、长度来筛选规则集。
sklearn adaboost_机器学习sklearn之随机森林
weixin_39559119的博客
11-26 260
大家好我是飘哥，这是飘哥整理的sklearn系列文章的学习笔记第二篇，我的开发环境时pycharm 2017.2，文中需要库如下：python 3.7.1scikit-learn 0.20.3numpy 1.15.4pandas 0.23.4 Matplotlib 3.0.2Scipy 1.1.0集成算法介绍 俗话说，三个臭皮匠顶个诸葛亮。类似的，如果集成一系列分类器的预测结果，也将会得到由...
【代码模版】sklearn实现随机森林模型建立
数据分析成长之路
03-02 1432
# 随机森林模型建立与训练 from sklearn.ensemble import RandomForestRegressor # 其他模型按需要选择即可 rfr = RandomForestRegressor(n_estimators=100, max_depth=3, random_state=0) # 参数自己看帮助文档进行选择 rfr.fit(x_train, y_train) #...
八、Sklearn决策树与随机森林
Norni的博客
03-20 316
参考url: https://jakevdp.github.io/PythonDataScienceHandbook/05.08-random-forests.html 无参数算法随机森林，是一种集成方法，通过集成多个比较简单的评估器形成累计效果，即若干评估器的多数投票(majority vote)的最终效果往往优于单个评估器投票的效果。 1、随机森林的诱因：决策树　　 　　随机森林是建立在决策...
随机森林模型sklearn_SKlearn参数详解—随机森林
weixin_39540315的博客
12-19 482
前言在GBDT篇我们说了GBDT和Adaboost的不同，那么RF和GBDT又有什么异同呢？主要有以下两点：模型迭代方式不同，GBDT是boosting模型，RF是bagging模型。GBDT只能使用CART模型，RF默认是CART模型，也可以选择ID3模型。参数同样也分为两部分，一部分是框架提升部分的参数，另一部分是决策树参数。参数因随机森林中的树是决策树，所以关于决策树的大部分参数与前面决策树...
python决策树可视化_如何用Python从随机森林模型中可视化出一个决策树
weixin_39794213的博客
11-28 589
在搭建机器学习模型时，如果能将模型可视化，能够大大帮助我们理解模型。此前集智曾分享一个叫做 ANN Visualizer 工具，只需一行 Python 代码就能给自己正在搭建的神经网络创建出简洁漂亮的可视化图形：目前 ANN Visualizer 能够可视化深层神经网络和卷积神经网络，但是对于一些更简单的模型比如随机森林，尚无法可视化。今天就教大家如何用 Python 和 Scikit-learn...
基于随机森林的特征提取方法
07-05
提出一种基于随机森林和转导推理的特征提取方法, 步骤如下: 1)利用带标签的训练样本建立随机森林模型; 2) 将无标签的测试数据导入随机森林模型中,生成全体数据(训练样本和测试数据)的相似性矩阵; 3)对该相似性矩阵进行 多维尺度变换得到全体数据的低维数据表示,即低维特征,使得原高维数据在低维空间中具有更好的可分性. UCI 数据 库的实验结果表明: 与主成分分析方法相比, 该方法将无标签测试集的数据分布信息转移到相似性矩阵中,更好地刻画 整个样本空间上的数据分布特性,从而提高分类器的性能,是一种行之有效的特征提取方法. 最后还讨论了特征提取维 数对模型准确率的影响,为实际应用提供参考.
随机森林原理解释及其中各个参数的含义中文解释 (1).zip
08-30
一 、RF原理解释： 首先，从给定的训练集通过多次随机的可重复的采样得到多个 bootstrap 数据集。接着，对每个 bootstrap 数据集构造一棵决策树，构造是通过迭代的将数据点分到左右两个子集中实现的，这个分割过程是一个搜索分割函数的参数空间以寻求最大信息增量意义下最佳参数的过程。然后，在每个叶节点处通过统计训练集中达到此叶节点的分类标签的直方图经验的估计此叶节点上的类分布。这样的迭代训练过程一直执行到用户设定的最大树深度（随机森林提出者Breiman采用的是ntree=500）或者直到不能通过继续分割获取更大的信息增益为止，网上的代码中作者都是对树的最大深度设置了最大值。
机器学习算法——决策树算法详细介绍，并使用sklearn实现案例预测，可视化决策树
Ma Sizhou
03-08 2754
目录一、决策树算法简介二、决策树分类原理1、熵1.1 概念1.2 案例2、决策树的划分依据一：信息增益2.1 概念2.2 案例：3、决策树的划分依据二：信息增益率3.1 概念3.2 案例3.2.1 案例一:3.2.2 案例二：3.3 为什么使用C4.5要好：4、决策树的划分依据三：基尼值和基尼指数4.1 概念4.2 案例 一、决策树算法简介 决策树思想的来源非常朴素，程序设计中的条件分支结构就是if-else结构，最早的决策树就是利用这类结构分割数据的一种分类学习方法。 决策树：是一种树形结构，其中每..
随机森林和KNN分类结果可视化（Sklearn)
qq_43649937的博客
12-03 1082
机器学习
sklearn中的RandomForestClassifier参数详解
studyvcmfc的专栏
05-28 5453
https://blog.csdn.net/qq_16633405/article/details/58596368
python 决策树规则提取_如何从scikit-learn决策树中提取决策规则？
weixin_39806065的博客
12-10 557
我相信这个答案比其他答案更正确：from sklearn.tree import _treedef tree_to_code(tree, feature_names):tree_ = tree.tree_feature_name = [feature_names[i] if i != _tree.TREE_UNDEFINED else "undefined!"for i in tree_.feat...
python 决策树规则提取_使用sklearn python通过决策树提取数据点的规则路径
weixin_39634985的博客
12-10 665
importnumpyasnpfromsklearn.model_selectionimporttrain_test_splitfromsklearn.datasetsimportload_irisfromsklearn.treeimportDecisionTreeClassifieriris=load_iris()X=iris.datay=iris.targetX_train,X_test,y_...
基于随机森林和规则抽取框架的防钓鱼浏览器开发
babyai996的博客
02-10 401
EPDB 方法的新颖之处在于新设计的浏览器架构，它通过修改现有的浏览器架构来构建，引入一个名为“智能引擎”的新模块，负责轻松实时检测钓鱼网站。在本文中，我们提出了一种新颖的技术，通过提出一种新颖的浏览器体系结构，可以在客户端毫不费力地识别网络钓鱼网站。为了确保每个人都可以使用这些工具，我们在名为“嵌入式网络钓鱼检测浏览器”(EPDB) 的浏览器架构中即兴创作并引入了检测方法，这是一种在提高安全性的同时保留现有用户体验的新方法. 新设计的浏览器架构引入了一个特殊的部分来实时执行网络钓鱼检测操作。
写一段提取数据并将随机森林模型可视化的代码
06-08
好的，以下是一段提取数据并将随机森林模型可视化的 Python 代码： ```python import pandas as pd from sklearn.ensemble import RandomForestClassifier from sklearn.datasets import load_iris from sklearn....
评论 2
添加红包

请填写红包祝福语或标题

个

红包个数最小为10个

元

红包金额最低5元

当前余额3.43元 前往充值 >
需支付：10.00元
成就一亿技术人!
领取后你会自动成为博主和红包主的粉丝 规则
hope_wisdom
发出的红包
实付元
使用余额支付
点击重新获取
扫码支付
钱包余额 0

抵扣说明：

1.余额是钱包充值的虚拟货币，按照1:1的比例进行支付金额的抵扣。
2.余额无法直接购买下载，可以购买VIP、付费专栏及课程。

余额充值