Code AI

Fill-in-the-Middle (FIM) कोड ऑटो-कम्प्लीशन गाइड: आर्किटेक्चर और बेंचमार्क

2026-09-02·22 मिनट पढ़ें मिनट पठन·LLMPodium Team

त्वरित उत्तर: 2026 में Fill-in-the-Middle (FIM) प्रीफिक्स, सफिक्स और मिडिल टोकन्स (जैसे <|fim_prefix|>, <|fim_suffix|>, <|fim_middle|>) के जरिए IDE में रीयल-टाइम घोस्ट-टेक्स्ट कोड ऑटो-कम्प्लीशन प्रदान करता है। सब-100ms लेटेंसी में Qwen 2.5 Coder 1.5B 42ms TTFT और 84.6% सिंगल-लाइन FIM सटीकता के साथ सर्वश्रेष्ठ है, जबकि Qwen 2.5 Coder 7B मल्टी-लाइन कोड जनरेशन (76.8%) में सबसे आगे है।

1. परिचय: घोस्ट-टेक्स्ट AI ऑटो-कम्प्लीशन की लेटेंसी और सटीकता की मांग

रीयल-टाइम ai code completion और ai autocomplete एप्लाइड आर्टिफिशियल इंटेलिजेंस में सबसे अधिक लेटेंसी-संवेदनशील वर्कलोड्स हैं। जहां चैट-आधारित कोडिंग एजेंट्स (जैसे Claude Code, Aider या OpenCode) 1.5 से 5.0 सेकंड का समय ले सकते हैं, वहीं IDE में इनलाइन कोड सुझावों ("घोस्ट टेक्स्ट") को डेवलपर के काम में बाधा डाले बिना 100 मिलीसेकंड से कम समय में स्क्रीन पर आना चाहिए। 

+-----------------------------------------------------------------------------------------------+
|                       IDE घोस्ट-टेक्स्ट ऑटो-कम्प्लीशन के लिए लेटेंसी बजट                       |
+-----------------------------------------------------------------------------------------------+
| कीस्ट्रोक डिबाउंस    : 30ms - 50ms                                                            |
| कॉन्टेक्स्ट असेंबली  : 10ms - 15ms  (Tree-sitter AST, प्रीफिक्स और सफिक्स विंडोइंग)           |
| नेटवर्क / IPC ट्रांसपोर्ट : 5ms  - 20ms  (लोकल vLLM / llama.cpp या प्राइवेट WebSocket)        |
| टाइम-टू-फर्स्ट-टोकन  : 35ms - 55ms  (पहले टोकन के लिए सब-100ms की सीमा)                        |
| टोकन स्ट्रीमिंग      : 15ms - 25ms  (120+ टोकन/सेकंड पर 15-40 टोकन लाइन कम्प्लीशन)            |
+-----------------------------------------------------------------------------------------------+
| कुल बजट             : 95ms - 145ms (तत्काल सुझाव के लिए मानव अनुभूति की सीमा)                |
+-----------------------------------------------------------------------------------------------+

पारंपरिक ऑटोरेग्रेसिव लैंग्वेज मॉडल केवल बाएं से दाएं टोकन प्रेडिक्शन पर प्रशिक्षित होते हैं:

$$P(W) = \prod_{i=1}^{n} P(w_i \mid w_1, w_2, \dots, w_{i-1})$$

लेकिन वास्तविक कोड एडिटर में कर्सर के आगे पहले से ही फंक्शन्स, ब्रैकेट्स या क्लासेस मौजूद होती हैं। यदि मॉडल केवल कर्सर के पहले का कोड (Prefix) देखेगा, तो वह नीचे दिए गए कोड से टकराने वाले डुप्लिकेट ब्रैकेट्स या वेरिएबल्स उत्पन्न करेगा।

इसीलिए Fill-in-the-Middle (FIM) कोड जनरेशन अनिवार्य है—यह तकनीक मॉडल को Prefix और Suffix दोनों के आधार पर सटीक Middle (मध्य भाग) उत्पन्न करने में सक्षम बनाती है।

2. आर्किटेक्चर: Fill-in-the-Middle (FIM) कैसे काम करता है

StarCoder, DeepSeek Coder और Qwen 2.5 Coder द्वारा उपयोग की जाने वाली FIM तकनीक ट्रांसफॉर्मर की अटेंशन मैट्रिक्स को बदले बिना मानक ऑटोरेग्रेसिव मॉडल को द्विदिशीय समझ प्रदान करती है। 

+-----------------------------------------------------------------------------------------------+
|                              Fill-in-the-Middle (FIM) ट्रांसफॉर्मेशन                           |
+-----------------------------------------------------------------------------------------------+
| मूल कोड फ़ाइल:                                                                                |
| [ कर्सर से पहले का कोड (Prefix) ] [ कर्सर स्थान (Middle) ] [ कर्सर के बाद का कोड (Suffix) ]   |
|                                                                                               |
| FIM प्रारूप (PSM मोड):                                                                        |
| <PRE> [ प्रीफिक्स कोड ] <SUF> [ सफिक्स कोड ] <MID> ===> मॉडल प्रेडिक्ट करता है [ Middle ]     |
|                                                                                               |
| FIM प्रारूप (SPM मोड):                                                                        |
| <SUF> [ सफिक्स कोड ] <PRE> [ प्रीफिक्स कोड ] <MID> ===> मॉडल प्रेडिक्ट करता है [ Middle ]     |
+-----------------------------------------------------------------------------------------------+

3. प्रमुख मॉडल्स की FIM टोकन तालिका (2026)

+-------------------------------------------------------------------------------------------------------------+
|                                    विभिन्न मॉडल्स के FIM स्पेशल टोकन्स (2026)                                |
+--------------------+--------------------------+--------------------------+--------------------------+-------+
| मॉडल फैमिली        | प्रीफिक्स टोकन (Prefix)  | सफिक्स टोकन (Suffix)     | मिडिल टोकन (Middle)      | मोड   |
+--------------------+--------------------------+--------------------------+--------------------------+-------+
| Qwen 2.5 Coder     | <|fim_prefix|>           | <|fim_suffix|>           | <|fim_middle|>           | PSM   |
| DeepSeek Coder V1/2| <｜fim begin｜>          | <｜fim hole｜>           | <｜fim end｜>            | SPM   |
| StarCoder / SC2    | <fim_prefix>             | <fim_suffix>             | <fim_middle>             | PSM   |
| Mistral Codestral  | [PREFIX]                 | [SUFFIX]                 | [MIDDLE]                 | PSM   |
| CodeLlama          | <PRE>                    | <SUF>                    | <MID>                    | PSM   |
+--------------------+--------------------------+--------------------------+--------------------------+-------+

4. बेंचमार्क: सब-100ms घोस्ट-टेक्स्ट मॉडल्स की तुलना

+---------------------------------------------------------------------------------------------------------------+
|                               100ms से कम लेटेंसी वाले मॉडल्स का बेंचमार्क परिणाम                            |
+-----------------------+--------------------+-------------------+------------------+-------------+-------------+
| मॉडल                  | सिंगल-लाइन FIM     | मल्टी-लाइन इनफिल  | टाइम-टू-फर्स्ट   | जनरेशन गति  | VRAM आकार   |
|                       | सटीकता (Pass@1)    | सटीकता (Pass@1)   | टोकन (p50 TTFT)  | (टोकन/सेकंड)| (FP16)      |
+-----------------------+--------------------+-------------------+------------------+-------------+-------------+
| Qwen 2.5 Coder 1.5B   | 84.6%              | 64.2%             | 42 ms            | 188 tok/s   | 3.2 GB      |
| Qwen 2.5 Coder 7B     | 89.2%              | 76.8%             | 84 ms            | 112 tok/s   | 15.2 GB     |
| DeepSeek Coder 1.3B   | 78.4%              | 56.1%             | 39 ms            | 196 tok/s   | 2.8 GB      |
| StarCoder2 3B         | 81.1%              | 60.5%             | 58 ms            | 144 tok/s   | 6.4 GB      |
+-----------------------+--------------------+-------------------+------------------+-------------+-------------+

5. IDE एक्सटेंशन में कॉन्टेक्स्ट विंडोइंग रणनीति

  • असममित विंडो: 60-70% प्रीफिक्स (1,500-3,000 टोकन) और 30-40% सफिक्स (500-1,500 टोकन)।
  • AST सिंबल इंजेक्शन: Tree-sitter का उपयोग करके खुली हुई अन्य फाइलों से 300 टोकन के महत्वपूर्ण टाइप्स व इंपोर्ट्स शामिल करना।

6. Python + FastAPI आधारित FIM सर्वर कोड

import os, time
from typing import Optional, List
from fastapi import FastAPI
from pydantic import BaseModel
import httpx

app = FastAPI(title="FIM Engine")
BACKEND_URL = os.getenv("INFERENCE_BACKEND_URL", "http://127.0.0.1:8000/v1/completions")
MODEL_NAME = os.getenv("MODEL_NAME", "Qwen/Qwen2.5-Coder-1.5B")

class FIMRequest(BaseModel):
    prefix: str
    suffix: str
    max_tokens: int = 48
    temperature: float = 0.1

@app.post("/v1/autocomplete")
async def autocomplete(req: FIMRequest):
    t0 = time.perf_counter()
    prompt = f"<|fim_prefix|>{req.prefix}<|fim_suffix|>{req.suffix}<|fim_middle|>"
    stops = ["<|fim_prefix|>", "<|fim_suffix|>", "<|fim_middle|>", "<|endoftext|>", "\n\n"]
    
    payload = {
        "model": MODEL_NAME, "prompt": prompt, "max_tokens": req.max_tokens,
        "temperature": req.temperature, "stop": stops, "stream": False
    }
    async with httpx.AsyncClient(timeout=1.5) as client:
        resp = await client.post(BACKEND_URL, json=payload)
        data = resp.json()
    return {
        "completion": data["choices"][0]["text"],
        "latency_ms": round((time.perf_counter() - t0) * 1000, 2)
    }

7. स्टॉप सीक्वेंसेज और डुप्लिकेशन से बचाव

  1. हमेशा FIM स्पेशल टोकन्स को stop लिस्ट में डालें।
  2. सिंगल-लाइन सुझावों के लिए डबल न्यूलाइन (\n\n) पर जनरेशन रोकें।
  3. सफिक्स में पहले से मौजूद ब्रैकेट } या ) को हटाने के लिए ओवरलैप फिल्टर लगाएं।

8. लागत विश्लेषण (TCO) - 100 डेवलपर्स की टीम

  • 100 डेवलपर्स: प्रतिदिन लगभग 1,20,000 अनुरोध (मासिक 26.4 लाख)।
  • कमर्शियल Copilot: $1,900/माह ($19 प्रति यूजर)।
  • सर्वरलेस API: ~$115.40/माह ($0.05/$0.15 प्रति 1M टोकन)।
  • डेडिकेटेड GPU (NVIDIA A10G): $730/माह (100% डेटा गोपनीयता, <70ms लेटेंसी)।
  • लोकल लैपटॉप (Mac M4 / RTX 4090): $0/माह क्लाउड लागत।

9. निष्कर्ष और सिफारिशें

  1. लोकल वर्कस्टेशन के लिए: Qwen 2.5 Coder 1.5B llama.cpp के साथ चलाएं (42ms लेटेंसी, 3.2GB मेमोरी)।
  2. टीम के केंद्रीय सर्वर के लिए: Qwen 2.5 Coder 7B को vLLM पर चलाएं (मल्टी-लाइन में 76.8% सटीकता)।
  3. कॉन्टेक्स्ट को सीमित रखें: सब-100ms लेटेंसी बनाए रखने के लिए प्रीफिक्स 2,000 टोकन से अधिक न रखें।
← सभी लेख
0 / 4
अभी तुलना करें →