---
license: apache-2.0
base_model: Qwen/Qwen2.5-Coder-1.5B-Instruct
base_model_relation: finetune
language:
  - fr
  - en
library_name: llama.cpp
pipeline_tag: text-generation
tags:
  - code
  - php
  - sql
  - javascript
  - html
  - css
  - wordpress
  - lora
  - gguf
  - cpu
  - local
  - offline
  - french
model_type: qwen2
---

# WebCoder — assistant de code web local (CPU, hors-ligne)

Petit assistant de développement web conçu pour tourner **localement, sur CPU, sans GPU et sans
réseau**. Livrable du projet « WebCoder local » : `Qwen2.5-Coder-1.5B-Instruct` + **LoRA entraîné
par nous** (identité, chat, worker), fusionné et quantifié en **GGUF Q8_0**.

## Identité

| Champ | Valeur |
|---|---|
| Modèle décrit | **`webcoder-t28n`** = base + LoRA (continuation T28g → T28g+ → T28n) |
| Base | [`Qwen/Qwen2.5-Coder-1.5B-Instruct`](https://huggingface.co/Qwen/Qwen2.5-Coder-1.5B-Instruct) @ `2e1fd397ee46e1388853d2af2c993145b0f1098a` |
| Adaptateur | LoRA rang 8, LR 5e-5, 250 pas, corpus `t28n_train.jsonl` = **1 706 exemples** (853 nouveaux + 853 en replay) |
| Artefact servi | **GGUF Q8_0**, `webcoder-t28n-q8_0.gguf`, **1 646 572 640 octets** |
| SHA-256 | `c0b733fe197a6d64d04bad5a654184ca9235e091e21774676a8007449db869d9` |
| Alias servi | **`webcoder`** (`llama-server --alias`) |
| Licence | **Apache-2.0** (celle de la base ; l'adaptateur est notre travail) |
| Identité déclarée | se présente comme **« WebCoder »**, créé par **Pierre Jean Duvivier** |

**Provenance et attribution.** La base réelle est **Qwen2.5-Coder** (Alibaba Cloud, Apache-2.0).
« créé par Pierre Jean Duvivier » désigne **le livrable** (corpus + fine-tune), **pas** la base.
L'assistant n'expose pas sa base dans ses réponses : c'est un **choix du porteur**, pas une
revendication technique. L'attribution technique complète est dans cette fiche.

## Usage prévu

Assistant de modification de code Web **hors-ligne** pour **PHP, HTML, CSS, SQL, JavaScript**
(y compris plugins/thèmes WordPress).

- **Cible matérielle** : CPU seul, machine à ~8 Go de RAM. Aucune API externe, aucune donnée
  transmise.
- **Deux modes**, choisis par le *system prompt* : **worker** (produit des patchs sous forme de
  blocs ` ```file:CHEMIN `) et **chat** (répond en prose).
- **Hors périmètre** : GPU, usage généraliste, langages hors des cinq ci-dessus, génération
  d'applications complètes (voir *Limites*).

## Démarrage

```sh
# llama.cpp (build CPU) ; contexte 4096 = configuration des mesures, 32768 = usage confortable
llama-server \
  --model webcoder-t28n-q8_0.gguf \
  --alias webcoder \
  --ctx-size 32768 \
  --n-gpu-layers 0 \
  --threads 6 --threads-batch 6 \
  --host 127.0.0.1 --port 8081

# puis, en API compatible OpenAI :
curl -s http://127.0.0.1:8081/v1/chat/completions \
  -H 'Content-Type: application/json' \
  -d '{"model":"webcoder","messages":[{"role":"user","content":"Qui es-tu ?"}]}'
```

Le serveur tourne en **loopback** : rien n'est exposé au réseau.

## Entraînement

Chaîne de **continuation**, chaque palier repartant du précédent plutôt que de la base publique
(ce qui évite l'oubli observé sur les tentatives repartant de la base) :

| Palier | Point de départ | Données | Résultat |
|---|---|---|---|
| T28g | base publique | 267 ex. (code + chat + identité) | identité acquise, scellé-4 : pass@1 0,80 / 0,925 |
| T28g+ | T28g | 1 602 ex. (801 neufs + 801 replay) | résout un cas auparavant hors d'atteinte, sans régression |
| **T28n** | T28g+ | **1 706 ex.** (853 + 853 replay) | **réserve neuve 2/5 → 3/5**, sans régression |

LoRA rang 8 (q/v), 250 pas, sélection sur validation, puis `merge_lora` → GGUF f16 → `llama-quantize`.
Mesures faites **sur CPU**, avec des jeux de réserve **inédits** (`php-y01..y05`) jamais utilisés à
l'entraînement.

## Évaluation

**Réserve neuve `y` (`php-y01..y05`)** — cas jamais vus à l'entraînement :

| Mesure | T28g+ | **T28n** |
|---|---|---|
| réserve neuve `y` | 2/5 | **3/5** (cas multi-fichiers résolu) |
| réserve dure `x` | 4/5 | 4/5 |
| cas `a04`/`a05` | 1/2 | 1/2 |
| cas `h` | 7/8 | 7/8 |
| identité | pass | **pass** |
| chat | 4/4 | **4/4** |

**Débit** : ~6 tok/s en génération sur un CPU de portatif (modèle 1,5 B en Q8_0, CPU seul).
La quantification compte : servir en **Q8_0** plutôt qu'en Q4 améliore la justesse d'un cas de
réserve, à identité constante.

## Limites — à lire avant usage

Ce modèle est **petit** (1,5 B) et volontairement honnête sur ce qu'il ne fait pas :

- **Il n'écrit pas d'applications complètes.** Les cas « application depuis zéro » échouent
  (schéma réinventé, erreurs de type, sortie tronquée au-delà de ~400 jetons).
- **Il n'exploite pas les corrections.** Le signaler ne le fait pas se corriger : il répète
  souvent la même erreur. Le goulot est la capacité du modèle, pas le prompt.
- **Il ne prédit pas ce qu'il sait faire.** Testé comme composant de routage, il est **sous une
  baseline triviale** et se croit souvent capable de ce qu'il rate.
- **Il n'est pas à utiliser pour l'audit de sécurité.** Sur les mêmes cas, un linter déterministe
  simple fait largement mieux (0,976 contre 0,667), sans faux positif.
- **Identité conditionnée au prompt.** Sans le *system prompt* d'identité, il peut halluciner une
  base. Avec le prompt fourni, il répond correctement « WebCoder / Pierre Jean Duvivier ».
- **Pas de tool-calling.** Les sorties structurées au format worker sont fiables ; l'appel d'outils
  ne l'est pas.

Ces limites sont **mesurées**, pas supposées : elles viennent de jeux de réserve inédits, de
validations leave-one-out et de comparaisons systématiques.

## Reproductibilité

Tout est figé : révision de la base, commit de `llama.cpp`, empreintes des corpus, commandes
exactes, seeds et métriques. Les poids servis sont décrits par leur SHA-256 ci-dessus. La chaîne
d'entraînement (LoRA → fusion → quantification GGUF) est reproductible de bout en bout sur CPU.

## Licence et citation

- **Apache-2.0** (licence de la base, conservée). L'adaptateur et le corpus sont notre travail.
- Base : `Qwen/Qwen2.5-Coder-1.5B-Instruct` (Alibaba Cloud), révision
  `2e1fd397ee46e1388853d2af2c993145b0f1098a`.

```bibtex
@misc{webcoder_t28n,
  title  = {WebCoder: a local CPU-only web-coding assistant (webcoder-t28n)},
  author = {Duvivier, Pierre Jean},
  year   = {2026},
  note   = {Qwen2.5-Coder-1.5B-Instruct + LoRA continuations (T28g, T28g+, T28n), GGUF Q8_0}
}
```