Pytorch: Изучаемый порог для активаций отсечения

Question

Как правильно обрезать активации ReLU с обучаемым порогом?Вот как я это реализовал, однако я не уверен, что это правильно:

class Net(nn.Module):
    def __init__(self):
        super(Net, self).__init__()

        self.act_max = nn.Parameter(torch.Tensor([0]), requires_grad=True)

        self.conv1 = nn.Conv2d(3, 32, kernel_size=5)
        self.conv2 = nn.Conv2d(32, 64, kernel_size=5)
        self.pool = nn.MaxPool2d(2, 2)
        self.relu = nn.ReLU()
        self.linear = nn.Linear(64 * 5 * 5, 10)

    def forward(self, input):
        conv1 = self.conv1(input)
        pool1 = self.pool(conv1)
        relu1 = self.relu(pool1)

        relu1[relu1 > self.act_max] = self.act_max

        conv2 = self.conv2(relu1)
        pool2 = self.pool(conv2)
        relu2 = self.relu(pool2)
        relu2 = relu2.view(relu2.size(0), -1)
        linear = self.linear(relu2)
        return linear


model = Net()
torch.nn.init.kaiming_normal_(model.parameters)
nn.init.constant(model.act_max, 1.0)
model = model.cuda()
optimizer = torch.optim.SGD(model.parameters(), lr=0.001)
for epoch in range(100):
    for i in range(1000):
        output = model(input)
        loss = nn.CrossEntropyLoss()(output, label)
        optimizer.zero_grad()
        loss.backward()
        optimizer.step()
        model.act_max.data = model.act_max.data - 0.001 * model.act_max.grad.data

Мне пришлось добавить последнюю строку, потому что без нее значение по какой-то причине не обновилось бы.

ОБНОВЛЕНИЕ: я сейчас пытаюсь метод для вычисления верхней границы (act_max) на основе градиентов для активаций:

1. Для всех активаций выше порога (relu1 [relu1> self.act_max]),посмотрите на их градиенты: вычислите среднее направление, на которое указывают все эти градиенты.
2. Для всех положительных активаций ниже порогового значения вычислите средний градиент, в каком направлении они хотят измениться.
3. Суммаиз этих средних градиентов определяет направление и величину изменения для act_max.

Answer 1

С этим кодом есть две проблемы.

1. Первый уровень реализации заключается в том, что вы используете операцию на месте, которая, как правило, плохо работает с autograd.Вместо

relu1[relu1 > self.act_max] = self.act_max

вы должны использовать операцию «без места», например

relu1 = torch.where(relu1 > self.act_max, self.act_max, relu1)

Другой является более общим: нейронные сети обычно обучаются с использованием методов градиентного спуска, и пороговые значения могут не иметь градиента - функция потерь не дифференцируема по отношению к пороговым значениям.

В вашей модели вывы используете грязный хакерранд (пишете ли вы как есть или используете torch.where) - model.act_max.grad.data определяется только потому, что для некоторых элементов их значение установлено на model.act_max.Но этот градиент ничего не знает о , почему им присвоено это значение.Чтобы сделать вещи более конкретными, давайте определим операцию отсечки C(x, t), которая определяет, будет ли x выше или ниже порога t

C(x, t) = 1 if x < t else 0

и запишем вашу операцию отсечения как продукт

clip(x, t) = C(x, t) * x + (1 - C(x, t)) * t

затем вы можете видеть, что порог t имеет двоякое значение: он контролирует, когда необходимо срезать (внутри C), и контролирует значение выше среза (трейлинг).t).Поэтому мы можем обобщить операцию как

clip(x, t1, t2) = C(x, t1) * x + (1 - C(x, t1)) * t2

Проблема с вашей операцией состоит в том, что она дифференцируема только по t2, но не t1.Ваше решение связывает их вместе, так что t1 == t2, но все равно это тот случай, когда градиентный спуск будет действовать так, как если бы не было изменения порога, а только изменение значения выше порога.

ДляПо этой причине в общем случае ваша операция порогового значения, возможно, не учитывает ценность, на которую вы надеетесь.Об этом следует помнить при разработке своих операций, но не гарантию сбоя - фактически, если вы рассмотрите стандарт ReLU для смещенного вывода некоторой линейной единицы, мы получим похожую картину.Мы определяем операцию отсечения H

H(x, t) = 1 if x > t else 0

и ReLU как

ReLU(x + b, t) = (x + b) * H(x + b, t) = (x + b) * H(x, t - b)

, где мы можем снова обобщить до

ReLU(x, b, t) = (x + b) * H(x, t)

и снова мы можем только узнать b и t неявно следует b.Все же, похоже, работает :) 1074 *