Я внедряю Inception-подобный CNN в pytorch. После блоков сверточных слоев у меня есть три полностью соединенных линейных слоя, за которыми следует сигмовидная активация, чтобы получить мой окончательный результат регрессии. Я тестирую эффекты выпадения слоев в этой сети, но это дает мне неожиданные результаты.
Вот код:
class MyInception(nn.Module):
def __init__(self, in_channels, verbose=False):
super(MyInception, self).__init__()
self.v = verbose
ic=in_channels; oc=16
self.inceptionBlock1 = InceptionBlock(in_channels=ic, out_channels=oc, maxpool=False, verbose=verbose)
self.inceptionBlock2 = InceptionBlock(in_channels=oc * 6, out_channels=oc, maxpool=False, verbose=verbose)
self.pool = nn.MaxPool2d(kernel_size=3, stride=2, padding=1)
self.regressor = nn.Sequential(
nn.Linear(oc * 6 * 35 * 35, 1024, bias=True),
nn.ReLU(inplace=True),
nn.Dropout(p=0.2, inplace=False), # <--- Dropout 1
nn.Linear(1024, 128, bias=True),
nn.ReLU(inplace=True),
nn.Dropout(p=0.2, inplace=False), # <--- Dropout 2
nn.Linear(128, 1, bias=True),
nn.Sigmoid()
)
def forward(self, x):
x = self.inceptionBlock1(x)
x = self.inceptionBlock2(x)
x = self.pool(x)
x = torch.flatten(x, 1)
x = self.regressor(x)
return x
def train(epochs=10, dot_every=25):
running = pd.DataFrame(columns=['Epoch','Round','TrainLoss','TestLoss','LearningRate'])
for epoch in range(epochs):
train_losses = []
model.train()
counter = 0
for images, targets in train_loader:
images = images.to(device)
targets = targets.to(device)
optimizer.zero_grad()
outputs = model(images)
loss = loss_fn(torch.flatten(outputs), targets)
train_losses.append( loss.item() )
loss.backward()
optimizer.step()
counter += 1
if counter % dot_every == 0:
print(".", end='.', flush=True)
test_loss = test()
else:
test_loss = -1.
lr = np.squeeze(scheduler.get_lr())
running = running.append(pd.Series([epoch, counter, loss.item(), test_loss, lr], index=running.columns), ignore_index=True)
test_loss = test()
train_loss = np.mean(np.asarray(train_losses))
running = running.append(pd.Series([epoch, counter, train_loss, test_loss, lr], index=running.columns), ignore_index=True)
print("")
print(f"Epoch {epoch+1}, Train Loss: {np.round(train_loss,4)}, Test Loss: {np.round(test_loss, 4)}, Learning Rate: {np.format_float_scientific(lr, precision=4)}")
return running
def test():
model.eval()
test_losses = []
for i, (images,targets) in enumerate(test_loader):
images = images.to(device)
targets = targets.to(device)
outputs = model(images)
loss = loss_fn(torch.flatten(outputs), targets)
test_losses.append( loss.item() )
mean_loss = np.mean(np.asarray(test_losses))
return mean_loss
# instantiate the model
model = MyInception(in_channels=4, verbose=False).to(device)
# define the optimizer and loss function
optimizer = Adam(model.parameters(), lr=0.001, weight_decay=0.0001)
loss_fn = nn.MSELoss()
# run it
results = train(epochs=10, dot_every=20)
Вот график потерь MSE для данные обучения. (красный = без отсева, зеленый = только для второго отсева, синий = только для первого отсева, фиолетовый = оба выпадения) Прогоны с выпадением имеют большие увеличения потерь на границах эпох (пунктирные вертикальные линии), при этом двойной выпадение даже имеет большой скачок в убытке в начале эпохи 10.
Важным моментом является испытательная потеря. Это намного более стабильно и не слишком отличается между двумя состояниями после 5-й эпохи, так что, возможно, мне все равно. Но я хотел бы понять, что происходит.
