cellsense-fim-0.5b/README.md

license, library_name, pipeline_tag, base_model, language, tags, model-index

license	library_name	pipeline_tag	base_model	language	tags	model-index
apache-2.0	transformers	text-generation	Qwen/Qwen2.5-Coder-0.5B	code	cellsense fim fill-in-the-middle code-completion jupyter notebook code qwen2	name results cellsense-fim-0.5b task dataset metrics type name text-generation Fill-in-the-Middle Code Completion name type split CellSense Jupyter FIM (private) cellsense-fim-large test type value name edit_similarity 0.641 Edit Similarity type value name bleu 43.09 BLEU type value name codebleu 0.346 CodeBLEU type value name token_accuracy 0.868 Token Accuracy type value name bits_per_byte 0.254 Bits per Byte

CellSense-FIM 0.5B

CellSense-FIM 0.5B is the smallest member of the CellSense-FIM model family — a set of long-context, fill-in-the-middle (FIM) code-completion models built specifically for Jupyter notebooks. It is fine-tuned from Qwen/Qwen2.5-Coder-0.5B on the (private) CellSense FIM dataset and supports a 32K-token context window.

Unlike general code models that treat a notebook as a flat file, CellSense-FIM models are trained on a more detailed context, that actually matters when you complete a cell:

• 🗂️ Repository-aware — the model is trained with surrounding files from the same repository in context, so completions respect helpers, constants, and conventions defined elsewhere in the project.
• 🔗 Local-import-aware — when your notebook imports from a sibling module, the relevant source and signatures are pulled into context, so the model completes calls to your code with the right signatures, not a plausible guess.
• 🎯 Task-aware — the files you have been reading and editing are almost always the most relevant to what you are working on right now. The context conditions on this context, so completions reflect where your attention has actually been — not just what happens to be open in the active tab.

The models are best paired with the CellSense Jupyter Lab Plugin, which assembles repository, local-import, and task context into the exact format the model was trained on — so the model consumes it natively with no prompt engineering on your part.

Model family

Model	Base	Params	Context
CellSense-FIM 0.5B (this model)	Qwen2.5-Coder-0.5B	0.5B	32K
CellSense-FIM 1.5B	Qwen2.5-Coder-1.5B	1.5B	32K
CellSense-FIM 3B	Qwen2.5-Coder-3B	3B	32K
CellSense-FIM 7B	Qwen2.5-Coder-7B	7B	32K

Evaluation

Evaluated on the held-out test split of the CellSense FIM dataset. CellSense-FIM is compared against its base model (Qwen2.5-Coder-0.5B) and a same-size general model (Qwen3-0.6B).

Fine-tuning on notebook-native FIM context yields large gains on the metrics that track real completion quality — edit similarity (0.11 → 0.64) and BLEU (4.7 → 43.1) — while keeping token accuracy strong. At 0.5B, CodeBLEU stays close to the base model; the larger family members improve it outright.

Likelihood metric — Bits per Byte (lower is better)

Model	Bits per Byte ↓
Qwen2.5-Coder-0.5B (base)	0.305
Qwen3-0.6B (base)	1.082
CellSense-FIM 0.5B (ours)	0.254

Usage

Prompt format (FIM)

The model uses the Qwen2.5-Coder FIM sentinels. For a single-file completion:

<|fim_prefix|>{code before the cursor}<|fim_suffix|>{code after the cursor}<|fim_middle|>

For repository / local-import-aware completion, prepend the relevant files before the FIM block:

<|repo_name|>{repo}<|file_sep|>{path/to/helper.py}
{contents of helper.py}
<|file_sep|>{path/to/notebook_cell}
<|fim_prefix|>{prefix}<|fim_suffix|>{suffix}<|fim_middle|>

💡 In practice you don't assemble this by hand — the CellSense JupyterLab plugin builds the repository-, import-, and task-aware context and emits exactly this format (see Serving with vLLM + CellSense below).

Transformers

from transformers import AutoModelForCausalLM, AutoTokenizer

model_id = "arun11karthik/cellsense-fim-0.5b"
tokenizer = AutoTokenizer.from_pretrained(model_id)
model = AutoModelForCausalLM.from_pretrained(model_id, device_map="auto")

prefix = "import pandas as pd\ndf = pd.read_csv('data.csv')\n"
suffix = "\ndf.head()\n"
prompt = f"<|fim_prefix|>{prefix}<|fim_suffix|>{suffix}<|fim_middle|>"

inputs = tokenizer(prompt, return_tensors="pt").to(model.device)
out = model.generate(**inputs, max_new_tokens=128, do_sample=False)
print(tokenizer.decode(out[0][inputs.input_ids.shape[1]:], skip_special_tokens=True))

Serving with vLLM + CellSense

The intended way to use this model is to serve it with vLLM and point the CellSense JupyterLab plugin at the server over its OpenAI-compatible API. CellSense handles all of the repository-, import-, and task-aware context assembly and the FIM prompt formatting for you.

1. Serve the model with vLLM

vLLM exposes an OpenAI-compatible endpoint, which is exactly what CellSense's openai_compatible provider expects:

pip install vllm

vllm serve arun11karthik/cellsense-fim-0.5b \
  --served-model-name cellsense-fim-0.5b \
  --max-model-len 32768 \
  --port 8000

This serves the API at http://localhost:8000/v1.

2. Point CellSense at the vLLM server

In the CellSense settings panel (left sidebar in JupyterLab), open Basic Settings and configure the OpenAI Compatible provider:

Setting	Value
Provider	OpenAI Compatible
Base URL	http://localhost:8000/v1
API Key	any non-empty string (vLLM ignores it, e.g. EMPTY)
Model	cellsense-fim-0.5b (must match --served-model-name)
Model Family	qwen2.5-coder

Click Save & Apply, then start typing in a notebook cell — ghost-text completions from your local model appear inline. Press Tab to accept.

🌐 The same setup works for a remote vLLM server: serve the model on your GPU box, expose port 8000, and set CellSense's Base URL to http://<host>:8000/v1.

Raw API check (optional)

To confirm the endpoint works before wiring up CellSense, query it directly with the FIM prompt:

curl http://localhost:8000/v1/completions \
  -H "Content-Type: application/json" \
  -d '{
    "model": "cellsense-fim-0.5b",
    "prompt": "<|fim_prefix|>import pandas as pd\ndf = pd.read_csv(\"data.csv\")\n<|fim_suffix|>\ndf.head()\n<|fim_middle|>",
    "max_tokens": 128,
    "temperature": 0.0
  }'

Ollama

For fully local, no-GPU-required inference, GGUF builds are published at arun11karthik/cellsense-fim-0.5b-GGUF. Ollama can pull and run these directly from the Hugging Face Hub — no manual download or Modelfile required. This is the recommended path for running CellSense entirely on your own machine: with Ollama, no code or context ever leaves your computer.

Available quantizations

Quantization	Size (approx.)	Notes	Pull with
Q5_K_M	~420 MB	Good quality / size trade-off	ollama run hf.co/arun11karthik/cellsense-fim-0.5b-GGUF:Q5_K_M
Q8_0	~531 MB	Near-lossless 8-bit quantization	ollama run hf.co/arun11karthik/cellsense-fim-0.5b-GGUF:Q8_0
BF16	~994 MB	Full bfloat16 precision — highest quality (recommended)	ollama run hf.co/arun11karthik/cellsense-fim-0.5b-GGUF:BF16

1. Install Ollama and pull the model

Install Ollama, then pull a quantization (this also registers the model so CellSense can use it):

ollama pull hf.co/arun11karthik/cellsense-fim-0.5b-GGUF:Q5_K_M

By default Ollama serves its API at http://localhost:11434. The model name as it appears in ollama list — hf.co/arun11karthik/cellsense-fim-0.5b-GGUF:Q5_K_M — is what you'll enter into CellSense below.

2. Install the CellSense JupyterLab plugin

pip install jupyterlab-cellsense
jupyter lab

See the CellSense repository for full installation options.

3. Point CellSense at your local Ollama model

Open the CellSense panel from the left sidebar in JupyterLab, go to Basic Settings, and configure the Ollama provider:

Setting	Value
Provider	Ollama
Base URL	http://localhost:11434
Model Family	cellsense
Model	hf.co/arun11karthik/cellsense-fim-0.5b-GGUF:Q5_K_M (must match the tag in ollama list)

✅ Set Model Family to cellsense. CellSense now ships first-class support for the CellSense-FIM models, so the plugin builds prompts in exactly the repository-, import-, and task-aware FIM format these models were trained on — no extra configuration needed.

Click Save & Apply, then start typing in a notebook cell — ghost-text completions from your local model appear inline. Press Tab to accept.

Raw API check (optional)

To confirm Ollama is serving the model with the correct FIM format before wiring up CellSense, query it directly:

curl http://localhost:11434/api/generate -d '{
  "model": "hf.co/arun11karthik/cellsense-fim-0.5b-GGUF:Q5_K_M",
  "prompt": "<|fim_prefix|>import pandas as pd\ndf = pd.read_csv(\"data.csv\")\n<|fim_suffix|>\ndf.head()\n<|fim_middle|>",
  "stream": false,
  "options": { "temperature": 0.0, "num_predict": 128 }
}'

Training

• Base model: Qwen/Qwen2.5-Coder-0.5B
• Dataset: the private CellSense FIM dataset — repository-, local-import-, and task-aware FIM examples mined from Jupyter notebooks
• Objective: fill-in-the-middle (FIM) code completion
• Context length: 32,768 tokens
• Checkpoint: best-validation checkpoint

Training data & privacy

CellSense-FIM was fine-tuned on a private corpus of fill-in-the-middle examples mined from Jupyter notebooks. The dataset is kept private as a precaution: PII masking was applied across the corpus and more rigororusly verified on the sampled subset used for training, but full masking across the entire source corpus has only been preliminarily checked and is not guaranteed.

As with any model trained on scraped code, this model may reproduce content from its training data, including any imperfectly masked sensitive strings. If you observe any leakage, please report it via the project's issue tracker (see the GitHub link above).

License

The finetuned weights are released under the GNU 3.0 License, whereas the base model was released under the Apache 2.0 license.

Citation

@misc{cellsense-fim,
  title  = {CellSense-FIM: Notebook-Native Fill-in-the-Middle Code Completion},
  author = {Arun Karthik},
  year   = {2026},
  howpublished = {\url{https://huggingface.co/arun11karthik/cellsense-fim-0.5b}}
}