1
$\begingroup$

Hi Community and thanks in advance for the help.

I am working on transfer learning - specifically GoogLeNet model with the Food101 Dataset. Code is below. I think everything is in order from data preprocessing through to training but the training times are incredibly long and the loss doesn’t seem to be converging. I was running it on CPU initially to make sure it was functioning fine before xfering to GPU to run. Code is below. Any advice or assistance would be greatly appreciated.

Model:

from torchinfo import summary 
for params in google_net.parameters():
    params.requires_grad = False
## Change the number of output params in the fc layer
num_classes = 101 ## output classes
google_net.fc = nn.Linear(1024, num_classes)

# Check Model Summary
sum = summary(google_net, 
        input_size=(128, 3, 256, 256), # make sure this is (batch_size, color_channels, height, width)
        verbose=0,
        col_names=["input_size", "output_size", "num_params", "trainable"],
        col_width=20,
        row_settings=["var_names"]
)
print(sum)

Only trainable layer in the output of above is the .fc layer at the end. Output below:

Total params: 5,703,429  
Trainable params: 103,525 ## .fc layer only
Non-trainable params: 5,599,904  
Total mult-adds (G): 47.92

Input size (MB): 19.27  
Forward/backward pass size (MB): 1651.82 
Params size (MB): 22.81  
Estimated Total Size (MB): 1693.90

Data Pre-Process

T_form_gog = transforms.Compose([transforms.CenterCrop(224),
                                transforms.Resize((256,256)),
                                transforms.ToTensor(), #standardise to 0-1
                                transforms.Normalize(
                                    mean = [0.485, 0.456, 0.406],
                                    std = [0.229, 0.224, 0.225])]) ## Taken from pytorch googlenet documentation 

trg_101_gog = torchvision.datasets.Food101(root = './data',
                                          split = 'train',
                                          transform = T_form_gog,
                                          download = True)

val_101_gog = torchvision.datasets.Food101(root = './data',
                                          split = 'test',
                                          transform = T_form_gog,
                                          download = True)

Data Loader:

from torch.utils.data import DataLoader
Batch_size = 128

trg_load_gog = DataLoader(trg_101_gog,
                          batch_size  = Batch_size,
                          shuffle = True,
                          )
val_load_gog = DataLoader(val_101_gog,
                          batch_size = Batch_size,
                          shuffle = True)

Params:

from torch import nn 
loss_fn = nn.CrossEntropyLoss()
optim = torch.optim.Adam(google_net.parameters(), lr = 0.001)

Train Loop:

from datetime import datetime as DT
NUM_EPOCHS = 30
train_losses = []

for epoch in range(NUM_EPOCHS):
    train_loss = 0
    test_loss = 0
    tic = DT.now()
    for batch, (img, label) in enumerate(trg_load_gog):

        ## zero the grads
        optim.zero_grad()

        ## forward 
        output = google_net(img)

        ## calc losses 
        loss = loss_fn(output.squeeze(), label.long())

        ## prop losses
        loss.backward()

        ## update weights
        optim.step()

        ## update loss 
        train_loss += loss.item()
    toc = DT.now()
    r_time = toc-tic
    train_losses.append(train_loss)
    print(f'epoch: {epoch}, train loss: {train_loss}, start time: {tic}, run time:{r_time}')

output is:

epoch: 0, train loss: 1524.6963007450104, run time:1:02:26.554898
epoch: 1, train loss: 1454.7811387777328, run time:1:07:53.805809
epoch: 2, train loss: 1419.673243880272, run time:1:07:17.671551
epoch: 3, train loss: 1395.2064596414566, run time:1:07:22.943297
epoch: 4, train loss: 1380.3496369123459, run time:1:07:15.002554
epoch: 5, train loss: 1365.1366027593613, run time:1:07:17.721393
Paused…

My initial thoughts are on the .fc. Should I add in other linear layers to make this more efficient/ effective. I was trying to use the original architecture as much as possible.

Any advice and/or assistance would be greatly appreciated.

Thanks again

$\endgroup$
1
  • $\begingroup$ Following on from the above post - I have taken a selection of images from each classification and OHE the targets. This has led to a model that can be trained in much shorter timeframes but as expected the accuracy leaves a lot to be desired. $\endgroup$
    – James
    Apr 24 at 4:37

0

Your Answer

By clicking “Post Your Answer”, you agree to our terms of service and acknowledge you have read our privacy policy.