main.py

# TODO: import necessary packages

import time
import datetime
import numpy as np
import pandas as pd
import torch
import torch.nn as nn

from embeddings import WordEmbeddings


# TODO: Define any constants you may need

EPOCHS = 10
BATCH_SIZE = 32

# use this in any functions you deem necessary once fully implemented!
word_embedding_model = WordEmbeddings()


def prepare_data():
    # TODO: Prepare the data to be trained on

    # TODO: Visualize some data points

    # TODO: Clean your data to only keep the features you want

    # TODO: Map Airline sentiment to negative = 0, neutral = 1, positive = 2

    # TODO: Transform `text` into a representation our MLP can handle

    # TODO: Make training and validation splits

    # TODO: Implement the train, val datasets, and train, val data loaders

    train_dataset = ...
    val_dataset = ...
    train_loader = ...
    val_loader = ...

    return train_dataset, val_dataset, train_loader, val_loader


def get_model() -> torch.nn.Module:
    # TODO: Return your custom MLP (you may have to define a custom class above!)
    pass


def train_one_epoch(model, loss_fn, train_loader, optimizer):
    # TODO: Implement following the instructions below
    # enable training mode on the model (hint use model.train())

    # add variables to keep track of the total loss, number of correct predictions, and total number of elements

    # for inputs, targets in train_loader:
        # move inputs and targets to device (since device may not be CPU)

        # zero out the gradients

        # compute model outputs

        # compute the loss
        # when keeping track of the total loss, you need to use .item() to get the value from the tensor
        # compute number correct in the batch and keep track of the total correct, and total processed

        # backpropagate the loss
        # perform and optimizer step

    # return accuracy for the epoch (total correct / total processed) and the average loss
    pass


def validate(model, loss_fn, val_loader):
    # TODO: Implement following the instructions below
    # enable evaluation mode on the model (hint use model.eval())

    # add variables to keep track of the total loss, number of correct predictions, and total number of elements

    # for inputs, targets in val_loader:
        # move inputs and targets to device (since device may not be CPU)

        # compute model outputs

        # measure accuracy and record loss

    # return accuracy and ave loss
    pass


def train(model, train_loader, val_loader, epochs):
    # TODO: Implement following the instructions below
    # Define the loss function
    # What kind of task are we performing? What kind of loss function should we use?

    # Define the optimizer (hint: start with Adam)

    # Define variables for logging (will need to plot train and validation loss and accuracy later on)

    train_loss = ...
    val_loss = ...
    train_accuracy = ...
    val_accuracy = ...

    # Start training
    start_time = time.time()
    # Hint: use tqdm to create a progress bar. TQDM can wrap any iterable, like the range(epochs) for example
    # pbar = tqdm(range(epochs))
    # for epoch in pbar:

        # train for one epoch (hint we may have implemented it already)
        # get validation accuracy and loss (hint we may have implemented it already)
        # save some logging info

        # optional: update the progress bar with the train and validation loss and accuracy
        # pbar.set_postfix(train_loss=train_loss, val_loss=val_loss, train_acc=train_acc1, val_acc=val_acc1)

    total_time = time.time() - start_time
    total_time_str = str(datetime.timedelta(seconds=int(total_time)))
    print('=' * 50)
    print(f'Training time {total_time_str}')
    print(f'Max accuracy {0.0:%.4f}')
    print('=' * 50)

    # return logging information
    return train_loss, val_loss, train_accuracy, val_accuracy


def evaluate(trained_model, sample_text):
    # TODO: implement this
    pass


def main():
    model = get_model()

    train_dataset, val_dataset, train_loader, val_loader = prepare_data()

    train_loss, val_loss, train_accuracy, val_accuracy = train(model, train_loader, val_loader, EPOCHS)

    # TODO: 1. plot train loss and validation loss

    # TODO: 2. plot train accuracy and validation accuracy

    # TODO: save the plots

    # TODO: evaluate
    evaluate(..., ...)


if __name__ == '__main__':
    main()