精华内容
下载资源
问答
  • 你必须知道495个C语言问题(PDF)

    热门讨论 2009-09-15 10:25:47
    3, 有的为4, 哪个是正确的? . . . . . . . . . . . . . . . . . . . . . 14 3.4 这个巧妙的表达式: a ˆ= b ˆ= a ˆ= b 它需要临时变量就可 以交换a 和b 的值。. . . . . . . . . . . . . . . . . . . . . . ....
  • 下面对程序的横线处填写不同语句的分析正确的是:(选择一项) A) 填充 break 使程序能够有退出循环的可能性。 B) 填充 continue 将使程序成为死循环,永远无法退出循环。 C) 填充 continue 使程序能够有退出循环的...
  • 最新在线作业试卷 最新在线作业试卷 南开15春学期C语言程序... printf( n ,x+y++y+Z=%d 输入数据的形式是25 , 13, 10<回车>则程序的输出结果是) x+y+z=48 x+y+z=35 x+z=35 不确定值 正确答案A 以下不正确的语句为) if(x
  • 不同编译器给出不同的i值,有的为3,有的为4,哪个是正确的? 34  *3.4 有这样一个巧妙的表达式:a^= b^= a^= b; 它需要临时变量就可以交换a和b的值。 34 3.5 可否用显式括号来强制执行我所需要的计算顺序并...
  • 决策树经过训练之后,看起来像以树状形式排列一系列if-then语句。一旦我们有了决策树,只要沿着树路径一直向下,正确回答每一个问题,最终就会得到答案。沿着最终叶节点向上回溯,就会得到一个有关最终分类...

    决策树是一种简单的机器学习方法。决策树经过训练之后,看起来像是以树状形式排列的一系列if-then语句。一旦我们有了决策树,只要沿着树的路径一直向下,正确回答每一个问题,最终就会得到答案。沿着最终的叶节点向上回溯,就会得到一个有关最终分类结果的推理过程。

    以下为决策树过程:

    初始化:

    #! /usr/bin/python
    # -*- coding: utf8 -*-
    # @Time    : 2018/9/6 17:36
    # @Author  : yukang
    
    class decisionnode:
        def __init__(self,col=-1,value=None,results=None,tb=None,fb=None):
            self.col=col
            #待检验的判断条件
            self.value=value
            #对应于为了使结果为true,当前列必须匹配的值
            self.results=results
            #针对当前分支的结果
            self.tb=tb
            #结果为true时,树上相对于当前节点的子树上的节点
            self.fb=fb
            #结果为false时,树上相对于当前节点的子树上的节点

    下面利用分类回归树的算法。为了构造决策树,算法首先创建一个根节点,然后评估表中的所有观测变量,从中选出最合适的变量对数据进行拆分。为了选择合适的变量,我们需要一种方法来衡量数据集合中各种因素的混合情况。对于混杂程度的测度,有几种度量方式可供选择:

    基尼不纯度:将来自集合中的某种结果随机应用于集合中某一数据项的预期误差率。大概意思是 一个随机事件变成它的对立事件的概率。

    • (1)基尼不纯度越小,纯度越高,集合的有序程度越高,分类的效果越好;

    • (2)基尼不纯度为 0 时,表示集合类别一致;

    • (3)基尼不纯度最高(纯度最低)时,f1=f2=…=fm=1m,

      IG(f)=1−(1m)2×m=1−1m

    例,如果集合中的每个数据项都属于同一分类,此时误差率为 0。如果有四种可能的结果均匀地分布在集合中,此时的误差率为1−0.25=0.75;

     

    维基上的公式是这样:

    下面是《集体智慧编程》中的python实现:

    def uniquecounts(rows):
        results = {}
        for row in rows:
            #The result is the last column
            r = row[len(row) - 1]
            if r not in results:
                results[r] = 0
            results[r] += 1
            return results
    
    def giniimpurity(rows):
        total = len(rows)
        counts = uniquecounts(rows)
        imp = 0
        for k1 in counts:
            p1 = float(counts[k1]) / total
            # imp+=p1*p1
            for k2 in counts:
                if k1 == k2:
                    continue
                p2 = float(counts[k2]) / total
                imp += p1 * p2
        return imp  # 1-imp

    每一结果出现次数除以集合总行数来计算相应概率,然后把所有这些概率值的乘积累加起来。这样得到某一行数据被随机分配到错误结果的总概率。(显然直接按照公式的算法(注释中)效率更高。)这一概率越高,说明对数据的拆分越不理想。

     

    熵:代表集合的无序程度。信息论熵的概念在吴军的《数学之美》中有很好的解释:


    我们来看一个例子,马上要举行世界杯赛了。大家都很关心谁会是冠军。假如我错过了看世界杯,赛后我问一个知道比赛结果的观 众“哪支球队是冠军”? 他不愿意直接告诉我, 而要让我猜,并且我每猜一次,他要收一元钱才肯告诉我是否猜对了,那么我需要付给他多少钱才能知道谁是冠军呢? 我可以把球队编上号,从 1 到 32, 然后提问: “冠军的球队在 1-16 号中吗?” 假如他告诉我猜对了, 我会接着问: “冠军在 1-8 号中吗?” 假如他告诉我猜错了, 我自然知道冠军队在 9-16 中。 这样只需要五次, 我就能知道哪支球队是冠军。所以,谁是世界杯冠军这条消息的信息量只值五块钱。 当然,香农不是用钱,而是用 “比特”(bit)这个概念来度量信息量。 一个比特是一位二进制数,计算机中的一个字节是八个比特。在上面的例子中,这条消息的信息量是五比特。(如果有朝一日有六十四个队进入决赛阶段的比赛,那 么“谁世界杯冠军”的信息量就是六比特,因为我们要多猜一次。) 读者可能已经发现, 信息量的比特数和所有可能情况的对数函数 log 有关。 (log32=5, log64=6。) 有些读者此时可能会发现我们实际上可能不需要猜五次就能猜出谁是冠军,因为象巴西、德国、意 大利这样的球队得冠军的可能性比日本、美国、韩国等队大的多。因此,我们第一次猜测时不需要把 32 个球队等分成两个组,而可以把少数几个最可能的球队分成一组,把其它队分成另一组。然后我们猜冠军球队是否在那几只热门队中。我们重复这样的过程,根据夺 冠概率对剩下的候选球队分组,直到找到冠军队。这样,我们也许三次或四次就猜出结果。因此,当每个球队夺冠的可能性(概率)不等时,“谁世界杯冠军”的信 息量的信息量比五比特少。香农指出,它的准确信息量应该是 
    = -(p1*log p1 + p2 * log p2 + ... +p32 *log p32), 其 中,p1,p2 , ...,p32 分别是这 32 个球队夺冠的概率。香农把它称为“信息熵” (Entropy),一般用符号 H 表示,单位是比特。有兴趣的读者可以推算一下当 32 个球队夺冠概率相同时,对应的信息熵等于五比特。有数学基础的读者还可以证明上面公式的值不可能大于五。对于任意一个随机变量 X(比如得冠军的球队),它的熵定义如下:


    《集》中的实现:

    def entropy(rows):
        from math import log
        log2=lambda x:log(x)/log(2) 
        results=uniquecounts(rows)
        #Now calculate the entropy
        ent=0.0
        for r in results.keys():
          p=float(results[r])/len(rows)
          ent=ent-p*log2(p)
        return ent

    熵和基尼不纯度之间的主要区别在于,熵达到峰值的过程要相对慢一些。因此,熵对于混乱集合的判罚要更重一些。

    我们的算法首先求出整个群组的熵,然后尝试利用每个属性的可能取值对群组进行拆分,并求出两个新群组的熵。算法会计算相应的信息增益。信息增益是指当前熵与两个新群组经加权平均后的熵之间的差值。算法会对每个属性计算相应的信息增益,然后从中选出信息增益最大的属性。通过计算每个新生节点的最佳拆分属性,对分支的拆分过程和树的构造过程会不断持续下去。当拆分某个节点所得的信息增益不大于0的时候,对分支的拆分才会停止:

    # 拆分数据集合,rows为父节点所有的数据,column代表根据第column的判断条件拆分,等于value则为真,否则为假
    def divideset(rows, column, value):
        set1, set2 = [], []
        # 如果是数值型数据,则以大于小于拆分
        if isinstance(value, int) or isinstance(value, float):
            for row in rows:
                if row[column] >= value:
                    set1.append(row)
                else:
                    set2.append(row)
        # 如果是标称数据,则以等于或不等于进行拆分
        else:
            for row in rows:
                if row[column] == value:
                    set1.append(row)
                else:
                    set2.append(row)
        return (set1, set2)
    
    def buildtree(rows, scoref=entropy):
        if len(rows) == 0:
            return decisionnode()
        current_score = scoref(rows)
        #Set up some variables to track the best criteria
        best_gain = 0.0
        best_criteria = None
        best_sets = None
        column_count = len(rows[0]) - 1
        for col in range(0, column_count):
            #Generate the list of different values in
            # this column
            column_values = {}
            for row in rows:
                column_values[row[col]] = 1
                # Now try dividing the rows up for each value
                #in this column
                for value in column_values.keys():
                    (set1, set2) = divideset(rows, col, value)
                    #Information gain
                    p = float(len(set1)) / len(rows)
                    gain = current_score - p * scoref(set1) - (1 - p) * scoref(set2)
                    if gain > best_gain and len(set1) > 0 and len(set2) > 0:
                        best_gain = gain
                        best_criteria = (col, value)
                        best_sets = (set1, set2)
                        #Create the sub branches
                        if best_gain > 0:
                            trueBranch = buildtree(best_sets[0])
                            falseBranch = buildtree(best_sets[1])
                            return decisionnode(col=best_criteria[0], value=best_criteria[1],
                                                tb=trueBranch, fb=falseBranch)
                        else:
                            return decisionnode(results=uniquecounts(rows))

    函数首先接受一个由数据行构成的列表作为参数。它遍历了数据集中的每一列,针对各列查找每一种可能的取值,并将数据集拆分成两个新的子集。通过将每个子集的熵乘以子集中所含数据项在元数据集中所占的比重,函数求出了每一对新生子集的甲醛平均熵,并记录下熵最低的那一对子集。如果由熵值最低的一对子集求得的加权平均熵比当前集合的当前集合的熵要大,则拆分结束了,针对各种可能结果的计数所得将会被保存起来。否则,算法会在新生成的子集继续调用buildtree函数,并把调用所得的结果添加到树上。我们把针对每个子集的调用结果,分别附加到节点的True分支和False分支上,最终整棵树就这样构造出来了。

    我们可以把它打印出来:

    def printtree(tree, indent=''):
        #Is this a leaf node?
        if tree.results != None:
            print (str(tree.results))
        else:
            #Print the criteria
            print (str(tree.col) + ':' + str(tree.value) + '?')
            # Print the branches
            print(indent+'T->',printtree(tree.tb,indent+' '))
            print(indent+'F->',printtree(tree.fb,indent+' '))

    现在到我们使用决策树的时候了。接受新的观测数据作为参数,然后根据决策树对其分类:

    def classify(observation,tree):
        if tree.results!=None:
            return tree.results
        else:
            v=observation[tree.col]
            branch=None
            if isinstance(v,int) or isinstance(v,float):
                if v>=tree.value:
                    branch=tree.tb
                else:
                    branch=tree.fb
            else:
                if v==tree.value:
                    branch=tree.tb
                else:
                    branch=tree.fb
            return classify(observation,branch)

    该函数采用与printtree相同的方式对树进行遍历。每次调用后,函数会根据调用结果来判断是否到达分支的末端。如果尚未到达末端,它会对观测数据评估,以确认列数据是否与参考值匹配。如果匹配,则会在True分支调用classify,不匹配则在False分支调用classify。

    上面方法训练决策树会有一个问题:

    过度拟合:它可能会变得过于针对训练数据,其熵值与真实情况相比可能会有所降低。剪枝的过程就是对具有相同父节点的一组节点进行检查,判断如果将其合并,熵的增加量是否会小于某个指定的阈值。如果确实如此,则这些叶节点会被合并成一个单一的节点,合并后的新节点包含了所有可能的结果值。这种做法有助于过度避免过度拟合的情况,使得决策树做出的预测结果,不至于比从数据集中得到的实际结论还要特殊:

    def prune(tree, mingain):
        #如果分支不是叶节点,则对其进行剪枝操作
        if tree.tb.results == None:
            prune(tree.tb, mingain)
        if tree.fb.results == None:
            prune(tree.fb, mingain)
    
        #如果两个分支都是叶节点,则判断它们是否需要合并
        if tree.tb.results != None and tree.fb.results != None:
            #构造合并后的数据集
            tb, fb = [], []
            for v, c in tree.tb.results.items():
                tb += [[v]] * c
            for v, c in tree.fb.results.items():
                fb += [[v]] * c
    
            #检查熵的减少情况
            delta = entropy(tb + fb) - (entropy(tb) + entropy(fb) / 2)
    
            if delta < mingain:
            # 合并分支
                tree.tb, tree.fb = None, None
                tree.results = uniquecounts(tb + fb)

    当我们在根节点调用上述函数时,算法将沿着树的所有路径向下遍历到只包含叶节点的节点处。函数会将两个叶节点中的结果值合起来形成一个新的列表,同时还会对熵进行测试。如果熵的变化小于mingain参数指定的值,则叶节点也可能成为删除对象,以及与其它节点的合并对象。

    如果我们缺失了某些数据,而这些数据是确定分支走向所必需的,那么我们可以选择两个分支都走。在一棵基本的决策树中,所有节点都隐含有一个值为1的权重,即观测数据项是否属于某个特定分类的概率具有百分之百的影响。而如果要走多个分支的话,那么我们可以给每个分支赋以一个权重,其值等于所有位于该分支的其它数据行所占的比重:

    def mdclassify(observation,tree):
        if tree.results!=None:
            return tree.results
        else:
            v=observation[tree.col]
        if v==None:
            tr,fr=mdclassify(observation,tree.tb),mdclassify(observation,tree.fb)
            tcount=sum(tr.values())
            fcount=sum(fr.values())
            tw=float(tcount)/(tcount+fcount)
            fw=float(fcount)/(tcount+fcount)
            result={}
            for k,v in tr.items():
                result[k]=v*tw
            for k,v in fr.items():
                result[k]=v*fw     
            return result
        else:
            if isinstance(v,int) or isinstance(v,float):
                if v>=tree.value:
                    branch=tree.tb
                else:
                    branch=tree.fb
            else:
                if v==tree.value:
                    branch=tree.tb
                else:
                    branch=tree.fb
            return mdclassify(observation,branch)

    mdclassify与classify相比,唯一的区别在于末尾处:如果发现有重要数据缺失,则每个分支的对应结果值都会被计算一遍,并且最终的结果值会乘以它们各自的权重。

    对与数值型问题,我们可以使用方差作为评价函数来取代熵或基尼不纯度。偏低的方差代表数字彼此都非常接近,而偏高的方差则意味着数字分散得很开。这样,选择节点判断条件的依据就变成了拆分后令数字较大者位于树的一侧,数字较小者位于树的另一侧。

    展开全文
  • 本章主要介绍了MATLAB基本程序元素、几种设计中经常使用数据类型和矩阵操作函数,以及程序设计5种句型(for、while循环结构、if、switch条件分支结构和try…catch结构)。以后以专题形式,分别详细讲解了编程...
  • 如何处理单元测试产生的数据,下列哪些说法是正确的?ABC A .测试数据入库时加特殊前缀标识。 B .测试数据使用独立的测试库。 C .自动回滚单元测试产生的脏数据。 D .无须区别,统一在业务代码中进行判断和...
  • 面试题8:写出bool、int、float、指针变量与“零值”比较的if语句 3.3 数据类型 面试题9:写出代码的输出结果 面试题10:C语言中合法的整型常数 面试题11:short i = 0; i = i + 1L;这两句有错吗 面试题12:char ...
  • 这样,因为w if 语句里定义,所以当if 语句执行完后它就无效了。这样 导致后果就是,按下enterBtn 后,主界面窗口一闪就没了。如果此时对程序 改动了,再次点击运行时,就会出现error: collect2: ld ...
  • 下面赋值不正确的语句是( )。 A) j=i; B) j=(long)i; C) i=(int)j; D) i=j; 26. 现有一整型数组a[4],它的所有数组元素是( )。 A) a0, a1, a2, a3 B) a[0], a[1], a[2], a[3] C) a[1], a[2], a[2], a[4] D) a[0], a...
  • jQuery详细教程

    2013-04-25 14:16:42
    • jQuery action() 执行对元素操作 示例 $(this).hide() - 隐藏当前元素 $("p").hide() - 隐藏所有段落 $("p.test").hide() - 隐藏所有 class="test" 段落 $("#test").hide() - 隐藏所有 id="test" 元素 ...
  • void ADOConn::OnInitDBConnect() //以下是连接数据库函数 { //初始化ole/com库环境,为访问ado接口做准备 ::CoInitialize(NULL); //I大写,和l小写尽然一样!!!!!!!!!!!!!!!!!!!!!!!...
  • c语言练习题

    2013-01-02 12:08:35
    10、 以下选项中不正确的整型常量是( )。  A) 12L B) -10 C) 1,900 D) 123U 11、 表达式( C )的值是0。 A)3%5 B)3/5)0 C)3/5 D)3 12、 设int x=3,y=4,z=5,则下列表达式中的值为0的是 ( ) A) ...
  • linux内核 0.11版本源码 带中文注释

    热门讨论 2009-08-31 15:10:21
    处理方法在fork()调用之后让main()使用 * 任何堆栈。因此就能有函数调用 - 这意味着fork 也要使用内嵌代码,否则我们在从fork()退出 * 时就要使用堆栈了。 * 实际上只有pause 和fork 需要使用内嵌方式...
  • A=rand(),B=rand(),C= ,都无法实现,因为通常只有一个开放寄存器。 [7] 按键式计算器实现起来非常容易(应算作其优点吧?!),无编程开发价值! 因此,本文计划用Microsoft Visual C++ 设计实现一个文本式计算器...
  • C语言程序设计模拟题 单项选择 1 若已定义x和y为double类型则表达式x=1,y=x+3/2 的值是A A2.0 B2.5 C1 D2 2 执行下面程序中的输出语句后,...} A20` B65 C10 D15 3 以下不正确的if语句形式是 Aif(x) {x++;y++;} Bif(x!=y
  • 《数据结构 1800题》

    热门讨论 2012-12-27 16:52:03
    13. 下面程序段中带有下划线的语句的执行次数数量级是( ) 【合肥工业大学 2001 三、1(2分)】 i:=n*n WHILE i<>1 DO i:=i div 2; 14. 计算机执行下面的语句时,语句 s执行次数为 _______ 。【南京理工大学 ...
  • 其他一些对数组或哈希表有用函数包括sort(),next(),prev()和each()。 对象 使用new语句产生一个对象: class foo { function do_foo () { echo "Doing foo."; } } $bar = new foo; $bar->do_foo(); 改变变量...
  • 如果该值为false,说明程序已经处于不正确的状态下,系统将给出警告或退出。一般来说,assertion用于保证程序最基本、关键的正确性。assertion检查通常在开发和测试时开启。为了提高性能,在软件发布后,assertion...
  • 不同编译器给出不同的结果, 有的为 3, 有的为 4, 哪个是正确的? o 4.4 这个巧妙的表达式: a ^= b ^= a ^= b 它需要临时变量就可以交换 a 和 b 的值。 o 4.5 我可否用括号来强制执行我所需要的计算顺序? o ...
  • JAVA 正则表达式

    热门讨论 2010-01-15 11:16:37
    if(matcher.find()) System.out.println(matcher.group(1)); } ◆截取 http://地址 //截取 url Pattern pattern = Pattern.compile("(http://|https://){1}[\\w\\.\\-/:]+"); Matcher matcher = pattern....
  • 所以上列语句在XML中正确的写法 1. sample 2.< b>< i>sample< /i>< /b> 3.< td>sample 4.< font color="red">samplar  另外,XML标记必须遵循下面的命名规则: 1.名字中可以包含字母、数字以及其它字母; 2...
  • javascript入门笔记

    2018-05-15 15:01:07
    调用:在JS中任何合法位置处,都可以通过 函数名() 方式进行调用 练习: 1、声明一个函数,名称为 change 2、在函数中 1、通过弹框,分两次,录入两个数字,保存在 a 和 b 2、先打印 a 和 b值 3、如果...
  • 答:启动一个线程调用start()方法,使线程所代表虚拟处理机处于可运行状态,这意味着它可以由JVM调度并执行。这并意味着线程就会立即运行。run()方法可以产生必须退出标志来停止一个线程。 40.接口是否可...
  • 不同编译器给出不同的i值,有的为3,有的为4,哪个是正确的? *3.4 有这样一个巧妙的表达式:a^=b^=a^=b;它需要临时变量就可以交换a和b的值。 3.5 可否用显式括号来强制执行我所需要的计算顺序并控制相关的副...
  • 若已定义x和y为double类型则表达式x=1,y=x+3/2 的值是 A2.0 执行下面程序中的...} A 20 以下不正确的if语句形式是 B if(x!=y) scanf%d&x) else scanf%d&y; 执行下面程序段后,s的值是 int s=5; C 10 下面程序段运行的结
  • java 面试题 总结

    2009-09-16 08:45:34
    如果该值为false,说明程序已经处于不正确的状态下,系统将给出警告或退出。一般来说,assertion用于保证程序最基本、关键的正确性。assertion检查通常在开发和测试时开启。为了提高性能,在软件发布后,assertion...

空空如也

空空如也

1 2 3
收藏数 53
精华内容 21
关键字:

以下不正确的if语句形式是()