Сиамская сеть Pytorch не сходится

Question

Доброе утро всем

Ниже представлена ​​моя реализация сиамской сети pytorch. Я использую размер партии 32, потери MSE и SGD с импульсом 0,9 в качестве оптимизатора.

class SiameseCNN(nn.Module):
    def __init__(self):
        super(SiameseCNN, self).__init__()                                      # 1, 40, 50
        self.convnet = nn.Sequential(nn.Conv2d(1, 8, 7), nn.ReLU(),             # 8, 34, 44
                                    nn.Conv2d(8, 16, 5), nn.ReLU(),             # 16, 30, 40
                                    nn.MaxPool2d(2, 2),                         # 16, 15, 20
                                    nn.Conv2d(16, 32, 3, padding=1), nn.ReLU(), # 32, 15, 20
                                    nn.Conv2d(32, 64, 3, padding=1), nn.ReLU()) # 64, 15, 20
        self.linear1 = nn.Sequential(nn.Linear(64 * 15 * 20, 100), nn.ReLU())
        self.linear2 = nn.Sequential(nn.Linear(100, 2), nn.ReLU())
        
    def forward(self, data):
        res = []
        for j in range(2):
            x = self.convnet(data[:, j, :, :])
            x = x.view(-1, 64 * 15 * 20)
            res.append(self.linear1(x))
        fres = abs(res[1] - res[0])
        return self.linear2(fres)

Каждая партия содержит чередующиеся пары, т.е. [pos, pos], [pos, neg], [pos, pos] и т.д... Однако сеть не сходится, и проблема кажется в том, что fres в сети одинаково для каждой пары (независимо от того, положительная это пара или отрицательная), а выход self.linear2(fres) всегда примерно равно [0.0531, 0.0770]. Это контрастирует с тем, что я ожидал, а именно, что первое значение[0.0531, 0.0770]будет ближе к 1 для положительной пары по мере обучения сети, а второе значение будет ближе к 1 для отрицательной пары. Эти два значения также необходимо суммировать до 1.

Я протестировал точно такую ​​же настройку и те же входные изображения для двухканальной сетевой архитектуры, где вместо подачи [pos, pos] вы бы сложили эти 2 изображения по глубине, например numpy.stack([pos, pos], -1). Размерnn.Conv2d(1, 8, 7) также меняется на nn.Conv2d(2, 8, 7)в этой настройке. Это прекрасно работает.

Я также протестировал точно такие же настройки и входные изображения для традиционного подхода CNN, где я просто передаю в сеть отдельные положительные и отрицательные изображения в градациях серого, вместо того, чтобы складывать их (как в случае с подходом с 2 каналами) или передавать их в сеть. как пары изображений (как в сиамском подходе). Это тоже отлично работает, но результаты не так хороши, как при двухканальном подходе.

РЕДАКТИРОВАТЬ (решения, которые я пробовал):

• Я пробовал несколько различных функций потерь, включая HingeEmbeddingLoss и CrossEntropyLoss, все они приводили к более или менее той же проблеме. Поэтому я думаю, что можно с уверенностью сказать, что проблема не вызвана используемой функцией потерь; MSELoss.
• Различные размеры партий также, похоже, не влияют на проблему.
• Я попытался увеличить количество обучаемых параметров, как это было предложено в модели Кераса для сиамской сети, не обучающейся и всегда прогнозирующей один и тот же выход. Также не работает.
• Пытался изменить архитектуру сети, как здесь реализовано: https://github.com/benmyara/pytorch-examples/blob/master/notebooks/1_NeuralNetworks/9_siamese_nn.ipynb. Другими словами, изменил прямой проход на следующий код. Также изменил потерю на CrossEntropy, а оптимизатор на Адама. Все равно не повезло:

def forward(self, data):
    res = []
    for j in range(2):
        x = self.convnet(data[:, j, :, :])
        x = x.view(-1, 64 * 15 * 20)
        res.append(x)
    fres = self.linear2(self.linear1(abs(res[1] - res[0]))))
    return fres 

• Я также попытался изменить всю сеть с CNN на линейную, как это реализовано здесь: https://github.com/benmyara/pytorch-examples/blob/master/notebooks/1_NeuralNetworks/9_siamese_nn.ipynb. По-прежнему не работает.
• Пытался использовать намного больше данных, как предлагается здесь: Модель Кераса для сиамской сети, не обучающаяся и всегда прогнозирующая один и тот же выход. Не повезло...
• Пытался использовать torch.nn.PairwiseDistance между выходами convnet. Сделано какое-то улучшение; сеть начинает сходиться в течение первых нескольких эпох, а затем каждый раз достигает одного и того же плато:

def forward(self, data):
    res = []
    for j in range(2):
        x = self.convnet(data[:, j, :, :])
        res.append(x)
    pdist = nn.PairwiseDistance(p=2)
    diff = pdist(res[1], res[0])
    diff = diff.view(-1, 64 * 15 * 10)
    fres = self.linear2(self.linear1(diff))
    return fres

Еще одна вещь, на которую следует обратить внимание, это то, что в контексте моего исследования сиамская сеть обучается для каждого объекта. Таким образом, первый класс связан с изображениями, содержащими рассматриваемый объект, а второй класс связан с изображениями, содержащими другие объекты. Не знаю, может ли это быть причиной проблемы. Однако это не проблема в контексте подходов традиционного CNN и 2-канального CNN.

По запросу вот мой обучающий код:

model = SiameseCNN().cuda()
ls_fn = torch.nn.BCELoss()
optim = torch.optim.SGD(model.parameters(),  lr=1e-6, momentum=0.9)
epochs = np.arange(100)
eloss = []
for epoch in epochs:
    model.train()
    train_loss = []
    for x_batch, y_batch in dp.train_set:
        x_var, y_var = Variable(x_batch.cuda()), Variable(y_batch.cuda())
        y_pred = model(x_var)
        loss = ls_fn(y_pred, y_var)
        train_loss.append(abs(loss.item()))
        optim.zero_grad()
        loss.backward()
        optim.step()
    eloss.append(np.mean(train_loss))
    print(epoch, np.mean(train_loss))

Запись dp в dp.train_set это класс с атрибутами train_set, valid_set, test_set, где каждый набор создается следующим образом:

DataLoader(TensorDataset(torch.Tensor(x), torch.Tensor(y)), batch_size=bs)

В соответствии с запросом, вот пример прогнозируемой вероятности и истинной метки, где вы можете видеть, что модель, похоже, не обучается:

Predicted:  0.5030623078346252 Label:  1.0
Predicted:  0.5030624270439148 Label:  0.0
Predicted:  0.5030624270439148 Label:  1.0
Predicted:  0.5030625462532043 Label:  0.0
Predicted:  0.5030625462532043 Label:  1.0
Predicted:  0.5030626654624939 Label:  0.0
Predicted:  0.5030626058578491 Label:  1.0
Predicted:  0.5030627250671387 Label:  0.0
Predicted:  0.5030626654624939 Label:  1.0
Predicted:  0.5030627846717834 Label:  0.0
Predicted:  0.5030627250671387 Label:  1.0
Predicted:  0.5030627846717834 Label:  0.0
Predicted:  0.5030627250671387 Label:  1.0
Predicted:  0.5030628442764282 Label:  0.0
Predicted:  0.5030627846717834 Label:  1.0
Predicted:  0.5030628442764282 Label:  0.0

Answer 1

Задача решена. Оказывается, сеть будет предсказывать один и тот же результат каждый раз, если вы каждый раз будете давать ей одни и те же изображения. Небольшая ошибка индексации с моей стороны во время разделения данных. Спасибо всем за помощь и поддержку. Вот пример конвергенции, как сейчас:

0 0.20198837077617646
1 0.17636818194389342
2 0.15786472541093827
3 0.1412761415243149
4 0.126698794901371
5 0.11397973036766053
6 0.10332610329985618
7 0.09474560652673245
8 0.08779258838295936
9 0.08199785630404949
10 0.07704121413826942
11 0.07276330365240574
12 0.06907484836131335
13 0.06584368328005076
14 0.06295975042134523
15 0.06039590438082814
16 0.058096024941653016

Answer 2

Я считаю, что ваш подход правильный и у вас все хорошо. Что мне кажется немного странным, так это последний слой с активацией RELU. Обычно с сиамскими сетями вы хотите вывести с высокой вероятностью, когда два входных изображения принадлежат одному классу, и с низкой вероятностью в противном случае. Таким образом, вы можете реализовать это с помощью одного выхода нейрона и функции активации сигмовидной кишки.

Поэтому я бы переопределил вашу сеть следующим образом:

class SiameseCNN(nn.Module):
    def __init__(self):
        super(SiameseCNN, self).__init__()                                      # 1, 40, 50
        self.convnet = nn.Sequential(nn.Conv2d(1, 8, 7), nn.ReLU(),             # 8, 34, 44
                                    nn.Conv2d(8, 16, 5), nn.ReLU(),             # 16, 30, 40
                                    nn.MaxPool2d(2, 2),                         # 16, 15, 20
                                    nn.Conv2d(16, 32, 3, padding=1), nn.ReLU(), # 32, 15, 20
                                    nn.Conv2d(32, 64, 3, padding=1), nn.ReLU()) # 64, 15, 20
        self.linear1 = nn.Sequential(nn.Linear(64 * 15 * 20, 100), nn.ReLU())
        self.linear2 = nn.Sequential(nn.Linear(100, 1), nn.Sigmoid())
        
    def forward(self, data):
        for j in range(2):
            x = self.convnet(data[:, j, :, :])
            x = x.view(-1, 64 * 15 * 20)
            res.append(self.linear1(x))
        fres = res[0].sub(res[1]).pow(2)
        return self.linear2(fres)

Затем, чтобы тренироваться последовательно, вы должны использовать бинарную кроссентропию:

criterion_fn = torch.nn.BCELoss()

И не забудьте установить метки на 1, если оба входных изображения принадлежат одному классу.

Кроме того, я рекомендую вам использовать небольшое выпадение, примерно 30% вероятности выпадения нейрона после linear1 слой.