The Open-source Competitors to o3-mini and o1

In a major growth for the AI group, Agentica and Collectively AI have launched an open-source AI coding mannequin named DeepCoder-14B. Providing code era capabilities on par with closed-source rivals like OpenAI’s o3-mini and o1, DeepCoder-14B positions itself as a formidable open-source different to proprietary fashions. Furthermore, this new mannequin ensures full transparency and developer accessibility. On this article, we’ll discover the options, coaching, and benchmark scores of DeepCoder-14B and examine its real-world efficiency with that of o3-mini and o1.

What’s DeepCoder-14B?

DeepCoder-14B is an open-source AI code era mannequin that includes 14 billion parameters. Not like proprietary options, it affords full transparency whereas matching the capabilities and efficiency of OpenAI’s o3-mini and o1. DeepCoder-14B thus demonstrates that open-source AI coding fashions can compete with {industry} leaders with out requiring large computational sources.

The mannequin makes use of modern coaching methods equivalent to Iterative Context Lengthening and Overlong Filtering, permitting it to purpose throughout 64K context home windows regardless of being educated solely on 32K contexts. Past its spectacular coding capabilities, DeepCoder-14B additionally demonstrates sturdy mathematical reasoning expertise in commonplace benchmark checks.

Key Options of DeepCoder-14B

DeepCoder-14B advances open-source AI coding fashions with capabilities rivaling proprietary options.

• Superior Coaching Strategies: Makes use of Iterative Context Lengthening to deal with 64K context. Implements DeepCoder-14B reinforcement studying with Overlong Filtering.
• Excessive-High quality Dataset: Educated on 24K verified coding issues. Every downside has strict quality control with 5+ take a look at circumstances.
• Absolutely Open-Supply: Supplies full transparency with all code and coaching information. Accessible on GitHub and Hugging Face.
• Useful resource-Environment friendly: Helps varied quantization strategies for effectivity. Suitable with TensorRT and vLLM inference programs.

DeepCoder-14B Benchmark Efficiency

Under we current a complete comparability of DeepCoder-14B towards main open-source and proprietary code era instruments. These benchmarks consider efficiency throughout a number of dimensions of coding functionality and cross-domain problem-solving.

DeepCoder-14B reveals exceptional efficiency throughout a number of benchmarks. It scores 60.6% on LiveCodeBench, almost matching proprietary options. The mannequin achieves a 1936 Codeforces score. Its HumanEval+ outcomes are spectacular. These achievements place it amongst top-tier fashions regardless of restricted sources.

The mannequin excels past coding with 73.8% accuracy on AIME math issues. This demonstrates distinctive switch studying capabilities. Our benchmarks validate our coaching methodology. They show cautious information curation works. Specialised fine-tuning methods are efficient. Open-source AI coding fashions can obtain state-of-the-art outcomes with reasonable dimension.

Behind DeepCoder’s Success: Sandbox Surroundings and Coaching Recipe

DeepCoder’s exceptional efficiency stems from its modern strategy to code analysis throughout coaching.

Modern Code Execution Infrastructure

On the coronary heart of DeepCoder’s spectacular efficiency lies a complicated code execution infrastructure that permits correct reward calculation throughout reinforcement studying. This technique tackles one of the vital difficult facets of coaching code era instruments: reliably evaluating 1000’s of code samples towards a number of take a look at circumstances. Right here’s how DeepCoder’s structure and coaching helps handle this situation.

Le me clarify this intimately.

1. Twin Sandbox Method

DeepCoder employs two complementary sandbox environments to make sure dependable code execution:

1. Collectively Code Interpreter: This production-ready surroundings gives distinctive velocity and safety at a remarkably economical worth level of simply 3¢ per downside. The crew scaled this resolution to deal with over 100 concurrent sandboxes, processing greater than 1,000 executions per minute. This sandbox captures commonplace enter/output streams whereas sustaining strict isolation from host programs.
2. Native Code Sandbox: For optimum reproducibility, the crew developed a guard-railed Python subprocess implementation that completely mirrors LiveCodeBench’s analysis methodology. This ensures that each one reported outcomes immediately correspond to the industry-standard benchmarks.

2. Principled Reward Design

Relatively than utilizing partial rewards that might result in “reward hacking,” DeepCoder implements a sparse End result Reward Mannequin with binary outcomes:

• Success (1): Code should cross all sampled take a look at circumstances
• Failure (0): Code fails any take a look at or violates formatting necessities

For issues with intensive take a look at suites, the system strategically samples the 15 most difficult checks, recognized by enter complexity.

GRPO+: Enhanced Coaching Algorithm

DeepCoder introduces the GRPO+ (Generalized Reward-Weighted Coverage Optimization Plus) algorithm into its coaching. GRPO+ is a major evolution of the GRPO algorithm that comes with key insights from DAPO (Diffusion Actor-Coverage Optimization) analysis.

Key Algorithmic Improvements in GRPO+

The crew made 4 essential modifications to allow secure coaching at scale:

1. Entropy Loss Elimination: By eradicating the entropy loss time period that often triggered coaching collapse, GRPO+ maintains constant exploration all through the coaching course of.
2. KL Loss Removing: Releasing the mannequin from being constrained to the unique SFT mannequin’s belief area improves each efficiency and coaching velocity by eliminating reference coverage calculations.
3. Overlong Filtering: This method prevents penalizing truncated sequences, preserving the mannequin’s long-context reasoning capabilities. Remarkably, this allowed DeepCoder to generalize to 64K contexts regardless of being educated solely on 32K sequences.
4. Clip Excessive: By adjusting the higher certain within the surrogate loss operate, GRPO+ encourages extra exploration whereas sustaining secure entropy ranges all through coaching.

These algorithmic enhancements work collectively to create DeepCoder’s distinctive studying sample: steadily growing response lengths, secure reward curves, and constant token-level entropy—all contributing to its distinctive coding capabilities.

Smarter Coaching: Scaling Context and Reasoning Collectively

Coaching massive fashions is already a heavy raise, however coaching them to purpose throughout lengthy contexts is a fair greater problem. Most fashions both compromise on the depth of reasoning or hit a wall when the context dimension will increase.

DeepCoder addresses this head-on with a two-pronged coaching strategy:

1. Iterative Context Lengthening

As an alternative of leaping to lengthy contexts instantly, the mannequin is educated in levels:

• Begins at 16K tokens
• Scales as much as 32K
• Evaluated at 64K — despite the fact that it was by no means educated on that size!

This gradual scaling permits the mannequin to discover ways to “suppose in longer paperwork” as an alternative of merely memorizing token spans. The outcomes communicate for themselves:

• 16K context: 54% on LiveCodeBench
• 32K context: 58%
• 64K context: 60.6% (regardless of zero coaching at that size)

2. Overlong Filtering (Impressed by DAPO)

To keep away from feeding the mannequin noisy, excessively lengthy samples that dilute studying, DeepCoder adopts overlong filtering, a method impressed by DAPO. This filters out coaching samples that exceed optimum size and helps preserve readability in what the mannequin learns.

Collectively, these methods make sure that the mannequin doesn’t simply develop — it grows smarter.

Information Curation: From Chaos to Clear, Verified Coding Issues

Let’s face it – coding datasets on the web is a large number! Whether or not scraped from GitHub, on-line judges, or boards, they’re typically incomplete, buggy, or inconsistent. That turns into an issue for reinforcement studying (RL), which depends on verifiable, constant reward alerts.

To unravel this, the AgenticAI crew constructed a customized information curation pipeline that focuses on:

• Together with solely official options that cross all take a look at circumstances
• Guaranteeing no less than 5 high-quality unit checks per downside
• Deduplicating coaching and take a look at units to keep away from leakage or analysis inflation

The code beneath reveals the core validation logic used of their information processing pipeline. This operate checks every downside towards high quality requirements earlier than permitting it into the dataset:

# Simplified information processing workflow utilizing customized information curation pipeline
def validate_problem(downside):
    if downside.test_cases < 5: 
        reject()
    if not passes_all_tests(downside.resolution):
        reject()
    if exists_in_test_split(downside):
        reject()
return downside

The result’s a clear, verifiable dataset of 24,000 coding issues – completely fitted to RL fine-tuning. This cautious filtering ensures that rewards throughout coaching really mirror correctness, not likelihood or overfitting.

DeepCoder-14B Reinforcement Studying at Scale: The rLLM Framework

Evaluating code is completely different from evaluating textual content. You’ll be able to’t simply examine token similarity – that you must run the code and take a look at its output, ideally 1000’s of occasions throughout edge circumstances. That’s the place DeepCoder’s open-source RL engine, rLLM is available in.

Right here’s what makes rLLM stand out:

• Constructed on the verl framework (reduces end2end coaching occasions by as much as 2x), an environment friendly coaching engine designed for code
• Able to working 1,000+ unit checks per minute
• Makes use of 100+ parallel sandboxes to judge submissions concurrently
• Helps each:
  • Collectively Code Interpreter (low-cost, quick, $0.03/downside)
  • Native sandbox mirroring LiveCodeBench for reproducibility

This infrastructure isn’t nearly velocity — it makes large-scale, verifiable RL coaching sensible. No hand-waving, no approximations; actual code, actual checks, actual outcomes.

Wish to attempt it? Head to the repo: github.com/agentica-project/rllm

Getting Palms-on with DeepCoder

Whereas DeepCoder’s efficiency metrics are spectacular, what makes this mission actually priceless to the AI group is its accessibility and reproducibility. This part walks by way of the sensible facets of working with this modern mannequin, from preliminary setup to superior coaching configurations.

Step 1: Setting Up Your Surroundings

DeepCoder’s growth crew has optimized the codebase for Python 3.10, making certain stability whereas leveraging trendy language options. The set up course of begins with making a devoted Conda surroundings:

conda create -n rllm python=3.10 -y
conda activate rllm

After navigating to the rllm listing, you’ll want to put in each the verl reinforcement studying framework and the principle package deal:

cd rllm
pip set up -e ./verl
pip set up -e .

This set up sample displays modular structure, with verl serving because the specialised DeepCoder-14B reinforcement studying engine that powers its spectacular code era capabilities.

Step 2: Making ready Coaching Information

One in all DeepCoder’s strengths lies in its meticulously curated dataset. The repository gives each the uncooked coaching information and preprocessing scripts to remodel it into optimized codecs for coaching.

To start working with this information:

# First, obtain the curated datasets from GDrive
python scripts/information/download_datasets.py
# Then generate optimized parquet recordsdata for coaching
python scripts/information/deepcoder_dataset.py  # For DeepCoder
# or
python scripts/information/deepscaler_dataset.py  # For DeepScaleR

These preprocessing steps implement the rigorous information quality control talked about earlier, making certain that each one code examples meet the strict necessities for DeepCoder-14B reinforcement studying.

Step 3: Coaching Choices for Totally different Scales

DeepCoder’s versatile coaching structure accommodates varied computational sources, making it accessible to each particular person researchers and bigger groups with important infrastructure.

For Particular person Researchers

These with entry to a single high-performance machine can start coaching with:

export MODEL_PATH="deepseek-ai/DeepSeek-R1-Distill-Qwen-1.5B"
./scripts/deepcoder/practice/file.sh --model $MODEL_PATH

This single-node configuration gives a wonderful entry level for experimenting with the framework or fine-tuning for particular domains.

For Analysis Groups

Bigger experiments profit from DeepCoder’s distributed coaching capabilities. The setup makes use of Ray for coordinating coaching throughout a number of machines:

1. The pinnacle node should initialize the Ray cluster:
2. Employee nodes then hook up with this coordinator:
3. With the cluster prepared, coaching will be launched:

1. The pinnacle node should initialize the Ray cluster:
   export VLLM_ATTENTION_BACKEND=XFORMERS
ray begin --head
2. Employee nodes then hook up with this coordinator:
   export VLLM_ATTENTION_BACKEND=XFORMERS
ray begin --address=[HEAD_NODE_ADDRESS]
3. With the cluster prepared, coaching will be launched:
   ./scripts/deepcoder/practice/file.sh --model [CHECKPOINT_PATH]

This scalable strategy was instrumental in reaching DeepCoder’s breakthrough efficiency, permitting the crew to successfully practice on longer context lengths and bigger datasets.

Step 4: Rigorous Analysis Framework

DeepCoder’s efficiency claims are backed by a complete analysis framework that routinely runs a number of situations of vLLM to check the mannequin’s capabilities:

./scripts/eval/eval_model.sh --model [CHECKPOINT_PATH] 
                           --datasets [DATASET1] [DATASET2] 
                           --output-dir [OUTPUT_DIR] 
                           --n [N_PASSES] 
                           --tp [TENSOR_PARALLEL_SIZE] 
                           --max-length [MAX_CONTEXT_LENGTH]

This analysis strategy mirrors the LiveCodeBench methodology, making certain that reported metrics precisely mirror real-world efficiency on difficult coding duties.

DeepCoder-14B Palms-on Efficiency

On this part, we discover DeepCoder-14B’s functionality to clarify elementary programming ideas in a transparent and beginner-friendly manner.

Job: Explaining a programming idea

Let’s use DeepCoder-14B to clarify how a hash desk works and see if it will possibly generate a Python instance for it.

Code:

response = llm.create_chat_completion(
    messages = [
        {
            "role": "user",
            "content": "Explain how a hash table works with an example in Python."
        }
    ]
)
print(response['choices'][0]['message']['content'])

print(response[‘choices’][0][‘message’][‘content’])

Overview:

DeepCoder-14B offered an impressively considerate and step-by-step conceptual breakdown of how hash tables operate. Right here’s what stood out:

• Personalised Reasoning: The response felt virtually like a newbie strolling by way of the idea out loud, which provides a relatable, instructional taste to the reason.
• Detailed Idea: It coated key concepts like hashing, collisions, chaining, open addressing, and their real-world implementation in Python by way of dictionaries.
• Structured Method: The mannequin didn’t soar into code instantly however as an alternative laid out the logic and design—outlining steps like creating the array, defining a hash operate, and dealing with collisions.
• Lacking Code Block: Though it promised to show a easy hash desk in Python, the code snippet wasn’t included on this output. For a completely full reply, you would possibly immediate it to “proceed with the Python code instance.”

Inference Efficiency Be aware: Whereas the mannequin output was conceptually sturdy, the latency was very excessive (~11 minutes whole time), indicating that DeepCoder-14B could also be finest fitted to non-realtime functions like content material era, tutoring, or documentation.

DeepCoder-14B vs o3-mini & o1: Efficiency Comparability

On this part, we’ll examine how DeepCoder-14B performs towards OpenAI’s o1 and 03-mini on two widespread programming duties – code era and bug fixing. We’ll give the identical 2 duties to DeepCoder-14B, o3-mini (simulated with Phi-2), and o1 (simulated with LLaMA-2 7B) and see how the fashions’ dimension and design affect code high quality, rationalization depth, and reasoning skill. From producing a easy operate to figuring out logic errors in recursive code, this comparability will give us a clearer image of when greater fashions actually shine, and when smaller ones maintain their very own.

Job 1: Code Era Instruments Comparability – DeepCoder vs o3-mini (Phi-2)

Let’s use DeepCoder-14B to generate a Python operate that finds all prime numbers between 1 and 100, and examine its response with that of o3-mini.

DeepCoder-14B Code:

response = llm.create_chat_completion(
    messages = [
        {
            "role": "user",
            "content": "Write a Python function to find prime numbers between 1 and 100."
        }
    ]
)
print("DeepCoder Output:n", response['choices'][0]['message']['content'])

Phi-2 (Simulating o3-mini) Code:

from transformers import AutoTokenizer, AutoModelForCausalLM, pipeline
tokenizer = AutoTokenizer.from_pretrained("microsoft/phi-2")
mannequin = AutoModelForCausalLM.from_pretrained("microsoft/phi-2", device_map="auto")
pipe = pipeline("text-generation", mannequin=mannequin, tokenizer=tokenizer
immediate = "Write a Python operate to seek out prime numbers between 1 and 100."
output = pipe(immediate, max_new_tokens=150)[0]["generated_text"]
print("Phi-2 Output:n", output)

Overview:

DeepCoder-14B gives a deeply considerate, step-by-step breakdown of the logic behind discovering prime numbers, mimicking how a newbie would possibly purpose by way of the issue. Whereas insightful, it doesn’t return precise code, which limits its usefulness for direct execution. In distinction, Phi-2 (o3-mini) delivers a clear, right Python operate with none rationalization—quick, environment friendly, and able to run. DeepCoder is healthier for instructional depth, whereas Phi-2 excels at sensible coding velocity and readability.

Job 2: Bug Fixing and Reasoning – DeepCoder vs o1 (LLaMA-2 7B)

Now let’s problem DeepCoder-14B with a basic debugging job. We’ll feed it a buggy recursive factorial operate and ask it to repair the code and clarify what went mistaken. We’ll then give the identical job to OpenAI’s o1 mannequin (simulated by LLaMA-27B) and examine their responses.

Buggy Code:

buggy_code = """
def factorial(n):
    if n == 0:
        return 0
    else:
        return n * factorial(n-1)
"""

“””

DeepCoder-14B:

response = llm.create_chat_completion(
    messages = [
        {
            "role": "user",
            "content": f"This code has a bug. Fix it and explain the correction:n{buggy_code}"
        }
    ]
)
print("DeepCoder Output:n", response['choices'][0]['message']['content'])

LLaMA-2 7B (simulating o1):

from transformers import AutoTokenizer, AutoModelForCausalLM, pipeline
tokenizer = AutoTokenizer.from_pretrained("meta-llama/Llama-2-7b-chat-hf")
mannequin = AutoModelForCausalLM.from_pretrained("meta-llama/Llama-2-7b-chat-hf", device_map="auto")
pipe = pipeline("text-generation", mannequin=mannequin, tokenizer=tokenizer)
immediate = "This code has a bug. Repair it and clarify the correction:n" + buggy_code
output = pipe(immediate, max_new_tokens=200)[0]["generated_text"]
print("LLaMA-2 Output:n", output)

Overview:

On this job, each DeepCoder-14B and o1 (LLaMA-2 7B) appropriately recognized the bug within the factorial operate—recognizing that the bottom case ought to return 1 as an alternative of 0. DeepCoder-14B demonstrated sturdy reasoning by strolling by way of the logic and highlighting how the wrong base case results in mistaken outcomes, notably for n=1.

Nevertheless, its output suffered from a essential flaw: a repetitive loop of “Wait, no,” which detracted from readability and made the response really feel unstable. In distinction, o1 offered a concise, clear, and proper response, sometimes together with each the mounted code and a short rationalization. Whereas it lacked DeepCoder’s depth of reasoning, o1’s reliability and readability made it extra appropriate for sensible use, particularly in deployment or instructional contexts.

Future Developments of DeepCoder-14B

Whereas present outcomes deal with coding, the crew plans to:

• Lengthen the context window to 128K by way of dynamic NTK scaling.
• Develop multimodal reasoning capabilities.
• Create specialised variants for safety auditing and legacy code modernization.

This launch marks a major step towards democratizing superior AI coding instruments, offering researchers and builders with:

• An entire coaching recipe matching proprietary mannequin efficiency.
• Infrastructure for verifiable RL at scale.
• Baseline for future open-source developments in program synthesis.

The mannequin’s MIT license ensures unrestricted business and analysis use, fostering innovation throughout the AI ecosystem. With its mixture of aggressive efficiency and full transparency, DeepCoder-14B establishes a brand new commonplace for open-source AI coding fashions growth.

DeepCoder-14B: Entry and Utilization

The whole lot about DeepCoder is constructed round transparency and group:

This makes it a fantastic useful resource for:

• Researchers exploring RL fine-tuning
• Hackers and builders constructing customized coding brokers
• Educators demonstrating how real-world AI coding programs are constructed and examined

Conclusion

In an period dominated by closed partitions and black-box fashions, DeepCoder-14B is a breath of recent air. It reveals that open-source AI coding fashions can scale, compete, and innovate – with out hiding behind APIs or paywalls. From context scaling to math generalization, from verified datasets to high-speed sandboxes, every part about DeepCoder feels considerate, intentional, and community-first.

Builders trying to improve their coding workflow can begin utilizing DeepCoder instantly. The mannequin’s spectacular efficiency on competition-level coding duties makes it appropriate for a variety of functions, from automated code completion to algorithmic problem-solving. When you’re constructing the way forward for AI-assisted growth, DeepCoder-14B isn’t simply price making an attempt – it’d grow to be your new baseline.

Often Requested Questions

Gen AI Intern at Analytics Vidhya 
Division of Laptop Science, Vellore Institute of Expertise, Vellore, India 

I’m at the moment working as a Gen AI Intern at Analytics Vidhya, the place I contribute to modern AI-driven options that empower companies to leverage information successfully. As a final-year Laptop Science pupil at Vellore Institute of Expertise, I carry a strong basis in software program growth, information analytics, and machine studying to my position. 

Be happy to attach with me at [email protected]