ml2:决策树算法

最新推荐文章于 2022-06-18 16:43:18 发布
最新推荐文章于 2022-06-18 16:43:18 发布
阅读量354 收藏
点赞数
CC 4.0 BY-SA版权
分类专栏： machine learnings算法
版权声明：本文为博主原创文章，遵循 CC 4.0 BY-SA 版权协议，转载请附上原文出处链接和本声明。
本文链接：https://blog.youkuaiyun.com/monk1992/article/details/102813148

决策树算法：
决策树常用于处理分类问题，也常用于数据挖掘，其主要优势是概念简单清晰，数据形式非常容易理解。
优点：计算复杂度不高，输出结果易于理解，对中间值的缺失不敏感，可以处理不相关的特征数据。
缺点：可能会产生过度匹配的问题。
适用数据类型：数值型和标称型。

划分数据：此处采用ID3算法，划分数据的原则是将无序的数据变得更加有序。

信息量和熵的概念
信息增益
信息增益：划分数据之前和之后信息发生的变化称为信息增益。
基尼不纯度：度量集合无序程度的方法，与熵类似。其概念是：从一个数据集中随机选取子项，度量其被错误的划分到其他组里的概率。 一个随机事件变成它的对立事件的概率。（以下关于基尼不纯度案例参考https://blog.youkuaiyun.com/JJBOOM425/article/details/79997440青山孤客）
基尼不纯度
案例：
一个随机事件X ，P(X=0)= 0.5 ,P(X=1)=0.5
那么基尼不纯度就为 P(X=0)(1 - P(X=0)) + P(X=1)(1 - P(X=1)) = 0.5
一个随机事件Y ，P(Y=0)= 0.1 ,P(Y=1)=0.9
那么基尼不纯度就为P(Y=0)(1 - P(Y=0)) + P(Y=1)(1 -P(Y=1)) = 0.18
很明显 X比Y更混乱，因为两个都为0.5 很难判断哪个发生。而Y就确定得多，Y=1发生的概率很大。而基尼不纯度也就越小。
结论：
（1）基尼不纯度可以作为 衡量系统混乱程度的 标准；
（2）基尼不纯度越小，纯度越高，集合的有序程度越高，分类的效果越好；
（3）基尼不纯度为 0 时，表示集合类别一致；
（4）在决策树中，比较基尼不纯度的大小可以选择更好的决策条件（子节点）。

#示例代码：
my_data = [['fan', 'C', 'yes', 32, 'None'],
           ['fang', 'U', 'yes', 23, 'Premium'],
           ['ming', 'F', 'no', 28, 'Basic']]
 
# 计算每一行数据的可能数量
def uniqueCounts(rows):
    results = {}
    for row in rows:
        # 对最后一列的值计算
        #r = row[len(row) - 1]
        # 对倒数第三的值计算，也就是yes 和no 的一列
        r = row[len(row) - 3]
        if r not in results: results[r] = 0
        results[r] += 1
    return results
 
# 基尼不纯度样例
def giniImpurityExample(rows):
    total = len(rows)
    print(total)
    counts = uniqueCounts(rows)
    print(counts)
    imp = 0
    for k1 in counts:#两个for循环计算，其实有更方便高效的计算方式
        p1 = float(counts[k1]) / total
        print(counts[k1])
        for k2 in counts:
            if k1 == k2: continue
            p2 = float(counts[k2]) / total
            imp += p1 * p2
   '''
   for k in counts:
     imp += float(counts[k]) / total * (1 - float(counts[k]) / total)
   '''
    return imp
 
 
gini = giniImpurityExample(my_data)
print('gini Impurity is %s' % gini)

采用信息增益的方式
划分数据集：

def splitDataSet(dataSet, axis, value):
    retDataSet = []
    for featVec in dataSet:
        if (featVec[axis] == value):
            reducedFeatVec = featVec[:axis]
            reducedFeatVec.extend(featVec[axis + 1:])
            retDataSet.append(reducedFeatVec)
    return retDataSet

选择最好的数据集划分方式：

def chooseBestFeatureToSplit(dataSet):
    numFeatures = len(dataSet[0]) - 1
    baseEntropy = calcShannonEnt(dataSet)
    bestInfoGain = 0.0
    bestFeature = -1
    for i in range(numFeatures):
        feature = [example[i] for example in dataSet]
        feature_unique = set(feature)
        newEntropy = 0.0
        for value in feature_unique:
            splitData = splitDataSet(dataSet, i, value)
            prob = len(splitData) / float(len(dataSet))
            newEntropy += prob * calcShannonEnt(splitData)
        newInfoGain = baseEntropy - newEntropy
        if (newInfoGain > bestInfoGain):
            bestInfoGain = newInfoGain
            bestFeature = i
    return bestFeature

递归构建决策树：

**def majorityCnt(classList):
    classCount = {}
    for vote in classList:
        classCount[vote] = classCount.get(vote, 0) + 1
    classCountsorted = sorted(classCount.items(), key=operator.itemgetter(1), reverse=True)
    return classCountsorted[0][0]


def createTree(dataSet, labels):
    classList = [example[-1] for example in dataSet]
    if (classList.count(classList[0]) == len(classList)):
        return classList[0]
    if (len(dataSet[0]) == 1):
        return majorityCnt(classList)
    bestFeature = chooseBestFeatureToSplit(dataSet)
    bestLabel = labels[bestFeature]
    del (labels[bestFeature])
    new_tree = {bestLabel: {}}
    featValues = [example[bestFeature] for example in dataSet]
    uniquevalue = set(featValues)
    for value in uniquevalue:
        label_tree = labels[:]
        new_tree[bestLabel][value] = createTree(splitDataSet(dataSet, bestFeature, value), label_tree)
    return new_tree**

辅助函数：

def calcShannonEnt(dataSet):
    numEntries = len(dataSet)
    labelCounts = {}
    for featVec in dataSet:
        currentLabel = featVec[-1]
        if currentLabel not in labelCounts:
            labelCounts[currentLabel] = 0
        labelCounts[currentLabel] += 1
    shannonEnt = 0.0
    for key in labelCounts:
        prob = float(labelCounts[key]) / numEntries
        shannonEnt -= prob * log(prob, 2)
    return shannonEnt
def splitDataSet(dataSet, axis, value):
    retDataSet = []
    for featVec in dataSet:
        if (featVec[axis] == value):
            reducedFeatVec = featVec[:axis]
            reducedFeatVec.extend(featVec[axis + 1:])
            retDataSet.append(reducedFeatVec)
    return retDataSet

使用决策树执行分类：

def classify(inputTree, featLabels, testVec):
    firstStr = list(inputTree.keys())[0]
    secondStr = inputTree[firstStr]
    featureIndex = featLabels.index(firstStr)
    for key in secondStr.keys():
        if (testVec[featureIndex] == key):
            if (type(secondStr[key]).__name__ == 'dict'):
                labels = classify(secondStr[key], featLabels, testVec)
            else:
                labels = secondStr[key]
    return labels

存储和提取决策树：

def storeTree(inputTree, filename):
    import pickle
    fw = open(filename, "wb")
    pickle.dump(inputTree, fw)
    fw.close()


def grabTree(filename):
    import pickle
    fr = open(filename, "rb")
    return pickle.load(fr)

用matplotlib绘制树形图：

# 绘制图形测试---样例
decisionNode = dict(boxstyle="sawtooth", fc="0.8")
leafNode = dict(boxstyle="round4", fc="0.8")
arrow_args = dict(arrowstyle="<-")


def plotNode(nodeTxt, centerPt, parentPt, nodeType):
    createPlot.ax1.annotate(nodeTxt, xy=parentPt, xycoords='axes fraction', xytext=centerPt, textcoords='axes fraction',
                            va='center', ha='center', bbox=nodeType, arrowprops=arrow_args)


def plotMidText(cntrPt, parentPt, txtString):
    xMid = (parentPt[0] - cntrPt[0]) / 2.0 + cntrPt[0]
    yMid = (parentPt[1] - cntrPt[1]) / 2.0 + cntrPt[1]
    createPlot.ax1.text(xMid, yMid, txtString)


def plotTree(myTree, parentPt, nodeTxt):
    numLeafs = getNumLeafs(myTree)
    depth = getTreeDepth(myTree)
    firstStr = list(myTree.keys())[0]
    cntrPt = (plotTree.xOff + (1.0 + float(numLeafs)) / 2.0 / plotTree.totalW, plotTree.yOff)
    plotMidText(cntrPt, parentPt, nodeTxt)
    plotNode(firstStr, cntrPt, parentPt, decisionNode)
    secondDict = myTree[firstStr]
    plotTree.yOff = plotTree.yOff - 1.0 / plotTree.totalD
    for key in secondDict.keys():
        if (type(secondDict[key]).__name__ == 'dict'):
            plotTree(secondDict[key], cntrPt, str(key))
        else:
            plotTree.xOff = plotTree.xOff + 1.0 / plotTree.totalW
            plotNode(secondDict[key], (plotTree.xOff, plotTree.yOff), cntrPt, leafNode)
            plotMidText((plotTree.xOff, plotTree.yOff), cntrPt, str(key))
    plotTree.yOff = plotTree.yOff + 1.0 / plotTree.totalD


def createPlot(inTree):
    fig = plt.figure(1, facecolor="white")
    fig.clf()
    axprops = dict(xticks=[], yticks=[])
    createPlot.ax1 = plt.subplot(111, frameon=False, **axprops)
    plotTree.totalW = float(getNumLeafs(inTree))
    plotTree.totalD = float(getTreeDepth(inTree))
    plotTree.xOff = -0.5 / plotTree.totalW
    plotTree.yOff = 1.0
    plotTree(inTree, (0.5, 1.0), "")
    # plotNode("a decision node", (0.5, 0.1), (0.1, 0.5), decisionNode)
    # plotNode("a leaf node", (0.8, 0.1), (0.3, 0.8), leafNode)
    plt.show()


# 绘制图形测试---样例
def getNumLeafs(myTree):
    numLeafs = 0
    firstStrs = list(myTree.keys())
    firstStr = firstStrs[0]
    secondStr = myTree[firstStr]
    for key in secondStr.keys():
        if (type(secondStr[key]).__name__ == 'dict'):
            numLeafs += getNumLeafs(secondStr[key])
        else:
            numLeafs += 1
    return numLeafs


def getTreeDepth(myTree):
    maxDepth = 0
    firstStr = list(myTree.keys())[0]
    secondStr = myTree[firstStr]
    for key in secondStr.keys():
        thisDepth = 0
        if (type(secondStr[key]).__name__ == 'dict'):
            thisDepth = 1 + getTreeDepth(secondStr[key])
        else:
            thisDepth = 1
        if maxDepth < thisDepth: maxDepth = thisDepth
    return maxDepth


def retrieveTree(i):
    listOfTrees = [{'no surfacing': {0: 'no', 1: {'flippers': {0: 'no', 1: 'yes'}}}},
                   {'no surfacing': {0: 'no', 1: {'flippers': {0: {'head': {0: 'no', 1: 'yes'}}, 1: 'no'}}}}
                   ]
    return listOfTrees[i]

本案例完整代码：

from math import log
import operator
import matplotlib.pyplot as plt


def calcShannonEnt(dataSet):
    numEntries = len(dataSet)
    labelCounts = {}
    for featVec in dataSet:
        currentLabel = featVec[-1]
        if currentLabel not in labelCounts:
            labelCounts[currentLabel] = 0
        labelCounts[currentLabel] += 1
    shannonEnt = 0.0
    for key in labelCounts:
        prob = float(labelCounts[key]) / numEntries
        shannonEnt -= prob * log(prob, 2)
    return shannonEnt


def chooseBestFeatureToSplit(dataSet):
    numFeatures = len(dataSet[0]) - 1
    baseEntropy = calcShannonEnt(dataSet)
    bestInfoGain = 0.0
    bestFeature = -1
    for i in range(numFeatures):
        feature = [example[i] for example in dataSet]
        feature_unique = set(feature)
        newEntropy = 0.0
        for value in feature_unique:
            splitData = splitDataSet(dataSet, i, value)
            prob = len(splitData) / float(len(dataSet))
            newEntropy += prob * calcShannonEnt(splitData)
        newInfoGain = baseEntropy - newEntropy
        if (newInfoGain > bestInfoGain):
            bestInfoGain = newInfoGain
            bestFeature = i
    return bestFeature


def majorityCnt(classList):
    classCount = {}
    for vote in classList:
        classCount[vote] = classCount.get(vote, 0) + 1
    classCountsorted = sorted(classCount.items(), key=operator.itemgetter(1), reverse=True)
    return classCountsorted[0][0]


def createTree(dataSet, labels):
    classList = [example[-1] for example in dataSet]
    if (classList.count(classList[0]) == len(classList)):
        return classList[0]
    if (len(dataSet[0]) == 1):
        return majorityCnt(classList)
    bestFeature = chooseBestFeatureToSplit(dataSet)
    bestLabel = labels[bestFeature]
    del (labels[bestFeature])
    new_tree = {bestLabel: {}}
    featValues = [example[bestFeature] for example in dataSet]
    uniquevalue = set(featValues)
    for value in uniquevalue:
        label_tree = labels[:]
        new_tree[bestLabel][value] = createTree(splitDataSet(dataSet, bestFeature, value), label_tree)
    return new_tree


def createDataSet():
    dataSet = [[1, 1, 'yes'], [1, 1, 'yes'], [1, 0, 'no'], [0, 1, 'no'], [0, 1, 'no']]
    labels = ['no surfacing', 'flippers']
    return dataSet, labels


def splitDataSet(dataSet, axis, value):
    retDataSet = []
    for featVec in dataSet:
        if (featVec[axis] == value):
            reducedFeatVec = featVec[:axis]
            reducedFeatVec.extend(featVec[axis + 1:])
            retDataSet.append(reducedFeatVec)
    return retDataSet


def classify(inputTree, featLabels, testVec):
    firstStr = list(inputTree.keys())[0]
    secondStr = inputTree[firstStr]
    featureIndex = featLabels.index(firstStr)
    for key in secondStr.keys():
        if (testVec[featureIndex] == key):
            if (type(secondStr[key]).__name__ == 'dict'):
                labels = classify(secondStr[key], featLabels, testVec)
            else:
                labels = secondStr[key]
    return labels


def storeTree(inputTree, filename):
    import pickle
    fw = open(filename, "wb")
    pickle.dump(inputTree, fw)
    fw.close()


def grabTree(filename):
    import pickle
    fr = open(filename, "rb")
    return pickle.load(fr)


myDat, labels = createDataSet()
print(myDat)
print(labels)
# print(splitDataSet(myDat, 0, 1))
# print(calcShannonEnt(myDat))
# print(chooseBestFeatureToSplit(myDat))
# print(createTree(myDat, labels))
feat_labels = labels.copy()
feat_labels2 = labels.copy()
classTree = createTree(myDat, feat_labels)

storeTree(classTree, "classifierfileStore.txt")
print("grabTree: ", grabTree("classifierfileStore.txt"))

print(classTree)
print("classify test result:", classify(classTree, feat_labels2, [1, 1]))

# 绘制图形测试---样例
decisionNode = dict(boxstyle="sawtooth", fc="0.8")
leafNode = dict(boxstyle="round4", fc="0.8")
arrow_args = dict(arrowstyle="<-")


def plotNode(nodeTxt, centerPt, parentPt, nodeType):
    createPlot.ax1.annotate(nodeTxt, xy=parentPt, xycoords='axes fraction', xytext=centerPt, textcoords='axes fraction',
                            va='center', ha='center', bbox=nodeType, arrowprops=arrow_args)


def plotMidText(cntrPt, parentPt, txtString):
    xMid = (parentPt[0] - cntrPt[0]) / 2.0 + cntrPt[0]
    yMid = (parentPt[1] - cntrPt[1]) / 2.0 + cntrPt[1]
    createPlot.ax1.text(xMid, yMid, txtString)


def plotTree(myTree, parentPt, nodeTxt):
    numLeafs = getNumLeafs(myTree)
    depth = getTreeDepth(myTree)
    firstStr = list(myTree.keys())[0]
    cntrPt = (plotTree.xOff + (1.0 + float(numLeafs)) / 2.0 / plotTree.totalW, plotTree.yOff)
    plotMidText(cntrPt, parentPt, nodeTxt)
    plotNode(firstStr, cntrPt, parentPt, decisionNode)
    secondDict = myTree[firstStr]
    plotTree.yOff = plotTree.yOff - 1.0 / plotTree.totalD
    for key in secondDict.keys():
        if (type(secondDict[key]).__name__ == 'dict'):
            plotTree(secondDict[key], cntrPt, str(key))
        else:
            plotTree.xOff = plotTree.xOff + 1.0 / plotTree.totalW
            plotNode(secondDict[key], (plotTree.xOff, plotTree.yOff), cntrPt, leafNode)
            plotMidText((plotTree.xOff, plotTree.yOff), cntrPt, str(key))
    plotTree.yOff = plotTree.yOff + 1.0 / plotTree.totalD


def createPlot(inTree):
    fig = plt.figure(1, facecolor="white")
    fig.clf()
    axprops = dict(xticks=[], yticks=[])
    createPlot.ax1 = plt.subplot(111, frameon=False, **axprops)
    plotTree.totalW = float(getNumLeafs(inTree))
    plotTree.totalD = float(getTreeDepth(inTree))
    plotTree.xOff = -0.5 / plotTree.totalW
    plotTree.yOff = 1.0
    plotTree(inTree, (0.5, 1.0), "")
    # plotNode("a decision node", (0.5, 0.1), (0.1, 0.5), decisionNode)
    # plotNode("a leaf node", (0.8, 0.1), (0.3, 0.8), leafNode)
    plt.show()


# 绘制图形测试---样例
def getNumLeafs(myTree):
    numLeafs = 0
    firstStrs = list(myTree.keys())
    firstStr = firstStrs[0]
    secondStr = myTree[firstStr]
    for key in secondStr.keys():
        if (type(secondStr[key]).__name__ == 'dict'):
            numLeafs += getNumLeafs(secondStr[key])
        else:
            numLeafs += 1
    return numLeafs


def getTreeDepth(myTree):
    maxDepth = 0
    firstStr = list(myTree.keys())[0]
    secondStr = myTree[firstStr]
    for key in secondStr.keys():
        thisDepth = 0
        if (type(secondStr[key]).__name__ == 'dict'):
            thisDepth = 1 + getTreeDepth(secondStr[key])
        else:
            thisDepth = 1
        if maxDepth < thisDepth: maxDepth = thisDepth
    return maxDepth


def retrieveTree(i):
    listOfTrees = [{'no surfacing': {0: 'no', 1: {'flippers': {0: 'no', 1: 'yes'}}}},
                   {'no surfacing': {0: 'no', 1: {'flippers': {0: {'head': {0: 'no', 1: 'yes'}}, 1: 'no'}}}}
                   ]
    return listOfTrees[i]


myTree = retrieveTree(0)
print(getNumLeafs(myTree))
print(getTreeDepth(myTree))
createPlot(myTree)

fr = open(r"C:\Users\tycho-wjr\Desktop\数据结构和算法相关\机器学习\机器学习实战中文\MLiA_SourceCode\machinelearninginaction\Ch03\lenses.txt")
lenses = [inst.strip().split("\t") for inst in fr.readlines()]
lensesLables = ['age', 'prescript', 'astigmatic', 'tearRate']
print(lenses)
lensesTree = createTree(lenses, lensesLables.copy())
print(lensesTree)
createPlot(lensesTree)
ML2
Cloud Era
12-31 1944
Modular Layer 2 (ML2) plugin提供新的L2框架，允许OpenStack用户同时使用DC中现有的多种L2网络技术。支持OVS，Linux bridge，Hyper-V L2 agents, 同时支持硬件设备和SDN Controller。   ML2支持所有非厂商特有的API extension，能与neutron标准DHCP agent协同工作。ML2使用servic
《机器学习实战：基于Scikit-Learn、Keras和TensorFlow第2版》-学习笔记（6）：决策树
Morganfs的博客
05-05 1822
· Hands-On Machine Learning with Scikit-Learn, Keras, and TensorFlow, 2nd Edition, by Aurélien Géron (O’Reilly). Copyright 2019 Aurélien Géron, 978-1-492-03264-9. · 环境：Anaconda（Python 3.8） + Pycharm · 学习时间：2022.05.04~2022.05.05 第六章 决策树
【ML2】KNN算法讲解及实战
kk的博客
01-28 393
一、前言 还是老话，本篇以实战为主，详细的算法步骤和公式推导很重要，必须同时找多篇对比才能融会贯通，以下是我看过的几篇博客，很牛逼，网址如下： 机器学习实战：https://www.cnblogs.com/zy230530/p/6780836.html 二、算法原理总结 1. 综述 1.1 Cover和Hart在1968年提出了最初的邻近算法 1.2 分类...
ML2自学笔记
xiaomi5410的博客
06-18 324
机器学习梯度下降
Neutron的ML2 扩展管理器
redwingz的博客
07-07 302
ML2的扩展管理器在Juno中介绍（更多详细信息可在批准的 spec中找到。此管理器功能允许扩展ML2资源，而又不必向ML2引入交叉关注点。这个机制已经应用于许多用例，当前使用此框架的扩展可在链接ml2/extensions 中找到，如下； data_plane_status.py dns_integration.py port_security.py qos.py uplink_status_...
Project_ML2:这是INSY695的最终项目-企业数据科学和生产中的机器学习II-Arnaud，Jules，Ram，Dorothy和Rameez
04-01
同时，也可能涉及到不同的机器学习算法，比如线性回归、决策树、随机森林、支持向量机或神经网络，以及可能的模型集成技术，如bagging、boosting或stacking。 为了深入理解这个项目，你需要解压文件并逐个检查这些...
ML2Team3：BUAD 5082机器学习2的团队3演示
02-12
2. **模型选择**：如何根据问题类型选择合适的算法，如线性回归、逻辑回归、决策树、随机森林、支持向量机或神经网络。 3. **数据预处理**：清理缺失值、异常值，进行归一化或标准化，以及特征缩放等。 4. **特征...
第8章：ML2程序代码在模式识别与机器学习中的应用
1.监督学习：监督学习算法是机器学习中重要的一类，其中包括线性回归、逻辑回归、决策树、支持向量机、神经网络等。这些算法在预测标签或分类任务中发挥关键作用。 2.非监督学习：与监督学习相对应，非监督学习不...
MADE_ML2
02-28
在这个项目中，学习者可能通过Jupyter Notebook来探索不同的机器学习算法，如线性回归、逻辑回归、支持向量机、决策树、随机森林、神经网络等。同时，他们还会学习如何处理数据，包括数据清洗、特征工程、数据标准化...
OpenStack网络指南（8）ML2 plug-in
fyggzb的博客
12-27 2205
架构模块层2（ML2）中Neutron plug-in是一个框架，允许OpenStack网络同时使用在复杂的现实世界数据中心中发现的各种第2层网络技术。 ML2框架区分可以配置的两种驱动程序： 类型驱动程序 定义OpenStack网络如何在技术上实现。示例：VXLAN 每种可用的网络类型由ML2类型驱动程序管理。类型驱动程序维护任何所需的特定类型的网络状态。它们验证供应商网络的类型特定信息，并
访问外网 ML2 的配置 - 每天5分钟玩转 OpenStack（103）
jj1130050965的博客
06-22 495
虽然外部网络是已经存在的网络，但我们还是需要在 Neutron 中定义外部网络的对象，这样 router 才知道如何将租户网络和外部网络连接起来。 上一节我们已经为创建外部网络配置了ML2，本节将通过 UI 创建 ext_net。 进入 Admin -> Networks 菜单，点击 “Create Network” 按钮。 显示创建页面。 Provider Network Type 选择 “Flat” Physical Network 填写 “external”，与 ml2..
neutron的ml2 配置
jason的笔记
10-10 1559
neutron的配置在/etc/neutron/neutron.conf中 从下面的配置中可以看到neutron采用的core_plugin 是ml2。 从type_drivers 知道ml2 已经默认帮我们加载了falt，vxlan.而type_drivers 总共有五种local,flat,vlan,gre,vxlan。我们这里默认加载了两种. 从tenant_network_typ
ML经典算法：决策树（1）
weixin_43786241的博客
04-27 556
目录1. 简介2. 划分选择2.1 信息增益（决策树ID3算法）2.2 增益率（C4.5 决策树算法 ）2.3 基尼指数（CART 决策树算法）         决策树 (decision tree ，或称判定树)是一类常见的机器学习方法，其核心思想是通过构建一个树状模型来对新样本进行预测。树的叶结点是预测结果，而所有非叶结点皆是一个决策过程。 1. 简介...
OpenStack之ML2的由来
程序的战歌
08-31 1015
OpenStack之ML2的由来 常见的core plugin有： linux bridge plugin 和 open vswitch plugin 背景 随着支持的 network provider 数量的增加，开发人员发现了两个突出的问题： 1只能在 OpenStack 中使用一种 core plugin，多种 network provider 无法共存。 2不同 plugin 之间存在大量重复代码，开发新的 plugin 工作量大。 ML2 Core Plugin： Mo
neutron ml2
boOO00
06-01 6633
在介绍ml2之前，先介绍下以往的core-plugin，它主要的工作是与数据库打交道，真正起作用的是agent，然而对于每种core-plugin来说他们绝大部代码是重复的，在实际的网络部署中，想用linuxbridge就不能用openvswitch，想用vlan就不能用gre。Ml2插件就可以很好解决这样的问题，在复杂的二层网络中可以灵活地部署网络。 Ml2插件是一种允许OpenStack网络
决策树初步学习
weixin_45342257的博客
11-13 344
【实验要求及步骤】 使用决策树预测隐形眼镜类型，可以帮助人们判断需要佩戴的镜片类型。 （1）收集数据：提供文本文件【lenses.txt】 （2）准备数据：解析tab键分隔的数据行。 （3）分析数据：快速检查数据，确保正确的解析数据内容，使用createPlot()函数绘制最终的树形图。 （4）训练算法：使用代码参考中的createTree(）函数。 （5）测试算法：编写测试函数验证决策树可以正确...
ML2 Plugin框架说明
实践求真知
04-09 1999
在H版本中，ML2 Plugin被添加意图取代所有的Core Plugin，它采用了更加灵活的结构进行实现，下图即为ML2 Plugin的实现框架。作为一个Core Plugin，ML2自然会实现network/subnet/port三种核心资源，同时它也实现了包括Port Binding等在内的部分扩展资源。ML2解耦了网络拓扑类型与底层的虚拟网络实现机制，并分别通过Driver的形式进行扩展，...
【python代码实现】决策树分类算法
热门推荐
weixin_47974364的博客
04-11 2万+
目录模拟数据决策树分类算法构建数据集绘制决策树代码 模拟数据 编号 年龄 收入范围 工作性质 信用评级 购买决策 01 <30 高 不稳定 较差 否 02 <30 高 不稳定 好 否 03 30-40 高 不稳定 较差 是 04 >40 中等 不稳定 较差 是 05 >40 低 稳定 较差 是 06 >40 低 稳定 好 否 07 30-40 低 稳定 好 是 08 <30 中等 不稳定 较差 否 09 <30 低 稳
评论
添加红包

请填写红包祝福语或标题

个

红包个数最小为10个

元

红包金额最低5元

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

抵扣说明：

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

余额充值