Helper code for the NLP Lab

[pxaris]

Issue που θα χρησιμοποιηθεί κατά τη διάρκεια του Εργαστηρίου NLP (στις 28/3/25) για τη σημείωση βοηθητικού κώδικα, οδηγιών κ.α.

• Prep-Lab: https://helios.ntua.gr/mod/assign/view.php?id=56264
• Lab: https://helios.ntua.gr/mod/assign/view.php?id=56484
• repository: https://github.com/slp-ntua/slp-labs/tree/master/lab3
• Related issues:
  • Helper code for NLP Lab #130
  • Helper code for Lab 3 #124

[pxaris]

Glove embeddings temp link: https://drive.google.com/file/d/1syI9RH18cFMuFxbjR836ban8EyM9KOGI/view?usp=sharing

[pxaris]

2

from nltk.tokenize import TweetTokenizer

...
tokenizer = TweetTokenizer()
self.data = [list(map(lambda x:x.lower(), tokenizer.tokenize(x))) for x in X]       
self.labels = y        
self.word2idx = word2idx

[pxaris]

7

# EX7 - Define our PyTorch-based DataLoader
train_loader = DataLoader(train_set, batch_size=BATCH_SIZE, shuffle=True)

8

criterion = torch.nn.CrossEntropyLoss() 
parameters = [param for param in model.parameters() if param.requires_grad]
optimizer = torch.optim.Adam(parameters, lr=0.001)

9

def train_dataset(_epoch, dataloader, model, loss_function, optimizer):
    # IMPORTANT: switch to train mode
    # enable regularization layers, such as Dropout
    model.train()
    running_loss = 0.0

    # obtain the model's device ID
    device = next(model.parameters()).device

    for index, batch in enumerate(dataloader, 1):
        # get the inputs (batch)
        inputs, labels, lengths = batch

        # EX9
        # move the batch tensors to the right device
        inputs = inputs.to(device)
        labels = labels.to(device)
        lengths = lengths.to(device)

        # Step 1 - zero the gradients
        # Remember that PyTorch accumulates gradients.
        # We need to clear them out before each batch!
        model.zero_grad()

        # Step 2 - forward pass: y' = model(x)
        if model.__class__.__name__ in ['BaselineDNN', 'LSTM']:
            outputs = model(inputs, lengths)
        else:
            outputs = model(inputs)

        # Step 3 - compute loss: L = loss_function(y, y')
        try:
            loss = loss_function(outputs, labels)
        except RuntimeError:
            # fix labels for single-values
            bin_labels = torch.nn.functional.one_hot(labels.long(), num_classes=2)
            loss = loss_function(outputs, bin_labels.float())

        # Step 4 - backward pass: compute gradient wrt model parameters
        loss.backward()

        # Step 5 - update weights
        optimizer.step()

        running_loss += loss.data.item()

        # print statistics
        progress(loss=loss.data.item(),
                 epoch=_epoch,
                 batch=index,
                 batch_size=dataloader.batch_size,
                 dataset_size=len(dataloader.dataset))

    return running_loss / index

10

def eval_dataset(dataloader, model, loss_function):
    # IMPORTANT: switch to eval mode
    # disable regularization layers, such as Dropout
    model.eval()
    running_loss = 0.0

    y_pred = []  # the predicted labels
    y = []  # the gold labels

    # obtain the model's device ID
    device = next(model.parameters()).device

    # IMPORTANT: in evaluation mode, we don't want to keep the gradients
    # so we do everything under torch.no_grad()
    with torch.no_grad():
        for index, batch in enumerate(dataloader, 1):
            # get the inputs (batch)
            inputs, labels, lengths = batch

            # EX9
            # Step 1 - move the batch tensors to the right device
            inputs = inputs.to(device)
            labels = labels.to(device)
            lengths = lengths.to(device)

            # Step 2 - forward pass: y' = model(x)
            if model.__class__.__name__ in ['BaselineDNN', 'LSTM']:
                outputs = model(inputs, lengths)
            else:
                outputs = model(inputs)

            # Step 3 - compute loss.
            # We compute the loss only for inspection (compare train/test loss)
            # because we do not actually backpropagate in test time
            try:
                loss = loss_function(outputs, labels)
            except RuntimeError:
                # fix labels for single-values
                bin_labels = torch.nn.functional.one_hot(labels.long(), num_classes=2)
                loss = loss_function(outputs, bin_labels.float())

            # Step 4 - make predictions (class = argmax of posteriors)
            predictions = torch.argmax(outputs, dim=1)

            # Step 5 - collect the predictions, gold labels and batch loss
            y_pred.append(predictions.cpu().numpy()) 
            y.append(labels.cpu().numpy())

            running_loss += loss.data.item()

    return running_loss / index, (y_pred, y)