blocks|key|641920|text|我可以想到3种方法来解决这种情况：|type|unstyled|depth|inlineStyleRanges|entityRanges|data|641921|1)随机欠采样-在此方法中，您可以从多数类中随机删除样本。|641922|2)随机过采样-在此方法中，您可以通过复制样本来增加样本。|641923|3)加权交叉熵-您也可以使用加权交叉熵，以便可以补偿少数类的损失值。See+here|offset|length|641924|我亲自尝试过method2，它确实显著提高了我的准确率，但不同的数据集可能会有所不同|641925|entityMap|0|LINK|mutability|MUTABLE|url|https://stackoverflow.com/questions/44560549/unbalanced-data-and-weighted-cross-entropy^0|0|0|0|Y|8|0|0|0^^$0|@$1|2|3|4|5|6|7|T|8|@]|9|@]|A|$]]|$1|B|3|C|5|6|7|U|8|@]|9|@]|A|$]]|$1|D|3|E|5|6|7|V|8|@]|9|@]|A|$]]|$1|F|3|G|5|6|7|W|8|@]|9|@$H|X|I|Y|1|Z]]|A|$]]|$1|J|3|K|5|6|7|10|8|@]|9|@]|A|$]]|$1|L|3|-4|5|6|7|11|8|@]|9|@]|A|$]]]|M|$N|$5|O|P|Q|A|$R|S]]]]

There are 3 ways I can think of tackling the situation :-

1)Random Under-sampling - In this method you can randomly remove samples from the majority classes.

2)Random Over-sampling - In this method you can increase the samples by replicating them.

3)Weighted cross entropy - You can also use weighted cross entropy so that the loss value can be compensated for the minority classes. <a href="https://stackoverflow.com/questions/44560549/unbalanced-data-and-weighted-cross-entropy">See here</a> 

I have personally tried method2 and it does increase my accuracy by significant value but it may vary from dataset to dataset

blocks|key|641937|text|我也面临着同样的问题，所以我实现了一个基于SparseCategoricalAccuracy的自定义类|type|unstyled|depth|inlineStyleRanges|offset|length|style|CODE|entityRanges|data|641938|class+BalancedSparseCategoricalAccuracy(keras.metrics.SparseCategoricalAccuracy):
++++def+__init__(self,+name='balanced_sparse_categorical_accuracy',+dtype=None):
++++++++super().__init__(name,+dtype=dtype)

++++def+update_state(self,+y_true,+y_pred,+sample_weight=None):
++++++++y_flat+=+y_true
++++++++if+y_true.shape.ndims+==+y_pred.shape.ndims:
++++++++++++y_flat+=+tf.squeeze(y_flat,+axis=[-1])
++++++++y_true_int+=+tf.cast(y_flat,+tf.int32)

++++++++cls_counts+=+tf.math.bincount(y_true_int)
++++++++cls_counts+=+tf.math.reciprocal_no_nan(tf.cast(cls_counts,+self.dtype))
++++++++weight+=+tf.gather(cls_counts,+y_true_int)
++++++++return+super().update_state(y_true,+y_pred,+sample_weight=weight)|code-block|syntax|javascript|641939|其思想是将每个类的权重设置为与其大小成反比。|641940|这段代码从Autograph中产生了一些警告，但我认为这些都是Autograph的错误，而且指标似乎工作得很好。|641941|entityMap^0|L|P|0|0|0|0^^$0|@$1|2|3|4|5|6|7|Q|8|@$9|R|A|S|B|C]]|D|@]|E|$]]|$1|F|3|G|5|H|7|T|8|@]|D|@]|E|$I|J]]|$1|K|3|L|5|6|7|U|8|@]|D|@]|E|$]]|$1|M|3|N|5|6|7|V|8|@]|D|@]|E|$]]|$1|O|3|-4|5|6|7|W|8|@]|D|@]|E|$]]]|P|$]]

I was facing the same issue so I implemented a custom class based off <code>SparseCategoricalAccuracy</code>:

<pre class="lang-py prettyprint-override"><code>class BalancedSparseCategoricalAccuracy(keras.metrics.SparseCategoricalAccuracy):
 def __init__(self, name='balanced_sparse_categorical_accuracy', dtype=None):
 super().__init__(name, dtype=dtype)

 def update_state(self, y_true, y_pred, sample_weight=None):
 y_flat = y_true
 if y_true.shape.ndims == y_pred.shape.ndims:
 y_flat = tf.squeeze(y_flat, axis=[-1])
 y_true_int = tf.cast(y_flat, tf.int32)

 cls_counts = tf.math.bincount(y_true_int)
 cls_counts = tf.math.reciprocal_no_nan(tf.cast(cls_counts, self.dtype))
 weight = tf.gather(cls_counts, y_true_int)
 return super().update_state(y_true, y_pred, sample_weight=weight)
</code></pre>

The idea is to set each class weight inversely proportional to its size.

This code produces some warnings from Autograph but I believe those are Autograph bugs, and the metric seems to work fine.

blocks|key|633736|text|我还没有测试过这段代码，，但是看看tensorflow==2.1.0的source+code，这可能适用于二进制分类的情况：|type|unstyled|depth|inlineStyleRanges|offset|length|style|BOLD|CODE|entityRanges|data|633737|from+tensorflow.keras.metrics+import+Recall
from+tensorflow.python.ops+import+math_ops


class+BalancedBinaryAccuracy(Recall):
++++def+result(self):
++++++++result+=+(math_ops.div_no_nan(self.true_positives,+self.true_positives+%2B+self.false_negatives)+%2B
++++++++++++++++++math_ops.div_no_nan(self.true_negatives,+self.true_negatives+%2B+self.false_positives))+/+2
++++++++return+result[0]+if+len(self.thresholds)+==+1+else+result|code-block|syntax|javascript|633738|entityMap|0|LINK|mutability|MUTABLE|url|https://github.com/tensorflow/tensorflow/blob/v2.1.0/tensorflow/python/keras/metrics.py#L1318-L1342^0|0|C|H|H|Z|B|0|0|0^^$0|@$1|2|3|4|5|6|7|T|8|@$9|U|A|V|B|C]|$9|W|A|X|B|D]]|E|@$9|Y|A|Z|1|10]]|F|$]]|$1|G|3|H|5|I|7|11|8|@]|E|@]|F|$J|K]]|$1|L|3|-4|5|6|7|12|8|@]|E|@]|F|$]]]|M|$N|$5|O|P|Q|F|$R|S]]]]

I have not tested this code yet, but looking at the <a href="https://github.com/tensorflow/tensorflow/blob/v2.1.0/tensorflow/python/keras/metrics.py#L1318-L1342" rel="nofollow noreferrer">source code</a> of <code>tensorflow==2.1.0</code>, this might work for the binary classification case:

<pre><code>from tensorflow.keras.metrics import Recall
from tensorflow.python.ops import math_ops


class BalancedBinaryAccuracy(Recall):
 def result(self):
 result = (math_ops.div_no_nan(self.true_positives, self.true_positives + self.false_negatives) +
 math_ops.div_no_nan(self.true_negatives, self.true_negatives + self.false_positives)) / 2
 return result[0] if len(self.thresholds) == 1 else result
</code></pre>

blocks|key|3861966|text|我不是Tensorflow方面的专家，但是在tf源代码中使用了一些度量实现之间的模式匹配，我想出了以下方法|type|unstyled|depth|inlineStyleRanges|entityRanges|data|3861967|from+tensorflow.python.keras+import+backend+as+K
from+tensorflow.python.keras.metrics+import+Metric
from+tensorflow.python.keras.utils+import+metrics_utils
from+tensorflow.python.ops+import+init_ops
from+tensorflow.python.ops+import+math_ops
from+tensorflow.python.keras.utils.generic_utils+import+to_list

class+BACC(Metric):

++++def+__init__(self,+thresholds=None,+top_k=None,+class_id=None,+name=None,+dtype=None):
++++++++super(BACC,+self).__init__(name=name,+dtype=dtype)
++++++++self.init_thresholds+=+thresholds
++++++++self.top_k+=+top_k
++++++++self.class_id+=+class_id

++++++++default_threshold+=+0.5+if+top_k+is+None+else+metrics_utils.NEG_INF
++++++++self.thresholds+=+metrics_utils.parse_init_thresholds(
++++++++++++thresholds,+default_threshold=default_threshold)
++++++++self.true_positives+=+self.add_weight(
++++++++++++'true_positives',
++++++++++++shape=(len(self.thresholds),),
++++++++++++initializer=init_ops.zeros_initializer)
++++++++self.true_negatives+=+self.add_weight(
++++++++++++'true_negatives',
++++++++++++shape=(len(self.thresholds),),
++++++++++++initializer=init_ops.zeros_initializer)
++++++++self.false_positives+=+self.add_weight(
++++++++++++'false_positives',
++++++++++++shape=(len(self.thresholds),),
++++++++++++initializer=init_ops.zeros_initializer)
++++++++self.false_negatives+=+self.add_weight(
++++++++++++'false_negatives',
++++++++++++shape=(len(self.thresholds),),
++++++++++++initializer=init_ops.zeros_initializer)

++++def+update_state(self,+y_true,+y_pred,+sample_weight=None):

++++++++return+metrics_utils.update_confusion_matrix_variables(
++++++++++++{
++++++++++++++++metrics_utils.ConfusionMatrix.TRUE_POSITIVES:+self.true_positives,
++++++++++++++++metrics_utils.ConfusionMatrix.TRUE_NEGATIVES:+self.true_negatives,
++++++++++++++++metrics_utils.ConfusionMatrix.FALSE_POSITIVES:+self.false_positives,
++++++++++++++++metrics_utils.ConfusionMatrix.FALSE_NEGATIVES:+self.false_negatives,
++++++++++++},
++++++++++++y_true,
++++++++++++y_pred,
++++++++++++thresholds=self.thresholds,
++++++++++++top_k=self.top_k,
++++++++++++class_id=self.class_id,
++++++++++++sample_weight=sample_weight)

++++def+result(self):
++++++++"""
++++++++Returns+the+Balanced+Accuracy+(average+between+recall+and+specificity)
++++++++"""
++++++++result+=+(math_ops.div_no_nan(self.true_positives,+self.true_positives+%2B+self.false_negatives)+%2B
++++++++++++++++++math_ops.div_no_nan(self.true_negatives,+self.true_negatives+%2B+self.false_positives))+/+2
++++++++
++++++++return+result

++++def+reset_states(self):
++++++++num_thresholds+=+len(to_list(self.thresholds))
++++++++K.batch_set_value(
++++++++++++[(v,+np.zeros((num_thresholds,)))+for+v+in+self.variables])

++++def+get_config(self):
++++++++config+=+{
++++++++++++'thresholds':+self.init_thresholds,
++++++++++++'top_k':+self.top_k,
++++++++++++'class_id':+self.class_id
++++++++}
++++++++base_config+=+super(BACC,+self).get_config()
++++++++return+dict(list(base_config.items())+%2B+list(config.items()))|code-block|syntax|javascript|3861968|我简单地将源代码中的Recall类实现作为模板，并对其进行了扩展，以确保定义了TP、TN、FP和FN。|offset|length|style|CODE|3861969|在那之后，我修改了result方法，这样它就可以计算出平衡的精度，就是这样:)|3861970|我将结果与sklearn的平衡准确率分数和匹配的值进行了比较，因此我认为它是正确的，但请仔细检查以防万一。|3861971|entityMap^0|0|0|A|6|0|9|6|0|5|7|0^^$0|@$1|2|3|4|5|6|7|S|8|@]|9|@]|A|$]]|$1|B|3|C|5|D|7|T|8|@]|9|@]|A|$E|F]]|$1|G|3|H|5|6|7|U|8|@$I|V|J|W|K|L]]|9|@]|A|$]]|$1|M|3|N|5|6|7|X|8|@$I|Y|J|Z|K|L]]|9|@]|A|$]]|$1|O|3|P|5|6|7|10|8|@$I|11|J|12|K|L]]|9|@]|A|$]]|$1|Q|3|-4|5|6|7|13|8|@]|9|@]|A|$]]]|R|$]]

I'm not an expert in Tensorflow but using a bit of pattern matching between metrics implementations in the tf source code I came up with this
<pre><code>from tensorflow.python.keras import backend as K
from tensorflow.python.keras.metrics import Metric
from tensorflow.python.keras.utils import metrics_utils
from tensorflow.python.ops import init_ops
from tensorflow.python.ops import math_ops
from tensorflow.python.keras.utils.generic_utils import to_list

class BACC(Metric):

 def __init__(self, thresholds=None, top_k=None, class_id=None, name=None, dtype=None):
 super(BACC, self).__init__(name=name, dtype=dtype)
 self.init_thresholds = thresholds
 self.top_k = top_k
 self.class_id = class_id

 default_threshold = 0.5 if top_k is None else metrics_utils.NEG_INF
 self.thresholds = metrics_utils.parse_init_thresholds(
 thresholds, default_threshold=default_threshold)
 self.true_positives = self.add_weight(
 'true_positives',
 shape=(len(self.thresholds),),
 initializer=init_ops.zeros_initializer)
 self.true_negatives = self.add_weight(
 'true_negatives',
 shape=(len(self.thresholds),),
 initializer=init_ops.zeros_initializer)
 self.false_positives = self.add_weight(
 'false_positives',
 shape=(len(self.thresholds),),
 initializer=init_ops.zeros_initializer)
 self.false_negatives = self.add_weight(
 'false_negatives',
 shape=(len(self.thresholds),),
 initializer=init_ops.zeros_initializer)

 def update_state(self, y_true, y_pred, sample_weight=None):

 return metrics_utils.update_confusion_matrix_variables(
 {
 metrics_utils.ConfusionMatrix.TRUE_POSITIVES: self.true_positives,
 metrics_utils.ConfusionMatrix.TRUE_NEGATIVES: self.true_negatives,
 metrics_utils.ConfusionMatrix.FALSE_POSITIVES: self.false_positives,
 metrics_utils.ConfusionMatrix.FALSE_NEGATIVES: self.false_negatives,
 },
 y_true,
 y_pred,
 thresholds=self.thresholds,
 top_k=self.top_k,
 class_id=self.class_id,
 sample_weight=sample_weight)

 def result(self):
 &quot;&quot;&quot;
 Returns the Balanced Accuracy (average between recall and specificity)
 &quot;&quot;&quot;
 result = (math_ops.div_no_nan(self.true_positives, self.true_positives + self.false_negatives) +
 math_ops.div_no_nan(self.true_negatives, self.true_negatives + self.false_positives)) / 2
 
 return result

 def reset_states(self):
 num_thresholds = len(to_list(self.thresholds))
 K.batch_set_value(
 [(v, np.zeros((num_thresholds,))) for v in self.variables])

 def get_config(self):
 config = {
 'thresholds': self.init_thresholds,
 'top_k': self.top_k,
 'class_id': self.class_id
 }
 base_config = super(BACC, self).get_config()
 return dict(list(base_config.items()) + list(config.items()))
</code></pre>
I've simply taken the <code>Recall</code> class implementation from the source code as a template and I extended it to make sure it has a TP,TN,FP and FN defined.
After that I modified the <code>result</code> method so that it calculates balanced accuracy and voila :)
I compared the results from this with <code>sklearn</code>'s balanced accuracy score and the values matched so I think it's correct, but do double check just in case.

I am implementing a CNN for an highly unbalanced classification problem and I would like to implement custum metrics in tensorflow to use the Select Best Model callback.
Specifically I would like to implement the balanced accuracy score, which is the average of the recall of each class (see sklearn implementation <a href="https://scikit-learn.org/stable/modules/generated/sklearn.metrics.balanced_accuracy_score.html" rel="nofollow noreferrer">here</a>), does someone know how to do it?

Balanced Accuracy Score in Tensorflow

翻译质量差，导致语言生硬或混乱。

没有提供实际的解决方法或示例。

解答不清晰，无法理解或解决问题。

页面排版不美观，阅读体验差。

文章

问答

视频

学习中心

腾讯云实验室

直播

竞赛

腾讯云代码分析专区

腾讯iOA零信任安全管理系统专区

腾讯云架构师技术同盟交流圈

腾讯云数据库专区

腾讯云顾问专区

腾讯云原生专区

腾讯混元专区

腾讯云TCE专区

腾讯云Lighthouse专区

腾讯云HAI专区

腾讯云Edgeone专区

腾讯云存储专区

腾讯云智能专区

腾讯轻联专区 

腾讯云开发专区

TAPD专区

腾讯轻量云游戏服专区

腾讯云最具价值专家

腾讯云架构师技术同盟

腾讯云创作之星

腾讯云开发者先锋

腾讯云代码助手

云原生构建

TAPD 敏捷项目管理

Cloud Studio

SDK中心

API中心

命令行工具

涵盖代码开发、场景应用、自动测试全流程，助你从零构建专属AI助手

一站式MCP教程库，解锁AI应用新玩法

我正在为一个高度不平衡的分类问题实现一个CNN，我想在tensorflow中实现客户指标，以使用Select Best Model回调。具体地说，我想实现平衡的准确率分数，这是每个类的召回率的平均值(参见sklearn implementation )，有人知道如何做到这一点吗？

问Tensorflow中的平衡精度分数
EN

Stack Overflow用户

社区

活动

圈层

关于

腾讯云开发者

热门产品

热门推荐

更多推荐

问Tensorflow中的平衡精度分数EN