精华内容
下载资源
问答
  • R语言 基础统计学之样本计算

    千次阅读 2020-02-07 19:20:36
    以下介绍基础统计学关于样本计算的问题,主要解决实际问题中在已知一些统计特征下,计算所必要的样本量,共有三种方式:总体方差已知时,总体方差未知时 ,估计比例为P时的三种情况下的样本量。 总体方差σ已知 若...

    #R语言 基础统计学之样本量计算

    以下介绍基础统计学关于样本量计算的问题,主要解决实际问题中在已知一些统计特征下,计算所必要的样本量,共有三种方式:总体方差已知时,总体方差未知时 ,估计比例为P时的三种情况下的样本量。

    总体方差σ已知

    若已知总体X的均值为μ,方差为σ2\sigma^2,可以依据基本公式:
    n=(Z1α/2σ2E)2 n = (\frac{Z_{1-\alpha/2}\sigma^2}{E})^2
    计算得出。

    通过R语言编写一个较为简单函数实现:

    sample_size1 <-  function(E,var,conf.leval) #E:最大允许误差,var:总体方差,conf.leval:置信水平
    {
      alpha = 1- conf.leval
      ((qnorm(1-alpha/2)*sqrt(var))/E)^2#函数qnorm():计算正态下的分位数值
    }
    
    

    简单例子:某小区30000户,调查人员将抽取合适样本调查用户一个月的平均收入,要求置信度为95%,最大允许误差为2,由历史经验表明家庭间收入的方差为600,则需要抽取多少户经行调查?

    > sample_size1 (E = 2,var = 600,conf.leval = 0.95) 
    [1] 576.2188
    

    总体方差未知时

    若已知总体X的均值为μ,总体方差σ2\sigma^2未知时,可以依据基本公式:

    n=(t1α/2(n1)sE)2 n = (\frac{t_{1-\alpha/2}(n-1)s}{E})^2
    公式中,t1α/2(n1)t_{1-\alpha/2}(n-1)是随自由度(n1)(n-1)二变化的,即在n未知时,t1α/2(n1)t_{1-\alpha/2}(n-1)也是未知的。一般情况下采用实验法(先用KaTeX parse error: Expected '}', got 'EOF' at end of input: Z_{1-\alpha/2)代替t1α/2(n1)t_{1-\alpha/2}(n-1)求出n0n_{0},再将n0n_{0}带入t1α/2(n1)t_{1-\alpha/2}(n-1)求出n1n_{1},重复后直至先后两次的n值的离差最小为止,最后的n1n_{1}即为确定的样本量。

    通过R语言编写一个较为简单函数实现:

    sample_size2 <- function(E,s,conf.leval,m)	#m:为给定的较大数
    {
      alpha = 1- conf.leval
      t0 = qt(alpha/2,m,lower.tail = F)#函数qt():计算t分位数
      n0 = (t0*s/E)^2
      t1 = qt(alpha/2,n0,lower.tail = F)
      n1 = (t1*s/E)^2
      while (abs(n1-n0)<0.5)	 #abs为衡量指标  可以替换成平方差等等。
      {
        no = (qt(alpha/2,n1,lower.tail = F)*s/E)^2
        n1 = (qt(alpha/2,n0,lower.tail = F)*s/E)^2
      }
      n1
    }
    

    简单例子:某小区30000户,调查人员将抽取合适样本调查用户一个月的平均收入,要求置信度为95%,最大允许误差为2,样本标准差为600\sqrt{600 },则需要抽取多少户经行调查?

    > sample_size2(2,sqrt(600),0.95,100)	#设定m值为100
     [1] 578.5885
    

    可以看到两个相同例子,在信息不相同的情况下,计算结果并未相差较大。

    估计比例为P时

    在样本量较大情况下,样本比例p近似服从正态分布,因此s的粗略估计值为p(1-p),故可以根据公式:
    n=(Z1α/2E)2p(1p) n = (\frac{Z_{1-\alpha/2}}{E})^2p(1-p)
    p一般根据历史经验数据所得,若p未知,一般情况下取p = 0.5。

    通过R语言编写一个较为简单函数实现:

    sample_size3 <- function(E,p,conf.leval)
    {
      alpha = 1- conf.leval
      ((qnorm(1-alpha/2)/E)^2)*p*(1-p)
    }
    

    简单例子:某工厂以往制作产品的合格率为80%,试估计工厂现在制作产品的合格率,要求估计误差小于3%,置信水平为95%情况下抽取多少产品数量。

    通过R语言编写一个较为简单函数实现:

    >sample_size3(E = 0.03,p = 0.8,conf.leval = 0.95)
    >[1] 682.926
    

    以上均为基本样本量计算的方式,而且是博主自己写的函数,读者可以通过自己编写更为简便的函数实现,欢迎交流,学无止境,加油!

    展开全文
  • 对于数量级较小的样本,考虑增大其在计算损失时负样本的损失,即,可作如下理解:假设大小样本比例为5:1,在训练时,如果发生小样本被误判为大样本的情况,计算损失时将这些负样本的损失扩大5倍...

    补充一些更详细的说明:

    数据集是大样本5000,小样本500,但实际上每个样本会包含多个groud truth,因此首先对数据做拆分和清洗

    统计出准确的大小样本比例约为5:1,然后从损失函数公式入手:

    对于数量级较小的样本,考虑增大其在计算损失时负样本的损失,即,可作如下理解:假设大小样本比例为5:1,在训练时,如果发生小样本被误判为大样本的情况,计算损失时将这些负样本的损失扩大5倍,主要修改如下红框部分,全文参考下方注释。

    -------------------------------------------------------------------------------分割线---------------------------------------------------------------------------

    最近做大作业,用到了目标检测算法,要解决样本不均衡的问题。

    样本不均衡除了数据扩增外,在损失函数上,容易想到,对于数目较少的类别,当检测类别错误时将惩罚加倍。这里从multibox loss下手,关于它的计算公式不再赘述,已有许多原理解析,写的相当不错。要来解析的是它的源码。

    其实已有许多自称源码解析,但是对于重要的部分讲解并不是很详细。。甚至翻译了一下注释就略过了。。。囧

    以下注解集合了各路神仙的帮助,以及一些个人理解,在此感谢某知乎作者(忘记叫啥了 和另一位CSDN博主。

    以下代码包含了一小段解决样本不均衡问题的部分,因为本人其实是写java的。。所以python写的可能比较丑,另外直接取了第一个标签,因为不知道多标签的时候应该怎么样的。。。所以对一张图有多个标注的可能还需要另外处理。

    多说几句,Tensor的很多语法一开始真的是难住了我这个python 0基础,比如一个Tensor 方括号中包含了另一个Tensor 和0比较的结果,之类的,一些很迷的操作,可能会有一些阻碍,解决方法就是多试试,然后就会发现,哦,原来这个操作是这样子的。

    各位,共勉。

        def forward(self, predictions, targets):
            """Multibox Loss
            Args:
                predictions (tuple): A tuple containing loc preds, conf preds,
                and prior boxes from SSD net.
                    conf shape: torch.size(batch_size,num_priors,num_classes)
                    loc shape: torch.size(batch_size,num_priors,4)
                    priors shape: torch.size(num_priors,4)
    
                targets (tensor): Ground truth boxes and labels for a batch,
                    shape: [batch_size,num_objs,5] (last idx is the label).
            """
            loc_data, conf_data, priors = predictions
            num = loc_data.size(0) # num here=batch size
            priors = priors[: loc_data.size(1), :] # priors = priors[:8732, :]
            num_priors = priors.size(0) # num_priors=8732
            num_classes = self.num_classes # num_classes = 3
    
            # match priors (default boxes) and ground truth boxes
            loc_t = torch.Tensor(num, num_priors, 4)# 定义目标定位值的tensor维度,size:(batch size, 8732, 4)
            conf_t = torch.LongTensor(num, num_priors)# 定义目标置信度的tensor维度,size:(batch size, 8732)
            for idx in range(num):
                truths = targets[idx][:, :-1].data # targets[0]中第一个到倒数第二个数值
                labels = targets[idx][:, -1].data # targets[0]中最后一个数值为label
                defaults = priors.data
                #在训练时,groundtruth boxes 与 default boxes(就是prior boxes) 按照如下方式进行配对:
                # 首先,寻找与每一个ground truth box有最大的jaccard overlap的default box,这样就能保证每一个groundtruth box与唯一的一个default box对应起来(所谓的jaccard overlap就是IoU)。
                # SSD之后又将剩余还没有配对的default box与任意一个groundtruth box尝试配对,只要两者之间的jaccard overlap大于阈值,就认为match(SSD 300 阈值为0.5)。
                # 显然配对到GT的default box就是positive,没有配对到GT的default box就是negative。
                match(
                    self.threshold,
                    truths,
                    defaults,
                    self.variance,
                    labels,
                    loc_t,
                    conf_t,
                    idx,
                )
            if self.use_gpu: # cpu到gpu的数据转换
                loc_t = loc_t.cuda()
                conf_t = conf_t.cuda()
            # wrap targets
            loc_t = Variable(loc_t, requires_grad=False) 
            conf_t = Variable(conf_t, requires_grad=False)
    
            pos = conf_t > 0 # pos.shape: torch.Size([batch size, 8732]),conf_t中所有大于0的地方,pos在该位置为1
            num_pos = pos.sum(dim=1, keepdim=True) # num_pos.shape: torch.Size([batch size, 1]) #每张图可匹配默认框数量
    
            # Localization Loss (Smooth L1)
            # Shape: [batch,num_priors,4]
            pos_idx = pos.unsqueeze(pos.dim()).expand_as(loc_data) # 增一维度size扩展为(32,8732,1) 再扩增为loc_data(32,8732,4)的维度
            loc_p = loc_data[pos_idx].view(-1, 4) # 此时loc_data和pos_idx维度一样,选择出positive的loc
            loc_t = loc_t[pos_idx].view(-1, 4) # 选出一样数量的目标定位值
            loss_l = F.smooth_l1_loss(loc_p, loc_t, size_average=False) # 用smooth_l1_los求损失
    
            # Compute max conf across batch for hard negative mining
            batch_conf = conf_data.view(-1, self.num_classes)
            loss_c = log_sum_exp(batch_conf) - batch_conf.gather(1, conf_t.view(-1, 1))
    
            # Hard Negative Mining
            loss_c = loss_c.view(num, -1)
            loss_c[pos] = 0  # filter out pos boxes for now
            loss_c = loss_c.view(num, -1)
            _, loss_idx = loss_c.sort(1, descending=True)
            _, idx_rank = loss_idx.sort(1) # 对于每个GT, idx_rank是该位置的priors的loss得分排名
            num_pos = pos.long().sum(1, keepdim=True)
            #clamp:将输入input张量每个元素的夹紧到区间 [min,max]
            #由于负样本数目远大于正样本数,因此将正负比例控制在1:3 -> negpos_ratio=3
            num_neg = torch.clamp(self.negpos_ratio * num_pos, max=pos.size(1) - 1)
            # 从所有idx_rank中挑选出在负样本范围内的样本id
            neg = idx_rank < num_neg.expand_as(idx_rank)
    
            # Confidence Loss Including Positive and Negative Examples
            pos_idx = pos.unsqueeze(2).expand_as(conf_data)
            neg_idx = neg.unsqueeze(2).expand_as(conf_data)
                
            # conf_data shape [batch,num_priors,num_classes]
            # 下面这部分是我解决样本不均衡的部分 不需要的可以略过
            ########################## 开始分割 #########################
            for idx in range(num):
                labels = targets[idx][:, -1].data
                if labels[0] == 0:
                    conf_data[idx][:][1] *= 5
            ########################## 结束分割 #########################
            conf_p = conf_data[(pos_idx+neg_idx).gt(0)].view(-1, self.num_classes)
            targets_weighted = conf_t[(pos + neg).gt(0)]
            loss_c = F.cross_entropy(conf_p, targets_weighted, size_average=False)
            
            # Sum of losses: L(x,c,l,g) = (Lconf(x, c) + αLloc(x,l,g)) / N
    
            N = num_pos.data.sum().double() # N为batch size个图像中检测到的positive框总数
            loss_l = loss_l.double() / N
            loss_c = loss_c.double() / N
            return loss_l, loss_c

     

    展开全文
  • 对于二分类问题, 当训练集中正负样本非常不均衡时, 如何处理数据以更好地训练...根据计算公式可以推知,在testing set出现imbalance时ROC曲线能保持不变,而PR则会出现大变化。 基于数据的方法 基于算法的方法 ...

    对于二分类问题, 当训练集中正负样本非常不均衡时, 如何处理数据以更好地训练分类模型?

    这里有个问题是:如何判断数据是否平衡呢?w(゚Д゚)w

    real world data经常会面临class imbalance问题,即正负样本比例失衡。根据计算公式可以推知,在testing set出现imbalance时ROC曲线能保持不变,而PR则会出现大变化。

    • 基于数据的方法
    • 基于算法的方法

    基于数据的方法

    • 对数据进行重采样, 使原本不均衡的样本变得均衡。 首先, 记样本数大的类别为Cmaj, 样本数小的类别为Cmin, 它们对应的样本集分别为Smaj和Smin。 根据题设, 有|Smaj|>>|Smin。最简单的处理不均衡样本集的方法是随机采样。 采样一般分为过采样( Oversampling) 和欠采样( Under-sampling) 。 随机过采样是从少数类样本集Smin中随机重复抽取样本( 有放回) 以得到更多样本; 随机欠采样则相反, 从多数类样本集Smaj中随机选取较少的样本( 有放回或无放回) 。

    直接的随机采样虽然可以使样本集变得均衡, 但会带来一些问题, 比如, 过采样对少数类样本进行了多次复制, 扩大了数据规模, 增加了模型训练的复杂度, 同时也容易造成过拟合; 欠采样会丢弃一些样本, 可能会损失部分有用信息, 造成模型只学到了整体模式的一部分。

    • 为了解决上述问题, 通常在过采样时并不是简单地复制样本, 而是采用一些方法生成新的样本。 例如, SMOTE算法对少数类样本集Smin中每个样本x, 从它在Smin中的K近邻中随机选一个样本y, 然后在x,y连线上随机选取一点作为新合成的样本( 根据需要的过采样倍率重复上述过程若干次) , 如图8.14所示。 这种合成新样本的过采样方法可以降低过拟合的风险。

    SMOTE算法为每个少数类样本合成相同数量的新样本, 这可能会增大类间重叠度, 并且会生成一些不能提供有益信息的样本。 为此出现Borderline-SMOTE、ADASYN等改进算法。 Borderline-SMOTE只给那些处在分类边界上的少数类样本合成新样本, 而ADASYN则给不同的少数类样本合成不同个数的新样本。 此外,还可以采用一些数据清理方法( 如基于Tomek Links) 来进一步降低合成样本带来的类间重叠, 以得到更加良定义( well-defined) 的类簇, 从而更好地训练分类器。

    • 同样地, 对于欠采样, 可以采用Informed Undersampling来解决由于随机欠采样带来的数据丢失问题。 常见的Informed Undersampling算法有:
    1. Easy Ensemble算法。 每次从多数类Smaj中上随机抽取一个子集E(|E|≈|Smin|),然后用E+Smin训练一个分类器; 重复上述过程若干次,得到多个分类器,最终的分类结果是这多个分类器结果的融合。
    2. Balance Cascade算法。 级联结构, 在每一级中从多数类Smaj中随机抽取子集E, 用E+Smin训练该级的分类器; 然后将Smaj中能够被当前分类器正确判别的样本剔除掉, 继续下一级的操作, 重复若干次得到级联结构; 最终的输出结果也是各级分类器结果的融合
    3. 其他诸如NearMiss(利用K近邻信息挑选具有代表性的样本) 、 Onesided Selection(采用数据清理技术) 等算法。在实际应用中, 具体的采样操作可能并不总是如上述几个算法一样, 但基本思路很多时候还是一致的。 例如, 基于聚类的采样方法, 利用数据的类簇信息来指导过采样/欠采样操作; 经常用到的数据扩充方法也是一种过采样, 对少数类样本进行一些噪声扰动或变换(如图像数据集中对图片进行裁剪、 翻转、 旋转、 加光照等) 以构造出新的样本; 而Hard Negative Mining则是一种欠采样, 把比较难的样本抽出来用于迭代分类器。

    基于算法的方法

    在样本不均衡时, 也可以通过改变模型训练时的目标函数(如代价敏感学习中不同类别有不同的权重) 来矫正这种不平衡性; 当样本数目极其不均衡时, 也可以将问题转化为单类学习( one-class learning) 、 异常检测( anomaly detection) 。

    异常检测

    Abnormal Detection(异常检测)和 Supervised Learning(有监督训练)在异常检测上的应用初探


    如何选择

    (1)在正负样本都非常少的情况下,应该采用数据合成的方式,例如:SMOTE算法和Borderline-SMOTE算法。

    (2)在正负样本都足够多且比例不是特别悬殊的情况下,应该考虑采样的方法或者是加权的方法。


    • 1.通过过抽样和欠抽样解决样本不均衡

    抽样是解决样本分布不均衡相对简单且常用的方法,包括过抽样和欠抽样两种。

    过抽样

    过抽样(也叫上采样、over-sampling)方法通过增加分类中少数类样本的数量来实现样本均衡,最直接的方法是简单复制少数类样本形成多条记录,这种方法的缺点是如果样本特征少而可能导致过拟合的问题;经过改进的过抽样方法通过在少数类中加入随机噪声、干扰数据或通过一定规则产生新的合成样本,例如SMOTE算法。

    欠抽样

    欠抽样(也叫下采样、under-sampling)方法通过减少分类中多数类样本的样本数量来实现样本均衡,最直接的方法是随机地去掉一些多数类样本来减小多数类的规模,缺点是会丢失多数类样本中的一些重要信息。

    总体上,过抽样和欠抽样更适合大数据分布不均衡的情况,尤其是第一种(过抽样)方法应用更加广泛。

    • 2.通过组合/集成方法解决样本不均衡

    组合/集成方法指的是在每次生成训练集时使用所有分类中的小样本量,同时从分类中的大样本量中随机抽取数据来与小样本量合并构成训练集,这样反复多次会得到很多训练集和训练模型。最后在应用时,使用组合方法(例如投票、加权投票等)产生分类预测结果。

    例如,在数据集中的正、负例的样本分别为100和10000条,比例为1:100。此时可以将负例样本(类别中的大量样本集)随机分为100份(当然也可以分更多),每份100条数据;然后每次形成训练集时使用所有的正样本(100条)和随机抽取的负样本(100条)形成新的数据集。如此反复可以得到100个训练集和对应的训练模型。

    这种解决问题的思路类似于随机森林。在随机森林中,虽然每个小决策树的分类能力很弱,但是通过大量的“小树”组合形成的“森林”具有良好的模型预测能力。

    如果计算资源充足,并且对于模型的时效性要求不高的话,这种方法比较合适。

    3.通过特征选择解决样本不均衡

    上述几种方法都是基于数据行的操作,通过多种途径来使得不同类别的样本数据行记录均衡。除此以外,还可以考虑使用或辅助于基于列的特征选择方法。

    一般情况下,样本不均衡也会导致特征分布不均衡,但如果小类别样本量具有一定的规模,那么意味着其特征值的分布较为均匀,可通过选择具有显著型的特征配合参与解决样本不均衡问题,也能在一定程度上提高模型效果。

     

    参考:

    样本不均衡问题

    正负样本不平衡处理方法总结

    分类中解决类别不平衡问题

    使用第三方库imblearn实现不平衡样本的样本均衡问题

    展开全文
  • 目录 1.二分类评价标准介绍 2. Tensorflow实现代码 ...正确率(Accuracy)表示政府样本被正确分类的比例计算公式如下: 其中NTP表示正类样本被正确分类的数目,NTN表示负类样本被正确分类的数目,NFP表示负...

    目录

    1.二分类评价标准介绍

    2. Tensorflow实现代码


    1.二分类评价标准介绍

    在进行二分类后需要对分类结果进行评价,评价的标准除了常用的正确率之外还有召回率精确度,虚警率和漏警率等。首先介绍一下最常用的正确率

    正确率(Accuracy)表示政府样本被正确分类的比例,计算公式如下:

    其中NTP 表示正类样本被正确分类的数目,NTN表示负类样本被正确分类的数目,NFP表示负类样本被分为正类的数目,NFN表示正类样本被分为负类的数目。

    精确率(Precision)表示原本为正类样本在所有被分为正类样本(正的被分为正的+错的被分为正的)的比例

    召回率(Recall)表示原本为正类样本在原本正类样本(正的被分为正的+正的被分为错的)的比例

    虚警率(False alarm)表示负类样本被分为正类样本在所有负类样本中的比例

    漏警率表示(Missing alarm)表示正类样本被分为负类样本在所有正类样本中的比例

    2. Tensorflow实现代码

    计算公式已经在第一节给出了,代码实现最难的部分不是计算而是对于数据格式的转换。本文背景为,利用保存好的模型在测试集上进行测试,然后对测试集的分分类结果进行评估。建议先看下这篇博客:Tensorflow在训练好的模型上进行测试

    直接上代码,其中函数的predict是预测结果,也就是神经网络的输出,real是真实的标签,sess就是tensorflow当前的会话,feed_dict是需要喂的数据。下面详细讲解一下代码

    函数tf.argmax()返回值是是数值最大值的索引位置,如果最大值位置相同,则分类正确,反之则分类错误

        predictions = tf.argmax(predict, 1)
        actuals = tf.argmax(real, 1)

    下面的代码是将上述代码获得到变量设置为元素为0或者1的矩阵,在后面计算的时候只需要按照逻辑与计算即可

        ones_like_actuals = tf.ones_like(actuals)
        zeros_like_actuals = tf.zeros_like(actuals)
        ones_like_predictions = tf.ones_like(predictions)
        zeros_like_predictions = tf.zeros_like(predictions)

    后面的都是按第一节公式计算的部分

     tp_op = tf.reduce_sum(
            tf.cast(
                tf.logical_and(
                    tf.equal(actuals, ones_like_actuals),
                    tf.equal(predictions, ones_like_predictions)
                ),
                "float"
            )
        )
    
        tn_op = tf.reduce_sum(
            tf.cast(
              tf.logical_and(
                tf.equal(actuals, zeros_like_actuals),
                tf.equal(predictions, zeros_like_predictions)
              ),
              "float"
            )
        )
    
        fp_op = tf.reduce_sum(
            tf.cast(
              tf.logical_and(
                tf.equal(actuals, zeros_like_actuals),
                tf.equal(predictions, ones_like_predictions)
              ),
              "float"
            )
        )
    
        fn_op = tf.reduce_sum(
            tf.cast(
              tf.logical_and(
                tf.equal(actuals, ones_like_actuals),
                tf.equal(predictions, zeros_like_predictions)
              ),
              "float"
            )
        )

    完整函数代码

    def tf_confusion_metrics(predict, real, session, feed_dict):
    
        predictions = tf.argmax(predict, 1)
        actuals = tf.argmax(real, 1)
    
        ones_like_actuals = tf.ones_like(actuals)
        zeros_like_actuals = tf.zeros_like(actuals)
        ones_like_predictions = tf.ones_like(predictions)
        zeros_like_predictions = tf.zeros_like(predictions)
    
        tp_op = tf.reduce_sum(
            tf.cast(
                tf.logical_and(
                    tf.equal(actuals, ones_like_actuals),
                    tf.equal(predictions, ones_like_predictions)
                ),
                "float"
            )
        )
    
        tn_op = tf.reduce_sum(
            tf.cast(
              tf.logical_and(
                tf.equal(actuals, zeros_like_actuals),
                tf.equal(predictions, zeros_like_predictions)
              ),
              "float"
            )
        )
    
        fp_op = tf.reduce_sum(
            tf.cast(
              tf.logical_and(
                tf.equal(actuals, zeros_like_actuals),
                tf.equal(predictions, ones_like_predictions)
              ),
              "float"
            )
        )
    
        fn_op = tf.reduce_sum(
            tf.cast(
              tf.logical_and(
                tf.equal(actuals, ones_like_actuals),
                tf.equal(predictions, zeros_like_predictions)
              ),
              "float"
            )
        )
        tp, tn, fp, fn = session.run([tp_op, tn_op, fp_op, fn_op], feed_dict)
    
        tpr = float(tp)/(float(tp) + float(fn))
        fpr = float(fp)/(float(fp) + float(tn))
        fnr = float(fn)/(float(tp) + float(fn))
    
        accuracy = (float(tp) + float(tn))/(float(tp) + float(fp) + float(fn) + float(tn))
    
        recall = tpr
        precision = float(tp)/(float(tp) + float(fp))
    
        f1_score = (2 * (precision * recall)) / (precision + recall)
    
        

     

    计算评价标准的函数不难,难得是调用函数,贴一下使用训练好的模型进行测试的代码,这部分可以结合:https://blog.csdn.net/sinat_35821976/article/details/80765145 来看。

    with tf.Session() as sess:
        saver = tf.train.import_meta_graph('./model.ckpt.meta')
        saver.restore(sess, './model.ckpt')# .data文件
        pred = tf.get_collection('pred_network')[0]
    
        graph = tf.get_default_graph()
        x = graph.get_operation_by_name('x').outputs[0]
        y_ = graph.get_operation_by_name('y_').outputs[0]
    
        y = sess.run(pred, feed_dict={x: test_x, y_: test_y})

    最后一行y,即网络输出是tensor,而实际标签test_y的类型也是ndarray。但是在函数def tf_confusion_metrics(predict, real, session, feed_dict)中predict、real需要为tensor类型,feed_dict中的数据不能为tensor类型,因此需要讲y转为ndarry类型,然后将test_y转为tensor类型,然后调用函数。具体实现如下:

    predictLabel = tf.constant(y)
    predictLabel =  predictLabel.eval()         # 将tensor转为ndarray
    realLabel = tf.convert_to_tensor(test_y)    # 将ndarray转为tensor
    tf_confusion_metrics(y, realLabel, sess, feed_dict={predict: predictLabel , real:test_y})

     

    展开全文
  • 实际计算时用p代替π 4.大样本的判定 大样本选取规则 5.例题 解 样本容量的确定 1.公式 如果不知道π可以取0.5 2.例题1 已知p 解 2.例题2 未知p 因为不知道p.没有π的估计值,所以选取理论上π的最大值...
  • 2·3 总体与样本 2·4 期望值 2·5 统计的假设检验 第十四章 初等几何学 1.总论 1·1 几何学简史 1·2 预备知识 2.有关直线的基本定理 2·1 两直线的夹角和平行 2·2 三角形的性质 2·3 平行四边形的性质 3.有关面积...
  • 2·3 总体与样本 2·4 期望值 2·5 统计的假设检验 第十四章 初等几何学 1.总论 1·1 几何学简史 1·2 预备知识 2.有关直线的基本定理 2·1 两直线的夹角和平行 2·2 三角形的性质 2·3 平行四边形的性质 3.有关面积...
  • 文章目录抽样抽样方法:概率抽样和非概率抽样样本量估计总体概率公式样本量公式汇总均值差异显著性检验单样本总体比例的检验两总体比例之差的...计算出的样本量,不一定全部有效,在试验时,需初步确定有效样本比例。用
  • 信息增益比例计算公式如下: 在上式中,SplitInf(K)称为分裂信息,它反映了属性数据的延展度与平衡性,计算公式如下:2)处理含有带缺失值属性的样本 C4.5算法在处理缺失数据时最常用的方法是,将这...
  • 速记:当不同类别的样本比例非常不均匀时,占比大的类别往往成为影响准确率的最主要因素。 详细:先给出准确率的计算公式: 显然,当负样本占99%时,分类器把所有样本都预测为负样本也可以获得99%的准确率。为...
  • •WOE的计算公式是: •WOE=ln[(坏样本/总坏样本)/(好样本/总好样本)]=ln[(坏样本/好样本)/(总坏样本/总好样本)] Pyi:是这个组中响应客户(坏样本)占所有样本中所有响应客户的比例 Pni:是这个组中未响应...
  • 1.计算公式 2.Python实战 三、均值方差归一化 1.计算公式 2.Python实战 四、归一化要点 五、使用scikit-learn进行数据归一化 一、介绍 为什么需要进行数据归一化? 举个简单的例子,样本1以[1, 200]输入到模型中去...
  • 训练好的模型,上线...对样例集 D,分类错误率计算公式如下 精度:是分类正确的样本数占样本总数的比例。这里的分类正确的样本数指的不仅是正例分类正确的个数还有反例分类正确的个数。对样例集 D,精度计算公...
  • 这个公式说明:当总样本足够大,抽样的结果和总样本的结果之间的差,超过误差范围的概率就非常小 二、概率近似正确(probably approximately correct,PCA) 解释了是否可以将从多个角度完成训练的“弱模型”,组合...
  • 在这种不平衡数据集上如不加以调整,模型很容易偏向大类别而放弃小类别(eg: 正负样本比例1:9,直接全部预测为负,acc也有90%。但正样本就完全被“抛弃”了)。此时整体acc挺高,但是部分类别完全不能被召回。 这时...
  • 双塔召回的损失函数 ...即user和item各一个塔,而其损失函数是pointwise loss,即对每个样本进行损失计算,而非上述需要为正样本搭配一系列的负样本然后进行损失计算,而具体采用的是交叉熵损失计算,如下公式: .
  • 精准率和召回率

    2020-09-29 11:15:34
    准确率、精准率和召回率的计算公式如下: 准确率(accuracy): (TP + TN )/( TP + FP + TN + FN) 精准率(precision):TP / (TP + FP),正确预测为正占全部预测为正的比例 召回率(recall): TP / (TP + FN),...
  • 既然精确率和召回率的概念以及计算公式都指向二分类问题,那么我们不妨将多分类问题转换为二分类问题来做。 先来看一下精确率和召回率的概念: 精确率是指分类正确的正样本个数占分类器判定为正样本的个数的比例。...
  • 模型常用参数

    2020-01-08 22:13:18
    模型常用参数 ... 1.错误率(Error Rate): 分类错误的样本...以D作为样本集,错误率计算公式如下: 解释:统计分类器预测出来的结果与真实结果不相同的个数,然后除以总的样例集D的个数 2.精度(Accuracy):是分类...
  • Pi:第 i 类样本的数量占总样本数量的比例  2)实例计算基尼系数 3 种情况计算基尼系数: 基尼系数的性质与信息熵一样:度量随机变量的不确定度的大小; G 越大,数据的不确...
  • 正确率(Accuracy)表示正负样本被正确分类的比例计算公式如下: 其中NTPN_{TP}NTP​ 表示正类样本被正确分类的数目,NTNN_{TN}NTN​表示负类样本被正确分类的数目,NFPN_{FP}NFP​表示负类样本被分为正类的数目,...
  • Jaccard系数与Jaccard距离

    万次阅读 2018-04-08 17:45:09
    jaccard系数相反的即为jaccard距离,用两个集合中不同元素所占元素的比例来衡量两个样本之间的相似度,公式为: Jaccard系数主要的应用的场景有 1.过滤相似度很高的新闻,或者网页去重 2.考试防作弊系统 3....
  • SMOTE算法

    2019-08-12 21:04:14
    (1)对于少数类中每一个样本x,以欧氏距离为标准计算它到少数类样本集中所有样本的距离,得到其k近邻 (2)根据样本不平衡比例设置一个采样比例以确定采样倍率N,对于每一个少数类样本x,从其k近邻中随机选择若干...
  • 决策树+代码实现

    千次阅读 2018-12-20 01:39:21
    信息熵计算公式: 其中 为集合中第K类属性所占样本比例。 Ent(D)的值越小,则D的纯度越高   假定离散属性a有x个可能的取值{a1,a2,…,ax},若使用a来对样本集D进行划分,则会产生x个分支节点,其中第x个...
  • 多标签分类的评价指标

    万次阅读 2018-01-24 19:03:22
    多标签分类作为多分类的一种推广,每个样本可以有多个类别,如下图的标签为:sea,sunset。...计算公式如下。 其中:|D|表示样本总数,|L|表示标签总数,xi和yi分别表示预测结果和ground trut
  • 目录: (1)错误率(Error rate)和精度(Accuracy) (2)查准率(准确率-Precision)、查全率(召回率-Recall) ...对样例集D,分类错误率计算公式如1所示。 (1) 对公式(1)解释:统计分类器预测出来的结...
  • 基尼系数

    千次阅读 2019-05-23 08:13:09
    Pi:第 i 类样本的数量占总样本数量的比例  2)实例计算基尼系数 3 种情况计算基尼系数: 基尼系数的性质与信息熵一样:度量随机变量的不确定度的大小; G 越大,数据的不确定性越高; G 越小,数据的不...
  • 机器学习 算法===GG

    2021-03-06 13:19:27
    机器学习 ...准确率、精准率和召回率的计算公式如下: 准确率(accuracy): (TP + TN )/( TP + FP + TN + FN) 精准率(precision):TP / (TP + FP),正确预测为正占全部预测为正的比例 召回率(reca

空空如也

空空如也

1 2 3 4
收藏数 67
精华内容 26
关键字:

样本比例计算公式