Why am I getting this message after running this code?
Code:
```
#!/usr/bin/env python3
"""
Full training script with low-memory loading and offload for DeepSeek model + LoRA adapters.
"""
import os
import json
import random
import numpy as np
import pandas as pd
import torch
from datasets import Dataset
from transformers import (
    AutoTokenizer,
    AutoModelForCausalLM,
    BitsAndBytesConfig,
    TrainingArguments,
    Trainer,
    DataCollatorForLanguageModeling
)
from peft import prepare_model_for_kbit_training, LoraConfig, get_peft_model

# ------------- Reproducibility Setup -------------
SEED = 42
random.seed(SEED)
np.random.seed(SEED)
torch.manual_seed(SEED)
if torch.cuda.is_available():
    torch.cuda.manual_seed_all(SEED)

# -----------------------------
# Step 1: Load and preprocess data
# -----------------------------
with open("balanced_labeled_conversations.json", "r") as f:
    data = json.load(f)

df = pd.DataFrame(data)
traits = ["witty", "sarcastic", "charming"]
df = df[df['trait'].isin(traits)].dropna(subset=["dialogue"])

def format_conversation_with_expert_token(row):
    token = f"[EXPERT: {row['trait'].upper()}]"
    return f"{token} 
 {row['dialogue']}\n
"

df["text"] = df.apply(format_conversation_with_expert_token, axis=1)
# Sample 10% for quick iteration
df = df.sample(frac=0.1, random_state=SEED).reset_index(drop=True)
print(f"Using {len(df)} examples ({len(df)/len(data):.0%} of original)")

# -----------------------------
# Step 2: Tokenization and special token addition
# -----------------------------
model_checkpoint = "deepseek-ai/deepseek-moe-16b-base"
tokenizer = AutoTokenizer.from_pretrained(model_checkpoint, trust_remote_code=True)
# Add expert tokens
special_tokens = [f"[EXPERT: {t.upper()}]" for t in traits]
num_added = tokenizer.add_tokens(special_tokens)
print(f"Added {num_added} special tokens: {special_tokens}")
if tokenizer.pad_token is None:
    tokenizer.pad_token = tokenizer.eos_token

def tokenize_data(batch):
    return tokenizer(
        batch["text"], padding="max_length", truncation=True, max_length=512
    )

dataset = Dataset.from_pandas(df[["text"]])
tokenized_dataset = dataset.map(tokenize_data, batched=True, remove_columns=["text"])

# -----------------------------
# Step 3: Load model with offload + prepare for LoRA
# -----------------------------
bnb_config = BitsAndBytesConfig(
    load_in_8bit=True,
    bnb_8bit_compute_dtype=torch.bfloat16,
    bnb_8bit_quant_type="nf4",
    bnb_8bit_use_double_quant=True
)

model = AutoModelForCausalLM.from_pretrained(
    model_checkpoint,
    trust_remote_code=True,
    torch_dtype=torch.bfloat16,
    quantization_config=bnb_config,
    device_map="auto",
    offload_folder="offload",
    offload_state_dict=True,
    low_cpu_mem_usage=True
)
model.resize_token_embeddings(len(tokenizer))
# Prepare for 8-bit training and add LoRA adapters
model = prepare_model_for_kbit_training(model)
lora_config = LoraConfig(
    r=16,
    lora_alpha=32,
    target_modules=["q_proj", "v_proj"],
    lora_dropout=0.05,
    bias="none",
    task_type="CAUSAL_LM"
)
model = get_peft_model(model, lora_config)
model.print_trainable_parameters()

# -----------------------------
# Step 4: Training setup and run
# -----------------------------
output_dir = "./deepseek_moe_expert_prompting"
training_args = TrainingArguments(
    output_dir=output_dir,
    per_device_train_batch_size=1,
    gradient_accumulation_steps=8,
    num_train_epochs=1,
    save_strategy="steps",
    save_steps=500,
    save_total_limit=2,
    logging_strategy="steps",
    logging_steps=50,
    do_eval=False,
    report_to="none",
    seed=SEED,
    load_best_model_at_end=False
)
trainer = Trainer(
    model=model,
    args=training_args,
    train_dataset=tokenized_dataset,
    tokenizer=tokenizer,
    data_collator=DataCollatorForLanguageModeling(tokenizer, mlm=False)
)
# Resume from checkpoint if available
epoch_ckpts = [d for d in os.listdir(output_dir)
              if d.startswith("checkpoint-")]
if epoch_ckpts:
    latest = max(epoch_ckpts, key=lambda x: int(x.split('-')[1]))
    trainer.train(resume_from_checkpoint=os.path.join(output_dir, latest))
else:
    trainer.train()

print("Training complete.")
trainer.save_model(output_dir)
tokenizer.save_pretrained(output_dir)
```
Message:
config.json: 
 1.07k/? [00:00<00:00, 198kB/s]
configuration_deepseek.py: 
 10.2k/? [00:00<00:00, 1.33MB/s]
A new version of the following files was downloaded from https://huggingface.co/deepseek-ai/deepseek-moe-16b-base:
- configuration_deepseek.py
. Make sure to double-check they do not contain any added malicious code. To avoid downloading new versions of the code file, you can pin a revision.
modeling_deepseek.py: 
 72.7k/? [00:00<00:00, 13.0MB/s]
A new version of the following files was downloaded from https://huggingface.co/deepseek-ai/deepseek-moe-16b-base:
- modeling_deepseek.py
. Make sure to double-check they do not contain any added malicious code. To avoid downloading new versions of the code file, you can pin a revision.
model.safetensors.index.json: 
 490k/? [00:00<00:00, 60.6MB/s]
Fetching 7 files: 100%
 7/7 [00:21<00:00, 21.45s/it]
model-00006-of-00007.safetensors: 100%
 5.00G/5.00G [00:21<00:00, 607MB/s]
model-00002-of-00007.safetensors: 100%
 5.00G/5.00G [00:19<00:00, 292MB/s]
model-00007-of-00007.safetensors: 100%
 2.77G/2.77G [00:15<00:00, 246MB/s]
model-00005-of-00007.safetensors: 100%
 5.00G/5.00G [00:21<00:00, 651MB/s]
model-00001-of-00007.safetensors: 100%
 5.00G/5.00G [00:21<00:00, 652MB/s]
model-00004-of-00007.safetensors: 100%
 5.00G/5.00G [00:21<00:00, 515MB/s]
model-00003-of-00007.safetensors: 100%
 5.00G/5.00G [00:21<00:00, 870MB/s]
Loading checkpoint shards:  86%
 6/7 [02:28<00:26, 26.51s/it]

Error Starting Kernel
Kernel died unexpectedly