DeepSeek-Coder-V2 ट्यूटोरियल: उदाहरण, इंस्टॉलेशन, बेंचमार्क्स

DeepSeek-Coder-V2 क्या है?

DeepSeek-Coder-V2 एक ओपन-सोर्स Mixture-of-Experts (MoE) कोड लैंग्वेज मॉडल है जो कोड-विशिष्ट कार्यों में GPT-4 के प्रदर्शन की टक्कर देता है। डेवलपर्स की सहायता के लिए डिज़ाइन किया गया यह मॉडल कई प्रमुख विशेषताएं पेश करता है:

• बहुभाषी: इसे कोड और प्राकृतिक भाषा, दोनों पर कई भाषाओं (जिनमें अंग्रेजी और चीनी शामिल हैं) में प्रशिक्षित किया गया है, जिससे यह वैश्विक डेवलपमेंट टीमों के लिए बहुउद्देश्यीय बनता है।
• बहुविध: 338 से अधिक प्रोग्रामिंग भाषाओं की विस्तृत श्रृंखला का समर्थन करता है, जो विविध कोडिंग परिवेश और आवश्यकताओं को पूरा करता है।
• वृहद् पैमाना: इसे कोड और पाठ डेटा के ट्रिलियनों टोकन पर प्री-ट्रेन किया गया है, जो विभिन्न कोडिंग परिदृश्यों में इसकी समझ और जनरेशन क्षमताओं को बढ़ाता है।
• कई आकार: मॉडल कई आकारों में उपलब्ध हैं, जिससे डेवलपर्स अपनी कंप्यूटेशनल संसाधनों और प्रोजेक्ट आवश्यकताओं के अनुरूप आकार चुन सकते हैं।

आप इस मॉडल तक DeepSeek की वेबसाइट पर पहुंच सकते हैं—वे पेड API एक्सेस और चैट की सुविधा देते हैं। सोर्स कोड GitHub पर उपलब्ध है और शोध-पत्र arXiv पर होस्ट किया गया है।

मॉडल Huggingface पर होस्ट किए गए हैं—हालाँकि, आकार के कारण मॉडल को लोकली चलाने के लिए आपको रिसर्च-ग्रेड हार्डवेयर की आवश्यकता होगी।

DeepSeek-Coder-V2 बेंचमार्क्स

आइए देखें कि DeepSeek-Coder-V2 बेंचमार्क्स पर कैसा प्रदर्शन करता है और यह GPT-4 Turbo, Gemini 1.5 Pro, Claude 3 Opus, LLaMA 3-70B और Codestral जैसे मॉडलों की तुलना में कैसा है।

स्रोत: Qihao Zhu व अन्य

HumanEval

HumanEval बेंचमार्क जनरेट किए गए कोड के विशिष्ट यूनिट टेस्ट पास करने पर कोड जनरेशन दक्षता को मापता है। DeepSeek-Coder-V2 ने इस बेंचमार्क पर 90.2% सटीकता हासिल कर उत्कृष्ट प्रदर्शन दिखाया। यह परिणाम जटिल परिस्थितियों में भी कार्यात्मक और सटीक कोड स्निपेट बनाने की मॉडल की क्षमता को रेखांकित करता है।

MBPP+

MBPP+ बेंचमार्क कोड समझ पर केंद्रित है और किसी मॉडल की कोड संरचना तथा सैमांटिक्स समझने-समझाने की क्षमता का आकलन करता है। DeepSeek-Coder-V2 ने यहाँ भी 76.2% सटीकता के साथ उत्कृष्ट प्रदर्शन किया, जो कोड के अर्थ और कार्यप्रणाली की इसकी मजबूत पकड़ को दर्शाता है।

MATH

MATH बेंचमार्क कोड के भीतर गणितीय तर्क क्षमताओं का परीक्षण करता है। DeepSeek-Coder-V2 ने 75.7% सटीकता के साथ अपनी बढ़त बनाए रखी, जो कोड में निहित गणितीय ऑपरेशन्स और लॉजिक संभालने में इसकी दक्षता को दर्शाता है—जो अनेक प्रोग्रामिंग कार्यों का एक अहम पहलू है।

GSM8K

GSM8K बेंचमार्क प्राइमरी-स्तर की गणितीय शब्द समस्याएँ हल करने पर केंद्रित है, जो शुद्ध कोड जनरेशन से परे किसी मॉडल की व्यापक समस्या-समाधान क्षमता का मूल्यांकन करता है। DeepSeek-Coder-V2 ने 94.9% सटीकता के साथ Claude 3 Opus से बस थोड़ा पीछे स्थान पाया, जो प्राकृतिक भाषा में प्रस्तुत गणितीय समस्याओं को समझने और हल करने की इसकी क्षमता दर्शाता है।

Aider

Aider बेंचमार्क किसी मॉडल की कोड सहायता और सुझाव देने की क्षमता का आकलन करता है। DeepSeek-Coder-V2 ने 73.7% सटीकता के साथ बढ़त बनाई, जो रीयल-टाइम मार्गदर्शन और सपोर्ट चाहने वाले डेवलपर्स के लिए इसे एक मूल्यवान टूल बनने की क्षमता का संकेत देता है।

LiveCodeBench

LiveCodeBench बेंचमार्क वास्तविक दुनिया के परिदृश्यों में कोड जनरेशन प्रदर्शन को मापता है। DeepSeek-Coder-V2 ने 43.4% सटीकता (GPT-4-Turbo-0409 के बाद दूसरा) हासिल की, जो व्यावहारिक संदर्भों में कार्यात्मक और उपयोगी कोड बनाने की इसकी क्षमता दर्शाता है।

SWE Bench बेंचमार्क

​​SWE-Bench बेंचमार्क विशेष रूप से AI मॉडलों का सॉफ्टवेयर इंजीनियरिंग कार्यों—जैसे कोड जनरेशन, डिबगिंग, और जटिल प्रोग्रामिंग अवधारणाओं की समझ—पर मूल्यांकन करता है। इस संदर्भ में, DeepSeek-Coder-V2 ने 12.7 का स्कोर हासिल किया, जो ठोस प्रदर्शन को इंगित करता है पर यह शीर्ष पर नहीं है। यह GPT-4-Turbo-0409 (18.7) और Gemini-1.5-Pro (18.3) से पीछे है, जिन्होंने इन कार्यों में बेहतर क्षमताएँ दिखाईं। फिर भी, DeepSeek-Coder-V2 ने Claude-3-Opus (11.7), Llama-3-70B (2.7) और Codestral जैसे मॉडलों से बेहतर प्रदर्शन किया, जो इस बेंचमार्क के आधार पर सॉफ्टवेयर इंजीनियरिंग अनुप्रयोगों के लिए इसे विश्वसनीय, भले ही शीर्ष-स्तरीय नहीं, विकल्प बताता है।

DeepSeek-Coder-V2 कैसे काम करता है

DeepSeek-Coder-V2, DeepSeek-V2 मॉडल की नींव पर आधारित है और कोड-विशिष्ट कार्यों में उच्च प्रदर्शन हासिल करने के लिए एक परिष्कृत Mixture-of-Experts (MoE) आर्किटेक्चर का उपयोग करता है। यह मॉडल कई विशेषज्ञ मॉडलों का सहारा लेता है, जिनमें से प्रत्येक अलग-अलग कोडिंग कार्यों में विशेषज्ञ होता है, और इनपुट कोड के आधार पर सबसे प्रासंगिक विशेषज्ञ का डायनेमिक चयन करता है। यह तरीका मॉडल की दक्षता और सटीकता, दोनों को बढ़ाता है।

DeepSeek-Coder-V2 का प्रशिक्षण कई महत्वपूर्ण घटकों को शामिल करता है। इसे 10.2 ट्रिलियन टोकन के व्यापक डेटासेट पर प्री-ट्रेन किया गया है, जिसमें 60% सोर्स कोड, 10% गणित कॉर्पस और 30% प्राकृतिक भाषा कॉर्पस शामिल हैं। यह विविध डेटासेट मॉडल को प्रभावी ढंग से कोड समझने और जनरेट करने में सक्षम बनाता है। सोर्स कोड डेटासेट में GitHub और CommonCrawl से लिए गए 1,170 बिलियन टोकन शामिल हैं, जो 338 प्रोग्रामिंग भाषाओं को कवर करते हैं—जो पिछले मॉडलों की तुलना में एक बड़ा विस्तार है।

प्री-ट्रेनिंग के बाद, मॉडल को एक विशेष इंस्ट्रक्शन डेटासेट से फाइन-ट्यून किया जाता है, जिसमें कोडिंग, गणितीय और सामान्य भाषा के निर्देश शामिल होते हैं। यह प्रक्रिया मॉडल की प्राकृतिक भाषा प्रॉम्प्ट्स के प्रति प्रतिक्रिया क्षमता में सुधार करती है और मॉडल को एक उपयोगी असिस्टेंट में बदल देती है।

जो लोग अंतर्निहित आर्किटेक्चर में रुचि रखते हैं, उनके लिए DeepSeek-V2 मॉडल—जिस पर DeepSeek-Coder-V2 आधारित है—Multi-head Latent Attention (MLA) और DeepSeekMoE फ्रेमवर्क जैसी नवाचारों को पेश करता है। ये नवाचार कुशल इन्फ़रेंस और किफायती प्रशिक्षण में योगदान देते हैं, जैसा कि DeepSeek-V2 के पेपर में विस्तार से बताया गया है, जो arXiv पर उपलब्ध है।

DeepSeek-Coder-V2 के साथ शुरुआत

DeepSeek-Coder-V2 मॉडल का उपयोग शुरू करने के कई तरीके हैं। आप मॉडल को Hugging Face की transformers लाइब्रेरी के माध्यम से एक्सेस करके लोकली चला सकते हैं। हालाँकि, ध्यान रखें कि मॉडल काफ़ी बड़े हैं और पर्याप्त कंप्यूटेशनल संसाधनों की आवश्यकता होती है।

वैकल्पिक रूप से, DeepSeek एक पेड API और ChatGPT जैसी ऑनलाइन चैट इंटरफ़ेस भी प्रदान करता है। DeepSeek की ऑनलाइन चैट सीधे चैट विंडो में HTML और JavaScript कोड भी चला सकती है! यह सुविधा काफी अभिनव है—मैंने ऐसा कुछ मिलते-जुलते रूप में केवल Artifacts में देखा है, जो Claude 3.5 Sonnet मॉडल का हिस्सा है। इस लेख में, हम अपने उदाहरणों के लिए चैट सुविधा का उपयोग करेंगे।

DeepSeek-Coder-V2: उदाहरण उपयोग

पहले उदाहरण के लिए, मैं मॉडल से HTML और JavaScript में Conway का गेम ऑफ़ लाइफ़ प्रोग्राम करने को कहूंगा। मैंने मॉडल से यह प्रॉम्प्ट पूछा: “क्या आप HTML में Conway का गेम ऑफ़ लाइफ़ लिख सकते हैं?” यहाँ प्रतिक्रिया है:

Certainly! Below is a simple implementation of Conway's Game of Life using HTML, CSS, and JavaScript. This version will display the grid in an HTML table and update it every second.संचालित द्वारा

<!DOCTYPE html>
<html lang="en">
<head>
    <meta charset="UTF-8">
    <meta name="viewport" content="width=device-width, initial-scale=1.0">
    <title>Conway's Game of Life</title>
    <style>
        table {
            border-collapse: collapse;
        }
        td {
            width: 10px;
            height: 10px;
            border: 1px solid #ccc;
        }
        .alive {
            background-color: black;
        }
        .dead {
            background-color: white;
        }
    </style>
</head>
<body>
    <h1>Conway's Game of Life</h1>
    <table id="grid"></table>
    <script>
        const N = 50; // Grid size
        let grid = createGrid(N);
        let intervalId;
        function createGrid(N) {
            let grid = new Array(N);
            for (let i = 0; i < N; i++) {
                grid[i] = new Array(N);
                for (let j = 0; j < N; j++) {
                    grid[i][j] = Math.random() > 0.7 ? 1 : 0;
                }
            }
            return grid;
        }
        function renderGrid(grid) {
            const table = document.getElementById('grid');
            table.innerHTML = '';
            for (let i = 0; i < N; i++) {
                const row = table.insertRow();
                for (let j = 0; j < N; j++) {
                    const cell = row.insertCell();
                    cell.classList.add(grid[i][j] ? 'alive' : 'dead');
                }
            }
        }
        function updateGrid(grid) {
            const newGrid = grid.map(row => row.slice());
            for (let i = 0; i < N; i++) {
                for (let j = 0; j < N; j++) {
                    const aliveNeighbors = countAliveNeighbors(grid, i, j);
                    if (grid[i][j] === 1) {
                        newGrid[i][j] = aliveNeighbors === 2 || aliveNeighbors === 3 ? 1 : 0;
                    } else {
                        newGrid[i][j] = aliveNeighbors === 3 ? 1 : 0;
                    }
                }
            }
            return newGrid;
        }
        function countAliveNeighbors(grid, x, y) {
            let count = 0;
            for (let i = -1; i <= 1; i++) {
                for (let j = -1; j <= 1; j++) {
                    if (i === 0 && j === 0) continue;
                    const newX = (x + i + N) % N;
                    const newY = (y + j + N) % N;
                    count += grid[newX][newY];
                }
            }
            return count;
        }
        function startGame() {
            intervalId = setInterval(() => {
                grid = updateGrid(grid);
                renderGrid(grid);
            }, 1000);
        }
        renderGrid(grid);
        startGame();
    </script>
</body>
</html>संचालित द्वारा

हम प्रतिक्रिया के अंत में “Run HTML” बटन पर क्लिक करके चैट विंडो में सीधे गेम ऑफ़ लाइफ़ भी चला सकते हैं।

स्क्रीनशॉट: लेखक द्वारा।

इसके बाद, मैंने मॉडल से गेम की एक डायनेमिक वेबसाइट बनाने को कहा, जहाँ मैं शुरुआती बोर्ड कॉन्फ़िगरेशन चुन सकूँ। परिणाम कुछ ऐसा दिखता है, और यह काफ़ी बेहतरी से काम करता है।

स्क्रीनशॉट: लेखक द्वारा।

अंतिम उदाहरण के लिए, मैंने मॉडल को एक कठिन Project Euler समस्या—“jumping frog”—पर परखा। यह रहा मॉडल द्वारा जनरेट किया गया कोड:

import numpy as np

MOD = 10**9


def matrix_power(matrix, n):
    result = np.identity(len(matrix), dtype=int)

    while n > 0:
        if n % 2 == 1:
            result = np.dot(result, matrix) % MOD

        matrix = np.dot(matrix, matrix) % MOD
        n //= 2

    return result


def fib_matrix(n):
    if n == 0:
        return 0
    elif n == 1:
        return 1

    A = np.array([[1, 1, 1], [1, 0, 0], [0, 1, 0]], dtype=int)
    A_power = matrix_power(A, n - 3)
    initial_vector = np.array([2, 1, 1])

    return np.dot(A_power, initial_vector)[0] % MOD


def S(L):
    result = 0

    for n in range(1, L + 1):
        f_n = fib_matrix(n)
        result = (result + f_n**3) % MOD

    return result


# Compute S(10**14) % 10**9
print(S(10**14))संचालित द्वारा

यह स्क्रिप्ट चलने में बहुत समय लेगी, इसलिए मैंने मॉडल से इसे ऑप्टिमाइज़ करने को कहा और यह आउटपुट मिला:

import numpy as np

MOD = 10**9


def matrix_power(matrix, n):
    result = np.identity(len(matrix), dtype=int)

    while n > 0:
        if n % 2 == 1:
            result = np.dot(result, matrix) % MOD
        matrix = np.dot(matrix, matrix) % MOD
        n //= 2

    return result


def fib_matrix(n):
    if n == 0:
        return 0
    elif n == 1:
        return 1

    A = np.array([[1, 1, 1], [1, 0, 0], [0, 1, 0]], dtype=int)
    A_power = matrix_power(A, n - 3)
    initial_vector = np.array([2, 1, 1])

    return np.dot(A_power, initial_vector)[0] % MOD


def find_pisano_period(m):
    previous, current = 0, 1
    for i in range(m * m):
        previous, current = current, (previous + current) % m
        if previous == 0 and current == 1:
            return i + 1


def S(L):
    pisano_period = find_pisano_period(MOD)
    period_sum = 0

    for n in range(1, pisano_period + 1):
        f_n = fib_matrix(n)
        period_sum = (period_sum + f_n**3) % MOD

    full_periods, remainder = divmod(L, pisano_period)
    result = (full_periods * period_sum) % MOD

    for n in range(1, remainder + 1):
        f_n = fib_matrix(n)
        result = (result + f_n**3) % MOD

    return result


# Compute S(10**14) % 10**9
print(S(10**14))संचालित द्वारा

मैंने ऑप्टिमाइज़ किया हुआ कोड आधे घंटे तक चलने दिया, लेकिन यह फिर भी परिणाम नहीं दे सका। जबकि मुझे लगता है कि समाधान सही हैं, चुनौती कोड को अनुकूलित करने में है। चूँकि केवल 328 लोगों ने इस समस्या को हल किया है, इसलिए यह आश्चर्यजनक नहीं है कि मॉडल इसे हल नहीं कर सका।

निष्कर्ष

DeepSeek-Coder-V2 ओपन-सोर्स कोडिंग असिस्टेंट्स के बढ़ते क्षेत्र में एक उल्लेखनीय जोड़ है, जो स्थापित मालिकाना मॉडलों के साथ प्रतिस्पर्धी प्रदर्शन दिखाता है।

DeepSeek-Coder-V2 का सर्वश्रेष्ठ उपयोग करने के लिए, स्पष्ट और विशिष्ट प्रॉम्प्ट्स दें। यदि आपको कोई बग मिलता है, तो डेवलपर्स को फीडबैक देने के लिए भी प्रोत्साहित करता हूँ।

यदि आप AI कोडिंग असिस्टेंट्स के बारे में अधिक जानना चाहते हैं, तो मैं यह DataFramed पॉडकास्ट सुनने की सलाह देता हूँ: The Future of Programming with Kyle Daigle, COO at GitHub.