Phi2 Nl2sql Lora

🚀 Model Card for Model ID

A fine - tuned version of Phi - 2 for the NL2SQL usecase on b - mc2/sql - create - context dataset, which provides an efficient solution for translating natural language to SQL queries.

🚀 Quick Start

This is a fine - tuned version of Phi - 2 for the NL2SQL usecase on the b - mc2/sql - create - context dataset. Note that this contains just the adapters, and you need to load the Phi2 model and add these adapters.

✨ Features

• High Efficiency: Performed better than defog/sqlcoder - 7b - 2 in terms of inference time and accuracy on the holdback dataset.
• Good Execution Success: The Finetuned Phi - 2 is 29% better than the SQLCoder based on execution success.
• Smaller Size Advantage: Due to its smaller size, it has an average 41% faster inference time compared to SQLCoder.

📦 Installation

No specific installation steps are provided in the original README. If you want to use the model, you can follow the usage examples below.

💻 Usage Examples

Basic Usage

# USING ON GPU MACHINE
from peft import PeftModel
from transformers import AutoModelForCausalLM, AutoTokenizer

model_name = "microsoft/phi-2"

model = AutoModelForCausalLM.from_pretrained(
    model_name,
    trust_remote_code=True,
    device_map="auto",
    torch_dtype=torch.float16
)

peftmodel = PeftModel.from_pretrained(model, "pavankumarbalijepalli/phi2-nl2sql-lora")
peftmodel = peftmodel.merge_and_unload()

tokenizer = AutoTokenizer.from_pretrained(model_name, trust_remote_code=True)
tokenizer.pad_token = tokenizer.eos_token
inputs = tokenizer(prompt, return_tensors="pt", padding=True, truncation=True)
inputs.to('cuda')

outputs = peftmodel.generate(**inputs, max_length=1000)
text = tokenizer.batch_decode(outputs,skip_special_tokens=True)[0]
print(text)

📚 Documentation

Model Details

Model Description

This model has been finetuned with b - mc2/sql - create - context on microsoft/phi - 2. It performed better than defog/sqlcoder - 7b - 2 in terms of inference time and accuracy on the holdback dataset. The evaluation is done on .gguf models on a CPU machine with limited RAM. The average inference times of the Phi - 2 and SQLCoder are 24 secs and 41 secs respectively, which means it is 41% faster on average. This is due to its smaller size. The Finetuned Phi - 2 is 29% better than the SQLCoder based on execution success. However, its major drawback is its context window of 2048 tokens, which requires additional input engineering to get results.

Model Sources

• Repository: [pavankumarbalijepalli/pr - phi2 - vs - defog](https://github.com/pavankumarbalijepalli/pr - phi2 - vs - defog/)
• Paper: [BITS Project Paper](https://github.com/pavankumarbalijepalli/pr - phi2 - vs - defog/blob/main/2021SC04115%20-%20Final.pdf)

Uses

Downstream Use

The model is supposed to be used for cases where you have a natural language question and a relevant database schema to retrieve a SQL query that answers the question. The context should be below 2048 tokens, and the output will be generated in PostgreSQL.

Out - of - Scope Use

• Generating Unintended Code: While the model can translate natural language into SQL queries, it may not be robust enough to handle complex logic or edge cases. Using it to generate critical production code could lead to errors or unexpected behavior in databases.
• Security Risks: NL2SQL models can be susceptible to adversarial attacks where malicious users input natural language designed to trick the model into generating SQL code with security vulnerabilities, like SQL injection attacks.
• Beyond its Training Scope: The model is trained on a specific SQL Language (e.g., PostgreSQL). Using it for a different SQL Syntax (e.g., MS SQL Server) could lead to inaccurate or nonsensical SQL queries.

Bias, Risks, and Limitations

• Bias and Fairness: The model's training data may contain biases that are reflected in the generated SQL queries. This could lead to unfair or discriminatory outcomes, especially if the data is not carefully curated.
• Interpretability and Explainability: NL2SQL models are often "black boxes" where it's difficult to understand how they translate natural language to SQL. This lack of interpretability makes it challenging to debug errors or ensure the generated queries are safe and efficient.
• Replacing Human Expertise: While the model can automate some SQL query generation tasks, it shouldn't be a complete replacement for human database administrators or analysts. Understanding the data schema and database design is crucial for writing efficient and secure SQL queries.

Recommendations

Users (both direct and downstream) should be made aware of the risks, biases, and limitations of the model.

Training Details

Training Data

@misc{b-mc2_2023_sql-create-context,
  title   = {sql-create-context Dataset},
  author  = {b-mc2}, 
  year    = {2023},
  url     = {https://huggingface.co/datasets/b-mc2/sql-create-context},
  note    = {This dataset was created by modifying data from the following sources: \cite{zhongSeq2SQL2017, yu2018spider}.},
}

Evaluation

Testing Data, Factors & Metrics

• Testing Data: Used b - mc2/sql - create - context and split the data into training and testing datasets. The holdout dataset is used for testing the model.
• Factors: The complexity of the questions are calculated using the number of tables per question, number of joins, group by, and sub - queries per answer. This complexity is used to prepare the test data by stratifying the split around the complexity.
• Metrics:
  • Execution Success: This metric is used to find out if the generated query is executable without arising any errors. For this, a sqllite3 connection is made to the memory, and using context the dummy tables are created. Then the predicted SQL is executed. This checks out if the generated query is in proper syntax, and if the model is hallucinating any new columns.
  • Inference Time: This metric is used to find out which model is providing results in less amount of time. This combined with the execution success gives the efficiency of the model.

Results

• Execution Success: Finetuned Phi - 2 has 29% more success rate than the SQLCoder - 7b - 2.
• Inference Time: Finetuned Phi - 2 has 41% increased inference speed than SQLCoder - 7b - 2.

Summary

• Reduced Inference Time and Memory Footprint: The fine - tuned Phi - 2 model demonstrated a reduction in inference time and memory usage compared to the DeFog SQLCoder. This is attributed to Phi - 2's smaller size and the efficiency of quantization techniques employed during fine - tuning. This finding implies that NL2SQL models can be deployed on lower - powered devices like laptops or even mobile phones, potentially democratizing access to this technology for a wider range of users.
• Competitive Performance on Easy and Medium Queries: The fine - tuned Phi - 2 achieved comparable performance to the DeFog SQLCoder in terms of accuracy on easy, medium, and hard difficulty queries. This indicates that Phi - 2, despite its smaller size, can effectively handle a significant portion of real - world NL2SQL tasks, especially for simpler queries.
• Challenges with Complex Queries: While Phi - 2 performed well on easier queries, it encountered challenges with complex queries, exhibiting a drop in execution success compared to the DeFog SQLCoder. This highlights the trade - off between model size and complexity, suggesting that larger models might still be necessary for tackling highly intricate tasks.
• Potential for Further Improvement: The fine - tuning process employed in this study can be further optimized by exploring different hyperparameter configurations and potentially investigating alternative fine - tuning techniques like adapter - based methods. This optimization has the potential to improve the model's performance on complex queries while maintaining its efficiency.

🔧 Technical Details

The model is a fine - tuned version of Phi - 2 on the b - mc2/sql - create - context dataset. The evaluation is done on .gguf models on a CPU machine with limited RAM. The complexity of the test questions is calculated based on multiple factors such as the number of tables, joins, group by, and sub - queries.

📄 License

The model is licensed under the MIT license.

Environmental Impact

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

Citation

No specific citation information is provided in a proper format in the original README. If there is a paper or blog post introducing the model, the APA and Bibtex information for that should be added here.