精华内容
下载资源
问答
  • 二进制-111怎么求的原码1000 0111的解答过程 追答: 要求使用8位机器码表示,那么,最左边是符号位,负号用 1 代表。 后面7位是数值,题目中只是给定了三位111,再补上四个0000,即凑够了8位。 补码编码规则是:用...

    若用8位机器码表示二进制数-111,则原码表示的十六进制形式是什么?补码表示的十六进制形式是什么?

    原码:1000 0111,十六进制形式:87H。(其中H表示16进制)

    补码:1111 1001,十六进制形式:F9H。

    请问:

    二进制-111怎么求的原码1000 0111的解答过程

    追答:

    要求使用8位机器码表示,那么,最左边是符号位,负号用 1 代表。
    后面7位是数值,题目中只是给定了三位111,再补上四个0000,即凑够了8位。

    补码编码规则是:用最高位表示符号,正数用0表示,负数用1表示,正数的补码是其原码本身,负数的补码的数值部分是对其原码的数值部分按位取反后加1。

    二进制数-111的8位补码表示为11111001,即十六进制的F9。

    在这里插入图片描述

    展开全文
  • 我们知道正则化的损失函数中前一项代表经验误差,而在概率模型中(决策树模型是一种概率模型),经验误差函数的获得往往通过将极大似然函数取反,即将极大化为极小而获得。因此,在概率模型中,极大似然函数与经验...

    决策树的损失函数是什么?

    决策树的损失函数通常是正则化的极大似然函数。

    正则化的决策树损失函数:

    在这里插入图片描述
    其中|T|代表叶节点个数,表示具体某个叶节点的样例数,表示叶节点经验熵。

    我们知道正则化的损失函数中前一项代表经验误差,而在概率模型中(决策树模型是一种概率模型),经验误差函数的获得往往通过将极大似然函数取反,即将求极大化为求极小而获得。因此,在概率模型中,极大似然函数与经验误差函数可以认为是相同的概念,那么必然就可以通过经验误差函数来推导出极大似然函数,以此来加深对决策树损失函数的理解。

    利用损失函数反向推导出极大似然函数

    在这里插入图片描述

    其中表示叶节点中类别为k的样本数。K表示样例类别总数。

    至此,损失函数被化简为这样,可以看到它与我们所要求的极大似然函数仅一步之遥:将求极小转为求极大,即去掉上式的负号,我们得到对数极大似然函数:
    在这里插入图片描述
    其对应的极大似然函数是:
    在这里插入图片描述
    至此,决策树模型的极大似然函数推导完毕。

    总结:

    先对各叶节点之间进行极大似然估计,再对各叶节点内部进行极大似然估计,由此得到决策树模型中的极大似然函数。

    如何理解决策树的损失函数?

    1.决策树本质上是按照某种方法/某些条件对数据进行分类.正如一般的树结构,这个分类是可以不断嵌套,按层逐级细分的,直到满足某个/某些条件为止. -个最简单的例子是,对某个数据按照一个条件进行分类,这就是最简单的树,可以用很简单的代码实现.

    例如有个数据集,其中-一个指标的直方图如图所示,如果按照该指标将数据集分为A和B两类的话,最简单的方式就是给定一个國值40,小于该阈值的,则为B,大于等于该阈值的,则为A.
    在这里插入图片描述
    代码简单的写成:

      if value < 40:
      return 'B'
      else:
      return 'A'
    

    当然,这个分类的效果很一般,大概正确率是79%.详细情况见图:
    在这里插入图片描述
    这种最简单的分类情况,就是一个只有两个节点的树,看起来就是:
    在这里插入图片描述
    在这里,简单粗暴,但效果并不太好.于是,我们烧着树,吃着火锅唱着歌“决策燃棵树,树在锅下泣,本来要生长,奈何烧太急".

    2.为了让"决策树"的决策做的更好,我们不能满足于"两条腿"的树,于是,我们给这棵树浇灌,让它茁壮成长.比如,下面就是一棵长得更好的树:

    在这里插入图片描述
    问题在于怎样长出这么一棵好看"的树出来呢?其中-种方法是“贪婪",也就是,先设定好规则,然后不断进行二分分裂,知道满足预定的条件就截止
    3. "贪婪"算法还算不错,但有其固有的缺陷,也就是有可能陷入局部最优的情况. -一个可能的例子是,对于某个节点再次分裂会使得整棵树的效果变差,那么这个时候,树的生长就该停止了.但其实这个时候,如果某个子节点再次生长(分裂),效果能够更好.比如:
    在这里插入图片描述
    比如上图,在Case 0的时候,尝试对AB进行分裂,分裂成AB1和AB2,见Case 1,发现效果变差,那么贪婪算法就会停止在这个分支的生长.但其实如果对AB1继续分裂,见Case 2,这时效果有可能变得更好.但贪婪算法一般不会尝试这一步,于是乎,错过了人生中更加美好的时刻.

    4.为了解决"贪婪"存在的一-些问题, -种办法是,先"生成"一棵足够大的树,然后对其进行剪枝,看看是否效果能够更好,如果能够更好的话,就把"该枝"给剪了,留下"残缺"的树.大概的样子是:
    在这里插入图片描述

    在Case 0的时候,先生成一棵较大的树.然后尝试着对AB2这个点进行剪枝,剪去3和4两个叶子节点测试一下效果如何?测试的结果是效果变差了,于是该剪去的枝得保留.然后呢尝试着对5,6和7,8等节点进行剪枝,发现效果变好,就继续, -直剪到保留AC为止,就是Case 2的情况.

    5.怎么剪枝呢?当然不能想上述一眼傻傻的一点点试,有一个流行的方法叫"成本-复杂度剪枝".大概是先生成-棵足够大的树T0,然后将这棵树进行剪枝,然后通过设定好的标准来衡量何时终止剪枝.这个标准就是题主截图中的公式:
    在这里插入图片描述
    在这个公式中,a可以认为是一个参数, 用来调节树的大小以及树与数据拟合好坏之间的权衡.这个值为0的话,就是初始的大树T0了. 这个值越大,树就越小,被剪去的枝枝叶叶就越多,而那个T是表示树的叶子节点的个数, +号后面的部分大概就可以理解了,可以认为是树的复杂度.

    在这里插入图片描述
    在这里插入图片描述
    上图中mce是指误分率,由于中间有个折点(在0.5的位置), 导致了其不可分.而熵则是平滑的曲线。

    展开全文
  • 机器学习的概念

    2018-08-22 10:13:35
    决策:怎么选择最优的模型,即评估模型的好坏,这时候要用到损失函数,即真实值与训练结果的误差尽可能小。平方损失函数 算法:就是,求解未知的方法。偏导。 认真想一下,任何的模型,度离不开上述所讲。  ...

    学数据分析的,机器学习常挂在嘴边。机器学习是什么?模型?不是,不是。看完李航大师的统计学习方法,机器学习可能就是:模型、决策、算法。

    举例子:

    模型:线性回归

    决策:怎么选择最优的模型,即评估模型的好坏,这时候要用到损失函数,即真实值与训练结果的误差尽可能小。平方损失函数

    算法:就是,求解未知数的方法。求偏导。

    认真想一下,任何的模型,度离不开上述所讲。

     

    展开全文
  • 切换机器或寻求帮助时请注意这一点。 您的提交将在同一台计算机上评分,因此,只要您的实现对其他所有内容都是正确的,这些值就将保持一致。 对于所有标记(线性,二次和双精度ÿ...
  • 我在看机器学习实战时对其中的代码非常费解,说好的利用偏导数求最值怎么代码中没有体现啊,就一个简单的式子:θ= θ-αΣ [( hθ(x(i))-y(i)) ] * xi 。经过查找资料才知道,书中省去了大量的理论推导过程,其中...

    声明:本篇博文是学习《机器学习实战》一书的方式路程,系原创,若转载请标明来源。

    1 Logistic 回归算法的原理

    1.1 需要的数学基础

    我在看机器学习实战时对其中的代码非常费解,说好的利用偏导数求最值怎么代码中没有体现啊,就一个简单的式子:θ= θ - α Σ [( hθ(x(i))-y(i) ) ] * xi 。经过查找资料才知道,书中省去了大量的理论推导过程,其中用到了线性函数、sigmoid 函数、偏导数、最大似然函数、梯度下降法。下面让我们一窥究竟,是站在大神的肩膀描述我自己的见解。

    1.2 Logistic 回归的引入

    Logistic 回归是概率非线性模型,用于处理二元分类结果,名为回归实为分类。下面给出一个二元分类的例子,如下图所示:

    图中数据分成两类,打叉的一类用 y = 1 表示,另一类为圆圈用 y= 0 表示。现在我们要对数据进行分类,要找到一个分类函数(边界线),我们很容易得出一个线性函数对其分类:0 = θ0 + θ1x1 + θ2x2 。但我们想要的函数应该是,能接受所有的输入然后预测类别。例如:在两个分类的情况下,函数输出 0 或 1。因此,我们就需要引入Sigmoid 函数,这个函数的性质可以满足要求。Sigmoid 函数:

    Sigmoid 函数的值域为(0,1),且具有良好的从0 到 1 的跳跃性,如在两个不同的坐标尺度下的函数图形:

    所以,我们把线性方程和Sigmoid 函数结合起来就能解决问题。即 :分类预测函数 hθ (x) = g( θ0 + θ1x1 + θ2x2) .我们就可以对样本数据进行分类,如下图所示:

     

    对于线性的分类边界,如下形式:

    分类预测函数,如下形式:

    其中,θ是向量 θ (θ0, θ1,... ,θn) 的转置,向量 x ( x, x1 ,... , xn),n -1为数据的维度,x0 =1,这是便于计算。

     1.3 分类预测函数问题的转化成求θ

     通过上面的分析,我们得出了分类预测函数 hθ(x) , 但其中向量 x 是已知的(x 是未知类别号的对象数据),向量 θ 未知,即我们把求分类函数问题转化成求向量 θ 。因为Sigmoid 函数的取值区间(0,1),那我们可以看做概率 P(y = 1 | xi ; θ)= hθ(x) , 表示在 xi 确定的情况下,类别 y = 1 的概率。由此,我们也可以得出在 xi 确定的情况下,类别 y = 0 的概率  P(y = 0 | xi ; θ)= 1 -  P(y = 1 | xi ; θ)= 1 - hθ(x) . 即 :

    我们可以将这两个式子合并得:

    其中的 y = 0 或 1 .

    这时候我们可以利用最大似然函数对向量 θ 求值,可以理解为选取的样本数据的概率是最大的,那么样本数为 m 的似然函数为:

    通过对数的形式对似然函数进行变化,对数似然函数:

     

     这里的最大似然函数的值就是我们所要求的向量 θ , 而求解的方法利用梯度下降法。

    1.4 梯度下降法求解θ

     在用梯度下降法时,我们将会利用Sigmoid 函数的一个性质: g(z) = g(z)[ 1- g(z) ]

    构造一个Cost函数(损失函数),该函数表示预测的输出(h)与训练数据类别(y)之间的偏差,可以是二者之间的差(h-y)或者是其他的形式。综合考虑所有训练数据的“损失”,将Cost求和或者求平均,记为J(θ)函数,表示所有训练数据预测值与实际类别的偏差。

    损失函数:

     

    J(θ)代价函数:

     

    其中,x(i) 每个样本数据点在某一个特征上的值,即特征向量x的某个值,y(i) 是类别号,m 是样本对象个数。

    梯度下降法含义:

    梯度下降法,就是利用负梯度方向来决定每次迭代的新的搜索方向,使得每次迭代能使待优化的目标函数逐步减小。梯度其实就是函数的偏导数。

    这里对用梯度下降法对 J (θ) 求最小值,与求似然函数的最大值是一样的。则 J(θ) 最小值的求解过程:

    其中 α 是步长。

    则可以得出:

    因为 α 是个常量,所以一般情况可以把 1/m 省去,省去不是没有用1/m ,只是看成 α 和1/m 合并成 α 。

    最终式子为:

    这就是一开始,我对代码中公式困惑的地方。在这里我在补充一点,以上的梯度下降法可以认为是批量梯度下降法(Batch Gradient Descent),由于我们有m个样本,这里求梯度的时候就用了所有m个样本的梯度数据。下面介绍随机梯度下降法(Stochastic Gradient Descent):

     随机梯度下降法,其实和批量梯度下降法原理类似,区别在与求梯度时没有用所有的m个样本的数据,而是仅仅选取一个样本j来求梯度。随机梯度下降法,和4.1的批量梯度下降法是两个极端,一个采用所有数据来梯度下降,一个用一个样本来梯度下降。自然各自的优缺点都非常突出。对于训练速度来说,随机梯度下降法由于每次仅仅采用一个样本来迭代,训练速度很快,而批量梯度下降法在样本量很大的时候,训练速度不能让人满意。对于准确度来说,随机梯度下降法用于仅仅用一个样本决定梯度方向,导致解很有可能不是最优。对于收敛速度来说,由于随机梯度下降法一次迭代一个样本,导致迭代方向变化很大,不能很快的收敛到局部最优解。公式为:

    到这里已经把Logistics 回归的原理推导完成。这里对以上推导做一次总结:

     边界线 ——> Sigmoid 函数 ——>求向量 θ ——> P(y=1 | x ; θ) = hθ(x) —— > 似然函数 l (θ) ——> 代价函数 J (θ) ——> 梯度下降法求解向量 θ ——> 最终公式 θj

     2 使用python 实现Logistic 回归

    2.1 Logistic 回归梯度上升优化算法

    2.1.1 收集数据和处理数据

    1 # 从文件中提取数据
    2 def loadDataSet():
    3     dataMat = [] ; labelMat = []
    4     fr = open('testSet.txt')
    5     for line in fr.readlines(): # 对文件的数据进行按行遍历
    6         lineArr  = line.strip().split()
    7         dataMat.append([1.0, float(lineArr [0]), float(lineArr[1])])
    8         labelMat.append(int(lineArr[2])) # 数据的类别号列表
    9     return dataMat , labelMat

    2.1.2 Sigmoid 函数

    1 # 定义sigmoid 函数
    2 def sigmoid(inX):
    3     return longfloat( 1.0 / (1 + exp(-inX)))

    使用longfloat() 是为防止溢出。 

     2.1.3 批量梯度上升算法的实现

     1 # Logistic 回归梯度上升优化算法
     2 def gradAscent(dataMatIn, classLabels):
     3     dataMatrix = mat(dataMatIn) # 将数列转化成矩阵
     4     labelMat = mat(classLabels).transpose() # 将类标号转化成矩阵并转置成列向量
     5     m,n = shape(dataMatrix) # 获得矩阵dataMatrix 的行、列数
     6     alpha = 0.001 # 向目标移动的步长
     7     maxCycles = 500 # 迭代次数
     8     weights = ones((n ,1)) # 生成 n 行 1 列的 矩阵且值为1
     9     for k in range(maxCycles):
    10         h = sigmoid(dataMatrix*weights) # dataMatrix*weights 是 m * 1 的矩阵,其每一个元素都会调用sigmoid()函数,h 也是一个 m * 1 的矩阵
    11         error = (labelMat - h) # 损失函数
    12         weights = weights + alpha + dataMatrix.transpose()* error # 每步 weights 该变量
    13     return weights.getA()

    解释第 13 行代码:矩阵通过这个getA()这个方法可以将自身返回成一个n维数组对象 ,因为plotBestFit()函数中有计算散点x,y坐标的部分,其中计算y的时候用到了weights,如果weights是矩阵的话,weights[1]就是[0.48007329](注意这里有中括号!),就不是一个数了,最终你会发现y的计算结果的len()只有1,而x的len()则是60。

    2.2 根据批量梯度上升法分析数据:画出决策边界

     1 # 对数据分类的边界图形显示
     2 def plotBestFit(weights):
     3     import matplotlib.pyplot as plt
     4     dataMat,labelMat=loadDataSet()
     5     dataArr = array(dataMat)
     6     n = shape(dataArr)[0] # 数据的行数,即对象的个数
     7     xcord1 = []; ycord1 = [] # 对类别号为 1 的对象,分 X 轴和 Y 轴的数据
     8     xcord2 = []; ycord2 = [] # 对类别号为 0 的对象,分 X 轴和 Y 轴的数据
     9     for i in range(n): # 对所有的对象进行遍历
    10         if int(labelMat[i])== 1:  # 对象的类别为:1
    11             xcord1.append(dataArr[i,1]); ycord1.append(dataArr[i,2])
    12         else:
    13             xcord2.append(dataArr[i,1]); ycord2.append(dataArr[i,2])
    14     fig = plt.figure()
    15     ax = fig.add_subplot(111)
    16     ax.scatter(xcord1, ycord1, s=30, c='red', marker='s') # 对散点的格式的设置,坐标号、点的大小、颜色、点的图形(方块)
    17     ax.scatter(xcord2, ycord2, s=30, c='green') # 点的图形默认为圆
    18     x = arange(-3.0, 3.0, 0.1)
    19     y = (-weights[0]-weights[1]*x)/weights[2] # 线性方程 y = aX + b,y 是数据第三列的特征,X 是数据第二列的特征
    20     ax.plot(x, y)
    21     plt.xlabel('X1'); plt.ylabel('X2')
    22     plt.show()

    运行结果:

    有结果效果图可知,边界线基本可以对样本进行较好的分类。

    2.3 利用随机梯度上升法训练样本

     

     1 # 随机梯度上升法
     2 def stocGradAscent0(dataMatrix, classLabels, numIter=150):
     3     m,n = shape(dataMatrix )
     4     weights = ones(n)
     5     for j in range(numIter): # 迭代次数
     6         dataIndex = range(m) #
     7         for i in range(m): # 对所有对象的遍历
     8             alpha = 4/(1.0+j+i)+0.01  # 对步长的调整
     9             randIndex = int (random.uniform(0,len(dataIndex))) # 随机生成一个整数,介于 0 到 m
    10             h = sigmoid(sum(dataMatrix[randIndex]*weights)) # 对随机选择的对象计算类别的数值(回归系数值)
    11             error = classLabels[randIndex] - h # 根据实际类型与计算类型值的误差,损失函数
    12             weights = weights + alpha * error * dataMatrix[randIndex]  # 每步 weights 改变值
    13             del(dataIndex [randIndex]) # 去除已经选择过的对象,避免下次选中
    14     return weights

    在随机梯度上升法求解的 θ ,对样本进行分类,并画出其边界线,运行的结果图:

    利用随机梯度上升法,通过150 次迭代得出的效果图和批量梯度上升法的效果图差不过,但随机梯度的效率比批量梯度上升法快很多。

     3 实例:从疝气病症预测病马的死亡率

     3.1 未知对象的预测

    1 # 对未知对象进行预测类别号
    2 def classifyVector(inX , weights):
    3     prob = sigmoid(sum(inX * weights)) # 计算回归系数
    4     if prob > 0.5:
    5         return 1.0
    6     else:
    7         return 0.0

    3.2 样本数据和测试函数

     

     1 # 实例:从疝气病预测病马的死亡率
     2 def colicTest():
     3     frTrain = open('horseColicTraining.txt'); frTest = open('horseColicTest.txt')# 数据文件
     4     trainingSet = []; trainingLabels = [] # 样本集和类标号集的初始化
     5     for line in frTrain.readlines():
     6         currLine = line.strip().split('\t') # 根据制表符进行字符串的分割
     7         lineArr =[]
     8         for i in range(21):
     9             lineArr.append(float(currLine[i]))
    10         trainingSet.append(lineArr)
    11         trainingLabels.append(float(currLine[21]))
    12     #trainWeights = stocGradAscent0(array(trainingSet), trainingLabels, 500) # 通过对训练样本计算出回归系数
    13     trainWeights = gradAscent(array(trainingSet), trainingLabels)   # 通过对训练样本计算出回归系数
    14     errorCount = 0; numTestVec = 0.0 # 错误个数和错误率的初始化
    15     # 预测样本的遍历
    16     for line in frTest.readlines():
    17         numTestVec += 1.0
    18         currLine = line.strip().split('\t')
    19         lineArr =[]
    20         for i in range(21):
    21             lineArr.append(float(currLine[i]))
    22         if int(classifyVector(array(lineArr), trainWeights))!= int(currLine[21]): # 预测的类别号与真实类别号的比较
    23             errorCount += 1
    24     errorRate = (float(errorCount)/numTestVec)
    25     print u'本次测试的错误率是; %f' % errorRate
    26     return errorRate

    3.3 预测结果函数

    1 # 预测结果函数
    2 def multiTest():
    3     numTests = 10; errorSum = 0.0
    4     for k in range(numTests):
    5         errorSum += colicTest()
    6     print u'经过 %d 次测试结果的平均错误率是: %f ' % (numTests ,errorSum /float(numTests))

    利用随机梯度上升法训练的样本集,测试结果:

    利用批量梯度上升法训练的样本集,测试结果:

    附 完整程序

      1 # coding:utf-8
      2 from numpy import *
      3 
      4 # 从文件中提取数据
      5 def loadDataSet():
      6     dataMat = [] ; labelMat = []
      7     fr = open('testSet.txt')
      8     for line in fr.readlines(): # 对文件的数据进行按行遍历
      9         lineArr  = line.strip().split()
     10         dataMat.append([1.0, float(lineArr [0]), float(lineArr[1])])
     11         labelMat.append(int(lineArr[2])) # 数据的类别号列表
     12     return dataMat , labelMat
     13 
     14 # 定义sigmoid 函数
     15 def sigmoid(inX):
     16     return longfloat( 1.0 / (1 + exp(-inX)))
     17 
     18 # Logistic 回归批量梯度上升优化算法
     19 def gradAscent(dataMatIn, classLabels):
     20     dataMatrix = mat(dataMatIn) # 将数列转化成矩阵
     21     labelMat = mat(classLabels).transpose() # 将类标号转化成矩阵并转置成列向量
     22     m,n = shape(dataMatrix) # 获得矩阵dataMatrix 的行、列数
     23     alpha = 0.001 # 向目标移动的步长
     24     maxCycles = 500 # 迭代次数
     25     weights = ones((n ,1)) # 生成 n 行 1 列的 矩阵且值为1
     26     for k in range(maxCycles):
     27         h = sigmoid(dataMatrix*weights) # dataMatrix*weights 是 m * 1 的矩阵,其每一个元素都会调用sigmoid()函数,h 也是一个 m * 1 的矩阵
     28         error = (labelMat - h) # 损失函数
     29         weights = weights + alpha + dataMatrix.transpose()* error # 每步 weights 该变量
     30     return weights.getA()
     31 
     32 # 对数据分类的边界图形显示
     33 def plotBestFit(weights):
     34     import matplotlib.pyplot as plt
     35     dataMat,labelMat=loadDataSet()
     36     dataArr = array(dataMat)
     37     n = shape(dataArr)[0] # 数据的行数,即对象的个数
     38     xcord1 = []; ycord1 = [] # 对类别号为 1 的对象,分 X 轴和 Y 轴的数据
     39     xcord2 = []; ycord2 = [] # 对类别号为 0 的对象,分 X 轴和 Y 轴的数据
     40     for i in range(n): # 对所有的对象进行遍历
     41         if int(labelMat[i])== 1:  # 对象的类别为:1
     42             xcord1.append(dataArr[i,1]); ycord1.append(dataArr[i,2])
     43         else:
     44             xcord2.append(dataArr[i,1]); ycord2.append(dataArr[i,2])
     45     fig = plt.figure()
     46     ax = fig.add_subplot(111)
     47     ax.scatter(xcord1, ycord1, s=30, c='red', marker='s') # 对散点的格式的设置,坐标号、点的大小、颜色、点的图形(方块)
     48     ax.scatter(xcord2, ycord2, s=30, c='green') # 点的图形默认为圆
     49     x = arange(-3.0, 3.0, 0.1)
     50     y = (-weights[0]-weights[1]*x)/weights[2] # 线性方程 y = aX + b,y 是数据第三列的特征,X 是数据第二列的特征
     51     ax.plot(x, y)
     52     plt.xlabel('X1'); plt.ylabel('X2')
     53     plt.show()
     54 
     55 # 随机梯度上升法
     56 def stocGradAscent0(dataMatrix, classLabels, numIter=150):
     57     m,n = shape(dataMatrix )
     58     weights = ones(n)
     59     for j in range(numIter): # 迭代次数
     60         dataIndex = range(m) #
     61         for i in range(m): # 对所有对象的遍历
     62             alpha = 4/(1.0+j+i)+0.01  # 对步长的调整
     63             randIndex = int (random.uniform(0,len(dataIndex))) # 随机生成一个整数,介于 0 到 m
     64             h = sigmoid(sum(dataMatrix[randIndex]*weights)) # 对随机选择的对象计算类别的数值(回归系数值)
     65             error = classLabels[randIndex] - h # 根据实际类型与计算类型值的误差,损失函数
     66             weights = weights + alpha * error * dataMatrix[randIndex]  # 每步 weights 改变值
     67             del(dataIndex [randIndex]) # 去除已经选择过的对象,避免下次选中
     68     return weights
     69 
     70 # 对未知对象进行预测类别号
     71 def classifyVector(inX , weights):
     72     prob = sigmoid(sum(inX * weights)) # 计算回归系数
     73     if prob > 0.5:
     74         return 1.0
     75     else:
     76         return 0.0
     77 
     78 # 实例:从疝气病预测病马的死亡率
     79 def colicTest():
     80     frTrain = open('horseColicTraining.txt'); frTest = open('horseColicTest.txt')# 数据文件
     81     trainingSet = []; trainingLabels = [] # 样本集和类标号集的初始化
     82     for line in frTrain.readlines():
     83         currLine = line.strip().split('\t') # 根据制表符进行字符串的分割
     84         lineArr =[]
     85         for i in range(21):
     86             lineArr.append(float(currLine[i]))
     87         trainingSet.append(lineArr)
     88         trainingLabels.append(float(currLine[21]))
     89     trainWeights = stocGradAscent0(array(trainingSet), trainingLabels, 500) # 通过随机梯度上升法计算回归系数
     90     #trainWeights = gradAscent(array(trainingSet), trainingLabels)   # 通过批量梯度上升法计算出回归系数
     91     errorCount = 0; numTestVec = 0.0 # 错误个数和错误率的初始化
     92     # 预测样本的遍历
     93     for line in frTest.readlines():
     94         numTestVec += 1.0
     95         currLine = line.strip().split('\t')
     96         lineArr =[]
     97         for i in range(21):
     98             lineArr.append(float(currLine[i]))
     99         if int(classifyVector(array(lineArr), trainWeights))!= int(currLine[21]): # 预测的类别号与真实类别号的比较
    100             errorCount += 1
    101     errorRate = (float(errorCount)/numTestVec)
    102     print u'本次测试的错误率是; %f' % errorRate
    103     return errorRate
    104 
    105 # 预测结果函数
    106 def multiTest():
    107     numTests = 10; errorSum = 0.0
    108     for k in range(numTests):
    109         errorSum += colicTest()
    110     print u'经过 %d 次测试结果的平均错误率是: %f ' % (numTests ,errorSum /float(numTests))
    111 
    112 if __name__ == '__main__':
    113   # 用批量梯度上升法画边界线
    114     '''
    115     dataSet, labelSet = loadDataSet()
    116     #weights = gradAscent(dataSet, labelSet)
    117     #plotBestFit(weights)
    118     '''
    119     # 用随机梯度上升法画边界线
    120     '''
    121      dataSet, labelSet = loadDataSet()
    122     #weightss = stocGradAscent0(array(dataSet), labelSet )
    123     #plotBestFit(weightss)
    124    '''
    125    # 实例的预测
    126     multiTest()
    View Code

     

    转载于:https://www.cnblogs.com/pursued-deer/p/7819539.html

    展开全文
  • 代价函数我们之前已经知道怎么求了,现在只需要求代价函数的偏导即可。 采用如下方法,先进行前向传播算法,然后再进行反向传播算法(Backpropagation Algorithm),反向传播算法与前向传播算法方向相反,它...
  • 困惑解答,为了减法运算,机器中都用补码表示了,那为什么还用减法的指令。 如此题:SUB AL,BL.AL=80H,BL=80H。在机器中是怎么算的?直接减还是再变成补码然后算加法。 溢出标志和进位标志是什么?
  • 当我们要运用高级算法进行梯度下降时,需要计算两个值,代价函数和代价函数的偏导:代价函数我们之前已经知道怎么求了,现在只需要求代价函数的偏导即可。采用如下方法,先进行前向传播算法,然后再进行反向传播...
  • 1. 决策树怎么做回归 让所有节点平均值。 2. 熵、联合熵、条件熵、交叉熵、KL散度(相对熵),信息增益,互信息,信息增益率的计算 简介: 熵用于衡量不确定性,所以均分的时候熵最大 KL散度用于度量两个...
  • 机器学习(三)线性回归模型、广义线性回归模型、非线性回归模型   线性回归(数据集要满足正态...那我们怎么求呢?在这之前大家先要了解一些偏导的知识 为了方便大家理解,举一个通俗易懂的例子   多元...
  • 第一次面试一面就直接挂了。。写个总结。 面试问题: ...(1)模型算法相关 (2)AUC法(roc曲线怎么画的) 总结: 1.简历上的项目一定要写的多一点。我写的太少面试官没东西问了。。 2.数据结构特...
  • a在用梯度下降法训练模型的时候,有时候我们要在训练前大概了解一下参数,那么怎么进行调试呢。Bobo老师分享了一种方法,我分享给大家。  1、主要思想 这种思想主要是根据导数的定义,其实梯度就是多元导数对单个...
  • 答: 随着网络层变深, activations倾向于越大和越小的方向前进, 往大走梯度爆炸(回想一下你在梯度时, 每反向传播一层, 都要乘以这一层的activations), 往小走进入死区, 梯度消失。 这两个问题最大的...
  • 机器学习算法对于数据分析的应用理解 sql题,就是说了说,但是自己答的太差了 个人项目的问题,基本就是细节处理 AB test 随机森林,kmeans 怎么判断模型效果 大数定理相关的 携程 自我介绍 SQL - 分层、...
  • ![图片说明]... 解释,hex与hex Integer的区别??还有如何透过内存窗口看机器代码?是从左到右还是从右到左(那串16进制的),还是要看大端和小端???
  • 怎么求第k大的数字呢? 先猜一个guess,然后统计与这个相等的数字的个数记为same,小于这个的个数记为smaller 然后调整guess,直到 smaller < k and smaller+same >= k 具体点说,先猜一个guess,然后让10台...
  • hdu4864 Task(贪心)

    2018-07-20 16:26:54
    每个机器也有两个值最大工作时间x1和最大工作难度y1, 机器可以胜任某个工作的条件是:机器在时间上和难度上均大于任务,机器胜任一个工作可以拿到x*500+2*y的钱,现在问你怎么匹配才能使匹配最大且钱最多。...
  • 接下来的n行每行2*p+1个,第一个机器工作的效率,其余代表机器加工前和后电脑的变化,求机器一起工作的最大效率,并输出路径。 思路:由于源点的流入和普通链接点的流入,可能会大于当前点的容量,因此拆点....
  • 核桃的数量练习

    2018-02-20 18:38:08
    开始看到题目想了好久怎么求最小公倍数,刚开始想用穷举法,发现是不可行的。后来想到自己求最小公倍数的时候一般是把两个数字相乘再来看有没有更小的,但是人思考和机器思考的方式真的不一样,当分太多情况的时候...
  • 第十九题 3-17简单循环 模拟除法 2个正整数相除所得小数结果的小数点...模拟就是模仿着人怎么计算除法,机器怎么计算除法 想想自己,是不是可以将除法计算到小数点后任意位 那我们就从人怎么计算除法开始研究 这里
  • 软考--原码、补码、反码

    热门讨论 2016-10-16 15:58:49
     数值在计算机中表示形式为机器数,计算机只能识别0和1,使用的是二进制,而在日常生活中使用的是10进制,并且我们用的数值有正负之分,所以在计算机中就用一个数的最高位存放符号(0为正,1为负)。这就是原码 ...
  • 中文编程思想(续)

    2017-06-08 15:23:42
    前面我提到这样一个设想:输入... 那么就需要把这句话让机器正确的拆分成:输入/整数/a/和/b/,//两个/最大值。  我一直在想怎么正确拆分和组合呢,终于想起来编译原理有词法分析和语法分析,应该可以拿来用。
  • 【数学基础】矩阵的特征向量、特征值及其含义

    万次阅读 多人点赞 2018-08-31 11:37:08
    在线代课上,老师会教我们怎么求矩阵的特征值与特征向量。但是并不会讲特征值与特征向量到底有着什么样的几何意义或者物理意义,或许讲了但也比较模糊。矩阵的特征值与特征向量在各种机器学习算法与应用场景中都有...
  • 刚开始的时候不知道怎么建图,原先想的是把任务和机器的mode[0,n+m)进行连接,(因为任务要全部完成)。但是发现这样不对啊,题目的是最小的任务。如果这样建图,根本不出来。后来看到题解说是一边是A,一边是...
  • N个的全排列 8皇后问题 分而治之(减而治之) 二分查找——减而治之 归并排序——分而治之 贪心 最小生成树 Prim, Kruskal 单源最短路 Dijkstra 动态规划 背包 士兵路径 三、时间、空间复杂度 常见时间...
  • 第9章 逻辑回归

    2020-03-28 13:22:00
    对于机器学习算法来说,本质就是出一个函数小f,如果此时有一个样本x,经过f的运算之后就会得到一个预测值,通常称之为y。y的值实际上就是本身我们关心的那个指标。但是在逻辑回归中,我们得到的y的值本质是一个...
  • 今天看了RF,发现里面有一个1/3的概率,到底怎么求出来的,我看了,推了一下公式。 模型评估方法 在机器学习中,通常把样本分成训练集和测试集,在划分样本的过程中,存在着不同的抽样方法。 有哪些抽样方法,他们...
  • BZOJ 2104 K-th Number

    2015-08-29 16:20:48
    区间内第k小的。 解题思路: 据说是主席树裸题,也可以用归并树划分树来搞。 然而我这么弱怎么可能会呢…… 算了算复杂度和POJ的机器速度,YY了半天,写个模拟,卡时过了。 #include struct node{...
  • 2.2.5 写一个程序, 要求功能:出用1,2,5这三个不同个组合的和为100的组合个 2.2.6 实现一个函数,把一个字符串中的字符从小写转为大写 2.2.7 随机输入一个,判断它是不是对称(回文)(如3,121,...

空空如也

空空如也

1 2 3 4
收藏数 62
精华内容 24
关键字:

机器数怎么求