Update README.md

README.md

@@ -69,22 +69,210 @@ This model is ideal for educational purposes, particularly in coding test prepar
 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.
 
 
-## How to Get Started with the Model
+## 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:
+1. 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.
+2. 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:
+```markdown
+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:**
 
-Use the code below to get started with the model.
+- **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
-from transformers import AutoModelForCausalLM, AutoTokenizer
+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.
+
+---------------------------------------------
 
-model_name = "MinnieMin/gemma-2-2b-it-ThinkLink"
-model = AutoModelForCausalLM.from_pretrained(model_name)
-tokenizer = AutoTokenizer.from_pretrained(model_name)
+## **Objective**:
 
-inputs = tokenizer("What algorithm should I use for this problem?", return_tensors="pt")
-outputs = model.generate(**inputs)
-print(tokenizer.decode(outputs[0]))
+- 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
+```markdown
+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 :
+1. Problem Type Clarified:
+- Clearly defines the problem as Maximum Product, making it easier for learners to understand which algorithm or approach to apply.
+2. Challenging Part Identified:
+- Highlights the importance of sorting the array as the challenging part, helping learners focus on the critical difficulty in the solution.
+3. 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.
+4. 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
+```markdown
+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 :
+1. Problem Type Clarified:
+- The problem is clearly defined as Dynamic Programming, helping learners quickly identify the appropriate approach.
+2. Challenging Part Identified:
+- Highlights the importance of sorting the array as the challenging part, helping learners focus on the critical difficulty in the solution.
+3. 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.
+4. 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