Dalam perkembangan penting bagi komuniti AI, Agentica dan bersama-sama AI telah mengeluarkan model pengekodan AI sumber terbuka bernama DeepCoder-14b. Menawarkan keupayaan penjanaan kod setanding dengan pesaing sumber tertutup seperti Openai's O3-Mini dan O1, DeepCoder-14B kedudukannya sebagai alternatif sumber terbuka yang hebat untuk model proprietari. Selain itu, model baru ini memastikan ketelusan penuh dan kebolehcapaian pemaju. Dalam artikel ini, kami akan meneroka ciri-ciri, latihan, dan skor penanda aras DeepCoder-14B dan membandingkan prestasi dunia sebenar dengan O3-Mini dan O1.

Jadual Kandungan

• Apa itu DeepCoder-14b?
• Prestasi penanda aras DeepCoder-14B
• Di sebalik Kejayaan DeepCoder: Persekitaran Kotak Sandbox dan Resipi Latihan
• Curation Data: Dari kekacauan hingga membersihkan, masalah pengekodan yang disahkan
• DeepCoder-14B Pembelajaran Pengukuhan pada Skala: Rangka Kerja RLLM
• Mendapatkan tangan dengan DeepCoder
• Prestasi Hands-On DeepCoder-14B
• DeepCoder-14b vs O3-Mini & O1: Perbandingan Prestasi
• Perkembangan masa depan DeepCoder-14b
• DeepCoder-14B: Akses dan Penggunaan
• Kesimpulan
• Soalan yang sering ditanya

Apa itu DeepCoder-14b?

DeepCoder-14b adalah model penjanaan kod AI sumber terbuka yang memaparkan 14 bilion parameter. Tidak seperti alternatif proprietari, ia menawarkan ketelusan lengkap sambil memadankan keupayaan dan prestasi Openai's O3-Mini dan O1. Oleh itu, DeepCoder-14b menunjukkan bahawa model pengekodan AI sumber terbuka dapat bersaing dengan pemimpin industri tanpa memerlukan sumber pengiraan besar-besaran.

Model ini menggunakan teknik latihan inovatif seperti pemanjangan konteks berulang dan penapisan yang berlebihan, yang membolehkannya menjadi alasan di seluruh tingkap konteks 64K walaupun dilatih hanya pada konteks 32K. Di luar keupayaan pengekodannya yang mengagumkan, DeepCoder-14b juga menunjukkan kemahiran penalaran matematik yang kuat dalam ujian penanda aras standard.

Ciri-ciri utama DeepCoder-14b

DeepCoder-14b memajukan model pengekodan AI sumber terbuka dengan keupayaan bersaing dengan alternatif proprietari.

• Teknik Latihan Lanjutan : Menggunakan Pemanjangan Konteks Iteratif untuk mengendalikan konteks 64K. Melaksanakan pembelajaran tetulang DeepCoder-14B dengan penapisan yang berlebihan.
• Dataset berkualiti tinggi : Dilatih pada masalah pengekodan yang disahkan 24K. Setiap masalah mempunyai kawalan kualiti yang ketat dengan 5 kes ujian.
• Sumber Terbuka Sepenuhnya : Menyediakan ketelusan lengkap dengan semua kod dan data latihan. Tersedia di Github dan memeluk muka.
• Sumber yang cekap : Menyokong pelbagai kaedah kuantisasi untuk kecekapan. Serasi dengan sistem inferensi TensorRT dan VLLM.

Prestasi penanda aras DeepCoder-14B

Di bawah ini kami membentangkan perbandingan komprehensif DeepCoder-14B terhadap alat penjanaan kod terbuka dan proprietari yang terkemuka. Penanda aras ini menilai prestasi merentasi pelbagai dimensi keupayaan pengekodan dan penyelesaian masalah silang domain.

DeepCoder-14B menunjukkan prestasi yang luar biasa merentasi pelbagai tanda aras. Ia mencatatkan 60.6% pada LiveCodeBench, hampir sepadan alternatif proprietari. Model ini mencapai penarafan codeforces 1936. Keputusan manusia yang mengagumkan. Pencapaian ini meletakkannya di kalangan model peringkat teratas walaupun sumber terhad.

Model ini melampaui pengekodan dengan ketepatan 73.8% pada masalah matematik aime. Ini menunjukkan keupayaan pembelajaran pemindahan yang luar biasa. Penanda aras kami mengesahkan metodologi latihan kami. Mereka membuktikan kerja kurasi yang berhati -hati. Teknik penalaan halus khusus adalah berkesan. Model pengekodan AI sumber terbuka dapat mencapai hasil yang canggih dengan saiz sederhana.

Di sebalik Kejayaan DeepCoder: Persekitaran Kotak Sandbox dan Resipi Latihan

Prestasi yang luar biasa DeepCoder berpunca daripada pendekatan inovatifnya untuk penilaian kod semasa latihan.

Infrastruktur Pelaksanaan Kod Inovatif

Di tengah -tengah prestasi yang mengagumkan DeepCoder terletak infrastruktur pelaksanaan kod yang canggih yang membolehkan pengiraan ganjaran yang tepat semasa pembelajaran tetulang. Sistem ini menangani salah satu aspek yang paling mencabar dari alat penjanaan kod latihan: dengan pasti menilai beribu -ribu sampel kod terhadap pelbagai kes ujian. Begini bagaimana seni bina dan latihan DeepCoder membantu menangani isu ini.

Le saya terangkan ini secara terperinci.

1. Pendekatan Kotak Dual Sandbox

DeepCoder menggunakan dua persekitaran kotak pasir pelengkap untuk memastikan pelaksanaan kod yang boleh dipercayai:

1. Bersama-sama Kod Interpreter : Persekitaran siap pengeluaran ini memberikan kelajuan dan keselamatan yang luar biasa pada titik harga yang sangat ekonomik hanya 3 ￠ setiap masalah. Pasukan ini mengukur penyelesaian ini untuk mengendalikan lebih daripada 100 kotak pasir serentak, memproses lebih daripada 1,000 hukuman mati seminit. Kotak pasir ini menangkap aliran input/output standard sambil mengekalkan pengasingan yang ketat dari sistem tuan rumah.
2. Kotak pasir kod tempatan : Untuk reproducibility maksimum, pasukan itu membangunkan pelaksanaan subprocess Python yang dilancarkan yang sempurna yang mencerminkan metodologi penilaian LiveCodeBench. Ini memastikan bahawa semua keputusan yang dilaporkan secara langsung sesuai dengan tanda aras standard industri.

2. Reka bentuk ganjaran berprinsip

Daripada menggunakan ganjaran separa yang boleh membawa kepada "penggodaman ganjaran," DeepCoder melaksanakan model ganjaran hasil yang jarang dengan hasil binari:

• Kejayaan (1) : Kod mesti lulus semua kes ujian sampel
• Kegagalan (0) : Kod gagal sebarang ujian atau melanggar keperluan pemformatan

Untuk masalah dengan suite ujian yang luas, sistem secara strategik mencatatkan 15 ujian yang paling mencabar, yang dikenal pasti oleh kerumitan input.

GRPO: Algoritma Latihan yang Dipertingkatkan

DeepCoder memperkenalkan algoritma pengoptimuman dasar GRPO (Generalisasi Plus Plus) ke dalam latihannya. GRPO adalah evolusi penting dalam algoritma GRPO yang menggabungkan pandangan utama dari penyelidikan DAPO (Penyebaran Pelakon-Policy Optimization).

Inovasi algoritma utama dalam GRPO

Pasukan membuat empat pengubahsuaian kritikal untuk membolehkan latihan yang stabil pada skala:

1. Penghapusan kehilangan entropi : Dengan menghapuskan istilah kehilangan entropi yang sering menyebabkan keruntuhan latihan, GRPO mengekalkan penerokaan yang konsisten sepanjang proses latihan.
2. Pembuangan KL Rugi : Membebaskan model daripada dikekang ke rantau kepercayaan model SFT yang asal meningkatkan kedua -dua prestasi dan kelajuan latihan dengan menghapuskan pengiraan dasar rujukan.
3. Penapisan Berlebihan : Teknik ini menghalang menghukum urutan yang dipotong, memelihara keupayaan penalaran konteks panjang model. Hebatnya, ini membolehkan DeepCoder untuk umum kepada konteks 64K walaupun dilatih hanya pada urutan 32K.
4. Klip Tinggi : Dengan menyesuaikan terikat atas dalam fungsi kehilangan pengganti, GRPO menggalakkan lebih banyak penjelajahan sambil mengekalkan tahap entropi yang stabil sepanjang latihan.

Penambahbaikan algoritma ini berfungsi bersama untuk mewujudkan corak pembelajaran tersendiri DeepCoder: peningkatan panjang tindak balas, lengkung ganjaran yang stabil, dan entropi tahap token yang konsisten-semua menyumbang kepada keupayaan pengekodan yang luar biasa.

Latihan yang lebih bijak: Konteks skala dan penalaran bersama

Latihan model besar sudah menjadi angkat berat, tetapi melatih mereka untuk membuat alasan dalam konteks yang panjang adalah cabaran yang lebih besar. Kebanyakan model sama ada berkompromi dengan kedalaman penalaran atau memukul dinding apabila saiz konteks meningkat.

DeepCoder menangani masalah ini dengan pendekatan latihan dua arah:

1. Pemanjangan konteks berulang

Daripada melompat ke konteks yang panjang dengan segera, model dilatih secara berperingkat:

• Bermula pada token 16k
• Skala sehingga 32k
• Dinilai pada 64K - walaupun ia tidak pernah dilatih pada panjangnya!

Penskalaan secara beransur -ansur ini membolehkan model untuk belajar bagaimana untuk "berfikir dalam dokumen yang lebih lama" dan bukan hanya menghafal token. Hasilnya bercakap untuk diri mereka sendiri:

• Konteks 16K: 54% pada LiveCodeBench
• Konteks 32K: 58%
• Konteks 64K: 60.6% (walaupun latihan sifar pada panjangnya)

2. Penapisan Overlong (Diilhamkan oleh Dapo)

Untuk mengelakkan makan model yang bising, sampel yang berlebihan panjang yang mencairkan pembelajaran, DeepCoder mengamalkan penapisan yang berlebihan, teknik yang diilhamkan oleh Dapo. Ini menapis sampel latihan yang melebihi panjang optimum dan membantu mengekalkan kejelasan dalam model yang dipelajari.

Bersama -sama, strategi ini memastikan bahawa model itu tidak hanya berkembang - ia tumbuh lebih pintar.

Curation Data: Dari kekacauan hingga membersihkan, masalah pengekodan yang disahkan

Mari kita hadapi - data pengekodan di internet adalah kekacauan! Sama ada dikikis dari GitHub, hakim dalam talian, atau forum, mereka sering tidak lengkap, kereta, atau tidak konsisten. Itu menjadi masalah untuk pembelajaran tetulang (RL), yang bergantung kepada isyarat ganjaran yang dapat disahkan dan konsisten.

Untuk menyelesaikannya, pasukan AgentIcai membina saluran paip data adat yang memberi tumpuan kepada:

• Termasuk hanya penyelesaian rasmi yang lulus semua kes ujian
• Memastikan sekurang-kurangnya 5 ujian unit berkualiti tinggi setiap masalah
• Set latihan dan ujian deduplicating untuk mengelakkan kebocoran atau inflasi penilaian

Kod di bawah menunjukkan logik pengesahan teras yang digunakan dalam saluran paip pemprosesan data mereka. Fungsi ini memeriksa setiap masalah terhadap piawaian kualiti sebelum membenarkannya masuk ke dataset:

 # Aliran kerja pemprosesan data yang dipermudahkan menggunakan saluran paip pengendalian data tersuai
def validate_problem (masalah):
    jika masalah.test_cases <p> Hasilnya adalah dataset yang bersih dan dapat disahkan sebanyak 24,000 masalah pengekodan-sangat sesuai untuk penalaan RL. Penapisan yang teliti ini memastikan bahawa ganjaran semasa latihan sebenarnya mencerminkan ketepatan, bukan peluang atau overfitting.</p><h2> DeepCoder-14B Pembelajaran Pengukuhan pada Skala: Rangka Kerja RLLM</h2><p> Menilai kod adalah berbeza daripada menilai teks. Anda tidak boleh membandingkan persamaan token - anda perlu menjalankan kod dan menguji outputnya, beribu -ribu kali merentasi kes kelebihan. Di sinilah enjin RL sumber terbuka DeepCoder, RLLM masuk.</p><p> <strong>Inilah yang membuat RLLM menonjol:</strong></p>

• Dibina di atas kerangka VERL (R Educes End2end Times Latihan sehingga 2x) , enjin latihan yang cekap yang direka untuk kod
• Mampu menjalankan 1,000 ujian unit seminit
• Menggunakan 100 kotak pasir selari untuk menilai penyerahan secara serentak
• Menyokong kedua -duanya:
  • Bersama Penterjemah Kod (Murah, Cepat, $ 0.03/Masalah)
  • Kotak pasir tempatan mencerminkan liveCodeBench untuk reproducibility

Infrastruktur ini bukan hanya mengenai kelajuan-ia menjadikan latihan RL berskala besar, praktikal. Tiada melambai tangan, tiada perkiraan; Kod sebenar, ujian sebenar, hasil sebenar.

Mahu mencubanya? Kepala ke repo: github.com/agentica-project/rllm

Mendapatkan tangan dengan DeepCoder

Walaupun metrik prestasi DeepCoder mengagumkan, apa yang menjadikan projek ini benar -benar berharga kepada komuniti AI adalah kebolehcapaian dan kebolehulangannya. Bahagian ini berjalan melalui aspek praktikal bekerja dengan model inovatif ini, dari persediaan awal hingga konfigurasi latihan lanjutan.

Langkah 1: Menyediakan persekitaran anda

Pasukan pembangunan DeepCoder telah mengoptimumkan asas untuk Python 3.10, memastikan kestabilan sambil memanfaatkan ciri bahasa moden. Proses pemasangan bermula dengan mewujudkan persekitaran konda khusus:

 conda create -n rllm python = 3.10 -y
Conda mengaktifkan RLLM

Selepas menavigasi ke direktori RLLM, anda perlu memasang rangka kerja pembelajaran tetulang VERL dan pakej utama:

 cd rllm
pemasangan pip -e ./verl
PIP INSTALL -E.

Corak pemasangan ini mencerminkan seni bina modular, dengan VERL berkhidmat sebagai enjin pembelajaran tetulang DeepCoder-14B khusus yang menguasai keupayaan penjanaan kod yang mengagumkan.

Langkah 2: Menyediakan data latihan

Salah satu kekuatan DeepCoder terletak pada dataset yang teliti. Repositori menyediakan kedua -dua data latihan mentah dan skrip pra -proses untuk mengubahnya menjadi format yang dioptimumkan untuk latihan.

Untuk mula bekerja dengan data ini:

 # Pertama, muat turun dataset curated dari gdrive
Skrip Python/Data/Muat turun_Datasets.py
# Kemudian menjana fail parket yang dioptimumkan untuk latihan
skrip python/data/deepcoder_dataset.py # untuk deepCoder
# atau
skrip python/data/deepscaler_dataset.py # untuk deepScaler

Langkah-langkah pra-proses ini melaksanakan kawalan kualiti data yang ketat yang disebut tadi, memastikan semua contoh kod memenuhi keperluan yang ketat untuk pembelajaran tetulang DeepCoder-14B.

Langkah 3: Pilihan Latihan untuk Skala yang Berbeza

Senibina latihan fleksibel DeepCoder menampung pelbagai sumber pengiraan, menjadikannya mudah diakses oleh penyelidik individu dan pasukan yang lebih besar dengan infrastruktur yang signifikan.

Untuk penyelidik individu

Mereka yang mempunyai akses ke mesin berprestasi tinggi tunggal boleh memulakan latihan dengan:

 Eksport Model_Path = "DeepSeek-AI/DeepSeek-R1-Distill-Qwen-1.5b"<br><br> ./scripts/deepcoder/train/file.sh ---model $ model_path

Konfigurasi nod tunggal ini menyediakan titik masuk yang sangat baik untuk bereksperimen dengan kerangka atau penalaan halus untuk domain tertentu.

Untuk pasukan penyelidikan

Eksperimen yang lebih besar mendapat manfaat daripada keupayaan latihan diedarkan DeepCoder. Persediaan menggunakan sinar untuk menyelaraskan latihan merentasi pelbagai mesin:

1. Node kepala mesti memulakan cluster sinar:
2. Nod pekerja kemudian menyambung ke penyelaras ini:
3. Dengan kelompok siap, latihan dapat dilancarkan:

1. Node kepala mesti memulakan cluster sinar:
   Eksport vllm_attention_backend = xformers
   Ray Start -Head
2. Nod pekerja kemudian menyambung ke penyelaras ini:
   Eksport vllm_attention_backend = xformers
   Ray Start --Address = [HEAD_NODE_ADDRESS]
3. Dengan kelompok siap, latihan dapat dilancarkan:
   ./scripts/deepcoder/train/file.sh ---model [checkpoint_path]

Pendekatan berskala ini memainkan peranan penting dalam mencapai prestasi terobosan DeepCoder, yang membolehkan pasukan melatih dengan berkesan panjang konteks dan dataset yang lebih besar.

Langkah 4: Rangka kerja penilaian yang ketat

Tuntutan prestasi DeepCoder disokong oleh rangka kerja penilaian yang komprehensif yang secara automatik menjalankan pelbagai contoh VLLM untuk menguji keupayaan model:

 ./scripts/eval/eval_model.sh ---model [checkpoint_path] \
                           --datasets [dataset1] [dataset2] \
                           --Output-dir [output_dir] \
                           --n [n_pass] \
                           --tp [tensor_parallel_size] \
                           --max-length [max_context_length]

Pendekatan penilaian ini mencerminkan metodologi LiveCodeBench, memastikan metrik yang dilaporkan secara tepat mencerminkan prestasi dunia nyata pada tugas pengekodan yang mencabar.

Prestasi Hands-On DeepCoder-14B

Dalam bahagian ini, kami meneroka keupayaan DeepCoder-14B untuk menerangkan konsep pengaturcaraan asas dengan cara yang jelas dan mesra pemula.

Tugas: Menjelaskan konsep pengaturcaraan

Mari kita gunakan DeepCoder-14b untuk menerangkan bagaimana jadual hash berfungsi dan lihat jika ia dapat menghasilkan contoh python untuknya.

Kod:

 respons = llm.create_chat_completion (
    Mesej = [
        {
            "Peranan": "Pengguna",
            "Kandungan": "Jelaskan bagaimana jadual hash berfungsi dengan contoh dalam Python."
        }
    ]
)
cetak (respons ['pilihan'] [0] ['mesej'] ['kandungan'])

Kajian:

DeepCoder-14b menyediakan pecahan konseptual yang sangat bijak dan langkah demi langkah tentang bagaimana jadual hash berfungsi. Inilah yang menonjol:

• Penalaran yang diperibadikan: Tanggapan ini dirasakan hampir seperti pemula yang berjalan melalui konsep dengan kuat, yang menambah rasa pendidikan yang relatable kepada penjelasan.
• Teori terperinci: Ia meliputi idea-idea utama seperti hashing, perlanggaran, berantai, alamat terbuka, dan pelaksanaan dunia sebenar mereka di Python melalui kamus.
• Pendekatan berstruktur: Model ini tidak melompat ke dalam kod dengan segera tetapi sebaliknya meletakkan langkah -langkah logik dan reka bentuk seperti membuat array, menentukan fungsi hash, dan mengendalikan perlanggaran.
• Blok kod yang hilang: Walaupun ia berjanji untuk menunjukkan jadual hash mudah di Python, coretan kod tidak termasuk dalam output ini. Untuk jawapan yang lengkap, anda mungkin meminta "teruskan dengan contoh kod Python."

Nota prestasi kesimpulan: Walaupun output model secara konseptual kuat, latensi adalah sangat tinggi (~ 11 minit jumlah masa), menunjukkan bahawa DeepCoder-14b mungkin paling sesuai untuk aplikasi bukan realtime seperti penjanaan kandungan, tunjuk ajar, atau dokumentasi.

DeepCoder-14b vs O3-Mini & O1: Perbandingan Prestasi

Dalam bahagian ini, kami akan membandingkan bagaimana DeepCoder-14B melakukan terhadap OpenAI's O1 dan 03-Mini pada dua tugas pengaturcaraan biasa-penjanaan kod dan penetapan pepijat. Kami akan memberikan 2 tugas yang sama kepada DeepCoder-14B, O3-Mini (disimulasikan dengan PHI-2), dan O1 (disimulasikan dengan Llama-2 7b) dan melihat bagaimana saiz dan reka bentuk kod kualiti kod, kedalaman penjelasan, dan keupayaan penalaran. Dari menghasilkan fungsi mudah untuk mengenal pasti kesilapan logik dalam kod rekursif, perbandingan ini akan memberi kita gambaran yang lebih jelas apabila model yang lebih besar benar -benar bersinar, dan apabila yang lebih kecil memegang mereka sendiri.

Tugas 1: Perbandingan Alat Penjanaan Kod-DeepCoder vs O3-Mini (PHI-2)

Mari kita gunakan DeepCoder-14b untuk menghasilkan fungsi python yang mendapati semua nombor utama antara 1 dan 100, dan bandingkan responsnya dengan O3-Mini.

Kod DeepCoder-14B:

 respons = llm.create_chat_completion (
    Mesej = [
        {
            "Peranan": "Pengguna",
            "Kandungan": "Tulis fungsi python untuk mencari nombor utama antara 1 dan 100."
        }
    ]
)
Cetak ("Output DeepCoder: \ n", Response ['Pilihan'] [0] ['Mesej'] ['Kandungan'])

Kod PHI-2 (meniru O3-Mini):

 Dari Transformers mengimport autotokenizer, automelforcausallm, saluran paip
tokenizer = autotokenizer.from_pretrained ("microsoft/phi-2")
Model = automodelforcausallm.from_pretrained ("microsoft/phi-2", device_map = "auto")
paip = saluran paip ("generasi teks", model = model, tokenizer = tokenizer
prompt = "Tulis fungsi python untuk mencari nombor perdana antara 1 dan 100."
output = paip (prompt, max_new_tokens = 150) [0] ["Generated_text"]
Cetak ("output phi-2: \ n", output)

Kajian:

DeepCoder-14B menyediakan pecahan langkah demi langkah yang sangat bijak, langkah demi langkah di sebalik mencari nombor perdana, meniru bagaimana pemula mungkin membuat alasan melalui masalah ini. Walaupun berwawasan, ia tidak mengembalikan kod sebenar, yang mengehadkan kegunaannya untuk pelaksanaan langsung. Sebaliknya, PHI-2 (O3-Mini) menyampaikan fungsi python yang bersih dan betul tanpa penjelasan-cepat, cekap, dan bersedia untuk dijalankan. DeepCoder lebih baik untuk kedalaman pendidikan, sedangkan PHI-2 cemerlang pada kelajuan pengekodan praktikal dan kejelasan.

Tugas 2: Penetapan dan Penalaran Bug-DeepCoder vs O1 (Llama-2 7b)

Sekarang mari kita mencabar DeepCoder-14b dengan tugas debugging klasik. Kami akan memberi makan fungsi faktori rekursif kereta dan memintanya untuk membetulkan kod dan menerangkan apa yang salah. Kami kemudian akan memberikan tugas yang sama untuk model Openai O1 (disimulasikan oleh Llama-27b) dan membandingkan tanggapan mereka.

Kod Buggy:

 buggy_code = "" "
Def Factorial (n):
    jika n == 0:
        kembali 0
    lain:
        kembali n * factorial (n-1)
"" "

DeepCoder-14b:

 respons = llm.create_chat_completion (
    Mesej = [
        {
            "Peranan": "Pengguna",
            "Kandungan": f "Kod ini mempunyai pepijat. Betulkannya dan jelaskan pembetulan: \ n {buggy_code}"
        }
    ]
)
Cetak ("Output DeepCoder: \ n", Response ['Pilihan'] [0] ['Mesej'] ['Kandungan'])

Llama-2 7b (Simulasi O1):

 Dari Transformers mengimport autotokenizer, automelforcausallm, saluran paip
tokenizer = autotokenizer.from_pretrained ("meta-llama/llama-2-7b-chat-hf")
Model = automelforcausallm.from_pretrained ("meta-llama/llama-2-7b-chat-hf", device_map = "auto")
paip = saluran paip ("generasi teks", model = model, tokenizer = tokenizer)
prompt = "Kod ini mempunyai pepijat. Betulkannya dan terangkan pembetulan: \ n" Buggy_code
output = paip (prompt, max_new_tokens = 200) [0] ["Generated_text"]
Cetak ("output llama-2: \ n", output)

Kajian:

Dalam tugas ini, kedua-dua DeepCoder-14b dan O1 (Llama-2 7b) dengan betul mengenal pasti pepijat dalam fungsi faktorial-mengiktiraf bahawa kes asas harus kembali 1 dan bukannya 0. DeepCoder-14b menunjukkan alasan yang kuat dengan berjalan melalui logik dan menonjol

Walau bagaimanapun, outputnya mengalami kecacatan kritikal: gelung berulang -ulang "tunggu, tidak," yang merosot dari kebolehbacaan dan membuat respons tidak stabil. Sebaliknya, O1 memberikan tindak balas ringkas, bersih, dan betul, biasanya termasuk kod tetap dan penjelasan ringkas. Walaupun ia tidak mempunyai kedalaman penalaran DeepCoder, kebolehpercayaan dan kejelasan O1 menjadikannya lebih sesuai untuk kegunaan praktikal, terutamanya dalam penggunaan atau konteks pendidikan.

Perkembangan masa depan DeepCoder-14b

Walaupun keputusan semasa memberi tumpuan kepada pengekodan, pasukan merancang untuk:

• Memperluas tetingkap konteks ke 128K melalui skala NTK dinamik.
• Membangunkan keupayaan penalaran multimodal.
• Buat varian khusus untuk pengauditan keselamatan dan pemodenan kod warisan.

Siaran ini menandakan langkah penting ke arah demokrasi alat pengekodan AI yang maju, menyediakan penyelidik dan pemaju dengan:

• Resipi latihan lengkap yang sepadan dengan prestasi model proprietari.
• Infrastruktur untuk RL yang dapat disahkan pada skala.
• Baseline untuk kemajuan sumber terbuka masa depan dalam sintesis program.

Lesen MIT model memastikan penggunaan komersil dan penyelidikan yang tidak terhad, memupuk inovasi di seluruh ekosistem AI. Dengan kombinasi prestasi kompetitif dan ketelusan penuh, DeepCoder-14B menetapkan standard baru untuk pembangunan model pengekodan AI sumber terbuka.

DeepCoder-14B: Akses dan Penggunaan

Segala -galanya mengenai DeepCoder dibina di sekitar ketelusan dan komuniti:

• Berat model : tersedia secara terbuka melalui muka pelukan
• Paip Latihan : Dikongsi melalui RLLM GitHub Repo
• Pecahan Blog : Catatan Pengertian Rasmi

Ini menjadikannya sumber yang hebat untuk:

• Penyelidik meneroka penalaan RL
• Penggodam dan pemaju membina ejen pengekodan tersuai
• Pendidik menunjukkan bagaimana sistem pengekodan AI dunia sebenar dibina dan diuji

Kesimpulan

Dalam era yang dikuasai oleh dinding tertutup dan model kotak hitam, DeepCoder-14b adalah nafas udara segar. Ia menunjukkan bahawa model pengekodan AI sumber terbuka boleh skala, bersaing, dan berinovasi-tanpa bersembunyi di belakang API atau paywalls. Dari konteks skala ke generalisasi matematik, dari dataset yang disahkan ke kotak pasir berkelajuan tinggi, segala-galanya mengenai DeepCoder merasakan pemikiran yang bijak, disengajakan, dan masyarakat.

Pemaju yang ingin meningkatkan aliran kerja pengekodan mereka boleh mula menggunakan DeepCoder dengan segera. Prestasi yang mengagumkan model pada tugas pengekodan peringkat persaingan menjadikannya sesuai untuk pelbagai aplikasi, dari penyelesaian kod automatik ke penyelesaian masalah algoritma. Jika anda membina masa depan pembangunan AI-Assisted, DeepCoder-14B tidak hanya bernilai mencuba-ia mungkin menjadi garis dasar baru anda.

Soalan yang sering ditanya

A. DeepCoder-14B mencabar keupayaan model O3-Mini dengan menyampaikan prestasi pengekodan yang setanding (60.6% pass@1 pada LiveCodeBench) semasa menjadi sumber terbuka sepenuhnya. Ia menyediakan akses penuh kepada berat, dataset, dan kerangka latihan, membolehkan pemaju untuk mengaudit, menyesuaikan diri, dan menggunakan model tanpa lesen yang ketat.

A. Model ini menggunakan strategi latihan inovatif seperti pemanjangan konteks berulang, skala dari token 16K hingga 32K semasa latihan semasa menyebarkan konteks 64K. Digabungkan dengan penapisan yang berlebihan untuk menghilangkan data bising dan grpo -a algoritma RL yang halus-ia mengoptimumkan penalaran tanpa kembung parameter, memastikan kecekapan sumber yang dapat dilihat melalui grafik kecekapan O3-Mini vs DeepCoder-14B.

A. DeepCoder-14B skor 1936 pada codeforces (5% teratas pesaing manusia) dan 73.8% pada masalah matematik AIME, menunjukkan penalaran silang domain. Ia sepadan dengan ketepatan DeepCoder-14B vs O3-mini walaupun menggunakan separuh parameter, membuktikan model yang lebih kecil dapat menyaingi rakan proprietari yang lebih besar melalui latihan yang dioptimumkan.

A. Codebase berlesen MIT, memeluk penempatan muka, dan rangka kerja latihan RLLM yang boleh dihasilkan membolehkan pemaju menyesuaikannya untuk tugas khusus (misalnya, pemodenan kod warisan) atau mengintegrasikannya ke dalam IDES. Penanda aras telus dan persekitaran kotak pasir memastikan ujian yang boleh dipercayai, tidak seperti model tertutup dengan penilaian legap.

A. Ya. Sistem Dual Sandbox (berasaskan awan dan tempatan) mengesahkan kod terhadap kes ujian yang ketat, dan sokongan konteks 64K membolehkan analisis codebase yang panjang. Pemaju melaporkan kejayaan dalam mengautomasikan pembetulan pepijat, penjanaan ujian, dan penyelesaian masalah algoritma pada tahap persaingan.

A. Dataset 24K-Problem menguatkuasakan ≥5 kes ujian yang disahkan setiap masalah dan perpecahan kereta api/ujian yang ketat untuk mengelakkan kebocoran. Curation ini memastikan ganjaran RL yang bersih, mengurangkan risiko overfitting yang biasa dalam dataset yang dikikis.

Atas ialah kandungan terperinci DeepCoder-14b: Pertandingan sumber terbuka untuk O3-Mini dan O1. Untuk maklumat lanjut, sila ikut artikel berkaitan lain di laman web China PHP!