The Open-source Competitors to o3-mini and o1

In a major growth for the AI neighborhood, 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 various to proprietary fashions. Furthermore, this new mannequin ensures full transparency and developer accessibility. On this article, we are going to discover the options, coaching, and benchmark scores of DeepCoder-14B and evaluate 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 alternate 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 assets.

The mannequin makes use of progressive coaching strategies corresponding to Iterative Context Lengthening and Overlong Filtering, permitting it to cause throughout 64K context home windows regardless of being educated solely on 32K contexts. Past its spectacular coding capabilities, DeepCoder-14B additionally demonstrates robust mathematical reasoning abilities in normal benchmark assessments.

Key Options of DeepCoder-14B

DeepCoder-14B advances open-source AI coding fashions with capabilities rivaling proprietary alternate 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: Skilled on 24K verified coding issues. Every downside has strict qc with 5+ take a look at instances.
• Totally Open-Supply: Gives full transparency with all code and coaching knowledge. Out there on GitHub and Hugging Face.
• Useful resource-Environment friendly: Helps varied quantization strategies for effectivity. Appropriate with TensorRT and vLLM inference methods.

DeepCoder-14B Benchmark Efficiency

Under we current a complete comparability of DeepCoder-14B in opposition to 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 exhibits exceptional efficiency throughout a number of benchmarks. It scores 60.6% on LiveCodeBench, almost matching proprietary alternate options. The mannequin achieves a 1936 Codeforces score. Its HumanEval+ outcomes are spectacular. These achievements place it amongst top-tier fashions regardless of restricted assets.

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 knowledge curation works. Specialised fine-tuning strategies are efficient. Open-source AI coding fashions can obtain state-of-the-art outcomes with average dimension.

Behind DeepCoder’s Success: Sandbox Setting and Coaching Recipe

DeepCoder’s exceptional efficiency stems from its progressive method 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 method tackles one of the crucial difficult elements of coaching code era instruments: reliably evaluating hundreds of code samples in opposition to a number of take a look at instances. Right here’s how DeepCoder’s structure and coaching helps deal with this subject.

Le me clarify this intimately.

1. Twin Sandbox Strategy

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

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

2. Principled Reward Design

Fairly than utilizing partial rewards that would result in “reward hacking,” DeepCoder implements a sparse Final result Reward Mannequin with binary outcomes:

• Success (1): Code should go all sampled take a look at instances
• 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 assessments, 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 workforce made 4 essential modifications to allow secure coaching at scale:

1. Entropy Loss Elimination: By eradicating the entropy loss time period that incessantly triggered coaching collapse, GRPO+ maintains constant exploration all through the coaching course of.
2. KL Loss Elimination: 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 system 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 perform, 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 giant fashions is already a heavy carry, however coaching them to cause throughout lengthy contexts is a fair larger 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 method:

1. Iterative Context Lengthening

As a substitute 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 learn to “assume 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 way impressed by DAPO. This filters out coaching samples that exceed optimum size and helps keep readability in what the mannequin learns.

Collectively, these methods be certain 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 multitude! Whether or not scraped from GitHub, on-line judges, or boards, they’re usually incomplete, buggy, or inconsistent. That turns into an issue for reinforcement studying (RL), which depends on verifiable, constant reward alerts.

To resolve this, the AgenticAI workforce constructed a customized knowledge curation pipeline that focuses on:

• Together with solely official options that go all take a look at instances
• Making certain at the very least 5 high-quality unit assessments per downside
• Deduplicating coaching and take a look at units to keep away from leakage or analysis inflation

The code beneath exhibits the core validation logic used of their knowledge processing pipeline. This perform checks every downside in opposition to high quality requirements earlier than permitting it into the dataset:

# Simplified knowledge processing workflow utilizing customized knowledge 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 suited to RL fine-tuning. This cautious filtering ensures that rewards throughout coaching really replicate correctness, not probability or overfitting.

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

Evaluating code is totally different from evaluating textual content. You may’t simply evaluate token similarity – it’s good to run the code and take a look at its output, ideally hundreds of occasions throughout edge instances. 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 assessments 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 assessments, actual outcomes.

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

Getting Fingers-on with DeepCoder

Whereas DeepCoder’s efficiency metrics are spectacular, what makes this undertaking really priceless to the AI neighborhood is its accessibility and reproducibility. This part walks by means of the sensible elements of working with this progressive mannequin, from preliminary setup to superior coaching configurations.

Step 1: Setting Up Your Setting

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

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 bundle:

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: Getting ready Coaching Information

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

To start working with this knowledge:

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

These preprocessing steps implement the rigorous knowledge qc talked about earlier, making certain that every 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 assets, making it accessible to each particular person researchers and bigger groups with vital 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/prepare/file.sh --model $MODEL_PATH

This single-node configuration offers 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 top 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 top 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/prepare/file.sh --model [CHECKPOINT_PATH]

This scalable method was instrumental in attaining DeepCoder’s breakthrough efficiency, permitting the workforce to successfully prepare 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 method mirrors the LiveCodeBench methodology, making certain that reported metrics precisely replicate real-world efficiency on difficult coding duties.

DeepCoder-14B Fingers-on Efficiency

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

Process: Explaining a programming idea

Let’s use DeepCoder-14B to clarify how a hash desk works and see if it might 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’])

Evaluation:

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

• Personalised Reasoning: The response felt virtually like a newbie strolling by means of the idea out loud, which provides a relatable, academic taste to the reason.
• Detailed Principle: It coated key concepts like hashing, collisions, chaining, open addressing, and their real-world implementation in Python through dictionaries.
• Structured Strategy: 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 perform, and dealing with collisions.
• Lacking Code Block: Though it promised to exhibit 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 Notice: Whereas the mannequin output was conceptually robust, the latency was very excessive (~11 minutes whole time), indicating that DeepCoder-14B could also be finest suited to non-realtime functions like content material era, tutoring, or documentation.

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

On this part, we’ll evaluate how DeepCoder-14B performs in opposition to OpenAI’s o1 and 03-mini on two frequent 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 influence code high quality, clarification depth, and reasoning means. From producing a easy perform to figuring out logic errors in recursive code, this comparability will give us a clearer image of when larger fashions actually shine, and when smaller ones maintain their very own.

Process 1: Code Technology Instruments Comparability – DeepCoder vs o3-mini (Phi-2)

Let’s use DeepCoder-14B to generate a Python perform that finds all prime numbers between 1 and 100, and evaluate 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 perform to search out prime numbers between 1 and 100."
output = pipe(immediate, max_new_tokens=150)[0]["generated_text"]
print("Phi-2 Output:n", output)

Evaluation:

DeepCoder-14B offers a deeply considerate, step-by-step breakdown of the logic behind discovering prime numbers, mimicking how a newbie would possibly cause by means 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, appropriate Python perform with none clarification—quick, environment friendly, and able to run. DeepCoder is best for academic depth, whereas Phi-2 excels at sensible coding velocity and readability.

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

Now let’s problem DeepCoder-14B with a basic debugging activity. We’ll feed it a buggy recursive factorial perform and ask it to repair the code and clarify what went fallacious. We’ll then give the identical activity to OpenAI’s o1 mannequin (simulated by LLaMA-27B) and evaluate 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)

Evaluation:

On this activity, each DeepCoder-14B and o1 (LLaMA-2 7B) appropriately recognized the bug within the factorial perform—recognizing that the bottom case ought to return 1 as an alternative of 0. DeepCoder-14B demonstrated robust reasoning by strolling by means of the logic and highlighting how the inaccurate base case results in fallacious 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, usually together with each the mounted code and a short clarification. Whereas it lacked DeepCoder’s depth of reasoning, o1’s reliability and readability made it extra appropriate for sensible use, particularly in deployment or academic contexts.

Future Developments of DeepCoder-14B

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

• Prolong the context window to 128K by means 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 normal for open-source AI coding fashions growth.

DeepCoder-14B: Entry and Utilization

All the things about DeepCoder is constructed round transparency and neighborhood:

This makes it an amazing useful resource for:

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

Conclusion

In an period dominated by closed partitions and black-box fashions, DeepCoder-14B is a breath of contemporary air. It exhibits 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 little thing about DeepCoder feels considerate, intentional, and community-first.

Builders seeking 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. In the event you’re constructing the way forward for AI-assisted growth, DeepCoder-14B isn’t simply price making an attempt – it would turn out to be your new baseline.

Incessantly Requested Questions