[ { "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": "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": "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": "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": "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?" ] } ]