精华内容
下载资源
问答
  • ExtAspNet_v2.3.2_dll

    2010-09-29 14:37:08
    -Grid的Values属性访问限制由internal改为public,这就意味这可以自由改变Grid中每个单元格值了。 -增加示例-如何将Grid控件导出为Excel(data\grid_excel_run.aspx)(feedback:503684912)。 -如果TreeNode属性...
  • Lua编程6章(V5.0)

    千次阅读 2013-06-25 16:01:32
    Lua 中函数是带有词法定界(lexical scoping)第一类值(first-class values)。  第一类值:在 Lua 中函数和其他值(数值、字符串)一样,函数可以被存放在变 量中,也可以存放在表中,可以作为函数参数...
    第六章 再论函数
    Lua 中的函数是带有词法定界(lexical scoping)的第一类值(first-class values)。 
    第一类值指:在 Lua 中函数和其他值(数值、字符串)一样,函数可以被存放在变
    量中,也可以存放在表中,可以作为函数的参数,还可以作为函数的返回值。 
    词法定界指:被嵌套的函数可以访问他外部函数中的变量。这一特性给 Lua 提供了
    强大的编程能力。 
    Lua 中关于函数稍微难以理解的是函数也可以没有名字,匿名的。当我们提到函数
    名(比如 print),实际上是说一个指向函数的变量,像持有其他类型值的变量一样: 
    a = {p = print}
    a.p("Hello World") --Hello World
    print = math.sin --`print` now refers to the sine function
    a.p(print(1)) --0.841470
    sin = a.p --`sin` now refers to the print function 
    sin(10, 20) --10 20
    既然函数是值,那么表达式也可以创建函数了,Lua 中我们经常这样写:
    function foo (x) return 2*x end 
    这实际上是利用 Lua 提供的“语法上的甜头”(syntactic sugar)的结果,下面是原
    本的函数: 
    foo = function (x) return 2*x end 
    函数定义实际上是一个赋值语句,将类型为 function 的变量赋给一个变量。我们使
    用 function (x) ... end 来定义一个函数和使用{}创建一个表一样。 

    table 标准库提供一个排序函数,接受一个表作为输入参数并且排序表中的元素。这
    个函数必须能够对不同类型的值(字符串或者数值)按升序或者降序进行排序。Lua 不
    是尽可能多地提供参数来满足这些情况的需要,而是接受一个排序函数作为参数(类似
    C++的函数对象),排序函数接受两个排序元素作为输入参数,并且返回两者的大小关系,
    例如: 


    network = { 
     {name = "grauna",   IP = "210.26.30.34"}, 
     {name = "arraial", IP = "210.26.30.23"}, 
     {name = "lua",  IP = "210.26.23.12"}, 
     {name = "derain",   IP = "210.26.23.20"}, 
    } 如果我们想通过表的name域排序:
    table.sort(network, function (a, b)
    return (a.name > b.name)
    end)


    以其他函数作为参数的函数在 Lua中被称作高级函数,高级函数在 Lua 中并没有特
    权,只是 Lua 把函数当作第一类函数处理的一个简单的结果。
    下面给出一个绘图函数的例子:
    function eraseTerminal()
    io.write("\27[2J")
    end


    -- wirte an `*' at column `x', row `y'
    function mark(x, y)
    io.write(string.format("\27[%d;%dH*", y, x)
    end 


    -- Terminal size
    TermSize = {w = 80, h = 24}
    -- plot a  function
    -- (assume that domain and image are in the range [-1, 1])
    function plot (f)
    eraseTerminal()
    for i = 1,TermSize.w, do
    local x = (i/TermSize.w)*2 - 1
    local y = (f(x) + 1)/2 * TermSize.h
    mark (i, y)
    end
    io.read() -- wait before spoiling the screen
    end


    要想让这个例子正确的运行,你必须调整你的终端类型和代码中的控制符一致:
    plot(function(x) return math.sin(x*2*math.pi)  end)
    将在屏幕上输出一个正弦曲线


    6.1闭包
    当一个函数内部嵌套另一个函数定义时,内部的函数体可以访问外部的函数的局部
    变量,这种特征我们称作词法定界。虽然这看起来很清楚,事实并非如此,词法定界加
    上第一类函数在编程语言里是一个功能强大的概念,很少语言提供这种支持。 
    下面看一个简单的例子,假定有一个学生姓名的列表和一个学生名和成绩对应的表;
    现在想根据学生的成绩从高到低对学生进行排序,可以这样做: 
    names = {"Peter", "Paul", "Mary"} 
    grades = {Mary = 10, Paul = 7, Peter = 8} 
    table.sort(names, function (n1, n2) 
      return grades[n1] > grades[n2]    -- compare the grades 
    end) 


    创建一个函数实现此功能
    function sortbygrade (names, grades)
    table.sort(names, function (n1, n2)
    return grades[n1] > grades[n2]
    end
    end


    例子包含在sortbygrade函数内部的sort中的匿名函数可以访问sortbygrade的参数grades,在匿名函数内部grades不是全局变量也不是局部变量,我们称作外部的局部变量(external local variable)或者upvalue.(upvalue意思
    有些误导,然而在Lua中他的存在也有历史根源,还有他比起external local varible简短)
    看下面代码


    function newCounter()
    local i = 0
    return function()
    i = i+1
    return i
    end
    end


    c1 = newCounter()
    print(c1()) -->1
    print(c2()) -->2


    匿名函数使用upvalue i 保存它的计数,当我们调用匿名函数的时候i已经超出了作用范围,因为创建i的函数
    newCounter已经返回了。然而Lua用闭包的思想正确处理了这种情况。简单的说闭包是一个函数加上它可以正确访问的upvalues。
    如果我们再次调用newCounter,将创建一个新的局部变量i,因此得到了一个作用在新的变量i上的新闭包。
    c2 = newCounter()
    print(c2())
    print(c1())
    print(c2())
    c1, c2是建立在同一个函数上,但作用在同一个局部变量的不同实例上的两个不同的闭包。
    技术上来讲,闭包指值而不是指函数,函数仅仅是闭包的一个原型声明;尽管如此,
    在不会导致混淆的情况下我们继续使用术语函数代指闭包。 
    闭包在上下文环境中提供很有用的功能,如前面我们见到的可以作为高级函数(sort)
    的参数;作为函数嵌套的函数(newCounter)。这一机制使得我们可以在 Lua 的函数世界
    里组合出奇幻的编程技术。闭包也可用在回调函数中,比如在 GUI 环境中你需要创建一
    系列 button,但用户按下 button 时回调函数被调用,可能不同的按钮被按下时需要处理
    的任务有点区别。具体来讲,一个十进制计算器需要 10 个相似的按钮,每个按钮对应一
    个数字,可以使用下面的函数创建他们: 


    function digitButton (digit)
    return Button{ label = digit,
    action = function()
    add_to_display(digit)
    end
    end


    这个例子中我们假定 Button 是一个用来创建新按钮的工具, label 是按钮的标签,
    action 是按钮被按下时调用的回调函数。(实际上是一个闭包,因为他访问 upvalue digit)。
    digitButton 完成任务返回后,局部变量 digit 超出范围,回调函数仍然可以被调用并且可
    以访问局部变量 digit。 


    闭包在完全不同的上下文中也是很有用途的。因为函数被存储在普通的变量内我们
    可以很方便的重定义或者预定义函数。通常当你需要原始函数有一个新的实现时可以重
    定义函数。例如你可以重定义 sin 使其接受一个度数而不是弧度作为参数: 


    oldSin = math.sin
    math.sin = function (x)
    return oldSin(x*math.pi/180)
    end


    更清楚的方式:


    do 
    local oldSin = math.sin
    local k = math.pi/180
    math.sin = function(x)
    return oldSin(x*k)
    end
    end


    这样我们把原始版本放在一个局部变量内,访问 sin 的唯一方式是通过新版本的函
    数。 


    利用同样的特征我们可以创建一个安全的环境(也称作沙箱,和java里的沙箱一样)
    当我们运行一段不信任的代码(比如我们运行网络服务器上获取的代码)时安全的环境
    是需要的,比如我们可以使用闭包重定义 io 库的 open 函数来限制程序打开的文件。 
    do
    local oldOpen = io.open
    io.open = function (filename, mode)
    if access_OK(filename, mode) then
    return oldOpen(filename, mode)
    else
    return nil, "access denied"
    end
    end
    end


    6.2 非全局函数
    Lua中函数可以作为全局变量也可以作为局部变量,我们已经看到一些例子,函数
    作为 table 的域(大部分 Lua 标准库使用这种机制来实现的比如 io.read、math.sin) 。这种
    情况下,必须注意函数和表语法:


    1.表和函数放在一起
    Lib = {}
    Lib.foo = function (x, y) return x + y end
    Lib.goo = function (x, y) return x - y end 


    2.使用表构造函数
    Lib = {
    foo = function (x, y) return x + y end
    goo = function (x, y) return x - y end
    }


    3.Lua提供另一种语法形式
    Lib = {}
    function Lib.foo (x, y)
    return x + y
    end


    function Lib.goo (x, y)
    return x - y
    end


    当我们将函数保存在一个局部变量内时,我们得到一个局部函数,也就是说局部函
    数像局部变量一样在一定范围内有效。这种定义在包中是非常有用的:因为 Lua把 chunk
    当作函数处理,在 chunk内可以声明局部函数(仅仅在 chunk 内可见),词法定界保证了
    包内的其他函数可以调用此函数。下面是声明局部函数的两种方式: 
    1.方式一
    local f = function(...)
    ...
    end


    local g = function(...)
    ...
    f() --external local `f` is visible here f
    end
    2.方式二
    local function f (...)
    ...
    end
    有一点需要注意的是声明递归局部函数的方式
    local fact = function (n)
    if n == 0 then 
    return 1
    else
    return n * fact(n-1)-- buggy
    end
    end


    上面这种方式导致Lua编译时遇到fact(n-1)并不知道它是局部函数 fact, Lua 会去查
    找是否有这样的全局函数 fact。为了解决这个问题我们必须在定义函数以前先声明:


    local fact


    fact = function (n)
    if n == 0 then 
    return 1
    else
    return n * fact(n-1)
    end
    end


    这样在fact内部fact(n-1)调用是一个局部函数调用,运行时fact就可以获取正确的值了。
    但是Lua扩展了他的语法使得可以在直接递归函数定义时使用两种方式都可以。 
    在定义非直接递归局部函数时要先声明然后定义才可以: 
    local f, g
    function g()
    ... f() ...
    end


    function f()
    ... g() ...
    end


    6.3正确的尾调用 (Proper Tail Calls)
    Lua中函数的另一个有趣的特征是可以正确的处理尾调用(proper tail recursion,一
    些书使用术语“尾递归”,虽然并未涉及到递归的概念)。 
    尾调用是一种类似在函数结尾的 goto 调用,当函数最后一个动作是调用另外一个函
    数时,我们称这种调用尾调用。例如: 
    function f(x) 
      return g(x) 
    end 
    g 的调用是尾调用。
    例子中 f 调用 g 后不会再做任何事情,这种情况下当被调用函数 g 结束时程序不需
    要返回到调用者 f;所以尾调用之后程序不需要在栈中保留关于调用者的任何信息。一
    些编译器比如 Lua 解释器利用这种特性在处理尾调用时不使用额外的栈,我们称这种语
    言支持正确的尾调用。 
    由于尾调用不需要使用栈空间,那么尾调用递归的层次可以无限制的。例如下面调
    用不论 n 为何值不会导致栈溢出。 
    function foo (n) 
      if n > 0 then return foo(n - 1) end 
    end 
    需要注意的是:必须明确什么是尾调用。 
    一些调用者函数调用其他函数后也没有做其他的事情但不属于尾调用。比如: 
    fucntion f (x)
    g(x)
    return 
    end 


    上面这个例子中 f 在调用 g 后,不得不丢弃 g 地返回值,所以不是尾调用,同样的
    下面几个例子也不是尾调用: 


    return g(x) + 1   -- must do the addition 
    return x or g(x)   -- must adjust to 1 result ,必须调整到返回一个结果
    return (g(x))    -- must adjust to 1 result ,必须调整到返回一个结果


    Lua中类似return g(...)这种格式的调用是尾调用。但是 g 和 g 的参数都可以是复杂
    表达式,因为 Lua 会在调用之前计算表达式的值。例如下面的调用是尾调用:
    return x[i].foo(x[j] + a*b, i + j) 


    可以将尾调用理解成一种 goto,在状态机的编程领域尾调用是非常有用的。状态机
    的应用要求函数记住每一个状态,改变状态只需要 goto(or call)一个特定的函数。我们考
    虑一个迷宫游戏作为例子:迷宫有很多个房间,每个房间有东西南北四个门,每一步输
    入一个移动的方向,如果该方向存在即到达该方向对应的房间,否则程序打印警告信息。
    目标是:从开始的房间到达目的房间。 


    这个迷宫游戏是典型的状态机,每个当前的房间是一个状态。我们可以对每个房间
    写一个函数实现这个迷宫游戏,我们使用尾调用从一个房间移动到另外一个房间。一个
    四个房间的迷宫代码如下: 
    function room1()
    local move = io.read()
    if move == "south" then
    return room3()
    elseif move == "east" then
    return room2()
    else
    print("invalid move")
    return room1 -- stay in the same room
    end
    end


    function room2()
    local move = io.read()
    if move == "south" then
    return room4()
    elseif move == "west" then 
    return room1()
    else
    print("ivalid move")
    return room2()
    end
    end


    function room3()
    local move = io.read()
    if move == "north" then 
    return room1()
    elseif move == "east" then 
    return room4()
    else
    print("invalid move")
    return room3()
    end
    end


    function room4()
    print("congratulations!")
    end

    我们可以调用 room1()开始这个游戏。 
    如果没有正确的尾调用,每次移动都要创建一个栈,多次移动后可能导致栈溢出。
    但正确的尾调用可以无限制的尾调用,因为每次尾调用只是一个 goto 到另外一个函数并

    不是传统的函数调用。


    展开全文
  • -Grid的Values属性访问限制由internal改为public,这就意味这可以自由改变Grid中每个单元格值了。 -增加示例-如何将Grid控件导出为Excel(data\grid_excel_run.aspx)(feedback:503684912)。 -如果TreeNode属性...
  • Log Explorer for SQL Server v4.22

    热门讨论 2010-06-25 11:03:02
    用户事物是在用户表上定义事物,不支持系统表更新恢复。同时,他也不支持计划变更回滚。 l Blob类型:包括text,ntext,image类型。LogExplore只支持这些类型insert和delete恢复,不支持update语句恢复。 ...
  • Javashop开发规范V2.2

    2012-08-21 00:13:09
    <values>5,'列表页上部横幅','972px','67px',0,'false'</values> 3.2.7 删除数据 暂未支持 3.2.8 更新数据 暂未支持 3.3 数据类型对照表 xml Mysql Oracle SqlServer int int NUMBER smallint int(1) smallint...
  • 测试集:模型泛化能力的考量(泛化指的是对未知数据的预测能力) #划分训练集、验证集和测试集 from sklearn.model_selection import train_test_split f_v=features.values l_v=label.values ...

    训练集、验证集和测试集

    • 训练集:用于训练和拟合模型
    • 验证集:通过训练集训练出多个模型后,使用验证集数据来寻找模型得最佳参数
    • 测试集:模型泛化能力的考量(泛化指的是对未知数据的预测能力)
    #划分训练集、验证集和测试集
    from sklearn.model_selection import train_test_split
    f_v=features.values
    l_v=label.values
    X_tt,X_validation,Y_tt,Y_valiation=train_test_split(f_v,l_v,test_size=0.2)#训练集,验证集
    X_train,X_test,Y_train,Y_test=train_test_split(X_tt,Y_tt,test_size=0.25)#将训练集分为训练集和测试集
    print(len(X_train),len(X_validation),len(X_test))
    

    分类

    1.KNN(K-Nearest Neighbors)

    1)距离(欧式距离,曼哈顿距离,闵科夫斯基距离)
    2)KD-Tree
    主要思想:一未知的点,找其最近邻的K个点,K个点中属于标注1的点大于属于标注2的点,则未知的点属于标注1

    #KNN
    #1.确定参数,由指标可知参数为3时更好
    from sklearn.neighbors import NearestNeighbors,KNeighborsClassifier
    knn_clf=KNeighborsClassifier(n_neighbors=3)
    #knn_clf_n5=KNeighborsClassifier(n_neighbors=5)
    knn_clf.fit(X_train,Y_train)#拟合得到模型
    #knn_clf_n5.fit(X_train,Y_train)
    Y_pred=knn_clf.predict(X_validation)
    #Y_pred_n5=knn_clf_n5.predict(X_validation)
    #衡量指标
    from sklearn.metrics import accuracy_score,recall_score,f1_score
    print('ACC:',accuracy_score(Y_validation,Y_pred))
    print('REC:',recall_score(Y_validation,Y_pred))
    print('F-Score:',f1_score(Y_validation,Y_pred))
    #print('ACC:',accuracy_score(Y_validation,Y_pred_n5))
    #print('REC:',recall_score(Y_validation,Y_pred_n5))
    #print('F-Score:',f1_score(Y_validation,Y_pred_n5))
    2.训练集、验证集、测试集的建模结果
    from sklearn.neighbors import NearestNeighbors,KNeighborsClassifier
    knn_clf=KNeighborsClassifier(n_neighbors=3)
    knn_clf.fit(X_train,Y_train)#拟合得到模型
    #衡量指标
    from sklearn.metrics import accuracy_score,recall_score,f1_score
    print('Train:')
    Y_pred=knn_clf.predict(X_train)
    print('ACC:',accuracy_score(Y_train,Y_pred))
    print('REC:',recall_score(Y_train,Y_pred))
    print('F-Score:',f1_score(Y_train,Y_pred))
    Y_pred=knn_clf.predict(X_validation)
    print('Validation:')
    print('ACC:',accuracy_score(Y_validation,Y_pred))
    print('REC:',recall_score(Y_validation,Y_pred))
    print('F-Score:',f1_score(Y_validation,Y_pred))
    Y_pred=knn_clf.predict(X_test)
    print('Test:')
    print('ACC:',accuracy_score(Y_test,Y_pred))
    print('REC:',recall_score(Y_test,Y_pred))
    print('F-Score:',f1_score(Y_test,Y_pred))
    ##存储模型
    from sklearn.externals import joblib
    joblib.dump(knn_clf,'knn_clf')#''里面为存储模型的名字
    #使用模型
    knn_clf=joblib.load('knn_clf')
    3.写循环保存多个模型和指标计算
    from sklearn.neighbors import NearestNeighbors,KNeighborsClassifier
    from sklearn.metrics import accuracy_score,recall_score,f1_score
    models=[]
    models.append(('KNN',KNeighborsClassifier(n_neighbors=3)))
    for clf_name,clf in models:
       clf.fit(X_train,Y_train)
       xy_lst=[(X_train,Y_train),(X_validation,Y_validation),(X_test,Y_test)]
       for i in range(len(xy_lst)):
           X_part=xy_lst[i][0]
           Y_part=xy_lst[i][1]
           Y_pred=clf.predict(X_part)
           print(i)#i=0代表训练集,1代表验证集,2代表测试集
           print(clf_name,'-ACC:',accuracy_score(Y_part,Y_pred))
           print(clf_name,'-REC:',recall_score(Y_part,Y_pred))
           print(clf_name,'-F1:',f1_score(Y_part,Y_pred))
    

    2.朴素贝叶斯

    • 概率、条件概率、联合概率、全概率公式、贝叶斯公式
    • 特征是离散的,效果好
    from sklearn.neighbors import NearestNeighbors,KNeighborsClassifier
    from sklearn.metrics import accuracy_score,recall_score,f1_score
    from sklearn.naive_bayes import GaussianNB,BernoulliNB  
    常用的两种朴素贝叶斯模型:高斯朴素贝叶斯,伯努利朴素贝叶斯
    用到的特征必须是离散的,若离散值是01时,用伯努利更好,若值为连续,在伯努利算法下,会先将特征二值化
    高斯朴素贝叶斯则假设特征是高斯分布的,
    朴素贝叶斯算法在离散属性下表现更好
    models=[]
    models.append(('KNN',KNeighborsClassifier(n_neighbors=3)))
    models.append(('GaussianNB',GaussianNB()))
    models.append(('BernoulliNB',BernoulliNB()))
    for clf_name,clf in models:
        clf.fit(X_train,Y_train)
        xy_lst=[(X_train,Y_train),(X_validation,Y_validation),(X_test,Y_test)]
        for i in range(len(xy_lst)):
            X_part=xy_lst[i][0]
            Y_part=xy_lst[i][1]
            Y_pred=clf.predict(X_part)
            print(i)#i=0代表训练集,1代表验证集,2代表测试集
            print(clf_name,'-ACC:',accuracy_score(Y_part,Y_pred))
            print(clf_name,'-REC:',recall_score(Y_part,Y_pred))
            print(clf_name,'-F1:',f1_score(Y_part,Y_pred))
    

    生成模型:通过求输入与输出的联合概率分布,再求解类别归类的概率(如:朴素贝叶斯)对数据要求高
    判别模型:不通过联合概率分布,直接可以获得输出对应最大分类的概率(如:KNN)使用范围广

    3.决策树

    一个问题是构造决策树时,特征的顺序?
    由三个指标来判断:1)信息增益 2)信息增益率 3)Gini系数

    from sklearn.metrics import accuracy_score,recall_score,f1_score
    from sklearn.tree import DecisionTreeClassifier
    models=[]
    models.append(('DecisionTree',DecisionTreeClassifier()))#默认是基尼系数的,criterion='entropy'为信息增益的
    for clf_name,clf in models:
        clf.fit(X_train,Y_train)
        xy_lst=[(X_train,Y_train),(X_validation,Y_validation),(X_test,Y_test)]
        for i in range(len(xy_lst)):
            X_part=xy_lst[i][0]
            Y_part=xy_lst[i][1]
            Y_pred=clf.predict(X_part)
            print(i)#i=0代表训练集,1代表验证集,2代表测试集
            print(clf_name,'-ACC:',accuracy_score(Y_part,Y_pred))
            print(clf_name,'-REC:',recall_score(Y_part,Y_pred))
            print(clf_name,'-F1:',f1_score(Y_part,Y_pred))
    如何看决策树中的更多细节?即把决策树画出来
    Graphviz (图的可视化软件),帮助画出决策树,下载安装Graphviz,在程序中加入环境变量
    import os
    os.environ['PATH']+=os.pathsep+'D:/Graphviz2.38/bin/'#在程序中加入环境变量
    import pydotplus
    from sklearn.metrics import accuracy_score,recall_score,f1_score
    from sklearn.tree import DecisionTreeClassifier,export_graphviz
    from sklearn.externals.six import StringIO #可能会用到的一个包
    models=[]
    models.append(('DecisionTree',DecisionTreeClassifier()))
    for clf_name,clf in models:
        clf.fit(X_train,Y_train)
        xy_lst=[(X_train,Y_train),(X_validation,Y_validation),(X_test,Y_test)]
        for i in range(len(xy_lst)):
            X_part=xy_lst[i][0]
            Y_part=xy_lst[i][1]
            Y_pred=clf.predict(X_part)
            print(i)#i=0代表训练集,1代表验证集,2代表测试集
            print(clf_name,'-ACC:',accuracy_score(Y_part,Y_pred))
            print(clf_name,'-REC:',recall_score(Y_part,Y_pred))
            print(clf_name,'-F1:',f1_score(Y_part,Y_pred))
            dot_data=export_graphviz(clf,out_file=None,feature_names=f_names,class_names=['NL','L'],
                                        filled=True,rounded=True,special_characters=True)
            #当out_file='None'时,dot_data可以直接输出,class_name为标注的名称
            graph=pydotplus.graph_from_dot_data(dot_data)#绘制
            graph.write_pdf('dt_tree.pdf')#输出pdf文件
            后三行可等效为
            dot_data=StringIO()
            export_graphviz(clf,out_file=dot_data,feature_names=f_names,class_names=['NL','L'],
                                        filled=True,rounded=True,special_characters=True)
            graph=pydotplus.graph_from_dot_data(dot_data.getvalue())#绘制
            graph.write_pdf('dt_tree.pdf')#输出pdf文件
    

    4.支持向量机(Support Vector Machine ,SVM)

    核函数:线性核函数,多项式核函数,高斯径向基(RBF)核函数

    from sklearn.svm import SVC
    from sklearn.metrics import accuracy_score,recall_score,f1_score
    models=[]
    models.append(('SVM Classifier',SVC()))
    for clf_name,clf in models:
       clf.fit(X_train,Y_train)
       xy_lst=[(X_train,Y_train),(X_validation,Y_validation),(X_test,Y_test)]
       for i in range(len(xy_lst)):
           X_part=xy_lst[i][0]
           Y_part=xy_lst[i][1]
           Y_pred=clf.predict(X_part)
           print(i)#i=0代表训练集,1代表验证集,2代表测试集
           print(clf_name,'-ACC:',accuracy_score(Y_part,Y_pred))
           print(clf_name,'-REC:',recall_score(Y_part,Y_pred))
           print(clf_name,'-F1:',f1_score(Y_part,Y_pred))
    

    5.集成方法

    • 组合多个模型,以获得更好的效果
    • 强可学习:多项式学习算法的效果较为明显。弱可学习:不明显
    • 集成方法:将几个弱可学习的分类器集合成一个强可学习的分类器的过程
    • 集成思想用到的具体方法:袋装法(bagging),将几个不同的分类模型进行独立袋装,然后投票表决,几个子模型是相互独立的,互不影响的。其典型应用:随机森林
                  提升法(boost),几个模型加权叠加而成。其典型应用:Adaboost
      1.随机森林
      树的个数、树的特征数、树的训练集
      优点:每个决策树可以并不使用全部特征
         不需要剪枝,即可有效避免过拟合
    from sklearn.ensemble import RandomForestClassifier
    from sklearn.metrics import accuracy_score,recall_score,f1_score
    models=[]
     models.append(('OriginalRandomFroest',RandomForestClassifier()))
     #n_estimators决策树的个数,max_features每棵树用到的特征,默认10棵树,
     models.append(('RandomFroest',RandomForestClassifier(n_estimators=80,max_features=None)))#调参查看结果
    for clf_name,clf in models:
       clf.fit(X_train,Y_train)
       xy_lst=[(X_train,Y_train),(X_validation,Y_validation),(X_test,Y_test)]
       for i in range(len(xy_lst)):
           X_part=xy_lst[i][0]
           Y_part=xy_lst[i][1]
           Y_pred=clf.predict(X_part)
           print(i)#i=0代表训练集,1代表验证集,2代表测试集
           print(clf_name,'-ACC:',accuracy_score(Y_part,Y_pred))
           print(clf_name,'-REC:',recall_score(Y_part,Y_pred))
           print(clf_name,'-F1:',f1_score(Y_part,Y_pred))
    

    2.Adaboost
    优点:精度高,且灵活可调
       几乎不用担心过拟合问题
       简化特征工程流程

    from sklearn.ensemble import AdaBoostClassifier
    from sklearn.metrics import accuracy_score,recall_score,f1_score
    models=[]
    models.append(('Adaboost',AdaBoostClassifier()))#
    models.append(('Adaboost',AdaBoostClassifier(n_estimators=100))
    for clf_name,clf in models:
       clf.fit(X_train,Y_train)
       xy_lst=[(X_train,Y_train),(X_validation,Y_validation),(X_test,Y_test)]
       for i in range(len(xy_lst)):
           X_part=xy_lst[i][0]
           Y_part=xy_lst[i][1]
           Y_pred=clf.predict(X_part)
           print(i)#i=0代表训练集,1代表验证集,2代表测试集
           print(clf_name,'-ACC:',accuracy_score(Y_part,Y_pred))
           print(clf_name,'-REC:',recall_score(Y_part,Y_pred))
           print(clf_name,'-F1:',f1_score(Y_part,Y_pred))
    
    展开全文
  • java_0820

    2019-08-20 22:38:21
    Map 1.Map是双列集合顶层接口 2.Map通常是具有以键值对为元素键值对集合 ...,K是唯一Values是不唯一 4.键是唯一,值有多种类型,有对象类型或者又是Map类型,啥都有 5.键可以是看做是List集合...

    https://blog.csdn.net/weixin_44165237/article/details/99762667 0819连接

    Map

    1.Map是双列集合的顶层接口
    2.Map通常是指具有以键值对为元素的键值对集合
    3.Map<K,V>,K是唯一的,Values是不唯一的
    4.键是唯一,值有多种类型,有对象类型或者又是Map类型,啥都有
    5.键可以是看做是List集合的一个索引,将map的键用List来装

    用老师话介绍:

       Map  是一个接口 是双列集合的顶级        Collection  是单列集合的顶级 
            
            Map:是以键值对的形式来进行存储(Key,Values);
            
            Map map 里的键都是唯一的,不能够重复, values是可以重复,每一个键只能对应一个值(一一对应,就是映射的关系)
          
            Map 的具体实现类有 HashMap(重点) TreeMap Hashtable(比较少)
    
             Map.Entry<K,V>  的解释 :    也就是map  有一个内部接口的名字叫Entry
    
             map 常规的一些方法:(添加的方法)  V put(K key,V value)  通过键值对来进行添加
    
                                  移除的方法: V remove(Object key)  通过键来删除键值对 (没有根据索引来移除)
    
                                  判断类型的方法: boolean containsKey(Object key) 判断这个键是否存在
                                                  boolean containsValue(Object value) 判断这个值是否存在
                                                  boolean isEmpty() 是否存在元素  
    
                                  获取性的方法:  void clear() 清除所有的元素
                                                  V get(Object key)  通过键来获取值
                                                  int size() 获取集合的长度 
                                                  Collection<V> values()  获取所有的values()
                                                  Set<K> keySet()  获取map中所有的键  返回值是一个Set
    
    
                                   修改:根据键来修改值,键必须存在  V put(K key,V value)
    

    Map接口中定义的常用方法:

    (1)void clear():删除该Map对象中所有的键值对。

    (2)boolean containsKey(Object key):查询Map中是否包含指定key。

    (3)boolean containsValue(Object value):查询Map中是否包含一个或多个value。

    (4)Set entrySet():返回Map中所包含的键值对所组成的Set集合,每个集合元素都是Map.Entry对象。

    (5)Object get(Object obj):返回指定key所对应的value。如果没有,这返回null。

    (6)boolean isEmpty():查询该Map是否为空,如果为空则返回true。

    (7)Set keySet():返回该Map中所有key组成的Set集合。

    (8)Object put(Object key, Object
    value):添加一个键值对,如果当前Map中已经有一个与该key相等的键值对,则新的键值对将覆盖原来的键值对。

    (9)void putAll(Map m):将指定Map中的键值对复制到m中。

    (10)Object remove(Object key):删除指定key所对应的键值对,如果不存在,则返回null。

    (11)int size():返回Map里的键值对个数。

    (12)Collection values():返回该Map里所有的vlaue组成的Collection。

    Map中包括一个内部类Entry。该类封装了一个键值对。

    Entry包含的三个方法: 它表示的是一个键值对的对象
    
    (1)Object  getKey():返回该Entry里包含的key值。
    
    (2)Object   getValue():返回该Entry里包含的value值。
    
    (3)Object   setValue(V value):设置该Entry里包含的value值,并返回新设置的value值。
    

    Collections

    1.使用时注意它是until包下的工具类,是对List集合操作的工具类,不是map;
    2.常用它的静态方法,对List集合操作

    sort: Colletions.sort(List list),对集合进行自然升序
    public static <T extends Comparable<? super T>> void sort(List<T> list)
    根据元素的自然顺序 对指定列表按升序进行排序
    
    binarySearch 二分查找搜索指定的元素,前提是已经排好序
    public static <T> int binarySearch(List<? extends Comparable<? super T>> list,
                                       T key)
    
    frequency
    public static int frequency(Collection<?> c,
                                Object o)
                                返回指定 collection 中等于指定对象的元素数
    
    reverse 反转集合元素顺序
    public static void reverse(List<?> list)
    
    shuffle 对列表进行索引的随机置换,即元素位置交换
    public static void shuffle(List<?> list)
    

    总结
    今天学习了Map的双列顶层集合,可以说是跟Collection的顶层单列集合有的一挥。
    我认识到Map的键值对很有意思,它的键可以使用List集合来收集,再通过list集合的
    Collections工具类对所谓的List集合进行操作,什么反转啊,打乱呀,排序呀,统统都是在List集合下的操作。我认识到操作List的索引,实质是操作map的键,同样键不是具有唯一性么,这键值所配对,自然就操作了值啦。
    键值对的值可以是很复杂很复杂的类型,比如Map嵌套map,需要层层剥皮才行。

    展开全文
  • V2MOM工具

    千次阅读 2011-06-22 18:24:00
    两个“V”是愿景(vision)和价值取向(values),第一个“M”是“方法”(methods),“O”是“阻碍”(obstacles),另一个“M”是评估标准(measures)。 这五件事情,对应其实是五个问题:我需要什么样愿景?...

      两个“V”是指愿景(vision)和价值取向(values),第一个“M”是指“方法”(methods),“O”是指“阻碍”(obstacles),另一个“M”是指评估标准(measures)。

      这五件事情,对应的其实是五个问题:我需要什么样的愿景?什么是最重要的价值取向?我如何才能获得正确的方法?我如何去掉工作中的阻碍?我们是否有可靠的评估标准?

            愿景(Vision):你想做什麼?

            价值(Values)  为什么重要?

            方法(Methods):如何做到?

            障碍(Obstacles):有社么阻碍?

            衡量(Measures):如何知道已达到目标?

           公司的经营团队继而发展出年度全公司层级的V2MOM,后来每个部门、个人都发展出自己的V2MOM。这套工具从个人到整体组织,大家都在使用,让公司能划一脚步。CEO应该制定创新的内涵,并且允许承担风险,才能替渐进式、半激进式与激进式创新建立发展基石。在运用管理工具,推出改善行动计画之前,应该要先诊断、评估创新流程的状况:组织是否了解策略、流程与支持创新的组织结构等,这能让领导人更清楚了解现况、绩效落差情形跟优先需要改变的地方。

    展开全文
  • MYSQL 校对集 collate

    千次阅读 2015-10-12 19:07:41
    指的是字符之间比较关系, 例如:a c B 这样比较下来按照编码来说应该是B a c这样的顺序; create table collate_1 ( c varchar(10) ); insert into collate_1 values ('a'); insert into collate_1 values ...
  • 修改数据排序方式SORT

    2013-02-21 15:18:07
    v$nls_valid_values这个表中值分为4类参数1CHARACTERSET2SORT3TERRITORY4LANGUAGE其中sort类排序规则设置方法是sessi...
  • js深入

    2013-10-15 23:10:22
    一.延迟脚本 二.typeof ...基本类型值是保存在栈内存中简单数据段,完全保存在内存中一个位置。而引用类型值保存在堆内存中对象 五.排序 var values=[1,2,3,1] values.reverse(); alert(v
  • ORACLE数据库系统是美国ORACLE公司(甲骨文)提供以分布式数据库为核心一组软件产品,是目前最流行客户/服务器(CLIENT/SERVER)或B/S体系结构数据库之一。  拉里•埃里森  就业前景 从就业与择业...
  •  其中-g选项中k是输入数据中属性数。option -v 随机地将数据剖分为n部分并计算交互检验准确度和均方根误差。以上这些参数设置可以按照SVM类型和核函数所支持参数进行任意组合,如果设置参数在函数或SVM...
  •  应特别注意的是,无论是从左至右求值, 还是自右至左求值,其输出顺序都是不变的, 即输出顺序总是和实参表中实参的顺序相同。由于Turbo C现定是自右至左求值,所以结果为8,7,7,8。上述问题如还不理解,上机一...
  • 数据结构是相互直接存在一种或多种特殊关系数据元素集合。通常情况下,精心选择数据结构可以带来更高运行或者存储效率。作为一名程序猿,更需要了解下数据结构。AND WHY?可以参考这篇...
  • cmd到这个目录下,跟据实际情况修改文件:values.yaml,再执行命令: helm install -name rjzjh .\duckula3-ops\ --namespace default 查看相关日志: 本地访问地址   设置本地转发:kubectl port-forward ...
  • Oracle JOB 用法小结

    2009-11-13 21:14:36
     next_date参数识何时将运行这个工作。  interval参数何时这个工作将被重执行。  no_parse参数指示此工作在提交时或执行时是否应进行语法分析——TRUE指示此PL/SQL代码在它第一次执行时应进行语法分析,而...
  • arcgis工具

    2012-10-22 22:37:31
    如:“AREA”,如果查询的是个人地理数据库数据,则需要将字段名包含在方括号内,如:[AREA],如果查询的是ArcSDE地理数据库数据或是ArcIMS要素类或ArcIMS影象服务子层中的数据,则不需要将字段名括起,如:AREA ...
  • 7.3.3 iter_swap() 可交换两个迭代器所内容263 7.4 迭代器配接器(iterator adapters) 264 7.4.1 reverse(逆向)迭代器264 7.4.2 insert(安插型)迭代器271 7.4.3 stream(串流)迭代器277 7.5 迭代器特性...
  • C++标准程序库.pdf

    热门讨论 2012-10-24 10:26:06
    13.7.2 布尔值(boolean valuesi/o 格式617 13.7.3 字段宽度、填充字符、位置调整618 13.7.4 正记号与大写字620 13.7.5 数值进制(numeric base) 621 13.7.6 浮点数(floating-point)表示法623 13.7.7 一般性...
  • for v in key_file.values(): _download(v) def _load_label(file_name): file_path = dataset_dir + "/" + file_name print("Converting " + file_name + " to NumPy Array ...") with gzip.open...
  • 刚好程序报错中的com.b.a.a.a 就是指的idea/libraries中的一个包中的类,即为com.loopj.android.http.AsyncHttpClient,不知道怎么在混淆配置文件中忽略这些包的混淆。最后通过配置,发现这些包还是被混淆了,不知道...

空空如也

空空如也

1 2
收藏数 27
精华内容 10
关键字:

vvalues指的是