improve questions for SFT

example.json

@@ -1,32 +1,395 @@
 [
     {
-        "challenge": "Complete the function to calculate the factorial of a number using recursion",
-        "solution": "if n <= 1:\n    return 1\nreturn n * factorial(n-1)",
-        "placeholder": "def factorial(n):\n    # TODO: Implement recursive factorial calculation\n    pass",
-        "context": "Factorial is the product of all positive integers less than or equal to n. For example, factorial(5) = 5 * 4 * 3 * 2 * 1 = 120. Base case is n=1 or n=0 which returns 1."
+        "challenge": "Integrate Early Stopping Callback to Prevent Over-training",
+        "solution": "early_stopping = EarlyStoppingCallback(\n    early_stopping_patience=3,\n    early_stopping_threshold=0.01\n)\ntrainer = SFTTrainer(\n    model=model,\n    train_dataset=dataset,\n    config=SFTConfig(),\n    callbacks=[early_stopping]\n)",
+        "placeholder": "# The current early stopping settings allow training to proceed too long. Adjust to stop training promptly upon divergence:\nearly_stopping = EarlyStoppingCallback(\n    early_stopping_patience=10,    # Patience value is too high\n    early_stopping_threshold=0.1   # Threshold is too loose\n)\ntrainer = SFTTrainer(\n    model=model,\n    train_dataset=dataset,\n    config=SFTConfig(),\n    callbacks=[]                   # Add the early stopping callback here\n)",
+        "context": "Validation loss starts diverging around step 400 and increases by approximately 0.02 per step for 3 consecutive steps. The early stopping mechanism should be sensitive enough (patience between 2-4 steps and a threshold between 0.005-0.02) to halt training when overfitting begins.",
+        "assessment_criteria": [
+            "Ensure the early_stopping_patience is within 2 to 4 steps.",
+            "Verify that the early_stopping_threshold is between 0.005 and 0.02.",
+            "Confirm that EarlyStoppingCallback is added to the callbacks list.",
+            "Make sure EarlyStoppingCallback is correctly imported."
+        ],
+        "image": "/Users/ben/code/code_assignment_app/images/2.png"
     },
     {
-        "challenge": "Implement a function to reverse a string without using built-in reverse methods",
-        "solution": "reversed_str = ''\nfor i in range(len(s)-1, -1, -1):\n    reversed_str += s[i]\nreturn reversed_str",
-        "placeholder": "def reverse_string(s):\n    # TODO: Implement string reversal\n    pass",
-        "context": "String reversal can be done by iterating from the end to the beginning or using slicing with a negative step. This tests understanding of string manipulation and iteration."
+        "challenge": "Set Up a Linear Learning Rate Scheduler Reflecting Gradual Loss Reduction",
+        "solution": "trainer = SFTTrainer(\n    model=model,\n    train_dataset=dataset,\n    config=SFTConfig(\n        learning_rate=3e-4,\n        lr_scheduler_type='linear',\n        num_train_epochs=3\n    )\n)",
+        "placeholder": "# The current configuration uses an inappropriate scheduler and parameter values. Update to match a linear decay:\ntrainer = SFTTrainer(\n    model=model,\n    train_dataset=dataset,\n    config=SFTConfig(\n        learning_rate=1e-4,         # Learning rate is too low\n        lr_scheduler_type='cosine', # Incorrect scheduler type\n        num_train_epochs=5          # Too many epochs\n    )\n)",
+        "context": "The image shows a linear decrease in loss from 0.8 to 0.2 over approximately 3 epochs. The learning rate scheduler should follow a linear decay pattern, so parameters must be adjusted to reflect this behavior.",
+        "assessment_criteria": [
+            "Ensure lr_scheduler_type is explicitly set to 'linear'.",
+            "Verify that learning_rate is within the range of 2e-4 to 4e-4.",
+            "Confirm that num_train_epochs is set between 2 and 4 to match the convergence pattern."
+        ],
+        "image": "/Users/ben/code/code_assignment_app/images/3.png"
     },
     {
-        "challenge": "Write a list comprehension that filters out all even numbers from the input list",
-        "solution": "return [num for num in numbers if num % 2 != 0]",
-        "placeholder": "def get_odd_numbers(numbers):\n    # TODO: Filter odd numbers using list comprehension\n    pass",
-        "context": "List comprehensions provide a concise way to create lists based on existing lists. The modulo operator % is used to test for odd/even numbers."
+        "challenge": "Tune TRL Training Arguments for Stable Convergence",
+        "solution": "trainer = SFTTrainer(\n    model=model,\n    args=TrainingArguments(\n        max_steps=2000,\n        learning_rate=5e-5,\n        gradient_accumulation_steps=4,\n        logging_steps=10\n    )\n)",
+        "placeholder": "trainer = SFTTrainer(\n    model=model,\n    args=TrainingArguments(\n        max_steps=____, # Pick a value between 1000-3000 steps\n        learning_rate=____, # Set a learning rate between 1e-5 and 1e-4\n        gradient_accumulation_steps=____, # Choose between 1 and 8\n        logging_steps=____ # Choose a value between 5 and 50\n    )\n)",
+        "context": "The provided image suggests a smooth and stable convergence over about 2000 steps, with a final loss near 0.1 and logs generated roughly every 10 steps. The training arguments must mirror this stability and reporting frequency.",
+        "assessment_criteria": [
+            "Confirm that max_steps is set between 1800 and 2200.",
+            "Ensure learning_rate lies between 4e-5 and 6e-5.",
+            "Verify that gradient_accumulation_steps is within 2 to 6.",
+            "Check that logging_steps is between 8 and 12."
+        ],
+        "image": "/Users/ben/code/code_assignment_app/images/4.png"
     },
     {
-        "challenge": "Complete the function to find the first non-repeating character in a string",
-        "solution": "char_count = {}\nfor char in s:\n    char_count[char] = char_count.get(char, 0) + 1\nfor char in s:\n    if char_count[char] == 1:\n        return char\nreturn None",
-        "placeholder": "def first_non_repeating(s):\n    # TODO: Find first non-repeating character\n    pass",
-        "context": "This problem tests dictionary usage and string iteration. The solution involves counting character frequencies and then finding the first character with count 1."
+        "challenge": "Optimize PEFT and Enable 4-bit Quantization for Memory-Efficient Training",
+        "solution": "peft_config = LoraConfig(r=16, lora_alpha=32)\nquant_config = BitsAndBytesConfig(load_in_4bit=True)\n\ntrainer = SFTTrainer(\n    model=model,\n    peft_config=peft_config,\n    quantization_config=quant_config\n)",
+        "placeholder": "peft_config = LoraConfig(\n    r=____, # Select a value between 4 and 32\n    lora_alpha=____ # Set to 4 times the chosen r\n)\nquant_config = BitsAndBytesConfig(\n    load_in_4bit=____ # Set to True or False\n)\n\ntrainer = SFTTrainer(\n    model=model,\n    peft_config=____,\n    quantization_config=____\n)",
+        "context": "For a 7B parameter model running on 24GB GPU, efficient training is critical. Adjust the PEFT settings with a LoRA adapter—choose r within 8 and 24 and set lora_alpha to 4 times the chosen r—to ensure low memory usage and effective regularization. Additionally, enable 4-bit quantization to further reduce resource consumption.",
+        "assessment_criteria": [
+            "Verify that r is set between 8 and 24.",
+            "Confirm that lora_alpha is exactly 4 times the r value.",
+            "Ensure that 4-bit quantization (load_in_4bit) is enabled (set to True).",
+            "Check that both peft_config and quantization_config are properly passed to the trainer."
+        ]
     },
     {
-        "challenge": "Implement a function that checks if a string is a valid palindrome",
-        "solution": "s = ''.join(char.lower() for char in s if char.isalnum())\nreturn s == s[::-1]",
-        "placeholder": "def is_palindrome(s):\n    # TODO: Check if string is palindrome (ignoring spaces and punctuation)\n    pass",
-        "context": "Palindrome check requires string cleaning (removing spaces/punctuation), case normalization, and comparison. String slicing with [::-1] provides an efficient way to reverse strings in Python."
+        "challenge": "Format Multi-turn Chat Conversation for Llama 2 Inference",
+        "solution": "tokenizer.apply_chat_template(\n    conversation=[\n        {\"role\": \"user\", \"content\": \"Hello!\"},\n        {\"role\": \"assistant\", \"content\": \"Hi there!\"},\n        {\"role\": \"user\", \"content\": \"How are you?\"}\n    ],\n    tokenize=False,\n    add_generation_prompt=True\n)",
+        "placeholder": "tokenizer.apply_chat_template(\n    conversation=____,       # Provide a list of message dictionaries with 'role' and 'content'\n    tokenize=____,           # Set to False to return a formatted string\n    add_generation_prompt=____ # Set to True to include the generation prompt\n)",
+        "context": "For proper inference with Llama 2, the conversation must be formatted as a multi-turn dialogue with clearly defined roles. The tokenizer should output a concatenated string (not tokenized) while also including a generation prompt to initiate the response.",
+        "assessment_criteria": [
+            "Ensure the conversation is formatted as a list of dictionaries each containing 'role' and 'content'.",
+            "Check that tokenize is explicitly set to False.",
+            "Confirm that add_generation_prompt is set to True."
+        ]
+    },
+    {
+        "challenge": "Set Up a LoRA Adapter Configuration for Efficient Model Fine-tuning",
+        "solution": "config = LoraConfig(\n    r=8,\n    lora_alpha=32,\n    target_modules=[\"q_proj\", \"v_proj\"],\n    lora_dropout=0.05,\n    bias=\"none\"\n)",
+        "placeholder": "config = LoraConfig(\n    r=____,              # Choose rank within 4 to 16\n    lora_alpha=____,       # Should be 4 times the chosen rank\n    target_modules=____,   # Specify the attention modules (e.g., ['q_proj', 'v_proj'])\n    lora_dropout=____,     # Set dropout between 0.01 and 0.1\n    bias=____              # Choose from 'none', 'all', or 'lora_only'\n)",
+        "context": "When fine-tuning a large (7B) model on limited GPU resources, a LoRA adapter helps reduce memory consumption and computational overhead.",
+        "assessment_criteria": [
+            "Confirm that r is within the range of 4 to 16.",
+            "Verify that lora_alpha is exactly 4 times the r value.",
+            "Ensure that target_modules is set to an appropriate list",
+            "Check that lora_dropout lies between 0.01 and 0.1."
+        ]
+    },
+    {
+        "challenge": "Combine Multiple LoRA Adapters Using Weighted Sum",
+        "solution": "merged_model = merge_lora_weights(\n    base_model=model,\n    adapters=[\n        (adapter1, 0.7),\n        (adapter2, 0.3)\n    ],\n    merge_strategy=\"weighted_sum\"\n)",
+        "placeholder": "merged_model = merge_lora_weights(\n    base_model=model,\n    adapters=[\n        (____, ____), # Add the first adapter and its weight\n        (____, ____)  # Add the second adapter and its weight\n    ],\n    merge_strategy=____ # Specify the merge strategy (e.g., 'weighted_sum')\n)",
+        "context": "For enhanced performance, you may need to merge different LoRA adapters (for example, one tuned for general instruction and another for task-specific nuances). The weighted sum should reflect the relative contribution of each adapter, with the weights summing to 1.0.",
+        "assessment_criteria": [
+            "Ensure that the weights for the adapters sum up to 1.0 (or very close, accounting for rounding).",
+            "Confirm that an appropriate merge_strategy (such as 'weighted_sum') is specified.",
+            "Verify that the adapters being merged have compatible architectures."
+        ]
+    },
+    {
+        "challenge": "Load Base Causal LM and Integrate a Pre-trained LoRA Adapter for Inference",
+        "solution": "model = AutoModelForCausalLM.from_pretrained(\n    \"base_model\",\n    device_map=\"auto\"\n)\nmodel = PeftModel.from_pretrained(\n    model,\n    \"lora_adapter\",\n    adapter_name=\"default\"\n).merge_and_unload()",
+        "placeholder": "model = AutoModelForCausalLM.from_pretrained(\n    ____,          # Specify the base model identifier\n    device_map=____ # Configure device mapping, e.g., 'auto'\n)\nmodel = PeftModel.from_pretrained(\n    ____,          # Provide the loaded base model\n    ____,          # Provide the LoRA adapter path\n    adapter_name=____ # Use the correct adapter name\n).____()       # Call the method to merge and unload adapter weights (e.g., merge_and_unload)\n",
+        "context": "For inference, first load the base model with device mapping, then incorporate the LoRA adapter",
+        "assessment_criteria": [
+            "Verify correct base model loading with device mapping",
+            "Ensure correct adapter loading",
+            "Confirm proper merging for inference"
+        ]
+    },
+    {
+        "challenge": "Configure SFTTrainer Learning Rate",
+        "solution": "trainer = SFTTrainer(\n    model=model,\n    train_dataset=dataset,\n    config=SFTConfig(\n        learning_rate=2e-5\n    )\n)",
+        "placeholder": "trainer = SFTTrainer(\n    model=model,\n    train_dataset=dataset,\n    config=SFTConfig(\n        learning_rate=5e-5  # TODO: Lower this value to prevent overfitting (should be < 3e-5)\n    )\n)",
+        "context": "The model is showing signs of overfitting with the current learning rate of 5e-5. A lower learning rate is needed for more stable training.",
+        "assessment_criteria": [
+            "Verify that learning_rate is below 3e-5"
+        ]
+    },
+    {
+        "challenge": "Configure LoRA Adapter Rank",
+        "solution": "config = LoraConfig(\n    r=16\n)",
+        "placeholder": "config = LoraConfig(\n    r=4  # TODO: Increase rank for better adaptation (should be between 8-24)\n)",
+        "context": "The current LoRA rank is too low for effective model adaptation. A higher rank will improve model capacity while keeping memory usage reasonable.",
+        "assessment_criteria": [
+            "Verify that r is set between 8 and 24"
+        ]
+    },
+    {
+        "challenge": "Configure SFTTrainer: Set max_steps for training duration",
+        "solution": "trainer = SFTTrainer(\n    model=model,\n    train_dataset=dataset,\n    config=SFTConfig(\n        max_steps=1000\n    )\n)",
+        "placeholder": "trainer = SFTTrainer(\n    model=model,\n    train_dataset=dataset,\n    config=SFTConfig(\n        max_steps=____ # Choose between 800-1200 steps\n    )\n)",
+        "context": "Based on the training curves, setting an appropriate number of steps is crucial to avoid overfitting while allowing sufficient training progress.",
+        "assessment_criteria": [
+            "Verify that max_steps is set between 800 and 1200 steps."
+        ]
+    },
+    {
+        "challenge": "Refine SFTTrainer: Adjust learning_rate to prevent overfitting",
+        "solution": "trainer = SFTTrainer(\n    model=model,\n    train_dataset=dataset,\n    config=SFTConfig(\n        learning_rate=2e-5\n    )\n)",
+        "placeholder": "sft_config = SFTConfig(\n    max_steps=____, \n    learning_rate=____, \n    weight_decay=____, \n    warmup_steps=____\n)",
+        "context": "A cautious learning rate is essential to prevent overly aggressive updates that can lead to overfitting.",
+        "assessment_criteria": [
+            "Verify that learning_rate is below 3e-5."
+        ]
+    },
+    {
+        "challenge": "Refine SFTTrainer: Increase weight_decay for stronger regularization",
+        "solution": "trainer = SFTTrainer(\n    model=model,\n    train_dataset=dataset,\n    config=SFTConfig(\n        weight_decay=0.02\n    )\n)",
+        "placeholder": "sft_config = SFTConfig(\n    max_steps=____, \n    learning_rate=____, \n    weight_decay=____, \n    warmup_steps=____\n)",
+        "context": "Increasing weight decay enhances regularization, which helps mitigate overfitting issues.",
+        "assessment_criteria": [
+            "Confirm that weight_decay is increased (greater than 0.01)."
+        ]
+    },
+    {
+        "challenge": "Refine SFTTrainer: Set appropriate warmup_steps relative to max_steps",
+        "solution": "trainer = SFTTrainer(\n    model=model,\n    train_dataset=dataset,\n    config=SFTConfig(\n        warmup_steps=100\n    )\n)",
+        "placeholder": "sft_config = SFTConfig(\n    max_steps=____, \n    learning_rate=____, \n    weight_decay=____, \n    warmup_steps=____\n)",
+        "context": "A sufficient warmup period helps the optimizer gradually adjust and avoids sudden gradient spikes.",
+        "assessment_criteria": [
+            "Check that warmup_steps is at least 10% of max_steps."
+        ]
+    },
+    {
+        "challenge": "Integrate Early Stopping: Set Callback Patience Correctly",
+        "solution": "early_stopping = EarlyStoppingCallback(\n    early_stopping_patience=3\n)",
+        "placeholder": "early_stopping = EarlyStoppingCallback(\n    early_stopping_patience=____ # Choose between 2-4 steps\n)",
+        "context": "An appropriate patience value helps stop training promptly when validation loss begins to increase.",
+        "assessment_criteria": [
+            "Confirm that early_stopping_patience is set between 2 and 4 steps."
+        ]
+    },
+    {
+        "challenge": "Integrate Early Stopping: Define Threshold for Early Stopping Trigger",
+        "solution": "early_stopping = EarlyStoppingCallback(\n    early_stopping_threshold=0.01\n)",
+        "placeholder": "early_stopping = EarlyStoppingCallback(\n    early_stopping_threshold=____\n)",
+        "context": "The threshold determines how sensitive the early stopping callback is when detecting divergence in validation loss.",
+        "assessment_criteria": [
+            "Verify that early_stopping_threshold is between 0.005 and 0.02."
+        ]
+    },
+    {
+        "challenge": "Configure Linear LR Scheduler: Set Correct Learning Rate",
+        "solution": "trainer = SFTTrainer(\n    model=model,\n    train_dataset=dataset,\n    config=SFTConfig(\n        learning_rate=3e-4\n    )\n)",
+        "placeholder": "sft_config = SFTConfig(\n    max_steps=____, \n    learning_rate=____, \n    weight_decay=____, \n    warmup_steps=____\n)",
+        "context": "A proper learning rate within the recommended range ensures a smooth linear decay as observed in training curves.",
+        "assessment_criteria": [
+            "Verify that learning_rate is within the range of 2e-4 to 4e-4."
+        ],
+        "image": "/Users/ben/code/code_assignment_app/images/3.png"
+    },
+    {
+        "challenge": "Configure Linear LR Scheduler: Set Proper Scheduler Type",
+        "solution": "trainer = SFTTrainer(\n    model=model,\n    train_dataset=dataset,\n    config=SFTConfig(\n        lr_scheduler_type='linear'\n    )\n)",
+        "placeholder": "sft_config = SFTConfig(\n    max_steps=____, \n    learning_rate=____, \n    weight_decay=____, \n    warmup_steps=____\n)",
+        "context": "Specifying a 'linear' scheduler type ensures that the learning rate decays uniformly.",
+        "assessment_criteria": [
+            "Ensure lr_scheduler_type is explicitly set to 'linear'."
+        ],
+        "image": "/Users/ben/code/code_assignment_app/images/3.png"
+    },
+    {
+        "challenge": "Configure Linear LR Scheduler: Adjust Number of Training Epochs",
+        "solution": "trainer = SFTTrainer(\n    model=model,\n    train_dataset=dataset,\n    config=SFTConfig(\n        num_train_epochs=3\n    )\n)",
+        "placeholder": "sft_config = SFTConfig(\n    max_steps=____, \n    learning_rate=____, \n    weight_decay=____, \n    warmup_steps=____\n)",
+        "context": "Setting the proper number of epochs helps the model converge in line with the observed linear loss reduction.",
+        "assessment_criteria": [
+            "Confirm that num_train_epochs is set between 2 and 4."
+        ],
+        "image": "/Users/ben/code/code_assignment_app/images/3.png"
+    },
+    {
+        "challenge": "Set TRL Training Args: Choose appropriate max_steps",
+        "solution": "trainer = SFTTrainer(\n    model=model,\n    args=TrainingArguments(\n        max_steps=2000\n    )\n)",
+        "placeholder": "sft_config = SFTConfig(\n    max_steps=____, \n    learning_rate=____, \n    weight_decay=____, \n    warmup_steps=____\n)",
+        "context": "Choosing an optimal value for max_steps ensures the training process is neither too short nor unnecessarily long.",
+        "assessment_criteria": [
+            "Confirm that max_steps is set between 1800 and 2200."
+        ],
+        "image": "/Users/ben/code/code_assignment_app/images/4.png"
+    },
+    {
+        "challenge": "Set TRL Training Args: Adjust learning_rate for stability",
+        "solution": "trainer = SFTTrainer(\n    model=model,\n    args=TrainingArguments(\n        learning_rate=5e-5\n    )\n)",
+        "placeholder": "sft_config = SFTConfig(\n    max_steps=____, \n    learning_rate=____, \n    weight_decay=____, \n    warmup_steps=____\n)",
+        "context": "A stable learning rate helps maintain smooth and consistent training progress.",
+        "assessment_criteria": [
+            "Ensure learning_rate lies between 4e-5 and 6e-5."
+        ],
+        "image": "/Users/ben/code/code_assignment_app/images/4.png"
+    },
+    {
+        "challenge": "Set TRL Training Args: Optimize gradient_accumulation_steps",
+        "solution": "trainer = SFTTrainer(\n    model=model,\n    args=TrainingArguments(\n        gradient_accumulation_steps=4\n    )\n)",
+        "placeholder": "sft_config = SFTConfig(\n    max_steps=____, \n    learning_rate=____, \n    weight_decay=____, \n    warmup_steps=____\n)",
+        "context": "Optimizing gradient accumulation helps smooth updates and is key for training stability.",
+        "assessment_criteria": [
+            "Verify that gradient_accumulation_steps is within 2 to 6."
+        ],
+        "image": "/Users/ben/code/code_assignment_app/images/4.png"
+    },
+    {
+        "challenge": "Set TRL Training Args: Define proper logging_steps frequency",
+        "solution": "trainer = SFTTrainer(\n    model=model,\n    args=SFTConfig(\n        logging_steps=10\n    )\n)",
+        "placeholder": "trainer = SFTTrainer(\n    model=model,\n    args=SFTConfig(\n        logging_steps=____ # Choose between 8 and 12\n    )\n)",
+        "context": "Logging at the correct frequency provides clear insights into training without excessive output.",
+        "assessment_criteria": [
+            "Check that logging_steps is between 8 and 12."
+        ],
+        "image": "/Users/ben/code/code_assignment_app/images/4.png"
+    },
+    {
+        "challenge": "Optimize PEFT: Select appropriate LoRA rank (r)",
+        "solution": "peft_config = LoraConfig(\n    r=16, \n    lora_alpha=32, \n    target_modules=[\"q_proj\", \"v_proj\"]\n)",
+        "placeholder": "peft_config = LoraConfig(\n    r=____ # Choose r value\n    ora_alpha=32, \n    target_modules=[\"q_proj\", \"v_proj\"]\n)",
+        "context": "The LoRA rank (r) directly affects model complexity and resource usage, so it should fall within an optimal range.",
+        "assessment_criteria": [
+            "Verify that r is set between 8 and 24."
+        ]
+    },
+    {
+        "challenge": "Optimize PEFT: Choose correct lora_alpha based on r",
+        "solution": "peft_config = LoraConfig(\n    r=16, \n    lora_alpha=32, \n    target_modules=[\"q_proj\", \"v_proj\"]\n)",
+        "placeholder": "peft_config = LoraConfig(\n    r=____, # Choose r value\n    lora_alpha=____, # Should be 4 times the chosen r (e.g., if r=8, then lora_alpha=32)\n    target_modules=[\"q_proj\", \"v_proj\"]\n)",
+        "context": "Setting lora_alpha proportionally (4× the rank, r) ensures balanced adaptive scaling as recommended in TRL examples.",
+        "assessment_criteria": [
+            "Confirm that lora_alpha is exactly 4 times the r value."
+        ]
+    },
+    {
+        "challenge": "Enable 4-bit Quantization for Efficient Training",
+        "solution": "quant_config = BitsAndBytesConfig(\n    load_in_4bit=True\n)",
+        "placeholder": "quant_config = BitsAndBytesConfig(\n    load_in_4bit=____\n)",
+        "context": "4-bit quantization significantly reduces memory requirements while maintaining acceptable performance.",
+        "assessment_criteria": [
+            "Ensure that load_in_4bit is set to True."
+        ]
+    },
+    {
+        "challenge": "Format Chat Conversation: Provide proper conversation list",
+        "solution": "tokenizer.apply_chat_template(\n    conversation=[\n        {\"role\": \"user\", \"content\": \"Hello!\"},\n        {\"role\": \"assistant\", \"content\": \"Hi there!\"}\n    ]\n)",
+        "placeholder": "tokenizer.apply_chat_template(\n    conversation=____ # Provide a list of dictionaries with 'role' and 'content'\n)",
+        "context": "A correctly formatted conversation list is essential to initiate multi-turn chat inference.",
+        "assessment_criteria": [
+            "Ensure the conversation is formatted as a list of dictionaries with 'role' and 'content'."
+        ]
+    },
+    {
+        "challenge": "Format Chat Conversation: Set tokenize option appropriately",
+        "solution": "tokenizer.apply_chat_template(\n    tokenize=False\n)",
+        "placeholder": "tokenizer.apply_chat_template(_____)",
+        "context": "Setting tokenize to False makes sure that the output remains a fully formatted string.",
+        "assessment_criteria": [
+            "Check that tokenize is explicitly set to False."
+        ]
+    },
+    {
+        "challenge": "Format Chat Conversation: Enable Generation Prompt",
+        "solution": "tokenizer.apply_chat_template(\n    add_generation_prompt=True\n)",
+        "placeholder": "tokenizer.apply_chat_template(_____)",
+        "context": "Enabling the generation prompt helps trigger the model's response generation effectively.",
+        "assessment_criteria": [
+            "Confirm that add_generation_prompt is set to True."
+        ]
+    },
+    {
+        "challenge": "Configure LoRA Adapter: Set rank parameter for efficient adaptation",
+        "solution": "config = LoraConfig(\n    r=8\n)",
+        "placeholder": "config = LoraConfig(\n    r=____, # Choose r value\n    lora_alpha=16,\n)",
+        "context": "Choosing a proper rank for the LoRA adapter is key for efficient fine-tuning with limited resources.",
+        "assessment_criteria": [
+            "Confirm that r is within the range of 4 to 16."
+        ]
+    },
+    {
+        "challenge": "Configure LoRA Adapter: Set lora_alpha as 4 times r",
+        "solution": "config = LoraConfig(\n    lora_alpha=32\n)",
+        "placeholder": "config = LoraConfig(\n    lora_alpha=____, # Should be 4 times the chosen r\n    r=4\n)",
+        "context": "Maintaining the ratio between lora_alpha and r is important for balanced adapter scaling.",
+        "assessment_criteria": [
+            "Verify that lora_alpha is exactly 4 times the r value."
+        ]
+    },
+    {
+        "challenge": "Configure LoRA Adapter: Specify target attention modules",
+        "solution": "config = LoraConfig(\n    target_modules=[\"q_proj\", \"v_proj\"]\n)",
+        "placeholder": "config = LoraConfig(\n    target_modules=____, # Specify a list of attention modules\n    r=4\n)",
+        "context": "Identifying and targeting the relevant attention modules helps focus the adapter's adjustments.",
+        "assessment_criteria": [
+            "Ensure that target_modules is set to an appropriate list (e.g., ['q_proj', 'v_proj'])."
+        ]
+    },
+    {
+        "challenge": "Configure LoRA Adapter: Define dropout rate",
+        "solution": "config = LoraConfig(\n    lora_dropout=0.05\n)",
+        "placeholder": "config = LoraConfig(\n    lora_dropout=____, # Set value between 0.01 and 0.1\n    r=4\n)",
+        "context": "An optimal dropout rate helps prevent overfitting during fine-tuning.",
+        "assessment_criteria": [
+            "Check that lora_dropout is between 0.01 and 0.1."
+        ]
+    },
+    {
+        "challenge": "Combine LoRA Adapters: Verify adapter weight sum",
+        "solution": "merged_model = merge_lora_weights(\n    base_model=model,\n    adapters=[(adapter1, 0.7), (adapter2, 0.3)],\n    merge_strategy=\"weighted_sum\"\n)",
+        "placeholder": "merged_model = merge_lora_weights(\n    base_model=model,\n    adapters=[(adapter1, 0.7), (adapter2, 0.3)],\n    merge_strategy=____\n)",
+        "context": "For a balanced merge of multiple adapters, their weights must sum to 1.0 (or very close, accounting for rounding).",
+        "assessment_criteria": [
+            "Ensure that the weights for the adapters sum up to 1.0 (or very close, accounting for rounding)."
+        ]
+    },
+    {
+        "challenge": "Combine LoRA Adapters: Specify a valid merge strategy",
+        "solution": "merged_model = merge_lora_weights(\n    base_model=model,\n    adapters=[(adapter1, 0.7), (adapter2, 0.3)],\n    merge_strategy=\"weighted_sum\"\n)",
+        "placeholder": "merged_model = merge_lora_weights(\n    base_model=model,\n    adapters=[(adapter1, 0.7), (adapter2, 0.3)],\n    merge_strategy=____\n)",
+        "context": "A valid merge strategy must be specified to correctly combine the contributions of each adapter.",
+        "assessment_criteria": [
+            "Confirm that an appropriate merge_strategy is specified (e.g., 'weighted_sum')."
+        ]
+    },
+    {
+        "challenge": "Load Base Model: Provide correct model identifier and device mapping",
+        "solution": "model = AutoModelForCausalLM.from_pretrained(\n    \"base_model\",\n    device_map=\"auto\"\n)",
+        "placeholder": "model = AutoModelForCausalLM.from_pretrained(____)\npeft_model = PeftModel.from_pretrained(____, ____)\n# Merge weights\nmodel = peft_model.____",
+        "context": "The base model must be loaded correctly with its device mapping before integrating adapters.",
+        "assessment_criteria": [
+            "Verify that the base model is loaded correctly with the proper device mapping."
+        ]
+    },
+    {
+        "challenge": "Load Pre-trained LoRA Adapter: Use correct adapter identifier",
+        "solution": "model = PeftModel.from_pretrained(\n    model,\n    \"lora_adapter\",\n    adapter_name=\"default\"\n)\n # Merge LoRA weights into base model\nmodel = peft_model.merge_and_unload()",
+        "placeholder": "Ensure to provide the correct adapter identifier",
+        "context": "model = PeftModel.from_pretrained(model, \"lora_adapter\")\n# Merge LoRA weights into base model",
+        "assessment_criteria": [
+            "Ensure that the correct adapter identifier is used to load the LoRA adapter."
+        ]
+    },
+    {
+        "challenge": "Merge LoRA Adapter: Successfully merge and unload adapter weights",
+        "solution": "model = PeftModel.from_pretrained(\n    model,\n    \"lora_adapter\",\n    adapter_name=\"default\"\n).merge_and_unload()",
+        "placeholder": "model = PeftModel.from_pretrained(____, ____)\n# Merge weights\nmodel = peft_model.____",
+        "context": "Merging and unloading the adapter weights prepares the model for efficient inference.",
+        "assessment_criteria": [
+            "Confirm that the adapter is merged with the base model and unloaded appropriately to optimize inference performance."
+        ]
+    },
+    {
+        "challenge": "Merge a LoRA adapter into the base model for inference",
+        "solution": "model = AutoModelForCausalLM.from_pretrained(\"base_model\")\npeft_model = PeftModel.from_pretrained(model, \"lora_adapter\")\n# Merge LoRA weights into base model\nmodel = peft_model.merge_and_unload()",
+        "placeholder": "model = AutoModelForCausalLM.from_pretrained(____)\npeft_model = PeftModel.from_pretrained(____, ____)\n# Merge weights\nmodel = peft_model.____",
+        "context": "You need to merge a trained LoRA adapter back into the base model for efficient inference",
+        "assessment_criteria": [
+            "Is base model loaded correctly?",
+            "Is LoRA adapter loaded with PeftModel?",
+            "Is merge_and_unload() used to combine weights?"
+        ]
+    },
+    {
+        "challenge": "Configure Training Duration for Fine-tuning",
+        "solution": "trainer = SFTTrainer(\n    model=model,\n    train_dataset=dataset,\n    num_train_epochs=3,\n    max_steps=None\n)",
+        "placeholder": "trainer = SFTTrainer(\n    model=model,\n    train_dataset=dataset,\n    num_train_epochs=10,    \n    max_steps=None\n)",
+        "context": "The model is showing signs of overfitting after epoch 5. Configure the trainer to use fewer epochs (2-4) to prevent this.",
+        "assessment_criteria": [
+            "Is num_train_epochs set between 2 and 4?",
+            "Is max_steps left as None to use epoch-based training?"
+        ]
     }
 ]