GLM-5.3 is live. Run Z.ai's latest model on Friendli Model APIs. Try it today ➜
ShindeGaurav-2207
Available on FriendliAI
Run this model inference on single tenant GPU with unmatched speed and reliability at scale.
Run this model inference with full control and performance in your environment.
Model Details
Model Provider
ShindeGaurav-2207
Model Tree
meta-llama/Llama-3.2-3B-Instruct
Input Modalities
Output Modalities
Supported Functionality
SQL2NL converts SQL queries into plain-English explanations of business intent. It identifies key metrics, dimensions, filters, and time windows; describes JOINs as business relationships ("customers linked to their orders"); interprets CTEs as logical analytical steps; and renders window functions as comparative analytics ("ranking customers by lifetime value"). Output is restricted to executive-friendly language with no SQL jargon.
uvicorn src.app:app)Prompt the model with a SQL query using the Llama 3 chat template it was fine-tuned on:
markdown
<|begin_of_text|><|start_header_id|>system<|end_header_id|>Translate the SQL query into an executive-level business logic description.No SQL jargon. Under 150 words.<|eot_id|><|start_header_id|>user<|end_header_id|>SQL Query:```sqlWITH customer_revenue AS (SELECT c.customer_id, SUM(o.total_amount) AS ltvFROM customers c JOIN orders o ON c.customer_id = o.customer_idWHERE o.order_date >= '2024-01-01'GROUP BY c.customer_id)SELECT customer_id, RANK() OVER (ORDER BY ltv DESC) AS rnk FROM customer_revenue
Business Logic Description:<|eot_id|><|start_header_id|>assistant<|end_header_id|>
markdown
Stop tokens: `<|eot_id|>`, `<|end_of_text|>`. For best fidelity use the original training system prompt ("*You are a SQL-to-plain-language translator…*") — see the training notebook in the repository. Typical output style: *"How many heads of the departments are older than 56?"*### Downstream Use<!-- This section is for the model use when fine-tuned for a task, or when plugged into a larger ecosystem/app -->Ships as part of the [SQL2NL project](https://github.com/ShindeGaurav-2207/SQL2NL): a `ModelManager` singleton with automatic Hugging Face Hub download, a `llama-cpp-python` inference engine, a FastAPI endpoint (`POST /v1/translate`) with Pydantic contracts, an Ollama `Modelfile`, and a quantitative evaluation harness (`eval/evaluate.py`).### Out-of-Scope Use<!-- This section addresses misuse, malicious use, and uses that the model will not work well for. -->The model does not generate SQL, optimize queries, execute anything, or know actual data values. It must not be used as an audited specification of query behavior — descriptions are informed guesses about intent that should be validated against execution results. DDL/DML translation and non-English input are out of distribution.## Bias, Risks, and Limitations<!-- This section is meant to convey both technical and sociotechnical limitations. -->- English only; trained on analytical SELECT queries.- May hallucinate table/column semantics when names are ambiguous (e.g., guessing that `status = 'X'` implies a specific business state).- Inherits biases of the Llama 3.2 base model.- Window-function and nested-CTE descriptions are strongest; very long (>200-line) queries may exceed reliable attention.- Explanations reflect plausible intent, not guaranteed semantics.### Recommendations<!-- This section is meant to convey recommendations with respect to the bias, risk, and technical limitations. -->Users (both direct and downstream) should treat outputs as documentation drafts, not ground truth, and verify against actual query behavior before acting on them.## How to Get Started with the ModelUse the code below to get started with the model.```pythonfrom transformers import pipelineimport torchpipe = pipeline("text-generation",model="ShindeGaurav-2207/SQL2NL",torch_dtype=torch.float16,device_map="auto",)messages = [{"role": "system", "content": "Translate the SQL query into executive-level business logic. No SQL jargon."},{"role": "user", "content": f"SQL Query:\n```sql\n{sql}\n```\n\nBusiness Logic Description:"},]print(pipe(messages, max_new_tokens=256)[0]["generated_text"][-1]["content"])
A curated set of 1,500 SQL → plain-language explanation conversations, generated via TuneKit and embedded in the training notebook (notebooks/finetune_llama32_sql_explanations.ipynb). Every example is a (system, user, assistant) triplet:
Fine-tuned with Unsloth (v2026.8.19) using QLoRA: the base model is loaded in 4-bit quantization (load_in_4bit=True, max sequence length 2048) while LoRA adapters train. Adapters were subsequently merged into the base weights and exported as merged 16-bit safetensors (~6.4 GB) plus a Q4_K_M GGUF.
Conversations rendered with the tokenizer's Llama 3 chat template via tokenizer.apply_chat_template(...) into a single text field; packing=False; no additional filtering.
[q_proj, k_proj, v_proj, o_proj, gate_proj, up_proj, down_proj] (all attention + MLP projections)Trained on a Kaggle cloud notebook (NVIDIA T4 class GPU). Final artifacts: LoRA adapter, merged 16-bit checkpoint (~6.4 GB across two safetensors shards), and Q4_K_M GGUF (~2 GB). Peak GPU memory and exact wall-clock time: [More Information Needed].
8 held-out analytical queries covering CTEs, window functions, multi-JOIN aggregations, cohort retention, funnel analysis, moving averages, and percentile breakdowns (eval/eval_dataset.json in the repository).
Query pattern category (CTE-heavy, window-function-heavy, JOIN-heavy).
Evaluated on the full 8-query benchmark (GTX 1650, greedy decoding, transformers backend). References are phrased in the same interrogative register the model was fine-tuned to produce:
| Metric | Score |
|---|---|
| Pass rate (cov ≥ 50% ∧ sim ≥ 70%) | 75% (6/8) |
| Keyword coverage | 65.1% avg |
| Semantic similarity | 0.774 avg |
| Avg latency | ~700 s/sample (CPU-offloaded FP16; GGUF/llama.cpp path is far faster) |
Per-sample similarity: 0.84 / 0.71 / 0.85 / 0.74 / 0.78 / 0.76 / 0.83 / 0.68. The two remaining failures (eval_006 moving-average query, eval_008 funnel query) produce correct but terse descriptions that omit some expected business terms — a genuine verbosity gap rather than misunderstanding.
The model reliably translates analytical SQL into faithful business-language descriptions matching its trained question-style register; 6 of 8 complex analytical queries pass both faithfulness metrics outright.
[More Information Needed]
Carbon emissions can be estimated using the Machine Learning Impact calculator presented in Lacoste et al. (2019).
LlamaForCausalLM — 3.21B parameters, 28 layers, hidden size 3072, GQA (24 query heads / 8 KV heads), SwiGLU MLP (intermediate 8192), RoPE (theta 500000, llama3 scaling, max positions 131072), vocabulary 128,256. Fine-tuning objective: next-token prediction on (system, SQL query) -> business logic pairs in the Llama 3 chat format (<|start_header_id|> … <|eot_id|>).
Kaggle single-GPU notebook (fine-tuning); CPU or NVIDIA GPU via llama.cpp n_gpu_layers (inference).
Unsloth v2026.8.19, TRL SFTTrainer, Hugging Face datasets, PyTorch on the Kaggle Docker image (transformers 5.5.0); llama-cpp-python and FastAPI for serving.
BibTeX:
bibtex
@misc{shinde2026sql2nl,author = {Shinde, Gaurav},title = {SQL2NL: Fine-tuned Llama 3.2 3B for SQL-to-Business-Logic Translation},year = {2026},howpublished = {\url{https://huggingface.co/ShindeGaurav-2207/SQL2NL}}}
APA:
Shinde, G. (2026). SQL2NL: Fine-tuned Llama 3.2 3B for SQL-to-business-logic translation [Computer software]. Hugging Face. https://huggingface.co/ShindeGaurav-2207/SQL2NL
WITH, read here as a logical analytical step.RANK() OVER (...)), explained as comparative analytics.See the project repository for the API server, GGUF/Ollama deployment path, Docker setup, and benchmark harness.
Gaurav Shinde