how do i modify this traim$\_$lm function in order to have a decreasing lower epoch, pass the sanity, perplexity, and causal check:

def train$\_$lm$($args$,$ train$\_$text, dev$\_$text, vocab$\_$index$)$:

$"""$

$$ :param args: command$-$line args, passed through here for your convenience

$$ :param train$\_$text: train text as a sequence of characters

$$ :param dev$\_$text: dev text as a sequence of characters

$$ :param vocab$\_$index: an Indexer of the character vocabulary $(27$ characters$)$

$$ :return: a NeuralLanguageModel instance trained on the given data

$"""$

$$ print$("$training text length:" $,$ len$($train$\_$text$))$

$$ # Set default values for missing args if necessary

$$ lr $=$ getattr$($args$,\text{'}$lr$\text{'},0\mathrm{.}01)$

$$ epochs $=$ getattr$($args$,$ 'epochs', $30)$

$$ batch$\_$size $=$ getattr$($args$,$ 'batch$\_$size', $20)$

$$ seq$\_$len $=$ getattr$($args$,$ 'seq$\_$len', $20)$

$$ model $=$ TransformerModel$($vocab$\_$size$=$len$($vocab$\_$index$))$ #this is necesssary to call the transfer from pytorch

$$

$$ # Set up optimizer and loss function

$$ optimizer $=$ torch.optim.Adam$($model$.$parameters$(),$ lr$=$lr$)$

$$ scheduler $=$ torch.optim.lr$\_$scheduler.ReduceLROnPlateau$($optimizer$,$ 'min', patience$=2)$

$$ loss$\_$function $=$ nn$.$CrossEntropyLoss$()$

$$ # Convert training text to indices

$$ train$\_$inds $=$ torch.tensor$([$vocab$\_$index.index$\_$of$($c$)$ for c in train$\_$text$],$ dtype$=$ torch.long$)$

$$ #training loop

$$ for epoch in range$($epochs$)$:

$$ model.train$()$

$$ total$\_$loss $=0$

$$ #num$\_$batches $=$ len$($train$\_$text$)//$ batch$\_$size

$$ # Train over batches of characters from the training data $($size args.batch$\_$size$)$

$$ for i in range$(0,$ len$($train$\_$inds$)-$ seq$\_$len, batch$\_$size$)$:

$$# Ensure the batch size fits within the available training data

$$ if i $+$ batch$\_$size $*$ seq$\_$len $>$ len$($train$\_$inds$)$:

$$ break $$# Skip the last incomplete batch

$$ # Get the input $($context$)$ and target $($next character$)$ for each batch $($Prepare input and target tensors$)$

$$ batch$\_$input $=$ train$\_$inds$[$i:i $+$ batch$\_$size $*$ seq$\_$len$]$

$$ #$.$view$($batch$\_$size, seq$\_$len$)$# $($batch$\_$size$=1,$ seq$\_$len$)$

$$ batch$\_$target $=$ train$\_$inds$[$i $+1$:i $+1+$ batch$\_$size $*$ seq$\_$len$]$

$$ #$.$view$($batch$\_$size, seq$\_$len$)$# $($seq$\_$len,$)$

$$ # print$(\text{'}$Batch$\_$size: $\text{'},$ batch$\_$size$)$

$$ # print$(\text{'}$Batch$\_$input: $\text{'},$ batch$\_$input$)$

$$ # print$(\text{'}$Batch$\_$target: $\text{'},$ batch$\_$target$)$

$$ # Ensure batch sizes are consistent

$$ if batch$\_$input.size$(0)!=$ batch$\_$size or batch$\_$target.size$(0)!=$ batch$\_$size:

$$ continue $$# Skip incomplete batches

$$# Reshape the batches into the correct format

$$ batch$\_$input $=$ batch$\_$input.view$($batch$\_$size, seq$\_$len$)$

$$ batch$\_$target $=$ batch$\_$target.view$($batch$\_$size, seq$\_$len$)$

$$ # if len$($batch$\_$input$)<$ seq$\_$len:

$$ # $$ pad$\_$size $=$ seq$\_$len $-$ len$($batch$\_$input$)$

$$ # $$ batch$\_$input $=$ torch.nn$.$functional.pad$($batch$\_$input, $(0,$ pad$\_$size$),$ 'constant', $0)$

$$ optimizer.zero$\_$grad$()$

$$ #forward pass trough the model

$$ output $=$ model$($batch$\_$input$)$ # Shape: $($batch$\_$size$=1,$ seq$\_$len, vocab$\_$size$)$

$$ # Calculate the loss $($comparing model output to batch$\_$target$)$

$$ loss $=$ loss$\_$function$($output$.$reshape$(-1,$ len$($vocab$\_$index$)),$ batch$\_$target.reshape$(-1))$

$$

$$ loss.backward$()$

$$ optimizer.step$()$

$$ total$\_$loss $+=$ loss.item$()$

$$ print$($f$"$ Epoch $\{$epoch $+1\}/\{$epochs$\},$ loss:$\{$total$\_$loss $/$ len$($train$\_$text$)\}")$

$$ scheduler.step$($total$\_$loss $/$ len$($train$\_$text$))$

$$

$$ return $$NeuralLanguageModel$($model$,$ vocab$\_$index$)$