标签: conv-neural-network

这是对三元组学习的简短回顾。我使用三个具有共享权重的卷积神经网络来生成人脸嵌入（锚、正、负），损失描述如下。

三重态损失：

anchor_output = ...  # shape [None, 128]
positive_output = ...  # shape [None, 128]
negative_output = ...  # shape [None, 128]

d_pos = tf.reduce_sum(tf.square(anchor_output - positive_output), 1)
d_neg = tf.reduce_sum(tf.square(anchor_output - negative_output), 1)

loss = tf.maximum(0., margin + d_pos - d_neg)
loss = tf.reduce_mean(loss)

当我只选择硬三元组 ( distance(anchor, positive) < distance(anchor, negative)) 时，损失非常小：0.08。当我选择所有三元组时，损失变得更大0.17855。这些只是 10 000 个三联体对的测试值，但我在实际集合（600 000 个三联体对）上得到了类似的结果。

为什么会出现这种情况？这是对的吗？

我使用 SGD 进行动量，从学习率 0.001开始。

如果我的输入大小为 5x5，步长为 1x1，滤波器大小为 3x3，那么我可以在纸上计算出卷积矩阵的最终大小将为 3x3。

但是，当输入大小更改为 28x28 或 50x50 时，我如何计算纸上卷积矩阵的大小？有什么公式或技巧可以做到这一点吗？

我正在尝试在 PyTorch 中实现迁移学习方法。这是我正在使用的数据集：Dog-Breed

这是我正在遵循的步骤。

1. Load the data and read csv using pandas.
2. Resize (60, 60) the train images and store them as numpy array.
3. Apply stratification and split the train data into 7:1:2 (train:validation:test)
4. use the resnet18 model and train. 

数据集位置

LABELS_LOCATION = './dataset/labels.csv'
TRAIN_LOCATION = './dataset/train/'
TEST_LOCATION = './dataset/test/'
ROOT_PATH = './dataset/'

读取 CSV（labels.csv）

def read_csv(csvf):
    # print(pandas.read_csv(csvf).values)
    data=pandas.read_csv(csvf).values
    labels_dict = dict(data)
    idz=list(labels_dict.keys())
    clazz=list(labels_dict.values())
    return labels_dict,idz,clazz

我这样做是因为有一个约束，我将在接下来使用 DataLoader 加载数据时提到该约束。

def class_hashmap(class_arr):
    uniq_clazz = Counter(class_arr) …

我无法为一维输入向量构建 CNN。

输入值示例：

df_x.iloc[300]
Out[33]:
0     0.571429
1     1.000000
2     0.971429
3     0.800000
4     1.000000
5     0.142857
6     0.657143
7     0.857143
8     0.971429
9     0.000000
10    0.000000
11    0.000000
12    0.000000
13    0.000000
14    0.000000
15    0.000000
Name: 300, dtype: float64

输出值示例：

df_y.iloc[300]
Out[34]:
0     0.571429
1     0.914286
2     1.000000
3     0.971429
4     0.800000
5     1.000000
6     0.914286
7     0.942857
8     0.800000
9     0.657143
10    0.857143
11    0.971429
12    0.000000
13    0.000000
14    0.000000
15    0.000000
16    0.000000
17    0.000000 …

在Yolo v3的滤波器的计算公式中，边界框的数量除以3（为什么？）。

为此，边界框的数量只允许是3的倍数。

但我想设置一个边界框。这可能吗？

如果可以的话，过滤器需要多少个？

下面是我想实现的代码。

[convolutional]
batch_normalize=1
size=3
stride=1
pad=1
filters=256
activation=leaky

[convolutional]
size=1
stride=1
pad=1
filters=????????? 
activation=linear

[yolo]
mask = 0,1,2
anchors = 10,13
classes=20
num=1
jitter=.3
ignore_thresh = .5
truth_thresh = 1
random=1

我尝试使用 CNN 进行二元分类。使用与https://www.udemy.com/deeplearning/上解释的完全相同的代码完成。但是，当我在我的 PC（CPU-8 GB RAM）上运行代码时，即使我将批量大小指定为 32，训练在每个 epoch 中的单个项目执行速度非常慢。但是，它在教师的计算机（尽管他也使用CPU）。训练集总共包含 8000 张图像，测试集包含 2000 张图像。我知道对于这么大的数据，处理肯定会很慢，但我注意到它比平常慢得多。

from keras.layers import Dense
from keras.layers import Convolution2D
from keras.layers import MaxPooling2D
from keras.layers import Flatten
from keras.models import Sequential
classifier=Sequential()

classifier.add(Convolution2D(32, (3, 3 ), input_shape=(64,64,3),activation='relu'))

classifier.add(MaxPooling2D(pool_size=(2 , 2)))

classifier.add(Flatten())

classifier.add(Dense(units=128, activation='relu'))
classifier.add(Dense(units=1, activation='sigmoid'))

classifier.compile(optimizer='adam' , loss='binary_crossentropy' ,metrics=['accuracy'])


from keras.preprocessing.image import ImageDataGenerator


train_datagen = ImageDataGenerator(
        rescale=1./255,
        shear_range=0.2,
        zoom_range=0.2,
        horizontal_flip=True)


test_datagen = ImageDataGenerator(rescale=1./255)


training_set = train_datagen.flow_from_directory(
        'dataset/training_set',
        target_size=(64, 64), #since 64,64,pixels
        batch_size=32,
        class_mode='binary')



test_set= test_datagen.flow_from_directory(
        'dataset/test_set', …

我正在使用自己的图像数据生成器。它生成图像批次的 0 、90、180 和 270 度旋转版本，并返回它们及其类别。我使用内置ImageDataGenerator函数来测试模型。然而flow_from_directory会产生不同的类别索引。的输出train_generator.class_indices是{'0': 0, '90': 1, '180': 2, '270': 3}. 但test_generator.class_indices归来{'0': 0, '180': 1, '270': 2, '90': 3}。我可以简单地更改旋转角度的顺序，但这个问题是由操作系统的文件系统引起的，我将在不同的操作系统上运行代码。在这种情况下，我需要一个自动化的解决方案。有没有办法改变flow_from_directory方法的类索引？

我正在比较用于海上搜救 (SAR) 目的的物体检测模型。从我使用的模型中，我得到了改进版 YOLOv3 的最佳结果，用于小物体检测和 FASTER RCNN。

对于 YOLOv3，我得到了最好的 mAP@50，但是对于 FASTER RCNN，我得到了更好的所有其他指标（精度、召回率、F1 分数）。现在我想知道如何阅读它以及在这种情况下哪个模型真的更好？

我想补充一点，数据集中只有两个类：小对象和大对象。我们选择这个解决方案是因为对我们来说，对象在类别之间的区别不像检测任何人类来源的对象那么重要。

然而，小的物体并不意味着小的 GT 边界框。这些是实际面积很小的物体 - 小于 2 平方米（例如人、浮标）。大物体是面积较大的物体（小船、轮船、独木舟等）。

以下是每个类别的结果：

以及来自数据集的两个示例图像（使用 YOLOv3 检测）：

我一直在阅读有关 Conv 网络的文章，并且自己编写了一些模型。当我看到其他模型的可视化图表时，它显示每一层都比最后一层更小更深。层有 3 个维度，如 256x256x32。这第三个数字是什么？我假设前两个数字是节点数，但我不知道深度是多少。

据我所知，这Triplet Loss是一个损失函数，它减少了锚点和正值之间的距离，但减少了锚点和负值之间的距离。此外，还添加了一个边距。

所以对于例子让我们假设： a Siamese Network，它给出了嵌入：

anchor_output = [1,2,3,4,5...] # embedding given by the CNN model
positive_output = [1,2,3,4,4...]
negative_output= [53,43,33,23,13...]

而且我认为我可以获得三重损失，例如：（我认为我必须使用 Lambda 层左右将其作为损失）

# calculate triplet loss
d_pos = tf.reduce_sum(tf.square(anchor_output - positive_output), 1)
d_neg = tf.reduce_sum(tf.square(anchor_output - negative_output), 1)

loss = tf.maximum(0., margin + d_pos - d_neg)
loss = tf.reduce_mean(loss)

那么到底是什么： tfa.losses.TripletHardLoss和 tfa.losses.TripletSemiHardLoss

据我所知，Semi 和 hard 是Siamese Techniques推动模型学习更多的数据生成技术类型。

我的想法：正如我在这篇文章中学到的，我认为你可以：

1. 生成一批说 3 个图像并制作一对 3 个27图像
2. 丢弃所有无效对（所有 i,j,k …