Cara Menjalankan DeepCoder Secara Lokal dengan Ollama

Menjalankan model pengkodean tingkat lanjut secara lokal memberdayakan pengembang untuk memanfaatkan AI mutakhir tanpa bergantung pada layanan cloud. DeepCoder, model pengkodean parameter 14B sumber terbuka penuh, menawarkan kinerja luar biasa yang sebanding dengan O3-mini. Ketika dipasangkan dengan Ollama, kerangka kerja ringan untuk menjalankan model bahasa besar (LLM), Anda dapat menerapkan DeepCoder di mesin Anda secara efisien. Panduan teknis ini memandu Anda melalui prosesnya, mulai dari penyiapan hingga eksekusi, sambil mengintegrasikan alat seperti Apidog untuk pengujian API.

💡

Sebelum menyelami lebih dalam, tingkatkan alur kerja Anda dengan mengunduh Apidog secara gratis. Alat pengujian API yang hebat ini melengkapi DeepCoder dengan memungkinkan Anda untuk memvalidasi dan men-debug kode terkait API yang dihasilkan oleh model. Unduh Apidog sekarang dan sederhanakan proses pengembangan Anda bersama dengan tutorial ini.

button

Apa itu DeepCoder?

DeepCoder adalah model pengkodean sumber terbuka parameter 14B yang dikembangkan melalui kolaborasi antara Agentica dan Together AI. Dibangun dengan menyempurnakan Deepseek-R1-Distilled-Qwen-14B dengan pembelajaran penguatan terdistribusi (RL), ia unggul dalam penalaran dan tugas pembuatan kode. Selain itu, versi 1.5B yang lebih kecil ada untuk lingkungan dengan sumber daya terbatas. Tidak seperti model berpemilik, sifat sumber terbuka DeepCoder memungkinkan transparansi dan penyesuaian penuh, menjadikannya favorit di antara para pengembang.

Ollama, di sisi lain, menyederhanakan penerapan LLM seperti DeepCoder. Ia menyediakan runtime ringan dan API untuk integrasi tanpa batas ke dalam alur kerja pengembangan. Dengan menggabungkan alat-alat ini, Anda membuka asisten pengkodean lokal yang kuat.

Prasyarat untuk Menjalankan DeepCoder Secara Lokal

Sebelum melanjutkan, pastikan sistem Anda memenuhi persyaratan. Inilah yang Anda butuhkan:

Perangkat Keras:

Mesin dengan setidaknya RAM 32GB (64GB direkomendasikan untuk model 14B).
GPU modern (mis., NVIDIA RTX 3090 atau lebih baik) dengan VRAM 24GB+ untuk kinerja optimal.
Atau, CPU dengan inti yang cukup (mis., Intel i9 atau AMD Ryzen 9) berfungsi untuk model 1.5B.

Perangkat Lunak:

Sistem Operasi: Linux (Ubuntu 20.04+), macOS, atau Windows (melalui WSL2).
Git: Untuk mengkloning repositori.
Docker (opsional): Untuk penerapan dalam wadah.
Python 3.9+: Untuk pembuatan skrip dan interaksi API.

Dependensi:

Ollama: Terpasang dan terkonfigurasi.
File model DeepCoder: Diunduh dari pustaka Ollama resmi.

Dengan semua ini tersedia, Anda siap untuk memasang dan mengonfigurasi lingkungan.

Langkah 1: Pasang Ollama di Mesin Anda

Ollama berfungsi sebagai tulang punggung untuk menjalankan DeepCoder secara lokal. Ikuti langkah-langkah ini untuk memasangnya:

Unduh Ollama:
Kunjungi situs web Ollama resmi atau gunakan pengelola paket. Untuk Linux, jalankan:

curl -fsSL https://ollama.com/install.sh | sh

Di macOS, gunakan Homebrew:

brew install ollama

Verifikasi Pemasangan:
Periksa versinya untuk memastikan Ollama terpasang dengan benar:

ollama --version

Mulai Layanan Ollama:
Luncurkan Ollama di latar belakang:

ollama serve &

Ini menjalankan server di localhost:11434, mengekspos API untuk interaksi model.

Ollama sekarang beroperasi. Selanjutnya, Anda akan mengambil model DeepCoder.

Langkah 2: Unduh DeepCoder dari Pustaka Ollama

DeepCoder tersedia di pustaka model Ollama. Inilah cara menariknya:

Tarik DeepCoder:
Unduh model 14B (atau 1.5B untuk pengaturan yang lebih ringan):

ollama pull deepcoder

Perintah ini mengambil versi yang ditandai terbaru. Untuk tag tertentu, gunakan:

ollama pull deepcoder:14b-preview

Pantau Kemajuan Unduhan:
Prosesnya mengalirkan pembaruan, menampilkan ringkasan file dan status penyelesaian. Harapkan unduhan multi-gigabyte untuk model 14B, jadi pastikan koneksi internet stabil.

Verifikasi Pemasangan:
Periksa apakah DeepCoder tersedia:

ollama list

Anda akan melihat deepcoder terdaftar di antara model yang terpasang.

Dengan DeepCoder diunduh, Anda siap untuk menjalankannya.

Langkah 3: Jalankan DeepCoder Secara Lokal dengan Ollama

Sekarang, jalankan DeepCoder dan uji kemampuannya:

Mulai DeepCoder:
Luncurkan model dalam sesi interaktif:

ollama run deepcoder

Ini membuka prompt tempat Anda dapat memasukkan kueri pengkodean.

Sesuaikan Parameter (Opsional):
Untuk penggunaan tingkat lanjut, sesuaikan pengaturan seperti suhu melalui file konfigurasi atau panggilan API (dibahas nanti).

DeepCoder sekarang berjalan secara lokal. Namun, untuk mengintegrasikannya ke dalam alur kerja, Anda akan menggunakan API-nya.

Langkah 4: Berinteraksi dengan DeepCoder melalui API Ollama

Ollama mengekspos API RESTful untuk akses terprogram. Inilah cara memanfaatkannya:

Periksa Ketersediaan API:
Pastikan server Ollama berjalan:

curl http://localhost:11434

Respons mengonfirmasi bahwa server aktif.

Kirim Permintaan:
Gunakan curl untuk menanyakan DeepCoder:

curl http://localhost:11434/api/generate -d '{
  "model": "deepcoder",
  "prompt": "Generate a REST API endpoint in Flask",
  "stream": false
}'

Respons mencakup kode yang dihasilkan, seperti:

from flask import Flask, jsonify

app = Flask(__name__)

@app.route('/api/data', methods=['GET'])
def get_data():
    return jsonify({"message": "Hello, World!"})

if __name__ == "__main__":
    app.run(debug=True)

Berintegrasi dengan Python:
Gunakan pustaka requests Python untuk interaksi yang lebih bersih:

import requests

url = "http://localhost:11434/api/generate"
payload = {
    "model": "deepcoder",
    "prompt": "Write a Node.js Express API",
    "stream": False
}
response = requests.post(url, json=payload)
print(response.json()["response"])

API membuka potensi DeepCoder untuk otomatisasi dan integrasi.

Langkah 5: Tingkatkan Pengujian API dengan Apidog

DeepCoder unggul dalam menghasilkan kode API, tetapi menguji API tersebut sangat penting. Apidog menyederhanakan proses ini:

Pasang Apidog:
Unduh dan pasang Apidog dari situs resminya.

button

Uji API yang Dihasilkan:
Ambil endpoint Flask dari sebelumnya. Di Apidog:

Buat permintaan baru.

Atur URL ke http://localhost:5000/api/data dan Kirim permintaan GET.

Verifikasi respons: {"message": "Hello, World!"}.

Otomatiskan Pengujian:
Gunakan pembuatan skrip Apidog untuk mengotomatiskan validasi, memastikan output DeepCoder memenuhi harapan.

Apidog menjembatani kesenjangan antara pembuatan kode dan penerapan, meningkatkan produktivitas.

Langkah 6: Optimalkan Kinerja DeepCoder

Untuk memaksimalkan efisiensi, sesuaikan pengaturan DeepCoder:

Akselerasi GPU:
Pastikan Ollama memindahkan komputasi ke GPU Anda. Periksa dengan:

nvidia-smi

Penggunaan GPU menunjukkan akselerasi yang berhasil.

Manajemen Memori:
Untuk model 14B, alokasikan VRAM yang cukup. Sesuaikan ruang swap di Linux jika diperlukan:

sudo fallocate -l 32G /swapfile
sudo chmod 600 /swapfile
sudo mkswap /swapfile
sudo swapon /swapfile

Kuantisasi Model:
Gunakan kuantisasi yang lebih kecil (mis., 4-bit) untuk model 1.5B:

ollama pull deepcoder:1.5b-q4

Penyesuaian ini memastikan DeepCoder berjalan dengan lancar di perangkat keras Anda.

Mengapa Memilih DeepCoder dengan Ollama?

Menjalankan DeepCoder secara lokal menawarkan keuntungan yang berbeda:

Privasi: Jaga agar kode sensitif tidak berada di server cloud.
Biaya: Hindari biaya berlangganan.
Kustomisasi: Sesuaikan model dengan kebutuhan Anda.

Memasangkannya dengan kerangka kerja ringan Ollama dan kemampuan pengujian Apidog menciptakan ekosistem pengembangan mandiri yang kuat.

Kesimpulan

Menyiapkan DeepCoder secara lokal dengan Ollama sangat mudah namun transformatif. Anda memasang Ollama, menarik DeepCoder, menjalankannya, dan mengintegrasikannya melalui API—semuanya dalam beberapa langkah. Alat seperti Apidog semakin meningkatkan pengalaman dengan memastikan API yang dihasilkan berfungsi dengan sempurna. Apakah Anda seorang pengembang solo atau bagian dari tim, pengaturan ini memberikan asisten pengkodean sumber terbuka yang kuat.

button