Guida al Fill-in-the-Middle (FIM) per il completamento del codice: Benchmark

---

1. Introduzione: I requisiti di latenza e accuratezza dell'autocompletamento Ghost-Text

Il ai code completion (completamento del codice via IA) e l'ai autocomplete in tempo reale rappresentano i carichi di lavoro più sensibili alla latenza nell'intelligenza artificiale applicata. Mentre gli agenti conversazionali (come Claude Code, Aider o OpenCode) possono permettersi da 1.5 a 5.0 secondi di elaborazione per pianificare interventi complessi, i suggerimenti inline nell'IDE ("ghost text") devono apparire in meno di 100 millisecondi per non interrompere il flusso mentale dello sviluppatore.

+-----------------------------------------------------------------------------------------------+
|                       Budget di latenza per l'autocompletamento Ghost-Text                    |
+-----------------------------------------------------------------------------------------------+
| Debounce tastiera     : 30ms - 50ms                                                           |
| Assemblaggio contesto : 10ms - 15ms  (Tree-sitter AST, ritaglio prefisso e suffisso)          |
| Rete / Trasporto IPC  : 5ms  - 20ms  (vLLM / llama.cpp locale o WebSocket aziendale)          |
| Time-To-First-Token   : 35ms - 55ms  (Soglia sub-100ms per il primo carattere visibile)       |
| Streaming token riga  : 15ms - 25ms  (15-40 token a oltre 120 token/s per la riga)           |
+-----------------------------------------------------------------------------------------------+
| BUDGET TOTALE         : 95ms - 145ms (Soglia percettiva umana per l'inserimento istantaneo)   |
+-----------------------------------------------------------------------------------------------+

Ad ogni tasto premuto corrisponde un evento di modifica documento. Se il suggerimento impiega più di 150ms per rendersi visibile, lo sviluppatore avrà già digitato il carattere successivo, provocando sfarfallio e inutili cicli di inferenza scartati.

I modelli causali tradizionali apprendono solo la predizione da sinistra verso destra:

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

In un editor di codice reale, tuttavia, il cursore si trova spesso prima di funzioni esistenti, classi o parentesi di chiusura. Se il modello riceve solo il prefisso prima del cursore, genererà inevitabilmente parentesi duplicate o variabili in conflitto con il codice sottostante.

Da qui la necessità della tecnica Fill-in-the-Middle (FIM): una metodologia di addestramento e inferenza che condiziona la generazione sia sul Prefix (codice prima del cursore) che sul Suffix (codice dopo il cursore), inserendo con precisione il blocco intermedio mancante (Middle).

---

2. Architettura del Fill-in-the-Middle (FIM)

Introdotto teoricamente dai ricercatori OpenAI (Bavarian et al.) ed esteso su modelli a pesi aperti come StarCoder, DeepSeek Coder e Qwen 2.5 Coder, FIM consente ai modelli autoregressivi di acquisire consapevolezza bidirezionale senza alterare le matrici di attenzione del Transformer.

+-----------------------------------------------------------------------------------------------+
|                               Trasformazione Fill-in-the-Middle (FIM)                         |
+-----------------------------------------------------------------------------------------------+
| File sorgente originale:                                                                      |
| [ CODICE PRIMA DEL CURSORE (Prefix) ] [ CURSORE (Middle) ] [ CODICE DOPO IL CURSORE (Suffix)] |
|                                                                                               |
| Trasformazione FIM (Modalità PSM):                                                            |
| <PRE> [ Token Prefisso ] <SUF> [ Token Suffisso ] <MID> ===> Il modello predice [ Middle ]    |
|                                                                                               |
| Trasformazione FIM (Modalità SPM):                                                            |
| <SUF> [ Token Suffisso ] <PRE> [ Token Prefisso ] <MID> ===> Il modello predice [ Middle ]    |
+-----------------------------------------------------------------------------------------------+

Durante il pre-addestramento, i file vengono divisi casualmente in tre parti: Prefix ($C_p$), Middle ($C_m$) e Suffix ($C_s$), allenando il modello su entrambi i formati PSM e SPM.

---

3. Tabella dei Token Speciali FIM (2026)

+-------------------------------------------------------------------------------------------------------------+
|                                      Token Speciali FIM per Modello                                         |
+--------------------+--------------------------+--------------------------+--------------------------+-------+
| Famiglia Modello   | Token Prefisso           | Token Suffisso           | Inizio Middle            | Modo  |
+--------------------+--------------------------+--------------------------+--------------------------+-------+
| 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. Benchmark: Modelli Ghost-Text Sub-100ms

+---------------------------------------------------------------------------------------------------------------+
|                               CONFRONTO BENCHMARK MODELLI GHOST-TEXT SUB-100MS                                |
+-----------------------+--------------------+-------------------+------------------+-------------+-------------+
| Modello               | Precisione FIM     | Infill Multilinea | Tempo Primo      | Velocità    | VRAM        |
|                       | Singola Riga       | Precisione(Pass@1)| Token (TTFT p50) | (Token/s)   | (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. Implementazione negli IDE e Assemblaggio Contesto

• Finestra Asimmetrica: 60-70% del budget al prefisso (1.500-3.000 token) e 30-40% al suffisso (500-1.500 token).
• Analisi AST con Tree-sitter: Estrazione di 300 token di interfacce e tipi da schede adiacenti.

---

6. Server Python FastAPI per FIM Autocomplete

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. Stop Sequence e Filtro Ridondanze

• Inserire sempre i token speciali FIM nell'array stop.
• Fermarsi al doppio a capo (\n\n) per completamenti veloci a riga singola.
• Rimuovere dal risultato finale eventuali parentesi già presenti nel suffisso.

---

8. TCO e Costi Mensili (100 Sviluppatori)

• 100 Sviluppatori: ~120.000 completamenti/giorno (2,64M al mese).
• Copilot Commerciale: $1.900/mese ($19/utente).
• API Serverless: ~$115,40/mese ($0,05/$0,15 per 1M token).
• Server GPU Dedicato (A10G): $730/mese (riservatezza al 100%, latenza <70ms).
• Macchine Locali (Mac M4 / RTX 4090): $0/mese di spesa cloud.

---

9. Conclusioni e Linee Guida

1. Per computer locali degli sviluppatori: Qwen 2.5 Coder 1.5B con llama.cpp (42ms TTFT e 3.2GB di memoria).
2. Per server condivisi di team: Qwen 2.5 Coder 7B tramite vLLM (76.8% di accuratezza multilinea).
3. Limitare rigorosamente la finestra: Non superare 2.000 token di prefisso per mantenere la latenza sotto i 100ms.