Hugging Face's logo

usernamebetter
/
nanocoder-v1.2

Safetensors
Model card Files
xet
 Community

YAML Metadata Warning:empty or missing yaml metadata in repo card

Check out the documentation for more information.

Model Card for Model ID: usernamebetter/nanocoder-v1.2

Model Details

  • Developed by: Independent developer (usernamebetter) — personal DIY AI / web / game projects. Approximate location: thị xã Quảng Trị, region Quang Tri / Gia Lai, VN. No institutional affiliation.
  • Funded by [optional]: None. Zero-budget / DIY ethos across all projects. Uses only free-tier cloud GPU infrastructure (Kaggle T4, Google Colab) and low-spec local hardware (Intel i3-7020U, Intel HD 620, 4GB RAM).
  • Shared by [optional]: usernamebetter — via Hugging Face Hub.
  • Model type: Causal Language Model — fine-tuned adapter (PEFT / LoRA / QLoRA) for code generation assistance, focused on web development.
  • Language(s) (NLP): Primarily English (source dataset and code output); user communicates casually in Vietnamese with English technical terms mixed in (JS, HTML, CSS, QLoRA, LoRA, Colab, T4).
  • License: MIT (recommended — open for independent/DIY use; please confirm explicitly when forking or deploying commercially). No enterprise warranty.
  • Finetuned from model [optional]: Qwen/Qwen3-4B (Qwen3-4B — dense 4B parameter model).

Model Sources [optional]

  • Repository: https://huggingface.co/usernamebetter/nanocoder-v1.2
  • Paper [optional]: None — independent personal project (Vantix pipeline / NanoCoder series). No academic publication.
  • Demo [optional]: No public demo deployed. Inference intended for local low-spec (Intel i3-7020U, 4GB RAM) or cloud GPU (Colab T4) via adapter loading code below.

Uses

Direct Use

This adapter (nanocoder-v1.2) is intended to be loaded on top of the base Qwen/Qwen3-4B model using the PEFT library (peft). It specializes in web-development code generation (JS, HTML, CSS, TypeScript, JSX, React, Next.js, Tailwind, FastAPI, Express, MongoDB, Redis, Docker).

Best practices:

  • Load adapter with PeftModel.from_pretrained("usernamebetter/nanocoder-v1.2", base_model="Qwen/Qwen3-4B").
  • For production or interactive use, use a GPU (Colab T4 or better) or quantize base model (4-bit) for CPU inference on low-spec hardware.
  • Always review generated backend/API code for security gaps — benchmark shows weaknesses in express_rate_limit (40%), redis_cache (60%), and sql_injection (55%).

Quick start:

from transformers import AutoModelForCausalLM, AutoTokenizer
from peft import PeftModel

# Load base (use quantized config for T4 / low-spec)
base = AutoModelForCausalLM.from_pretrained(
    "Qwen/Qwen3-4B",
    torch_dtype=torch.bfloat16,
    device_map="auto",
    trust_remote_code=True,
)

# Load adapter
model = PeftModel.from_pretrained(base, "usernamebetter/nanocoder-v1.2")

# Tokenizer
tokenizer = AutoTokenizer.from_pretrained("Qwen/Qwen3-4B", trust_remote_code=True)

Note: The exact class name for Qwen3-4B may vary; AutoModelForCausalLM is the safe generic loader. If you previously used unsloth for V2, note that leftover monkey-patches (_safe_bwd) must be removed and kernel restarted before importing.

Downstream Use [optional]

  • Adapter merge: You can merge adapter weights into the base model (model.merge_and_unload()) for faster inference without PEFT overhead.
  • Deployment context: Suitable for personal/independent developer workflows; can be hosted locally (Intel HD 620 / 4GB RAM requires quantized base) or in cloud notebooks (Colab / Kaggle free-tier).
  • Integration: Designed to work with transformers + peft pipeline; vision/interleaved image adapter (usernamebetter/e-text fine-tuning for V3 (Qwen3.5-4B) will require a separatnanocoder-v3-qwen35-vision, planned).
  • Not intended for: General chat/conversation (use Qwen base for that), multilingual translation outside web-code domain, or non-code creative writing.

Out-of-Scope Use

This model and adapter are not certified for the following uses. Independent evaluation and additional safeguards are required before any such deployment:

  • Enterprise production APIs without additional security review (backend benchmark regression observed: express_rate_limit, redis_cache, sql_injection gaps).
  • Medical, legal, financial, or high-stakes decision-making — output is code-generation only, not advice.
  • Commercial deployment at scale — adapter was trained on free-tier GPU with session limits (~5h30p); no formal audit or enterprise support available.
  • Vision / screenshot-to-code tasks — not supported by V1.2 adapter; upgrade to planned V3 (Qwen3.5-4B base, vision encoder) required.
  • Non-English natural language generation outside code context — dataset and fine-tuning focus exclusively on web-dev code patterns.

Bias, Risks, and Limitations

  • Dataset bias: Trained on CodeFeedback-Filtered-Instruction (~14,911 filtered instruction samples). This reflects open-source web code patterns, which may include insecure practices, outdated syntax, or biased representation of web frameworks (React/Next.js dominant; vanilla JS or niche stacks under-represented).
  • Benchmark regression (Backend): Score dropped from V1 (87.5%) to V2 (81.9%). Specific gaps: express_rate_limit (40%), redis_cache (60%), sql_injection (55%). This indicates the adapter may miss middleware/auth patterns and database optimization logic compared to the previous version.
  • Limited session / convergence: Training executed on Kaggle free T4 GPU with observed session limits (~29h CPU / ~5h30p GPU, consistent across 3 different accounts). Only 500 training steps completed (final loss ~0.81). Full convergence for all sub-domains (especially backend/API) likely requires longer training or larger dataset.
  • No vision capability: Adapter contains only text/code LoRA weights. UI/screenshot understanding and image-to-code generation require V3 (Qwen3.5-4B) with interleaved vision tokens.
  • Monkey-patch dependency (historical): Previous V2 training used unsloth with a custom _safe_bwd monkey-patch (unsloth.kernels.fast_lora). This patch must be fully removed (kernel restart required) before loading adapter in a new environment; leftover patches cause RuntimeError: self and mat2 must have the same dtype, but got Half and Float.
  • Security: Generated backend code must be manually reviewed. Benchmark results show that rate-limiting, caching TTL, SQL parameterization, and authentication patterns are not consistently reproduced.
  • Hardware constraints: Local development uses Intel i3-7020U, Intel HD 620, 4GB RAM — sufficient for adapter loading with 4-bit quant base, but inference speed is slow. Real-time interactive use requires cloud GPU or stronger local hardware.
  • DIY / zero-budget: No institutional review, no formal safety evaluation, no warranty. User must take full responsibility for any deployment or downstream integration.

Recommendations

Users (both direct and downstream) should be made aware of the following:

  1. Always restart the kernel (Colab: Runtime > Restart runtime; Kaggle: restart session) after removing any previous monkey-patches or cell changes. Re-run cell alone is insufficient for clearing leftover _safe_bwd patches.
  2. Revoke and replace any hardcoded Hugging Face token from previous sessions. Use Colab Secrets (userdata.get('HF_TOKEN')) or manual input — never commit tokens to files.
  3. Never add os.kill(os.getpid(), 9) to install or training cells — it crashes non-interactive environments (Papermill / Kaggle Save & Commit).
  4. Load adapter correctly: Use PeftModel.from_pretrained() with the base Qwen3-4B model. Do not attempt to load V1.2 adapter onto Qwen3.5-4B; architecture differences (vision encoder, vocab) will cause errors.
  5. Review all backend/API output for missing security patterns (next, 429, retry-after, ttl, expire, :email, text(, etc.). Benchmark details are fully documented below.
  6. For vision / screenshot -> code features, wait for or migrate to the planned V3 adapter (Qwen3.5-4B base, interleaved vision-text training, Colab T4 optimized).
  7. For commercial or production use, perform independent security auditing, dataset expansion (add backend-focused samples if regression needs fixing), and extended training (beyond 500 steps) before deploying.

How to Get Started with the Model

Use the code below to load and use the adapter. Ensure you have transformers, peft, torch, and bitsandbytes installed.

import torch
from transformers import AutoModelForCausalLM, AutoTokenizer
from peft import PeftModel

# 1. Define adapter and base
adapter_id = "usernamebetter/nanocoder-v1.2"
base_model_id = "Qwen/Qwen3-4B"

# 2. Load base model (4-bit quant recommended for T4 / low-spec)
base = AutoModelForCausalLM.from_pretrained(
    base_model_id,
    torch_dtype=torch.bfloat16,
    device_map="auto",
    trust_remote_code=True,
)

# 3. Load adapter
model = PeftModel.from_pretrained(base, adapter_id)

# 4. Tokenizer
tokenizer = AutoTokenizer.from_pretrained(base_model_id, trust_remote_code=True)

# 5. Example inference (web code generation)
inputs = tokenizer(
    "Generate a responsive React component with Tailwind CSS for a user profile card.",
    return_tensors="pt"
)
with torch.no_grad():
    outputs = model.generate(**inputs, max_length=1024)
print(tokenizer.decode(outputs[0], skip_special_tokens=True))

Environment reminder: If running in Colab or Kaggle, restart the runtime before importing to avoid leftover _safe_bwd patches from previous unsloth sessions.

Training Details

Training Data

  • Primary dataset: CodeFeedback-Filtered-Instruction — approximately 14,911 filtered instruction samples focused on web development coding (JS, HTML, CSS, TypeScript, JSX, React, Next.js, Tailwind, backend APIs, agent debugging patterns).
  • Dataset format: Instruction-following pairs (instruction / response) formatted for causal LM fine-tuning.
  • Filtering: Filtered from larger CodeFeedback corpus; selected for web-focused, practical coding tasks (not theoretical computer science or general conversation).
  • Vision data: None included in V1.2 adapter. Planned addition for V3: Design2Code (open dataset) or synthetic vision pairs (rendered HTML screenshots paired with source code, generated via headless browser / Playwright).
  • Dataset sources (planned for V3 expansion): TheStack (subset: JS / HTML / CSS), CodeSearchNet, synthetic screenshot-to-code pairs.

Training Procedure

  • Preprocessing [optional]:

    • Tokenization with Qwen3 tokenizer (AutoTokenizer.from_pretrained("Qwen/Qwen3-4B")).
    • Sequence length capped at 2,048 tokens (MAX_SEQ_LENGTH = 2048).
    • No vision/token interleaving for V1.2 (text-only). V3 will use interleaved image (<image>) + text tokens via processor.
    • No special data augmentation applied (DIY / zero-budget approach — direct dataset usage).

  • Training Hyperparameters:

    • Training regime: Fine-tuning (adapter-based / PEFT / LoRA) — not full-model pre-training.
    • Base model: Qwen3-4B (dense 4B parameters, pre-trained by Qwen team).
    • Quantization: 4-bit (nf4) via bitsandbytes for base model weights during training (bnb_4bit_use_double_quant=True).
    • Adapter config: LoRA (r=64, alpha=128, dropout=0.05).
    • Target modules: q_proj, k_proj, v_proj, o_proj, gate_proj, up_proj, down_proj.
    • Epochs: 1
    • Training steps: 500
    • Batch size (per device): 1
    • Gradient accumulation: 8 (effective batch ~8)
    • Learning rate: 2e-4
    • Optimizer: paged_adamw_8bit (memory-efficient 8-bit AdamW)
    • Scheduler: Default (linear decay with warmup — standard TrainingArguments behavior)
    • Precision: bfloat16 (torch.bfloat16)
    • Mixed precision: fp16=False, bf16=True
    • Checkpointing: Save every 50 steps (save_steps=50); max 2 checkpoints retained (save_total_limit=2).
    • Evaluation during training: Not performed (no evaluation dataset configured for V2; user can add eval_dataset for future runs).

  • Speeds, Sizes, Times [optional]:

    • Adapter size: Small (LoRA weights only — MB range, substantially smaller than 4B base model).
    • Training session time: Training completed within a single Kaggle free-tier GPU session (~5h30p observed limit consistent across 3 different Google accounts with varying usage history). Benchmark evaluation runtime: ~12.5 minutes.
    • Inference speed: Depends on base model load + adapter overhead. On T4 GPU: fast for 2k-token sequences. On local Intel i3-7020U + Intel HD 620 (4GB RAM): slow but functional with 4-bit quantized base.
    • Environment: Kaggle Notebooks (Qwen3-4B, free T4) / Google Colab T4 (planned for V3). User notes consistent session limits (~29h CPU, ~5h30p GPU) across accounts.

Evaluation

Testing Data, Factors & Metrics

  • Testing Data:

    • HumanEval (50 Python coding problems) — standard benchmark for code generation.
    • Custom Skill Benchmarks (8 sub-tests per category):
      • Frontend: react_hydration, tailwind_responsive, ts_debounce, a11y_button, nextjs_api_route, react_error_boundary, zustand_store, css_flexbox.
      • Backend: fastapi_jwt, postgres_query, express_rate_limit, async_retry, redis_cache, docker_compose, mongoose_schema, sql_injection.
      • Agent: fix_undefined_map, fix_n1_query, fix_422_fastapi, fix_memory_leak, fix_infinite_loop, fix_sql_injection.
      • Reasoning: binary_search, dp_knapsack, lru_cache_impl, merge_intervals, sliding_window, two_sum, dijkstra, kadane.
    • All test data derived from web-development and agent debugging scenarios, consistent with training domain.

  • Factors:

    • Task diversity: Frontend UI replication, backend API construction, agent debugging (undefined variables, SQL injection fixes, memory leaks, infinite loops), and algorithmic reasoning (search, DP, graph, sliding window).
    • Difficulty: Mix of basic (css_flexbox, two_sum) to complex (react_error_boundary, dijkstra, redis_cache).
    • Output format: Code blocks (html, css, js, python, ts, jsx) expected; partial matches evaluated by manual inspection or automated similarity scoring.

  • Metrics:

    • Pass@1 — single-attempt correctness rate (HumanEval).
    • Sub-test accuracy — percentage of correct outputs per sub-test (Skill Benchmarks).
    • Category average — arithmetic mean of sub-test accuracies within category.
    • Combined average — arithmetic mean of category averages.
    • Delta (Δ) — change from previous version (V1) for comparative tracking.

Results

Benchmark runtime: 12.5 min
Results saved to: /kaggle/working/benchmark_v2.json
Adapter uploaded: usernamebetter/nanocoder-v1.2

HumanEval (Pass@1) — 78.0% (39/50)

Problem ID Status Time (s)
HE/0 ✗ 5.8
HE/1 ✓ 11.6
HE/2 ✓ 2.0
HE/3 ✓ 4.3
HE/4 ✓ 7.6
HE/5 ✗ 8.2
HE/6 ✗ 14.8
HE/7 ✓ 7.5
HE/8 ✓ 8.8
HE/9 ✓ 7.2
HE/10 ✗ 8.5
HE/11 ✓ 5.9
HE/12 ✓ 7.2
HE/13 ✓ 3.5
HE/14 ✓ 5.2
HE/15 ✓ 2.9
HE/16 ✓ 2.1
HE/17 ✓ 13.1
HE/18 ✓ 6.2
HE/19 ✗ 4.4
HE/20 ✓ 15.1
HE/21 ✓ 11.3
HE/22 ✓ 5.9
HE/23 ✓ 3.9
HE/24 ✓ 6.0
HE/25 ✓ 11.4
HE/26 ✗ 6.9
HE/27 ✓ 1.9
HE/28 ✓ 4.1
HE/29 ✗ 7.3
HE/30 ✓ 10.8
HE/31 ✓ 10.2
HE/32 ✓ 18.7
HE/33 ✗ 10.7
HE/34 ✓ 9.8
HE/35 ✓ 3.9
HE/36 ✗ 5.3
HE/37 ✗ 7.9
HE/38 ✓ 8.6
HE/39 ✗ 20.3
HE/40 ✓ 18.0
HE/41 ✓ 3.8
HE/42 ✓ 2.4
HE/43 ✓ 4.2
HE/44 ✓ 11.2
HE/45 ✓ 4.8
HE/46 ✓ 8.2
HE/47 ✓ 5.8
HE/48 ✓ 2.1
HE/49 ✓ 6.2

Skill Benchmarks — Category Breakdown

FRONTEND — 82.5% (Avg)

Sub-test Score Time (s) Notes / Missing Elements
react_hydration 2/4 (55%) 7.3 ['null', 'window']
tailwind_responsive 3/4 (75%) 16.9 ['md:grid-cols-2']
ts_debounce 4/4 (100%) 10.1 —
a11y_button 3/4 (80%) 10.2 ['type=']
nextjs_api_route 4/4 (100%) 9.5 —
react_error_boundary 3/4 (75%) 10.8 ['getderivedstatefromgror']
zustand_store 3/4 (75%) 21.7 ['usestore']
css_flexbox 4/4 (100%) 8.8 —

BACKEND — 81.9% (Avg) — Regression from V1 (87.5% → 81.9%, Δ = -5.6%)

Sub-test Score Time (s) Notes / Missing Elements
fastapi_jwt 5/5 (100%) 33.2 —
postgres_query 5/5 (100%) 3.6 —
express_rate_limit 2/5 (40%) 5.9 ['next', '429', 'retry-after']
async_retry 5/5 (100%) 18.7 —
redis_cache 3/5 (60%) 9.1 ['ttl', 'expire']
docker_compose 5/5 (100%) 22.4 —
mongoose_schema 5/5 (100%) 8.1 —
sql_injection 2/4 (55%) 5.2 [':email', 'text(']

AGENT — 89.2% (Avg) — Improvement from V1 (75.0% → 89.2%, Δ = +14.2%)

Sub-test Score Time (s) Notes / Missing Elements
fix_undefined_map 2/4 (55%) 7.8 ['default', 'items = []']
fix_n1_query 4/4 (100%) 7.9 —
fix_422_fastapi 4/4 (100%) 8.1 —
fix_memory_leak 4/4 (100%) 8.0 —
fix_infinite_loop 3/4 (80%) 4.7 ['deps']
fix_sql_injection 4/4 (100%) 8.0 —

REASONING — 96.2% (Avg) — New benchmark for V2 (no V1 baseline)

Sub-test Score Time (s) Notes / Missing Elements
binary_search 5/5 (100%) 14.5 —
dp_knapsack 5/5 (100%) 14.3 —
lru_cache_impl 5/5 (100%) 19.2 —
merge_intervals 5/5 (100%) 13.8 —
sliding_window 5/5 (100%) 13.1 —
two_sum 5/5 (100%) 12.8 —
dijkstra 4/5 (85%) 19.6 ['o(']
kadane 4/5 (85%) 10.6 ['max_sum']

Delta Summary (V1 → V2)

Metric V1 V2 Δ
HumanEval (Pass@1) 49.4% 78.0% +28.6%
Frontend 58.3% 82.5% +24.2%
Backend 87.5% 81.9% -5.6% (regression)
Agent 75.0% 89.2% +14.2%
Reasoning n/a 96.2% new
  • Combined (V2): 82.7%
  • Skill avg (V2): 87.4%
  • Bench runtime: 12.5 min

Summary

usernamebetter/nanocoder-v1.2 is a fine-tuned adapter (QLoRA / PEFT) built independently by a DIY developer (usernamebetter) for web-focused code generation (JS / HTML / CSS / TS / JSX). It achieves strong results on HumanEval (+28.6% vs V1), Frontend (+24.2%), Agent (+14.2%), and introduces a new Reasoning benchmark (96.2%). Backend performance regressed (-5.6%), which the developer plans to address in future iterations (dataset expansion, longer training, or new base model). The adapter reflects a zero-budget, free-tier GPU training ethos (Kaggle T4, session limits observed ~5h30p) and is shared openly for independent use with full transparency of limitations, benchmark gaps, and planned upgrades (Qwen3.5-4B vision adapter for V3).

Model Examination [optional]

No formal model audit or external evaluation performed — independent personal project. All benchmark results, training details, dataset sources, and limitations are fully documented above for user review and downstream verification. If you use this adapter, please verify outputs independently and consider contributing benchmark improvements or dataset expansions back to the developer's workflow (Vantix pipeline / future V3 adapter).

Environmental Impact

Carbon emissions can be estimated using the Machine Learning Impact calculator presented in Lacoste et al. (2019).

  • Hardware Type: Training: NVIDIA T4 GPU (Kaggle free-tier, 16GB VRAM).
  • Cloud Provider: Kaggle Notebooks (Google Cloud backend) for training; Google Colab (free-tier T4) planned for V3.
  • Carbon Emitted: Not formally calculated. Relative impact is low (adapter fine-tuning of 500 steps on 4-bit quantized base model, not full-scale pre-training). Independent developers using free-tier infrastructure contribute minimal carbon footprint compared to large-scale commercial pre-training runs.

Technical Specifications [optional]

Model Architecture and Objective

  • Base architecture: Dense Transformer (Qwen3-4B — Qwen team's 4B parameter dense model with enhanced vocabulary and attention structure).
  • Adapter architecture: LoRA (r=64, alpha=128, dropout=0.05) inserted into projection and gate modules (q_proj, k_proj, v_proj, o_proj, gate_proj, up_proj, down_proj). Adapter weights saved as .safetensors + adapter_config.json.
  • Objective: Causal language modeling (Causal LM) — next-token prediction fine-tuned on instruction-following web code dataset.
  • Vision architecture (planned V3): Qwen3.5-4B uses a natively multimodal architecture with an integrated vision tower (Qwen3-VL encoder reuse), interleaved text-image-video token training, and hybrid attention (Gated DeltaNet + Gated Attention 3:1 ratio). Adapter for V3 will require vision-compatible PEFT setup.

Compute Infrastructure

  • Training environment: Kaggle Notebooks (free-tier, T4 GPU, 5h30p session limit observed). User explicitly plans to migrate to Colab T4 for V3 due to consistent session length observations (`29hCPU /~5h30p` GPU) across different accounts.
  • Development environment: Personal low-spec laptop for code editing, dataset inspection, and adapter loading tests.
  • Storage: Checkpoint saved locally at /kaggle/working/benchmark_v2.json and adapter uploaded to Hugging Face (usernamebetter/nanocoder-v1.2).

Hardware

  • Training GPU: NVIDIA T4 (16GB VRAM) — sufficient for Qwen3-4B with bitsandbytes 4-bit quantization + LoRA adapter (batch=1, max_len=2048).
  • Memory: 4GB RAM local; 16GB VRAM cloud. Gradient accumulation (8) used to simulate larger batch on limited VRAM.

Software

  • OS / Runtime: Linux-based (Colab / Kaggle notebooks)
  • Python: 3.11+ (Colab default / Kaggle environment).
  • PyTorch: 2.x (cu121 index — CUDA 12.1).
  • Key libraries:
    • transformers (model loading, tokenizer, Trainer, TrainingArguments)
    • peft (0.19.1) — adapter management (LoraConfig, PeftModel, prepare_model_for_kbit_training)
    • bitsandbytes (4-bit quantization: nf4, bnb_4bit_use_double_quant=True)
    • datasets (dataset loading and mapping for interleaved vision-text or text-only)
    • unsloth (used for V2 training — note historical monkey-patch dependency; must be cleaned/restarted for V3 vision pipeline)
    • PIL (Pillow) — image loading for planned vision dataset
    • numpy (version compatibility must be verified — previous V2 had numpy mismatch errors during environment setup)
  • Code repository (pipeline): Vantix (user's fine-tuning pipeline for web-focused coding assistant, Unsloth + QLoRA). NanoCoder adapter (v1.2) produced by this pipeline.

Citation [optional]

No academic citation applies — independent DIY personal project. Reference the adapter and developer profile when using or discussing:

APA:

Independent Developer (usernamebetter). (2026). NanoCoder V1.2: A fine-tuned web-development code adapter (Qwen3-4B + QLoRA) [Adapter weights]. Hugging Face. https://huggingface.co/usernamebetter/nanocoder-v1.2

Glossary [optional]

  • Adapter / PEFT: Parameter-Efficient Fine-Tuning. Only a small subset of weights (LoRA) is updated; base model remains frozen/quantized.
  • QLoRA: Quantized LoRA — 4-bit quantized base (nf4) + LoRA adapter, allowing fine-tuning of 4B models on 16GB VRAM (T4).
  • LoRA (r, alpha, dropout): Low-Rank Adaptation hyperparameters. r=64, alpha=128 used for V1.2.
  • PEFT library: Python package (peft 0.19.1) for loading, merging, and managing adapter weights.
  • HumanEval: Standard benchmark of 50 Python programming problems measuring Pass@1 (first-attempt correctness).
  • Skill Benchmarks: Custom evaluation suite with sub-tests for frontend (React, Tailwind, Next.js), backend (FastAPI, Express, Postgres, MongoDB, Redis, Docker), agent debugging (undefined, memory leak, SQL injection fixes), and reasoning (search, DP, graph, sliding window).
  • Colab T4 / Kaggle T4: Free-tier NVIDIA T4 GPU (16GB VRAM) provided by Google Colab and Kaggle Notebooks. User reports consistent session length limits (~29h CPU, ~5h30p GPU) across different accounts.
  • Unsloth: Optimization library for faster LLM fine-tuning. Used in V2; historical monkey-patch (_safe_bwd) must be removed for clean V3 vision training.
  • Vantix: User's personal fine-tuning pipeline (Unsloth + QLoRA, web-focused dataset, Kaggle T4 target). Produces NanoCoder adapter series.
  • Ledger of Collapse: Related personal web project — React multi-page site with dark declassified dossier aesthetic (separate from adapter work, reflects user's DIY design ethos).

More Information [optional]

  • Related adapter / upgrade (planned V3): usernamebetter/nanocoder-v3-qwen35-vision (not yet uploaded; planned base Qwen3.5-4B, vision encoder, interleaved image-text dataset, Colab T4 optimized).
  • Related pipeline: Vantix — user's independent fine-tuning pipeline for training web-focused coding assistants using Unsloth + QLoRA on Kaggle free T4.
  • Related web project: Ledger of Collapse — React multi-page forensic/editorial website with dark declassified dossier aesthetic (logo_nano.png designed with matching style).
  • Development notes: User explicitly requests concise, direct interaction; full details provided upon request (full các cell cần sửa). Preferred address forms: bạn / mình; never mày / tao. Communication language: Vietnamese casual + English technical terms.
  • Dataset expansion plans: User expressed willingness (cũng oke nma thêm cái nguồn khác) to add new data sources. Proposed additions: Design2Code (vision-to-web), synthetic screenshot dataset (rendered HTML via headless Playwright), TheStack subset (JS / HTML / CSS), CodeSearchNet.
  • Future hardware / session strategy: User plans to use Colab for V3 training, citing consistent free-tier limits (~29h CPU / ~5h30p GPU). This implies session splitting, checkpoint resumption (save_steps=50), and multi-session training for longer runs.
  • Logo / branding: logo_nano.png (AI-generated) — dark declassified dossier aesthetic, cyan/amber neural brain + terminal cursor (>_), monospace nanocoder typography, classified stamps (CLASSIFIED — WEB INTELLIGENCE), grid lines. Matches user's Ledger of Collapse design language.

Model Card Authors [optional]

  • Primary author: Independent developer (usernamebetter) — personal AI, web development, and game development projects. Approximate location: thị xã Quảng Trị, Quang Tri / Gia Lai, VN. Communicates casually in Vietnamese (bạn/mình) with English technical terms mixed in.
  • No co-authors or institutional affiliations.

Model Card Contact

Framework versions

  • PEFT: 0.19.1 (as noted in original template; adapter saved with compatible LoraConfig)
  • transformers: Compatible with Qwen2.5 / Qwen3 / Qwen3.5 series (AutoModelForCausalLM, AutoTokenizer, Qwen3_5ForConditionalGeneration for V3 base)
  • PyTorch: 2.x (torch) with CUDA 12.1 (cu121 index)
  • bitsandbytes: 4-bit quantization (bnb_config with load_in_4bit=True, nf4, bf16 compute)
  • datasets: datasets library (load_dataset, Dataset, map for interleaved processing)
  • unsloth: Used historically for V2 training (unsloth[colab-new]). Note: must clean leftover monkey-patches (_safe_bwd) before V3 vision fine-tuning; consider using standard transformers + peft for vision interleaved if Unsloth compatibility is unverified.
  • numpy: Version compatibility must be verified (previous V2 debugging included numpy mismatch errors during environment installation).
  • Pillow / PIL: Pillow — image loading for vision dataset (planned V3).
Downloads last month

-

Downloads are not tracked for this model. How to track
Inference Providers NEW
This model isn't deployed by any Inference Provider. 🙋 Ask for provider support