Error when calculating loss when fine tuning fcn_resnet101 segmentation model

username: alex_d
cooked: <p>I an trying to fine tune the fcn_resnet101 segmentation model with my own data and I am getting <code>AttributeError: 'collections.OrderedDict' object has no attribute 'log_softmax'</code> error when I run my code.</p>
<p>Below is a full print out of the error:</p>
<pre><code class="lang-auto">    model_ft, hist = train_model(model_ft, dataloaders_dict, criterion, optimizer_ft, num_epochs=num_epochs, is_inception=(model_name=="inception"))
  File "FineTuningTry1.py", line 266, in train_model
    loss = criterion(outputs, labels.long())
  File "/home/info/.local/lib/python3.5/site-packages/torch/nn/modules/module.py", line 547, in __call__
    result = self.forward(*input, **kwargs)
  File "/home/info/.local/lib/python3.5/site-packages/torch/nn/modules/loss.py", line 916, in forward
    ignore_index=self.ignore_index, reduction=self.reduction)
  File "/home/info/.local/lib/python3.5/site-packages/torch/nn/functional.py", line 1995, in cross_entropy
    return nll_loss(log_softmax(input, 1), target, weight, None, ignore_index, None, reduction)
  File "/home/info/.local/lib/python3.5/site-packages/torch/nn/functional.py", line 1316, in log_softmax
    ret = input.log_softmax(dim)
AttributeError: 'collections.OrderedDict' object has no attribute 'log_softmax'
</code></pre>
<p>It seems like the error is happening when calculating the loss with the <em>criterion</em> function, but I am not sure what to make of the ‘log_softmax’ error to try to find where I went wrong with my code.</p>
<p>Below is the code for the train_model function that I adjusted from this <a href="https://pytorch.org/tutorials/beginner/finetuning_torchvision_models_tutorial.html#model-training-and-validation-code" rel="nofollow noopener">tutorial</a>:</p>
<pre><code class="lang-auto">def train_model(model, dataloaders, criterion, optimizer, num_epochs=25, is_inception=False):

    since = time.time()
    val_acc_history = []
    best_model_wts = copy.deepcopy(model.state_dict())
    best_acc = 0.0
    for epoch in range(num_epochs):
        print('Epoch {}/{}'.format(epoch, num_epochs - 1))

        print('-' * 10)

        # Each epoch has a training and validation phase

        for phase in ['train', 'val']:

            if phase == 'train':
                model.train()  # Set model to training mode
            else:
                model.eval()   # Set model to evaluate mode


            running_loss = 0

            total_train = 0

            correct_train = 0

            # Iterate over data.

            for inputs, labels in dataloaders[phase]:

                inputs = inputs.to(device) #OriginalImage

                labels = labels.to(device) #Masks


                # zero the parameter gradients

                optimizer.zero_grad()

                # forward

                # track history if only in train

                with torch.set_grad_enabled(phase == 'train'):

                    # Get model outputs and calculate loss

                    # Special case for inception because in training it has an auxiliary output. In train

                    #   mode we calculate the loss by summing the final output and the auxiliary output

                    #   but in testing we only consider the final output.

                    if is_inception and phase == 'train':

                        # From https://discuss.pytorch.org/t/how-to-optimize-inception-model-with-auxiliary-classifiers/7958

                        outputs, aux_outputs = model(inputs)

                        loss1 = criterion(outputs, labels)

                        loss2 = criterion(aux_outputs, labels)

                        loss = loss1 + 0.4*loss2

                    else:

                        outputs = model(inputs)

                        loss = criterion(outputs, labels.long())

                    _, preds = torch.max(outputs, 1)

                    # backward + optimize only if in training phase

                    if phase == 'train':

                        loss.backward()

                        optimizer.step()

                # statistics

                running_loss += loss.item() #* inputs.size(0)

                total_train += labels.nelement()

                correct_train += preds.eq(labels.data).sum().item()

                train_accuracy = 100 * correct_train / total_train

            epoch_loss = running_loss / len(dataloaders[phase].dataset)

            epoch_acc = train_accuracy/len(dataloaders[phase].dataset)

            print('{} Loss: {:.4f} Acc: {:.4f}'.format(phase, epoch_loss, epoch_acc))

            # deep copy the model

            if phase == 'val' and epoch_acc &gt; best_acc:

                best_acc = epoch_acc

                best_model_wts = copy.deepcopy(model.state_dict())

            if phase == 'val':

                val_acc_history.append(epoch_acc)

        print()

    time_elapsed = time.time() - since

    print('Training complete in {:.0f}m {:.0f}s'.format(time_elapsed // 60, time_elapsed % 60))

    print('Best val Acc: {:4f}'.format(best_acc))

    # load best model weights

    model.load_state_dict(best_model_wts)

    return model, val_acc_history
</code></pre>
<p>and below is the part where I set the criterion and call the train_model function:</p>
<pre><code class="lang-auto"># Setup the loss fxn

criterion = nn.CrossEntropyLoss()

# Train and evaluate

model_ft, hist = train_model(model_ft, dataloaders_dict, criterion, optimizer_ft, num_epochs=num_epochs, is_inception=(model_name=="inception"))
</code></pre>
<p>If this isn’t enough information to help me figure out why I am getting this error, let me know and I’ll post other parts of my code. I just didn’t want to fill this post with unnecessary code.  Appreciate your help!</p>

username: alex_d
cooked: <p>I think I found the solution.</p>
<p>I didn’t realize the line below returned a dictionary so I had to index it.</p>
<p><code>outputs = model(inputs)</code></p>
<p>When I changed it to the line below I no longer get the same error</p>
<p><code>outputs = model(inputs)['out']</code></p>