精华内容
下载资源
问答
  • 实验结果证明,与现有对数强度微分标准偏差算法(DSDLI)相比,本文算法能够更好地恢复出血流图像信息,在重建图像中可以明显看到原算法的处理结果中看不出血流细节,更有利于光学相干层析术(OCT)系统在癌症、糖尿病、...
  • 提出了一种用于数字通信接受端TED(Timing Error Detector)模块的算法,它是基于已被广泛使用的Gardner...仿真表明,按照以最佳采样点附近Gardner表达式的斜率代表精确度这个标准,改进后的算法提高精确度30%~93%。
  • 减轻数据集和模型偏差的算法。 它旨在将实验室的算法研究转化为金融,人力资本管理,医疗保健和教育等广泛领域的实际实践。 我们邀请您使用它并进行改进。 对概念和功能进行了简要介绍。 这些提供了更深入的,面向...
  • 回归算法偏差方差平衡 一、标准线性回归 标准回归函数和数据导入函数 from numpy import * def loadDataSet(fileName): numFeat = len(open(fileName).readline().split('\t')) - 1 dataMat...

    前言:
    本篇文章基于《机器学习实战》第八章回归部分,加上了自己的理解。

    回归算法与偏差方差的平衡

    一、标准线性回归

    标准回归函数和数据导入函数

    from numpy import *
    def loadDataSet(fileName):
        numFeat = len(open(fileName).readline().split('\t')) - 1
        dataMat = [];labelMat = []
        fr = open(fileName)
        for line in fr.readlines():
            lineArr = []
            curLine = line.strip().split('\t')
            for i in range(numFeat):
                lineArr.append(float(curLine[i]))
            dataMat.append(lineArr)
            labelMat.append(float(curLine[-1]))
        return dataMat,labelMat
    
    def standRegres(xArr,yArr):
        xMat = mat(xArr);yMat = mat(yArr).T
        xTx = xMat.T*xMat
        #numpy.linalg.det()  计算方阵行列值
        if linalg.det(xTx) == 0.0:
            print('This matrix is singular,cannot do inverse')
            return
        ws = xTx.I * (xMat.T*yMat)  #回归系数
        return ws

    测试

    xArr,yArr = loadDataSet("E:\\DataMining\\资料\\machinelearninginaction\\Ch08\\ex0.txt")
    ws = standRegres(xArr,yArr)
    ws
    matrix([[3.00774324],
            [1.69532264]])
    

    开始拟合

    xMat = mat(xArr)
    yMat = mat(yArr)
    #拟合值,或叫预测值
    yHat = xMat*ws

    绘制拟合直线图

    import matplotlib.pyplot as plt
    fig = plt.figure()
    ax = fig.add_subplot(111)
    ax.scatter(xMat[:,1].flatten().A[0],yMat.T[:,0].flatten().A[0])
    xCopy = xMat.copy()
    xCopy.sort(0)
    yHat = xCopy*ws
    ax.plot(xCopy[:,1],yHat)
    plt.show()

    这里写图片描述

    计算两个序列的相关系数,评价模型的好坏

    #numpy 的corrcoef()
    yHat = xMat*ws
    corrcoef(yHat.T,yMat)
    array([[1.        , 0.98647356],
           [0.98647356, 1.        ]])
    

    解释:对角线1.0,表明yHat,yMat与自身的匹配是最完美的,而yHat,yMat之间的相关系数为0.986

    二、局部加权线性回归

    def lwlr(testPoint,xArr,yArr,k=1.0):
        xMat = mat(xArr);yMat = mat(yArr).T
        m = shape(xMat)[0]
        #eye(m,n,k) 生成对角矩阵;m,n代表行列,只写一个默认m=n;k代表对角向上或向下移动多少(不一定主对角)
        weights = mat(eye((m)))
        #确定权值大小
        for j in range(m):
            diffMat = testPoint - xMat[j,:]
            weights[j,j] = exp(diffMat*diffMat.T/(-2.0*k**2))
        xTx = xMat.T * (weights * xMat)
        if linalg.det(xTx) == 0.0:
            print('This matrix is singular,cannot do inverse')
            return
        #matrix.I  逆矩阵inverse
        ws = xTx.I * (xMat.T * (weights * yMat))
        return testPoint * ws
    
    def lwlrTest(testArr,xArr,yArr,k=1.0):
        '''
        此函数既做训练拟合用,也做测试用
        为每个样本点调用lwlr()
        返回预测结果
        '''
        m = shape(testArr)[0]
        yHat = zeros(m)
        for i in range(m):
            yHat[i] = lwlr(testArr[i],xArr,yArr,k)
        return yHat
    

    测试

    yArr[0]
    3.176513
    
    lwlr(xArr[0],xArr,yArr,1.0)
    matrix([[3.12204471]])
    
    lwlr(xArr[0],xArr,yArr,0.001)
    matrix([[3.20175729]])
    
    #整个数据集
    yHat = lwlrTest(xArr,xArr,yArr,0.01)
    #排序
    xMat = mat(xArr)
    srtInd = xMat[:,1].argsort(0)
    xSort = xMat[srtInd][:,0,:]
    #绘制
    fig = plt.figure()
    ax = fig.add_subplot(111)
    ax.plot(xSort[:,1],yHat[srtInd])   #划线
    ax.scatter(xMat[:,1].flatten().A[0],mat(yArr).T.flatten().A[0],s=2,c='red')   #画点
    plt.show()

    这里写图片描述

    解释:调整k值,当k=1.0时就是标准的线性回归,忽略了太多细节,属于欠拟合当k= 0.003时可以看到他过分的考虑了噪声,曲线局部会“突陡”,属与过拟合。

    三、预测鲍鱼的年龄

    分析预测误差函数

    def rssError(yArr,yHatArr):
        return ((yArr-yHatArr)**2).sum()
    #导入数据
    abX,abY = loadDataSet('E:\\DataMining\\资料\\machinelearninginaction\\Ch08\\abalone.txt')
    #训练三种模型(拟合三条回归线)
    yHat01 = lwlrTest(abX[0:99],abX[0:99],abY[0:99],0.1)
    yHat1 = lwlrTest(abX[0:99],abX[0:99],abY[0:99],1)
    yHat10 = lwlrTest(abX[0:99],abX[0:99],abY[0:99],10)

    分析预测误差的大小

    rssError(abY[0:99],yHat01.T)
    56.78420911837208
    
    rssError(abY[0:99],yHat1.T)
    429.89056187030394
    
    rssError(abY[0:99],yHat10.T)
    549.1181708826065
    

    解释:由上面可以看出核越小(k值越小),训练误差越低

    现在看看对于新数据模型效果如何

    yHat01 = lwlrTest(abX[100:199],abX[0:99],abY[0:99],0.1)
    rssError(abY[100:199],yHat01.T)
    25119.459111157415
    
    yHat1 = lwlrTest(abX[100:199],abX[0:99],abY[0:99],1)
    rssError(abY[100:199],yHat1.T)
    573.5261441895706
    
    yHat10 = lwlrTest(abX[100:199],abX[0:99],abY[0:99],10)
    rssError(abY[100:199],yHat10.T)
    517.5711905381745
    

    解释:从上面可以看出核大小为10时测试误差最小,但是他在训练集上误差却是最大的

    四、几种通过缩减系数来“理解”数据的方法

    岭回归

    def ridgeRegres(xMat,yMat,lam=0.2):
        xTx = xMat.T*xMat
        denom = xTx + eye(shape(xMat)[1])*lam
        if linalg.det(denom) ==0.0:
            print('This matrix is singular,cannot do inverse')
            return
        ws = denom.I * (xMat.T*yMat)
        return ws
    
    def ridgeTest(xArr,yArr):
        xMat = mat(xArr);yMat = mat(yArr).T
        #数据标准化
        yMean = mean(yMat,0)
        yMat = yMat - yMean
        xMeans = mean(xMat,0)
        xVar = var(xMat,0)          #var()是求方差,std是标准差,cov是协方差
        xMat = (xMat - xMeans)/xVar
        numTestPts = 30
        wMat = zeros((numTestPts,shape(xMat)[1]))
        #在30个不同的lam下调用岭回归函数
        for i in range(numTestPts):
            ws = ridgeRegres(xMat,yMat,exp(i-10))
            wMat[i,:] = ws.T
        return wMat

    在鲍鱼年龄预测上的测试

    abX,abY = loadDataSet('E:\\DataMining\\资料\\machinelearninginaction\\Ch08\\abalone.txt')
    #得到30个不同lambda参对应得回归系数
    ridgeWs = ridgeTest(abX,abY)
    ridgeWs[:3]
    array([[ 0.04304419, -0.02274163,  0.13214088,  0.02075182,  2.22403745,
            -0.99895298, -0.11725424,  0.16622922],
           [ 0.04304419, -0.02274164,  0.13214088,  0.02075182,  2.22403626,
            -0.99895275, -0.11725417,  0.16622934],
           [ 0.04304419, -0.02274164,  0.13214088,  0.02075182,  2.22403305,
            -0.99895211, -0.117254  ,  0.16622966]])
    
    #画图
    fig = plt.figure()
    ax = fig.add_subplot(111)
    ax.plot(ridgeWs)
    plt.show()

    这里写图片描述

    解释:横坐标是log(lam),纵坐标是Ws的各元素值。在最左边lambda最小时,所有系数的原始值与线性回归一致,且可以通过观察各个W值判断哪些特征对结果预测最有影响力(观察他们对应系数大小);而在最右边,系数全缩减为0;可以在中间找到某个lambda值使预测效果最好,且能降低模型复杂度(即减少过拟合)。

    五、前向逐步回归

    def regularize(xMat):
        '''0均值标准化处理函数'''
        inMat = xMat.copy()
        inMeans = mean(inMat,0)   #压缩行,对各列求均值
        inVar = var(inMat,0)      #计算列方差
        inMat = (inMat - inMeans)/inVar
        return inMat
    def stageWise(xArr,yArr,eps=0.01,numIt=100):
        '''
        输入eps为步长
        '''
        yMat = mat(yArr).T;xMat = mat(xArr)
        #标准化处理
        #mean(yMat,axis)  对yMat求均值,返回一个数(均值),当axis=0时,表示对列求均值
        yMean = mean(yMat,0)     
        yMat = yMat - yMean
        xMat = regularize(xMat)
        m,n = shape(xMat)
        returnMat = zeros((numIt,n))
        ws = zeros((n,1));wsTest = ws.copy();wsMax = ws.copy()
        for i in range(numIt):
            print(ws.T)
            lowestError = inf    #numpy.inf  代表一个无穷大的正数
            #对每一个特征
            for j in range(n):
                for sign in [-1,1]:
                    wsTest = ws.copy()
                    wsTest[j] += eps*sign
                    yTest = xMat*wsTest
                    rssE = rssError(yMat.A,yTest.A)
                    if rssE < lowestError:
                        lowestError = rssE
                        wsMax = wsTest
            ws = wsMax.copy()
            returnMat[i,:] = ws.T
        return returnMat
    #关于mean()的用法
    a = array([[1,2,3],[2,3,4],[3,4,5],[4,5,6]])
    a = mat(a)
    print(a)
    print(mean(a))
    print(mean(a,0))
    print(mean(a,1))
    print(a - mean(a,0))
    [[1 2 3]
     [2 3 4]
     [3 4 5]
     [4 5 6]]
    3.5
    [[2.5 3.5 4.5]]
    [[2.]
     [3.]
     [4.]
     [5.]]
    [[-1.5 -1.5 -1.5]
     [-0.5 -0.5 -0.5]
     [ 0.5  0.5  0.5]
     [ 1.5  1.5  1.5]]
    
    stageWise(abX,abY,0.01,200)
    [[0. 0. 0. 0. 0. 0. 0. 0.]]
    [[0.   0.   0.   0.01 0.   0.   0.   0.  ]]
    [[0.   0.   0.   0.02 0.   0.   0.   0.  ]]
    [[0.   0.   0.   0.03 0.   0.   0.   0.  ]]
    [[0.   0.   0.   0.04 0.   0.   0.   0.  ]]
    [[0.   0.   0.   0.05 0.   0.   0.   0.  ]]
    [[0.   0.   0.   0.06 0.   0.   0.   0.  ]]
    [[0.   0.   0.01 0.06 0.   0.   0.   0.  ]]
          ...
    [[ 0.05  0.    0.09  0.03  0.31 -0.64  0.    0.36]]
    [[ 0.04  0.    0.09  0.03  0.31 -0.64  0.    0.36]]
    [[ 0.05  0.    0.09  0.03  0.31 -0.64  0.    0.36]]
    [[ 0.04  0.    0.09  0.03  0.31 -0.64  0.    0.36]]
    [[ 0.05  0.    0.09  0.03  0.31 -0.64  0.    0.36]]
    [[ 0.04  0.    0.09  0.03  0.31 -0.64  0.    0.36]]
    
    
    
    
    
    array([[ 0.  ,  0.  ,  0.  , ...,  0.  ,  0.  ,  0.  ],
           [ 0.  ,  0.  ,  0.  , ...,  0.  ,  0.  ,  0.  ],
           [ 0.  ,  0.  ,  0.  , ...,  0.  ,  0.  ,  0.  ],
           ...,
           [ 0.05,  0.  ,  0.09, ..., -0.64,  0.  ,  0.36],
           [ 0.04,  0.  ,  0.09, ..., -0.64,  0.  ,  0.36],
           [ 0.05,  0.  ,  0.09, ..., -0.64,  0.  ,  0.36]])
    

    解释:w1,w6都是0,表明对应得特征对目标值无影响

    #更小的步长
    stageWise(abX,abY,0.001,5000)
    [[0. 0. 0. 0. 0. 0. 0. 0.]]
    [[0.    0.    0.    0.001 0.    0.    0.    0.   ]]
    [[0.    0.    0.    0.002 0.    0.    0.    0.   ]]
    [[0.    0.    0.    0.003 0.    0.    0.    0.   ]]
    [[0.    0.    0.    0.004 0.    0.    0.    0.   ]]
    [[0.    0.    0.    0.005 0.    0.    0.    0.   ]]
          ...
    [[ 3.300e-02 -1.000e-03  1.120e-01  2.200e-02  1.535e+00 -8.660e-01
      -8.000e-02  2.370e-01]]
    [[ 0.033 -0.002  0.112  0.022  1.535 -0.866 -0.08   0.237]]
    [[ 0.033 -0.002  0.112  0.022  1.536 -0.866 -0.08   0.237]]
    [[ 0.033 -0.002  0.112  0.022  1.537 -0.866 -0.08   0.237]]
           ...
    [[ 0.044 -0.011  0.12   0.022  2.023 -0.963 -0.105  0.187]]
    [[ 0.043 -0.011  0.12   0.022  2.023 -0.963 -0.105  0.187]]
    [[ 0.044 -0.011  0.12   0.022  2.023 -0.963 -0.105  0.187]]
    [[ 0.043 -0.011  0.12   0.022  2.023 -0.963 -0.105  0.187]]
    [[ 0.044 -0.011  0.12   0.022  2.023 -0.963 -0.105  0.187]]
    [[ 0.043 -0.011  0.12   0.022  2.023 -0.963 -0.105  0.187]]
    [[ 0.044 -0.011  0.12   0.022  2.023 -0.963 -0.105  0.187]]
    [[ 0.043 -0.011  0.12   0.022  2.023 -0.963 -0.105  0.187]]
    [[ 0.044 -0.011  0.12   0.022  2.023 -0.963 -0.105  0.187]]
    [[ 0.043 -0.011  0.12   0.022  2.023 -0.963 -0.105  0.187]]
    [[ 0.044 -0.011  0.12   0.022  2.023 -0.963 -0.105  0.187]]
    
    
    
    
    
    array([[ 0.   ,  0.   ,  0.   , ...,  0.   ,  0.   ,  0.   ],
           [ 0.   ,  0.   ,  0.   , ...,  0.   ,  0.   ,  0.   ],
           [ 0.   ,  0.   ,  0.   , ...,  0.   ,  0.   ,  0.   ],
           ...,
           [ 0.043, -0.011,  0.12 , ..., -0.963, -0.105,  0.187],
           [ 0.044, -0.011,  0.12 , ..., -0.963, -0.105,  0.187],
           [ 0.043, -0.011,  0.12 , ..., -0.963, -0.105,  0.187]])
    

    解释:对于上面的结果,每一行都是一组回归系数,他们当中可能有几组都能够拟合的很好,但是有一些是过拟合的(过拟合就是模型复杂度太高,方差很大,不同的数据集训练出来的模型变化非常大),它的偏差低,但是方差高。我们要做的是找到最合适的,即偏差,方差折中的回归系数。

    六、选择模型预测——k折交叉验证

    既然又有偏差,又有方差,我们要找到最好的模型,使偏差尽可能小的同时,方差也不大(模型复杂度也不高)。主要有两种,一种
    是前面的缩减系数的方法(也叫正则化)。另一种就是运用K折交叉验证。

    def crossValidation(xArr,yArr,numVal=10):
        m = len(yArr)
        indexList = list(range(m))
        errorMat = zeros((numVal,30))
        for i in range(numVal):
            trainX = [];trainY=[]
            testX = [];testY = []
            #shuffle() 方法将序列的所有元素随机排序
            random.shuffle(indexList)
            #分为训练集和测试集
            for j in range(m):
                #90%为训练集
                if j < m*0.9:
                    trainX.append(xArr[indexList[j]])
                    trainY.append(yArr[indexList[j]])
                else:
                    testX.append(xArr[indexList[j]])
                    testY.append(xArr[indexList[j]])
        wMat = ridgeTest(trainX,trainY)
        for k in range(30):
            #标准化
            matTestX = mat(testX);matTrainX=mat(trainX)
            meanTrain = mean(matTrainX,0)
            varTrain = var(matTrainX,0)
            matTestX = (matTestX - meanTrain)/varTrain
            yEst = matTestX * mat(wMat[k,:]).T + mean(trainY)
            errorMat[i,k] = rssError(yEst.A,array(testY))
        meanErrors = mean(errorMat,0)
        minMean = float(min(meanErrors))
        bestWeights = wMat[nonzero(meanErrors == minMean)]
        xMat = mat(xArr);yMat = mat(yArr).T
        meanX = mean(xMat,0);varX = var(xMat,0)
        unReg = bestWeights/varX
        print('最好的岭回归模型是:{}'.format(unReg))
        print('with constant term:{}'.format(-1*sum(multiply(meanX,unReg)) + mean(yMat)))
    crossValidation(abX,abY,10)
    最好的岭回归模型是:[[-1.24947602e-04  6.47437528e-01  1.20796442e+00  1.41475398e+01
       9.05786597e-03  6.12189768e-02  7.27225909e-01  5.19096306e-01]]
    with constant term:6.8431037532961785
    
    展开全文
  • 偏差(bias):描述是预测值(估计值)期望与真实值之间差距。偏差越大,越偏离真实数据,如下图第二行所示。 方差(variance):描述是预测值变化范围,离散程度,也就是离其期望值距离。方差越大,...

    1 偏差与方差

    • 偏差(bias):描述的是预测值(估计值)的期望与真实值之间的差距。偏差越大,越偏离真实数据,如下图第二行所示。
    • 方差(variance):描述的是预测值的变化范围,离散程度,也就是离其期望值的距离。方差越大,数据的分布越分散,如下图右列所示。
      这里写图片描述
    • 方差公式
      这里写图片描述
      Var(x)
      =E((x−E(x))2)
      =E(x2−2xE(x)+(E(x))2)
      =E(x2)−2E(x)E(x)+(E(x))2
      =E(x2)−2(E(x))2+(E(x))2
      =E(x2)−(E(x))2
      其实两个公式是等价的
    • 样本方差公式:
      这里写图片描述
      式中:这里写图片描述是样本的均值

    • 标准差(就是方差的平方根)
      标准差公式:
      这里写图片描述
      样本标准差公式:
      这里写图片描述
      为什么使用标准差?
      与方差相比,使用标准差来表示数据点的离散程度有3个好处:

      • 表示离散程度的数字与样本数据点的数量级一致,更适合对数据样本形成感性认知。依然以上述10个点的CPU使用率数据为例,其方差约为41,而标准差则为6.4;两者相比较,标准差更适合人理解。
      • 表示离散程度的数字单位与样本数据的单位一致,更方便做后续的分析运算。
      • 在样本数据大致符合正态分布的情况下,标准差具有方便估算的特性:66.7%的数据点落在平均值前后1个标准差的范围内、95%的数据点落在平均值前后2个标准差的范围内,而99%的数据点将会落在平均值前后3个标准差的范围内。

    2 协方差和相关系数

    • 1先贴一个链接 = =
      https://www.zhihu.com/question/20852004

    • 2 协方差covariance

      • 定义

      • 两个随机变量的协方差被定义为:
        这里写图片描述
        Cov(x,y)=E( (x−E(x)) (y−E(y)) )
        Cov(x,y)=E( (x−E(x)) (y−E(y)) )
        因此方差是一种特殊的协方差。当x=y时:Cov(x,y)=Var(x)=Var(y)。

      • 直观理解
        协方差表示的是两个变量总体误差的方差,这与只表示一个变量误差的方差不同。  如果两个变量的变化趋势一致,也就是说如果其中一个大于自身的期望值,另外一个也大于自身的期望值,那么两个变量之间的协方差就是正值。 如果两个变量的变化趋势相反,即其中一个大于自身的期望值,另外一个却小于自身的期望值,那么两个变量之间的协方差就是负值
      • 协方差矩阵(必定是一个方阵)
        covariance matrix
    • 2 相关系数

      • 相关系数通过方差和协方差定义。两个随机变量的相关系数被定义为:
        这里写图片描述
        这里写图片描述
      • 性质

        • 1、有界性
          相关系数的取值范围为-1到1,其可以看成是无量纲的协方差。
        • 2、统计意义
          值越接近1,说明两个变量正相关性(线性)越强,越接近-1,说明负相关性越强,当为0时表示两个变量没有相关性。

    3 PCA主元分析法

    4 DataFrame实现

    https://blog.csdn.net/u011707148/article/details/76973946
    主要是 DataFrame.corr()和DataFrame.corrwith()两个函数

    展开全文
  • 此时如果直接数误分类数的话,那么一个每次都预测人没有癌症的算法也是性能优异的。 此时,我们需要引入一对新的判别标准:Precision/Recall来进行算法的性能评判,它们的定义如下: 可以看出,Precision表示:...

    当我们对某些问题进行分类时,真实结果的分布会有明显偏差。

    例如对是否患癌症进行分类,testing set 中可能只有0.5%的人患了癌症。

    此时如果直接数误分类数的话,那么一个每次都预测人没有癌症的算法也是性能优异的。

    此时,我们需要引入一对新的判别标准:Precision/Recall来进行算法的性能评判,它们的定义如下:

    可以看出,Precision表示:预测一件事件发生,它实际发生的概率是多少。换言之:预测准的概率如何。

    Recall表示:一件事情实际发生了,能把它预测出来的概率是多少。换言之:预测漏的程度怎么样。

    通过使用这两个标准,在测试集分布严重不均与的时候,就能有效的评判算法性能了。

    在实际使用过程中要注意:要将出现概率极小但我们很关注的类的标签至为1,出现概率大的类标签置为0。

    不过,设定两个标准又导致了一个trade-off的问题:我们在选择算法的时候,到底是更看重Precison还会Recall呢?

    为了解决这种纠结,前人引入了一种叫F1 score或者F score的方式来进行评价算法。

    它的计算公式为:

    其中,P表示Precision值,R表示Recall值。

    可以看出,当P、R中任何一个为0时,整个F1 score的值都是0,表示该算法很差。

    当P、R都是1时,F1 score值是1,表示该算法非常好。

    转载于:https://www.cnblogs.com/instant7/p/4148296.html

    展开全文
  • 2019独角兽企业重金招聘Python工程师标准>>> ...

    近期频频登上头条的几项研究大多如此:比如利用算法识别犯罪团伙或者,利用图像识别判定同性恋。

    这些问题的出现往往是因为历史数据中的偏差特征,比如种族和性别上的小众团体,往往因此在机器学习预测中产生不利的歧视结果。在包括贷款,招聘,刑事司法和广告在内的各种广泛使用AI的领域,机器学习因其预测误差伤害到了历史上弱势群体,而广受诟病。

    本月,在瑞典斯德哥尔摩举行的第35届机器学习国际会议上,伯克利AI研究协会发布了一篇论文,来试图解决这一问题。

    545b89544270bf09decd2f53681766b03fb9d2ef

    这篇文章的主要目标,是基于社会福利的长期目标对机器学习的决策进行了调整。

    通常,机器学习模型会给出一个表述了个体信息的分数,以便对他们做出决定。 例如,信用评分代表了一个人的信用记录和财务活动,某种程度上银行也会根据信用评分判断该用户的信誉度。本文中将继续用“贷款”这一行为作为案例展开论述。

    如下图所示,每组人群都有信用评分的特定分布。

     

    信用评分和还款之间的分布

    569381d8c4d04c8bb2707ff71c373507546ab77c

    上图中,最上面的数字表示信用评分,评分越高表示偿还能力越强。每一圆圈表示一个人,深蓝色的圆圈表示将会偿还贷款的人,浅蓝色的圆圈表示将会拖欠贷款的人。

    通过定义一个阈值,就可以根据信用评分进行决策。例如,向信用评分超过阈值的人发放贷款,而拒绝向信用评分低于阈值的人发放贷款。这种决策规则被称为阈值策略。

    信用评分可以被解释为对拖欠贷款行为的估计概率。例如,信用评分为650的人中估计有90%的人可能会偿还他们的贷款。

    银行就可以给信用评分为650的个人发放相同的贷款,并获得预期的利润。同样,银行可以给所有信用评分高于650的个人发放贷款,并预测他们的利润。

     

    贷款阈值和盈亏结果

    928e67aabeca3b0c9efae7bb45c7bcd8b85ffc51

    不考虑其他因素,银行肯定会最大化自己的总利润。利润取决于银行从偿还贷款中获得的金额与从拖欠贷款中损失的金额之比。在上面的动图中,营收与亏损的比率的取值是-4~1。

    当损失的成本相对高于收益成本时,银行会更保守地发放贷款,并提高贷款阈值。我们称信用评分超过该阈值的人群比例为选择率(selection rate)。

     

    信用评分变化曲线

    是否发放贷款的决策不仅影响机构,而且影响个人。违约事件(借款人未能偿还贷款)不仅会让银行损失利润,也降低了借款人的信用评分。

    按时偿还贷款的行为会为银行带来利润,同时也会增加借款人的信用评分。在本文的示例中,借款人信贷评分变化率为-2~1,-2表示拖欠贷款,1表示偿还贷款。

    对于阈值策略,评分结果(outcome)的定义是人群信用评分的预期变化,也是选择率函数的一个参数,我们称这个函数为结果曲线。每组人群的选择率不同,信用评分曲线也不尽相同。

    转载于:https://my.oschina.net/u/3611008/blog/1818709

    展开全文
  • 机器学习算法 自制算法,了解算法的工作原理。... 其中,sd =标准偏差; m =均值; f(x)=点x的概率 用户定义的算法,使用OLSR概念执行线性回归 基于统计 直线方程为y = m * x + b,其中m是直线的斜率,b是y轴截距。
  • 算法模型选择标准

    千次阅读 2017-12-24 17:37:55
    偏差与方差 一、经验误差与过拟合机器学习始终都在关注一个误差概念,学习器在训练集上误差称为training error。在新样本误差称为泛化误差(generalization error),显然我们希望得到泛化误差小学习器。...
  • 针对基于RSSI加权质心定位算法会出现三边测量区域选择错误、只是用节点之间距离信息衡量信标节点影响力,忽略了各条信号传输路径中误差的标准偏差也不同问题...
  • 为了克服这个问题,我们开发了一个方差敏感模型,我们称之为标准化变量距离 (SVD),考虑到标准偏差和 z 分数(标准化变量)因素。 您可以从以下链接访问 Wine 和 WBCD 数据集: ...
  • 在本文中,我们为LMRP重新构造了原始非线性模型。 首先,我们引入了一组参数来表示为分配了潜在额外成本设施空间增加... 我们比较了新方法和拉格朗日松弛法,以恒定客户需求率和相等日需求标准偏差来求解LMRP。
  • 目前关于标准偏差的研究方法有两种,Lyon方法复杂且适合于简单耦合系统,Langley方法的运算量较大。本文在Lyon方法的基础上,结合统计能量分析方法中能量流传递独有特性,提出一种实用的标准偏差分析方法。利用...
  • 评价指标二:粒度分布范数相对标准偏差RN<5%;评价指标三:测量结果相对标准差(RSD)小于 2%。实验结果表明:当反演算法满足三个评价指标时,其稳定性好,重复精度高,可以获得最接近实际测量结果。
  • 算法

    2016-10-04 20:29:30
    0. 学习模型评价标准 ... 目标:计算出权重和偏差的梯度(通过反向传播误差的方式)。  下例中,其激活函数为Sigmoid函数:   2. 随机梯度下降法计算全过程  目标:更新权重和偏差。  
  • 该方法将识别CpG岛的位置的问题转化为序列标记问题,并根据CpG岛的位置的性质设计了相应的模型构建、训练以及解码的算法.利用本文算法可以对输入序列确定最有可能的标注序列,从而识别CpG岛的位置.通过对标准数据库的...
  • 利用Sobel算子检测出图像有效边缘,并对其强度水平进行定义,进而在最佳峰值信噪比准则下自适应设置滤波参数空间标准偏差和亮度标准偏差,从而得到自适应双边滤波器。最后,对本文滤波结果进行主客观质量评价。研究...
  • 常用去除离群值的算法

    万次阅读 2019-07-23 16:57:41
    数据预处理方法主要包括去极值、标准化、中性化。那么这里介绍以下常用去离群值方法,所谓离群值就是异常值,这个和极值其实并不一样。常用剔除离群值方法有MAD、、百分位法。参考资料:数据预处理(上)...
  • 采用四种评价融合效果量化判据: 标准偏差, 平均误差, 峰值信噪比(S/N)P和熵差。 将三种图像融合算法用于生物图像中细胞荧光图像和透射图像融合, 量化评价结果和视觉判断均说明, 对于以细胞荧光图像和透射图像为...
  • 【机器学习】偏差与方差和F1与BEP值关系 【机器学习】神经元模型以及感知机 在这篇文章里面将分析BP算法的原理 初始条件 在上一篇博客中已经分析了简单神经元应用,那就是与、或、非功能神经网络实现,但是...
  • 仿真结果表明,在低动态下,该算法的性能与标准KF算法接近,但在高动态下,该算法状态估计系统偏差和随机误差相对标准KF算法均有明显改善;同时,该算法可以有效地抑制标准KF算法在一般加速运动下滤波发
  • 用C ++编写的算法交易策略。 该程序运行一种算法交易策略,该策略利用布林带买卖股票。 需要每日价格数据的.csv文件。 策略:当股价低于移动平均线的指定标准偏差数量时,购买股票。 当股票价格高于移动平均线的...
  • 采用电磁仿真软件FEKO对混响室仿真模型进行数值分析,以表征混响室测试区域场均匀性电场标准偏差值为目标函数,结合遗传算法对混响室搅拌器桨叶夹角进行优化,得到了桨叶夹角最优解以及相应测试区域电场标准...
  • 近年来, 在基于Q学习算法的作业车间动态调度系统中, 状态-行动和奖励值靠人为主观设定, 导致学习效果不理想, 与已知最优解相比, 结果偏差较大. 为此, 基于作业车间调度问题特质, 对Q学习算法的要素进行重新设计, ...
  • 基于改进遗传算法的非线性仪表参数辨识,李雅梅,杨飞霞,分析了节流式流量仪表非线性及其导致计算结果的偏差,建立了仪表非线性模型。针对标准遗传算法(SGA)收敛速度慢、易早熟等缺�
  • 针对传统测量透镜焦距数据误差大问题,提出采用准蒙特卡罗算法进行分析。用液晶屏显示分化图形取代...实验仿真显示液晶显示屏测量焦距比目视测量焦距的标准偏差小,准蒙特卡罗算法的均方根误差比蒙特卡罗算法的小。
  • 为了增强彩色图像而不引起色彩...25幅低照度图像平均亮度、标准偏差和对比度分别提高了94.95%、20.93%和29.88%,相对于带色彩恢复多尺度Retinex算法的熵和对比度增量分别提高了7.34%和151.51%,效果优于Retinex算法
  • 传感器配准问题由传感器测量值平均最小二乘(LS)标准函数表示,采用递归两步优化算法来获得目标状态和传感器偏差估计。 最后,通过仿真来评估所提出算法的性能。 结果表明,它可以有效地解决注册问题。
  • 这几天在看刘汝佳老师的算法竞赛入门经典这本书,前两章讲的主要是有关c语言的输入输出语句,条件语句,以及循环语句,这些都是课本有的,没什么难度。从第三章开始,尽管有关知识点都是学过的,但是一些题目所要...
  • 首先假设一个薄膜模型,计算出其相应的椭偏参数(Ψ,Δ)的值,在这个计算值的基础上加入不同标准偏差的高斯噪声;然后将加入噪声后的值(Ψm,Δm)作为模拟的测量数据,采用模拟退火算法进行求解,验证得知这种方法求得的...

空空如也

空空如也

1 2 3 4 5 ... 20
收藏数 454
精华内容 181
关键字:

标准偏差的算法