Fine-tuning a Phi-3 LeetCode Expert? - Dataset Generation, Unsloth ++

Fine-tuning a Phi-3-style “LeetCode expert” starts with building a clean, structured dataset: each training example pairs a full LeetCode problem statement (including examples and constraints) with a step-by-step plan, a Python 3 solution, and an explanation. The workflow hinges on avoiding data contamination by selecting problems from a contest that has already ended, then converting those scraped problem texts into a consistent JSON schema with three fields: instruction, input, and output.

The dataset creation process begins by copying the LeetCode problem text—everything needed to solve it—then saving it in a repeatable template. The creator adds a “solution to problem X” section and uses a strong LLM (examples mentioned include Claude 3 Opus and GPT-4) to generate the reasoning and code. A system prompt is used to enforce structure: the model should provide a step-by-step chain-of-thought-style plan before writing Python code. The resulting output is then validated by pasting the generated code back into LeetCode’s Python 3 editor and running the test cases until the solution is accepted.

Once a single problem is verified, the same pattern is repeated across multiple problems. In the walkthrough, 13 LeetCode problems are assembled into a single dataset file, with each JSON record formatted so the instruction is standardized (e.g., “Solve the following lead code problem in Python 3 syntax”), the input contains the raw problem statement, and the output contains the step-by-step plan plus the final Python code and explanation. The dataset is then uploaded to Hugging Face as a public dataset, making it easy to reuse in training pipelines.

Training is performed using Unsloth notebooks aimed at fine-tuning an “F3 mini 4K instruct” model (Phi-3 family). The notebook loads the Hugging Face dataset, maps the instruction/input/response fields into the training format, and includes an EOS token for proper sequence termination. Training runs for a set number of epochs (60 is shown) and uses a small GPU setup (the walkthrough mentions a Tesla T4). Training loss declines from roughly 1.0 toward the mid-0.7 range, suggesting the model is learning patterns from the 13 examples.

Evaluation shows mixed results. A base test on a new easy LeetCode problem yields partial correctness, and the fine-tuned model does not consistently improve accuracy on the same task. Still, the fine-tuned model tends to follow the desired output structure—producing a step-by-step solution section, then a code solution, then an explanation—even when the code itself fails some test cases. The takeaway is less about achieving perfect LeetCode performance from a tiny dataset and more about demonstrating a practical, end-to-end method: scrape and verify problems, generate structured reasoning+code with a stronger model, validate with LeetCode, convert to JSON, upload to Hugging Face, then fine-tune with Unsloth.

The creator also notes that better results might require more data, different hyperparameters, or training a stronger base model (e.g., Llama 3 instead of Phi-3), but the core contribution remains the repeatable dataset-generation pipeline and the structured prompting that makes the fine-tuned outputs look like the target format.