here is my code, so right now i am training on sequences of length 192, but in my test set i have sequences of length 384. For some reason my model erros when calculating losss for the test set. train_inputs = train['train_inputs']
        train_labels = train['train_targets']

        #Initialize some arrays to keep track of model performance over time
        batch_train_losses, epoch_train_losses, epoch_test_losses, batch_train_acc, epoch_train_acc, epoch_test_acc, = [], [], [], [], [], []

        print("\u2714 Starting training...")
        for j in range(1, config.num_epoch+1):
            for i, batch in enumerate(list(zip(train_inputs, train_labels))):
                batch_inputs = batch[0].to(device)
                batch_labels = batch[1].to(device)

                #Evaluate and stop training settings
                #if i > config.max_batches: break

                logits, loss, acc = self.computeLoss(inputs=batch_inputs, labels=batch_labels, offset=0)
                #Training Core
                loss.backward()
                optimizer.step()
                optimizer.zero_grad()

                batch_train_losses.append(loss.item())
                batch_train_acc.append(acc)

            #Evaluate model every epoch and track results
            train_loss, test_loss, train_acc, test_acc = self.evaluateModel(epoch=j, train=train, test=test)
            epoch_test_losses.append(test_loss)
            epoch_train_losses.append(train_loss)

            epoch_test_acc.append(test_acc)
            epoch_train_acc.append(train_acc)

        #Plot model performance over time
        if plot: 
            createDualTrainPlot(batch_train_losses, batch_train_acc)
            createDualLossPlot(epoch_train_losses, epoch_test_losses)
            createDualAccuracyPlot(epoch_train_acc, epoch_test_acc)
            
    def computeLoss(self, inputs, labels, offset) -> Tuple[torch.Tensor, torch.Tensor, float]:

        """ returns the logits, loss and the accuracy respectively. """

        #labels are B x T
        #inputs are B x T x C

        config = self.config
        logits = self.forward(inputs) # B x T x C

        B, CL, H = logits.shape

        loss_function = nn.CrossEntropyLoss()
        loss = loss_function(logits.view(config.batch_size * CL, config.vocab_size), labels.view(config.batch_size * CL))

        pred = logits.argmax(dim=-1) # B x T x C ---> B x T
        correct_tokens = (pred == labels).sum().item() # B x T == B x T
        total_tokens = labels.numel()

        return logits, loss, correct_tokens/total_tokens
    
    #utility method for evaluating a dataset by type
    def __evaluateData(self, inputs, outputs) -> Tuple[float, float]:

        """ Helper function to evalute the model. Evaluates a dataset of batches.
        \n returns mean loss and accuracy respectively"""

        print("evaluate!")

        losses = 0
        accuracy = 0
        for i,batch in enumerate(list(zip(inputs, outputs))):
                batch_inputs = batch[0].to(device)
                batch_labels = batch[1].to(device)

                print(batch_inputs.shape)
                print(batch_labels.shape)

                logits, loss, acc = self.computeLoss(inputs=batch_inputs, labels=batch_labels, offset=self.config.cl_inc)
                losses += loss.item()
                accuracy += acc #is a float
        
        return round(losses / i, 4), round(accuracy / i, 4) #Return the means.

    @torch.no_grad()
    def evaluateModel(self, epoch : int, train, test) -> Tuple[float, float]:

        """ evaluates the models losses and accuracy for both train and test.
            \n returns train/test losses and train/test acurracy respectively."""

        self.eval()

        train_inputs = train['train_inputs']
        train_labels = train['train_targets']

        test_inputs = test['test_inputs']
        test_labels = test['test_targets']

        train_mean, train_acc = self.__evaluateData(train_inputs, train_labels)
        test_mean, test_acc = self.__evaluateData(test_inputs, test_labels)

        #Print status update of losses + accuracy
        print(f"Epoch: {epoch} Training Loss: {train_mean} Test Loss: {test_mean} Train Accuracy {train_acc} Test Accuracy {test_acc}")

        self.train()

        return train_mean, test_mean, train_acc, test_acc {
	"name": "RuntimeError",
	"message": "CUDA error: device-side assert triggered
CUDA kernel errors might be asynchronously reported at some other API call, so the stacktrace below might be incorrect.
For debugging consider passing CUDA_LAUNCH_BLOCKING=1.
Compile with `TORCH_USE_CUDA_DSA` to enable device-side assertions.
",
	"stack": "---------------------------------------------------------------------------
RuntimeError                              Traceback (most recent call last)
Cell In[2], line 12
      8 model = transformerModel(config)
     10 model.to(device)
---> 12 model.trainModel(train, test)

File c:\\Users\\Luke\\MorseLLM\\model\\GPT.py:215, in transformerModel.trainModel(self, train, test, plot)
    212     batch_train_acc.append(acc)
    214 #Evaluate model every epoch and track results
--> 215 train_loss, test_loss, train_acc, test_acc = self.evaluateModel(epoch=j, train=train, test=test)
    216 epoch_test_losses.append(test_loss)
    217 epoch_train_losses.append(train_loss)

File c:\\Users\\Luke\\AppData\\Local\\Programs\\Python\\Python310\\lib\\site-packages\\torch\\utils\\_contextlib.py:115, in context_decorator.<locals>.decorate_context(*args, **kwargs)
    112 @functools.wraps(func)
    113 def decorate_context(*args, **kwargs):
    114     with ctx_factory():
--> 115         return func(*args, **kwargs)

File c:\\Users\\Luke\\MorseLLM\\model\\GPT.py:287, in transformerModel.evaluateModel(self, epoch, train, test)
    284 test_labels = test['test_targets']
    286 train_mean, train_acc = self.__evaluateData(train_inputs, train_labels)
--> 287 test_mean, test_acc = self.__evaluateData(test_inputs, test_labels)
    289 #Print status update of losses + accuracy
    290 print(f\"Epoch: {epoch} Training Loss: {train_mean} Test Loss: {test_mean} Train Accuracy {train_acc} Test Accuracy {test_acc}\")

File c:\\Users\\Luke\\MorseLLM\\model\\GPT.py:266, in transformerModel.__evaluateData(self, inputs, outputs)
    263 print(batch_inputs.shape)
    264 print(batch_labels.shape)
--> 266 logits, loss, acc = self.computeLoss(inputs=batch_inputs, labels=batch_labels, offset=self.config.cl_inc)
    267 losses += loss.item()
    268 accuracy += acc #is a float

File c:\\Users\\Luke\\MorseLLM\\model\\GPT.py:244, in transformerModel.computeLoss(self, inputs, labels, offset)
    241 loss = loss_function(logits.view(config.batch_size * CL, config.vocab_size), labels.view(config.batch_size * CL))
    243 pred = logits.argmax(dim=-1) # B x T x C ---> B x T
--> 244 correct_tokens = (pred == labels).sum().item() # B x T == B x T
    245 total_tokens = labels.numel()
    247 return logits, loss, correct_tokens/total_tokens

RuntimeError: CUDA error: device-side assert triggered
CUDA kernel errors might be asynchronously reported at some other API call, so the stacktrace below might be incorrect.
For debugging consider passing CUDA_LAUNCH_BLOCKING=1.
Compile with `TORCH_USE_CUDA_DSA` to enable device-side assertions.
"
}