metadata

license: gemma
datasets:
  - RayBernard/leetcode
language:
  - en
base_model: google/gemma-2-2b-it
tags:
  - code-generation
  - nlp
  - transformers
  - causal-lm
  - coding-education

Model Card for ThinkLink Gemma-2-2B-IT

Model Summary

The ThinkLink Gemma-2-2B-IT model helps users solve coding test problems by providing guided hints and questions, encouraging self-reflection and critical thinking rather than directly offering solutions.

Model Details

Model Description

ThinkLink Gemma-2-2B-IT is a fine-tuned version of the Gemma-2-2B-IT model, aimed specifically at coding test preparation. It transforms how users interact with coding problems by prompting them with questions that guide them to the solution. This approach enhances learning outcomes by focusing on problem-solving strategies rather than rote solution delivery.

Developer: MinnieMin
Base Model: google/gemma-2-2b-it
Model Type: Causal Language Model (AutoModelForCausalLM)
Language: English
License: Gemma License
Fine-tuning Method: Low-Rank Adaptation (LoRA)
Model Size: 2.2B parameters

This model is intended to assist users by asking strategic questions about coding test problems, such as identifying problem types, challenging parts, and formulating structured solutions. The fine-tuning is centered on making the model act like a tutor, guiding users through the thought process rather than merely providing answers.

Model Sources

Repository: ThinkLink Gemma-2-2B-IT Model
Fine-tuned on: RayBernard/leetcode

Intended Use

Direct Use

This model is ideal for educational purposes, particularly in coding test preparation, where it generates hints and structured questions to help users solve problems step-by-step. The model is tailored for users looking to improve their coding and problem-solving skills by engaging with the problem rather than seeking direct solutions.

Downstream Use

Can be used in coding education platforms as a guided tutor for programming interview preparation.
Useful for platforms providing learning assistance in problem-solving, software development, or competitive programming.
With further fine-tuning, it could be adapted to other domains that benefit from structured problem-solving guidance, like mathematics or algorithmic reasoning.

Out-of-Scope Use

It is not suitable for users looking for direct and immediate solutions, as the model is designed to guide rather than answer directly.
It is not optimized for general-purpose natural language generation or tasks requiring complex reasoning outside coding-related problems.
It may not perform well in advanced mathematical or scientific computations without further fine-tuning.

Recommendations

Users should be aware that the model encourages self-reflection and thought processes, which may not always align with seeking quick solutions. The model’s effectiveness depends on user interaction and the problem context, and it may not perform well in certain programming domains without further fine-tuning.

Project Overview

Problem:

In the past, when preparing for Coding Tests, using LLM models felt like simply copying the answer sheet, which led to the perception that using these models was inappropriate. This is because the models focus solely on providing the answer. That is, LLM models directly deliver the solution without involving the user's thought process, resulting in an inefficient learning experience.
A shift in perspective: Could the Gemma model be used as a Tutor to help users prepare for Coding Tests?

Analysis of the Gemma Model

After inputting Coding Test problems into the Gemma model, the following observations were made:

Inconsistent Answer Format:
- The response format provided by the model is inconsistent. For example, some answers provide explanations only, while others include complete code, which can confuse the user.
Lack of Code or Incorrect Solutions:
- Some responses lack code or contain incorrect examples, which do not help the user solve the problem.

Conclusion: The Gemma model often provides inconsistent answers, making it less likely to aid in user learning effectively.

Example Response from the Original Gemma Model

Example 1: Closest Sum Problem

Problem Description:

1. Sort the input array `nums`.
2. Initialize the closest variable to be the sum of the first three elements.
3. Iterate through the sorted array with a pointer `i` running from the first element to the third-to-last element.
4. Initialize two-pointers left (set to i + 1) and right (set to the last element).
5. While left is less than right:
   a. Calculate the current sum `cur_sum` using the elements at positions `i`, `left`, and `right`.
   b. If `cur_sum` is equal to target, return it as the closest sum.
   c. Update the closest sum if the difference between target and `cur_sum` is less than the difference between target and closest.
   d. Move the left pointer forward if `cur_sum` is less than target, otherwise move the right pointer backward.
6. Return the closest sum found.

Gemma Model Response:

**Explanation:**

The code implements a solution to find the closest sum of three numbers in an array. It utilizes a two-pointer approach to efficiently explore the array and compare sums with the target value.

**Key Points:**

- **Sorting:** The input array is sorted to enable efficient searching.
- **Two-Pointers:** The code uses two pointers (`left` and `right`) to explore the array and compare sums.
- **Iteration:** The code iterates through the sorted array, comparing sums with the target value.
- **Comparison:** The code compares the difference between the target value and the current sum to determine the closest sum.
- **Update:** The code updates the `closest` sum if a smaller difference is found.

**Example:**

```
nums = [1, 2, 3, 4, 5]
target = 7

Sorted nums: [1, 2, 3, 4, 5]
closest = 7
```

**Code:**

```python
def closest_sum_of_three(nums, target):
    nums.sort()
    closest = nums[0] + nums[1] + nums[2]
    for i in range(3):
        left = i + 1
        right = nums[-1]
        while left < right:
            cur_sum = nums[i] + nums[left] + nums[right]
            if cur_sum == target:
                return cur_sum
            if abs(cur_sum - target) < abs(closest - target):
                closest = cur_sum
            if cur_sum < target:
                left += 1
            else:
                right -= 1
    return closest
```

**Note:** The code assumes that the input array `nums` is sorted in ascending order.
<end_of_turn>

Note: The code assumes that the input array nums is sorted in ascending order.
Interpretation:
- This code explains how to find the sum of three numbers closest to the target value in the nums array. However, the code contains errors and may not provide the intended results.

Objective:

Fine-tune the Gemma-2-2B-IT model to not only provide direct answers to coding test problems but to guide users through the problem-solving process using step-by-step hints, encouraging the user to think critically and explore solutions on their own.
Problems with the Original Model:
- "The original Gemma model often fails to provide essential code for solving the problem or presents incorrect code. This increases the risk of users misunderstanding and learning incorrect approaches."
Expected Outcome after Fine-Tuning:
- By fine-tuning, the model's consistency improves, providing appropriate hints that enhance problem-solving skills.
- The model encourages users to think critically and offers stepwise feedback that fosters deeper understanding.

Functionality and Structure

When a user submits a coding test problem, the fine-tuned Gemma model provides analysis and step-by-step hints instead of direct answers.
For example:
- First question: "What type of algorithm is required for this problem?"
- Second question: "What part of this problem do you find challenging (key to implementation)?"
- Third question: "Describe the approach you would take to solve the problem, including how to handle exceptions and potential errors."
This approach encourages users to think through the problem-solving process independently.

Conclusion

By creating a new dataset for fine-tuning, we were able to evaluate the model's performance improvement.

Example 1: Maximum Product Problem

The algorithm aims to find the maximum product of any three numbers in the given array. It first sorts the array, which allows easy access to the largest and smallest numbers. By sorting, the algorithm can quickly identify the highest and lowest values, which are crucial when dealing with negative numbers, as multiplying two negative numbers yields a positive product.

The main idea is to consider two scenarios:
1. The product of the three largest numbers.
2. The product of the two smallest (most negative) numbers multiplied by the largest number.

Steps:
1. Sort the array `nums` in ascending order.
2. Calculate the product of the last three numbers in the sorted array.
3. Calculate the product of the first two numbers (smallest) and the last number (largest).
4. Return the maximum value between the two products.

ThinkLink Model Response :

"problem_type": "Maximum Product",
"challenging_part": "Sorting the array",
"implementation_steps": [
    "Sort the array `nums` in ascending order.",
    "Calculate the product of the last three numbers in the sorted array.",
    "Calculate the product of the first two numbers (smallest) and the last number (largest).",
    "Return the maximum value between the two products."
],
"Answer Code": "```python\ndef maxProduct(nums):\n    nums.sort()\n    return max(nums[-1] * nums[-2] * nums[-3], nums[0] * nums[1] * nums[-1])\n```\n\n"

Interpretation :

Problem Type Clarified:

Clearly defines the problem as Maximum Product, making it easier for learners to understand which algorithm or approach to apply.

Challenging Part Identified:

Highlights the importance of sorting the array as the challenging part, helping learners focus on the critical difficulty in the solution.

Step-by-Step Explanation:

Provides a detailed breakdown of how to approach the problem, making it easier for learners to follow the steps. Sorting and calculating the product in two different ways and then comparing the results are explained effectively.

Concise Code Example:

The code example is concise and directly reflects the core logic needed to solve the problem. This allows learners to easily grasp both the theory and implementation.

Example 2: Longest Increasing Subsequence Problem

Given an integer array nums, find the length of the longest strictly increasing subsequence.

A subsequence is derived by deleting some or no elements without changing the order of the remaining elements.

Example:

Input: nums = [10, 9, 2, 5, 3, 7, 101, 18]
Output: 4
Explanation: The longest increasing subsequence is [2, 3, 7, 101], therefore the length is 4.

ThinkLink Model Response :

"problem_type": "Dynamic Programming",
"challenging_part": "Understanding the relationship between subsequences and the original array",
"implementation_steps": [
    "Create a DP table with the same size as the input array.",
    "Initialize the DP table with the maximum possible value for each index.",
    "Iterate through the input array and for each element, compare it with the previous element.",
    "If the current element is greater than the previous element, update the DP table with the maximum value of the current element.",
    "If the current element is less than the previous element, update the DP table with the maximum value of the previous element."
],
"Answer Code": "```python\ndef findLengthOfLCIS(nums):\n    if not nums:\n        return 0\n    n = len(nums)\n    dp = [1] * n\n    for i in range(1, n):\n        for j in range(i):\n            if nums[i] > nums[j]:\n                dp[i] = max(dp[i], dp[j] + 1)\n    return max(dp)\n```\n\n"

Interpretation :

Problem Type Clarified:

The problem is clearly defined as Dynamic Programming, helping learners quickly identify the appropriate approach.

Challenging Part Identified:

Highlights the importance of sorting the array as the challenging part, helping learners focus on the critical difficulty in the solution.

Step-by-Step Explanation:

The steps to solve the problem are explained in detail, from creating and initializing the DP table to updating values based on increasing subsequences. This helps learners clearly follow the process.

Concise Code Example:

The provided code is clear, concise, and directly applicable, allowing learners to easily understand how dynamic programming can be used to solve the problem.

Conclusion

By fine-tuning the Gemma model, we built a more consistent and learner-friendly system that helps users develop problem-solving skills independently. We plan to continue improving the model by training it on larger datasets and incorporating user feedback for ongoing enhancements.

Training Details

Training Data

The model was fine-tuned on a dataset primarily composed of LeetCode coding problems and solutions. The dataset was processed to focus on guiding users through steps such as identifying problem types, edge cases, and key strategies rather than providing direct solutions.

Dataset: RayBernard/leetcode
Size: Approximately 10,000 structured coding problems and related explanations

Training Procedure

Hardware: The model was trained on an L4 GPU using mixed precision (fp16) to optimize resource usage.
Training Time: Approximately 17 hours.
Training Method: The fine-tuning was performed using Low-Rank Adaptation (LoRA), which enables efficient fine-tuning with fewer parameters by adapting the weights of the base model.

Summary

The model was able to effectively guide users through various coding challenges by providing structured hints and questions that promoted deeper understanding.

Citation

BibTeX:

@misc{MinnieMin_gemma_2_2b_it_ThinkLink, author = {MinnieMin}, title = {ThinkLink Gemma-2-2B-IT: A Guided Problem-Solving Model}, year = {2024}, url = {https://huggingface.co/MinnieMin/gemma-2-2b-it-ThinkLink}, }