小编Jon*_*han的帖子

假设我有以下参数的网络:

1. 用于语义分割的完全卷积网络
2. 损失=加权二元交叉熵(但它可能是任何损失函数,无所谓)
3. 5类 - 输入是图像,地面实例是二元掩模
4. 批量大小= 16

现在,我知道损失是按以下方式计算的:二进制交叉熵应用于图像中关于每个类的每个像素.基本上,每个像素将有5个损耗值

这一步后会发生什么？

当我训练我的网络时,它只为一个纪元打印一个损失值.在生成单个值时需要进行多种级别的损失累积,以及在文档/代码中它的发生方式根本不明确.

1. 首先结合的是 - (1)类的损失值(例如5个值(每个类一个)得到每个像素组合)然后是图像中的所有像素或(2)图像中的每个像素个别班级,然后所有班级损失合并？
2. 这些不同的像素组合究竟是如何发生的 - 它在何处被求和/在哪里被平均？
3. Keras的binary_crossentropy平均值超过axis=-1.那么这是所有类的所有像素的平均值还是所有类的平均值,还是两者都是？

以不同的方式说明:不同类别的损失如何组合以产生图像的单一损失值？

这完全没有在文档中解释,对于对keras进行多类预测的人来说非常有用,无论网络类型如何.这是keras代码开始的链接,其中一个首先通过了损失函数.

我能找到最接近解释的是

loss:String(目标函数的名称)或目标函数.看到损失.如果模型具有多个输出,则可以通过传递字典或损失列表在每个输出上使用不同的损失.然后,模型将最小化的损失值将是所有单个损失的总和

来自keras.那么这是否意味着图像中每个类的损失只是总和？

此处的示例代码供有人试用.这是从Kaggle借来的基本实现,并针对多标签预测进行了修改:

# Build U-Net model
num_classes = 5
IMG_DIM = 256
IMG_CHAN = 3
weights = {0: 1, 1: 1, 2: 1, 3: 1, 4: 1000} #chose an extreme value just to check for any reaction
inputs = Input((IMG_DIM, IMG_DIM, IMG_CHAN))
s = Lambda(lambda x: …

我不太了解以下内容：

在Shelhamer等人提出的用于语义分割的FCN中，他们提出了像素到像素的预测以构造图像中对象的蒙版/精确位置。

在用于生物医学图像分割的FCN的略微修改版本中，U-net的主要区别似乎是“与从收缩路径中相应裁剪的特征图的串联”。

现在，为什么此功能特别是在生物医学细分方面有所作为？我可以指出的是，生物医学图像与其他数据集的主要区别在于，在生物医学图像中，定义对象的特征集不如每天常见的对象丰富。数据集的大小也受到限制。但是，此额外功能是否受这两个事实或其他原因的启发？

我正在尝试了解sigmoid_cross_entropy损失函数对图像分割神经网络的作用：

以下是相关的Tensorflow源代码：

zeros = array_ops.zeros_like(logits, dtype=logits.dtype)
cond = (logits >= zeros)
relu_logits = array_ops.where(cond, logits, zeros)
neg_abs_logits = array_ops.where(cond, -logits, logits)
return math_ops.add(
    relu_logits - logits * labels,
    math_ops.log1p(math_ops.exp(neg_abs_logits)), name=name)

我的主要问题是为什么math_ops.add()在返程中会有一个？加法是指图像中每个像素的损失总和，还是总和有所不同？我无法正确地遵循尺寸变化来推断总和。

我有以下图像：

我使用以下代码使用以下代码来概述该图像中的所有圆形斑点：

import numpy as np
import cv2

im = cv2.imread('im.jpg')

imgray = cv2.cvtColor(im,cv2.COLOR_BGR2GRAY)
ret,thresh = cv2.threshold(imgray,200,255,0)
contours, hierarchy = cv2.findContours(thresh,cv2.RETR_TREE,cv2.CHAIN_APPROX_SIMPLE)
cv2.drawContours(im,contours,-1,(0,0,255),1)

#(B,G,R)

cv2.imshow('image',im)
cv2.waitKey(0)
cv2.destroyAllWindows()

并产生此图像：

第一步很棒。但是我很难为蓝色斑点绘制不同的颜色轮廓。我尝试使用多个轮廓：

import numpy as np
import cv2

im = cv2.imread('im.jpg')

imgray = cv2.cvtColor(im,cv2.COLOR_BGR2GRAY)
ret,thresh = cv2.threshold(imgray,200,255,0)
ret, thresh2 = cv2.threshold(imgray,130,255,0)
contours, hierarchy = cv2.findContours(thresh,cv2.RETR_TREE,cv2.CHAIN_APPROX_SIMPLE)
contours2, hierarchy2 = cv2.findContours(thresh2,cv2.RETR_TREE,cv2.CHAIN_APPROX_SIMPLE)

cv2.drawContours(im,contours,-1,(0,0,255),1)
cv2.drawContours(im,contours2,-1,(0,255,0),1)

#(B,G,R)

cv2.imshow('image',im)
cv2.waitKey(0)
cv2.destroyAllWindows()

图像显示如下：

这种方法的第一个问题是它不能准确地仅勾勒出蓝色斑点。此外，threshold必须根据光线等情况为每个图像修改功能中的灵敏度等级。是否有更流畅的方法？

我有2个数据表的尺寸4x25.每个表都来自不同的时间点,但具有完全相同的元数据,实质​​上是相同的列和行标题.

鉴于列数很多,我认为最好heatmap使用seaborn库来表示Python.但是,我需要在同一个图中包含两个表.我能够创建一个表示单个数据表的热图.

df = pd.DataFrame(raw_data)
ax = sns.heatmap(df)
ax.set(yticklabels=labels)

但是,我不确定如何将两个数据表组合到同一个热图中.我能想到的唯一的办法是只创建一个新的DataFrame维度4x50,然后两个表放入一个和情节,使用热图.但是,我需要帮助解决以下问题:

1. 我不确定如何在热图的中间画一条线来区分2个表中的数据.读者看到列开始重复的位置以实现新数据的开始位置是令人讨厌的.
2. 一个更好的解决办法是申请2组数据的2个不同的着色方案中相同的热图,而不是只是简单地画线拦腰.

对上述问题的任何帮助都会非常有帮助.

注意:我并不像上面提到的那样,甚至不使用热图来表示数据.如果还有其他绘图建议,请告诉我.

这是我正在使用的代码（主要从Kaggle提取）：

inputs = Input((IMG_HEIGHT, IMG_WIDTH, IMG_CHANNELS))
...
outputs = Conv2D(4, (1, 1), activation='sigmoid') (c9)

model = Model(inputs=[inputs], outputs=[outputs])
model.compile(optimizer='adam', loss='dice', metrics=[mean_iou])

results = model.fit(X_train, Y_train, validation_split=0.1, batch_size=8, epochs=30, class_weight=class_weights)

我有4个班级非常不平衡。A级等于70％，B级= 15％，C级= 10％，D级= 5％。但是，我最关心D类。因此，我进行了以下类型的计算：D_weight = A/D = 70/5 = 14B类和A类的权重依此类推。（如果有更好的方法来选择这些权重，那就放心了）

在最后一行，我想正确设置class_weights和我做它像这样：class_weights = {0: 1.0, 1: 6, 2: 7, 3: 14}。

但是，当我这样做时，出现以下错误。

class_weight 3维尺寸目标不支持。

是否可以在最后一层之后添加一个密集层并将其用作虚拟层，以便我可以传递class_weights然后仅使用最后一个conv2d层的输出进行预测？

如果这不可能，那么我将如何修改损失函数（不过我知道这篇文章，但是，将权重传递给损失函数并不会减少损失，因为损失函数是针对每个类分别调用的）？目前，我正在使用以下损失函数：

def dice_coef(y_true, y_pred):
    smooth = 1.
    y_true_f = K.flatten(y_true)
    y_pred_f = K.flatten(y_pred)
    intersection = K.sum(y_true_f * y_pred_f)
    return (2. * …

当我使用keras的binary_crossentropy作为损失函数（即调用tensorflow的sigmoid_cross_entropy，它似乎只之间产生损耗值[0, 1]。然而，方程本身

# The logistic loss formula from above is
#   x - x * z + log(1 + exp(-x))
# For x < 0, a more numerically stable formula is
#   -x * z + log(1 + exp(x))
# Note that these two expressions can be combined into the following:
#   max(x, 0) - x * z + log(1 + exp(-abs(x)))
# To allow computing gradients at zero, we define custom …

我正在阅读多个相互冲突的 Stackoverflow 帖子，我对现实情况感到非常困惑。

我的问题如下。如果我在128x128x3图像上训练 FCN ，是否可以输入大小为256x256x3或 B)128x128或 C)的图像，因为在训练和测试期间输入必须相同？

考虑 SO post #1。在这篇文章中，它建议图像在输入和输出期间必须具有相同的尺寸。这对我来说很有意义。

SO post #2：在这篇文章中，它表明我们可以在测试期间转发不同大小的图像，如果您执行一些奇怪的挤压操作，这将成为可能。完全不确定这怎么可能。

SO post #3：在这篇文章中，它表明只有深度需要相同，而不是高度和宽度。这怎么可能？

据我了解，底线是，如果我在 上进行训练128x128x3，那么从输入层到第一个 conv 层，（1）会发生固定数量的步幅。因此，（2）固定的特征图大小，相应地，（3）固定数量的权重。如果我突然将输入图像大小更改为512x512x3，则由于大小的差异UNLESS，因此训练和测试中的特征图无法进行比较。

1. 当我输入一个 size 的图像时512x512，只128x128考虑顶部，而忽略图像的其余部分
2. 512x512 图像在被馈送到网络之前被调整大小。

有人可以澄清这一点吗？正如你所看到的，有很多关于这个的帖子没有一个规范的答案。因此，每个人都同意的社区辅助答案将非常有帮助。

我有一个8 GPU集群，当我运行一段Tensorflow代码（如下所示）时，它仅使用一个GPU而不是全部8。我使用确认了这一点nvidia-smi。

# Set some parameters
IMG_WIDTH = 256
IMG_HEIGHT = 256
IMG_CHANNELS = 3
TRAIN_IM = './train_im/'
TRAIN_MASK = './train_mask/'
TEST_PATH = './test/'

warnings.filterwarnings('ignore', category=UserWarning, module='skimage')
num_training = len(os.listdir(TRAIN_IM))
num_test = len(os.listdir(TEST_PATH))
# Get and resize train images
X_train = np.zeros((num_training, IMG_HEIGHT, IMG_WIDTH, IMG_CHANNELS), dtype=np.uint8)
Y_train = np.zeros((num_training, IMG_HEIGHT, IMG_WIDTH, 1), dtype=np.bool)
print('Getting and resizing train images and masks ... ')
sys.stdout.flush()

#load training images
for count, filename in tqdm(enumerate(os.listdir(TRAIN_IM)), total=num_training):
    img = imread(os.path.join(TRAIN_IM, filename))[:,:,:IMG_CHANNELS] …

我知道，从理论上讲，一批网络的损失只是所有单个损失的总和。这反映在用于计算总损耗的Keras代码中。相关的：

            for i in range(len(self.outputs)):
            if i in skip_target_indices:
                continue
            y_true = self.targets[i]
            y_pred = self.outputs[i]
            weighted_loss = weighted_losses[i]
            sample_weight = sample_weights[i]
            mask = masks[i]
            loss_weight = loss_weights_list[i]
            with K.name_scope(self.output_names[i] + '_loss'):
                output_loss = weighted_loss(y_true, y_pred,
                                            sample_weight, mask)
            if len(self.outputs) > 1:
                self.metrics_tensors.append(output_loss)
                self.metrics_names.append(self.output_names[i] + '_loss')
            if total_loss is None:
                total_loss = loss_weight * output_loss
            else:
                total_loss += loss_weight * output_loss

但是，我注意到，当我使用a batch_size=32和a 训练网络时batch_size=64，每个时期的损失值仍然或多或少地相同，只有a~0.05%有所不同。但是，两个网络的准确性都完全相同。因此，从本质上讲，批量大小对网络没有太大影响。

我的问题是，如果我将批处理量加倍，并假设损失确实在被累加，那么损失实际上不应该是以前的两倍，或者至少更大吗？精度保持不变的事实否定了网络可能以更大的批量学习得更好的借口。

无论批次大小如何，损失都大致相同，这一事实使我认为这是平均水平。