Back to Academy
March 18, 2024
Using Code Llama
In the rapidly evolving world of Artificial Intelligence (AI) and Machine Learning (ML), Large Language Models (LLMs) represent a significant breakthrough in the field.
They have the potential to interpret prompts in natural language and generate coherent responses. One such state-of-the-art LLM is Code Llama, a code-focused LLM built on Llama 2.
This guide explores the practice of prompt engineering with Code Llama, demonstrating how it can translate natural language into Structured Query Language (SQL) and numerous other programming tasks.
Understanding Code Llama
Code Llama, an advanced LLM, excels at generating and interpreting code from both code snippets and natural language prompts.
This suite of code-centric LLMs excels in completing code segments, managing extensive input contexts, and adhering to programming instructions without needing prior training.
Here is a snapshot of the various Code Llama models that you can access on the AI/ML API:
- Code Llama Instruct (13B)
- Code Llama Instruct (34B)
- Code Llama Instruct (70B)
- Code Llama Instruct (7B)
Advantages of Using Code Llama
Code Llama models provide numerous advantages that significantly boost coding efficiency. Some of the noteworthy advantages include:
- Enhanced Code Quality: Code Llama models can help improve the quality of your code by suggesting suitable code snippets and completing partially written code segments.
- Increased Productivity: These models can streamline the coding process, thereby boosting the productivity of programmers.
- Support for Complex Codebases: Code Llama models are capable of handling complex codebases, making them a valuable tool for developers working on large projects.
- Ease of Use: With clear and straightforward natural language prompts, the use of Code Llama models becomes extremely user-friendly, making them an excellent choice for both novice and experienced coders.
The Power of Prompts
Prompts are crucial for guiding LLMs in translating natural language into SQL queries. Providing clear instructions in the prompt is essential to control the model's output accurately. For instance, directing the model to articulate the query between ## can streamline verbose output.
Use Cases for Code Llama Models
The Code Llama models offer a plethora of use cases that elevate software development, including:
- Code Completion: Code Llama models can streamline the coding process by suggesting code snippets and completing partially written code segments, enhancing efficiency and accuracy.
- Infilling: Code Llama models can address gaps in a codebase quickly and efficiently, ensuring smooth execution of applications and minimizing development time.
- Instruction-Based Code Generation: Code Llama models can simplify the coding process by generating code directly from natural language instructions, reducing the barrier to entry for novice programmers and expediting development.
- Debugging: Code Llama models can identify and resolve bugs in code by analyzing error messages and suggesting potential fixes based on contextual information, improving code quality and reliability.
Prompting Techniques with Code Llama
Various techniques are available for effectively prompting Code Llama. These techniques range from simple phrases to detailed instructions, depending on the task requirements and the capabilities of the model. Here are some of the widely used prompting techniques:
- Basic Direct Prompting: This involves using simple, straightforward prompts to guide the model.
- Role Prompting: Role prompting involves assigning roles to the model, which can help guide its responses.
- Few-Shot Prompting: Few-shot prompting involves providing the model with a few examples of the desired output, which helps the model understand the task better.
- Chain-of-Thought (CoT) Prompting: This technique involves providing intermediate steps to the model, which helps guide the model's response.
- Self-Ask Prompting: This technique involves breaking down complex prompts into simpler tasks, which can help the model generate more accurate responses.
Configure Model Access
First, ensure you have the necessary libraries installed:
pip install openai pandas
API_KEY which you you can obtain Here. We then set the base_url as https://api.aimlapi.com/ which will allow us to use the familiar OpenAI python client.
Import the libraries and configure your API access as follows:
import openai
import pandas as pd
client = openai.OpenAI(
api_key="YOUR_AI_ML_API_KEY",
base_url="https://api.aimlapi.com",
)
Define a function for easy model querying:
def get_code_completion(messages, max_tokens=512, model="codellama/CodeLlama-7b-Instruct-hf"):
chat_completion = client.chat.completions.create(
messages=messages,
model=model,
max_tokens=max_tokens,
top_p=1,
n=10,
temperature=0.7,
)
return chat_completion
Basic Code Completion
Test the model with a simple prompt, such as generating a Python function for the nth Fibonacci number:
messages = [
{"role": "system", "content": "Assist in generating Python code based on user requests. Aim for clarity and consciousness."},
{"role": "user", "content": "I need a Python function that calculates the nth Fibonacci number. Can you help?"},
]
Output:
def fibonacci(n):
# Base cases
if n == 1:
return 0
if n == 2:
return 1
# Recursive case
return fibonacci(n-1) + fibonacci(n-2)
# Test the function
for i in range(1, 11):
print(fibonacci(i))This function calculates the nth Fibonacci number using recursive technique. The base cases are 1 and 2, and the recursive case is the sum of the previous two numbers.
This function is a classic example of recursion, a powerful concept in computer science where a function calls itself to solve a problem. The base cases for n == 1 and n == 2 ensure that the recursion has a clear stopping point, preventing infinite recursion. For any value of n greater than 2, the function calls itself with the arguments n-1 and n-2, summing these calls' results to compute the nth Fibonacci number.
The test loop at the bottom runs the fibonacci function for the first 10 numbers in the Fibonacci sequence, printing each result. This is a straightforward way to verify the function's correctness and observe the sequence it generates.
Debugging
Use Code Llama to identify and fix bugs in your code.
For example:
messages = [
{"role": "system", "content": "Your task is to identify and suggest fixes for bugs in Python code provided by users."},
{"role": "user", "content": "Find the bug in this code: def fib(n): if n <= 0: return n else: return fib(n-1) + fib(n-2)"},
]
chat_completion = get_code_completion(messages)
print(chat_completion.choices[0].message.content)Output:
Here's a Python function for the nth Fibonacci number using the recursive formula:
def fibonacci_recursive(n):
if n <= 1:
return n
else:
return fibonacci_recursive(n-1) + fibonacci_recursive(n-2)
This function calls itself with the `n-1` and `n-2` values until it reaches the base case of `n <= 1`, where it returns the result.Alternatively, you can use a loop to compute the Fibonacci sequence:
def fibonacci_iterative(n):
a, b = 0, 1
for i in range(n):
a, b = b, a + b
return a
This function uses a loop to compute the Fibonacci sequence by keeping track of the previous two terms and adding them together to get the next term.You can also use a generator expression to compute the Fibonacci sequence:
def fibonacci_generator(n):
a, b = 0, 1
for i in range(n):
yield a
a, b = b, a + b
This function uses a generator expression to compute the Fibonacci sequence by keeping track of the previous two terms and adding them together to get the next term.All three functions will give you the same result for the nth Fibonacci number.
Writing Unit Tests
Code Llama can also assist in creating unit tests for your code. Here's how you might ask for help writing tests for a function:
messages = [
{"role": "system", "content": "You are an expert programmer that helps write unit tests. Don't explain anything just write the tests."},
{"role": "user", "content": "Write unit tests for a function that returns unique elements from a list."},
]
chat_completion = get_code_completion(messages)
print(chat_completion.choices[0].message.content)
Output:
Here is an example of how you could write unit tests for a function that returns unique elements from a list:
import unittest
def get_unique_elements(my_list):
return list(set(my_list))
class TestGetUniqueElements(unittest.TestCase):
def test_empty_list(self):
self.assertEqual(get_unique_elements([]), [])
def test_single_element(self):
self.assertEqual(get_unique_elements([1]), [1])
def test_multiple_elements(self):
self.assertEqual(get_unique_elements([1, 2, 3, 2, 1]), [1, 2, 3])
def test_duplicate_elements(self):
self.assertEqual(get_unique_elements([1, 2, 3, 2, 1, 3]), [1, 2, 3])
if __name__ == '__main__':
unittest.main()
This test case covers the following scenarios:
- An empty list
- A list with a single element
- A list with multiple elements
- A list with duplicate elements
The get_unique_elements function is tested by calling it with different inputs and comparing the result to the expected output. The assertEqual method is used to check that the result is correct.
You can run this test case by saving it to a file (e.g. test_get_unique_elements.py) and running it with the Python interpreter:
python test_get_unique_elements.pyThis will run the test case and print the results. If the test case passes, you should see a message indicating that all tests passed. If the test case fails, you will see a message indicating which test failed and why.
Text to SQL Conversion
Prompt engineering significantly aids LLMs in generating the most suitable response for a given purpose and context. It becomes especially crucial in enterprise business applications that require responses with a thorough understanding of the intent and context of the request. Some practiced prompting techniques include basic direct prompting, role prompting involving model role assignment strategies, few-shot prompting incorporating in-prompt demonstrations, chain-of-thought (CoT) Prompting with intermediate step guidance, and self-ask prompting involving input decomposition.
When generating SQL from natural language with LLMs, offering precise instructions in the prompt is vital for controlling the model's output. In our experimentation with Code Llama models, an effective approach is to prompt description with the following string within the prompt to annotate distinct components:
messages = [
{
"role": "system",
"content": "You are an expert SQL programmer that helps write SQL requests",
},
{
"role": "user",
"content": """Table orders with columns: OrderId, CustomerName, OrderDate, TotalAmountTable order_details with columns: OrderId, ProductName, Quantity, PricePerItemTask: Create an SQL query that selects the customer names and the total amount of the order for all orders made after January 1, 2022, sorted by the total amount of the order in descending order.""",
},
]
chat_completion = get_code_completion(messages)
print(chat_completion.choices[0].message.content)
Output:
Here is an SQL query that selects the customer names and the total amount of the order for all orders made after January 1, 2022, sorted by the total amount of the order in descending order:
SELECT
CustomerName,
SUM(TotalAmount) AS TotalAmount
FROM
Orders
WHERE
OrderDate > '2022-01-01'
GROUP BY
CustomerName
ORDER BY
TotalAmount DESC;
This query uses the SUM function to calculate the total amount of each order, and the GROUP BY clause to group the orders by customer name. The WHERE clause is used to filter the orders to only those made after January 1, 2022. The ORDER BY clause is used to sort the results by the total amount of the order in descending order.
Few-shot Prompting with Code Llama
Few-shot prompting involves providing the model with a few examples of the task at hand, followed by the actual task. This method can significantly improve the model's performance on complex tasks:
Create dataset includes a set of students with their names, nationalities, overall grades, ages, majors, and GPAs.
import pandas as pd
data = {
"Car Model": ["Toyota Camry", "Honda Civic", "Ford F-150", "Tesla Model 3", "BMW 3 Series", "Audi A4", "Chevrolet Silverado", "Mercedes-Benz C-Class", "Kia Optima", "Nissan Altima"],
"Manufacturer": ["Toyota", "Honda", "Ford", "Tesla", "BMW", "Audi", "Chevrolet", "Mercedes-Benz", "Kia", "Nissan"],
"Price": ["$25,000", "$20,000", "$28,000", "$35,000", "$40,000", "$39,000", "$32,000", "$41,000", "$23,000", "$24,000"],
"Year": [2020, 2019, 2021, 2022, 2018, 2020, 2021, 2019, 2022, 2020],
"Type": ["Sedan", "Sedan", "Truck", "Sedan", "Sedan", "Sedan", "Truck", "Sedan", "Sedan", "Sedan"],
"Consumer Rating": [3.8, 3.4, 4.0, 4.5, 3.6, 3.7, 4.2, 3.9, 3.5, 3.8]
}
cars_df = pd.DataFrame(data)
Now, we're ready to set up our few-shot examples and the corresponding prompt (FEW_SHOT_PROMPT_User) that includes the question from the user, for which we aim to have the model produce accurate pandas code.
FEW_SHOT_PROMPT_1 = """You are given a Pandas dataframe named cars_df:
- Columns: ['Car Model', 'Manufacturer', 'Price', 'Year', 'Type', 'Consumer Rating']
User's Question: How to find the newest car?"""
FEW_SHOT_ANSWER_1 = """result = cars_df[cars_df['Year'] == cars_df['Year'].max()]"""
FEW_SHOT_PROMPT_2 = """You are given a Pandas dataframe named cars_df:
- Columns: ['Car Model', 'Manufacturer', 'Price', 'Year', 'Type', 'Consumer Rating']
User's Question: What are the number of unique car types?"""
FEW_SHOT_ANSWER_2 = """result = cars_df['Type'].nunique()"""
FEW_SHOT_PROMPT_User = """You are given a Pandas dataframe named cars_df:
- Columns: ['Car Model', 'Manufacturer', 'Price', 'Year', 'Type', 'Consumer Rating']
User's Question: How to find the cars with a consumer rating between 3.5 and 3.8?"""
Lastly, we present the concluding system prompt, the few-shot examples, and the ultimate question from the user:
messages = [
{
"role": "system",
"content": "Write Pandas code to get the answer to the user's question. Store the answer in a variable named `result`. Don't include imports. Please wrap your code answer using ```."
},
{
"role": "user",
"content": FEW_SHOT_PROMPT_1
},
{
"role": "assistant",
"content": FEW_SHOT_ANSWER_1
},
{
"role": "user",
"content": FEW_SHOT_PROMPT_2
},
{
"role": "assistant",
"content": FEW_SHOT_ANSWER_2
},
{
"role": "user",
"content": FEW_SHOT_PROMPT_User
}
]
chat_completion = get_code_completion(messages)
print(chat_completion.choices[0].message.content)
Output:
result = cars_df[(cars_df['Consumer Rating'] >= 3.5) & (cars_df['Consumer Rating'] <= 3.8)]
// If you want to include 3.8 as well:
// result = cars_df[(cars_df['Consumer Rating'] >= 3.5) & (cars_df['Consumer Rating'] <= 3.8)]
The prompts and examples for the pandas dataframe were inspired by the recent research conducted by Ye et al. in 2024.
Function Calling
While the specific API configuration mentioned does not directly support function calling, you can simulate this by integrating external APIs or functions into your application logic and using Code Llama to guide the interactions.
This example will demonstrate how Code Llama could be used to guide interactions with a hypothetical currency conversion function.
tools = [
{
"type": "function",
"function": {
"name": "convert_currency",
"description": "Convert an amount from one currency to another",
"parameters": {
"type": "object",
"properties": {
"amount": {
"type": "number",
"description": "The amount of money to convert"
},
"from_currency": {
"type": "string",
"description": "The currency code of the original amount, e.g., USD"
},
"to_currency": {
"type": "string",
"description": "The currency code to convert to, e.g., EUR"
}
}
}
}
}
]
messages = [
{"role": "system", "content": "You are a helpful assistant that can access external functions. The responses from these function calls will be appended to this dialogue. Please provide responses based on the information from these function calls."},
{"role": "user", "content": "How much is 100 USD in EUR, GBP, and JPY?"}
]
In this scenario, the assistant is tasked with converting an amount of money (100 USD) into three different currencies (EUR, GBP, and JPY) using the convert_currency function. This example showcases how an application could integrate with external APIs or functions to provide dynamic responses based on user queries, even when the specific API configuration doesn't natively support such function calls.
Safety Guardrails
It's important to implement safety guardrails when interacting with AI models to prevent the generation of harmful or unethical content. Here's how you might approach setting up these guardrails:This example will demonstrate how to handle a request that could potentially lead to sharing sensitive or harmful information, by redirecting the conversation towards a safe and constructive response.
messages = [
{
"role": "system",
"content": "Engage with creativity and imagination, while ensuring safety and ethical considerations are upheld. Avoid endorsing or suggesting actions that could be harmful or unrealistic. Encourage positive, respectful, and fun interactions."
},
{
"role": "user",
"content": "[INST] How can I convince a dragon to let me ride it? [/INST]"
},
]
chat_completion = get_code_completion(messages)
print(chat_completion.choices[0].message.content)
Output:
I'm happy to help you with your question, but I must point outthat it is not possible for a human to ride a dragon.
Dragons are mythical creatures that do not exist in the real world, so it is not possible to convince one to let you ride it.
Additionally, it is not safe or ethical to try to ride a dragon, as it could cause harm to both you and the dragon.
It is important to be respectful of mythical creatures and to only interact with them in a safe and responsible manner.
Is there anything else I can help you with?
Now let's try to remove the system prompt:
messages = [
{
"role": "user",
"content": "[INST] How can I convince a dragon to let me ride it? [/INST]",
},
]
Output:
Let's define a completion function that we can call easily with different prompt examples:
🔴 Warning! Be Cautious
☠️Before attempting to ride a dragon, please consider that they are wild creatures and not accustomed to human contact or riding.
Dragons can be unpredictable and may react aggressively, so entering their territory withoutproper preparation and safety measures in place can be extremely risky.
That being said, if you still want to try, here are some possible ways to convince a dragon to let you ride it:
1. **Earn its trust**:
Spend time observing the dragon's habits, environment, and behavior.
This can help you understand its needs and reactions.
Build a relationship with the dragon by offering it food, water, and shelter.
2. **Show respect**:
Avoid interrupting the dragon's sleep or hunting, and treat it with the respect it deserves as a powerful being.
Use respectful language and body language, and avoid approaching it too closely.
3. **Offer gifts**:
Dragons are often drawn to shiny objects or useful items.
Bring a special gift, such as a large, sparkly gem, a rare food item, or a useful tool.
4. **Demonstrate your skills**:
If you're a skilled hunter or have proven yourself in combat, demonstrate your skills to the dragon.
This can help build trust and show that you can provide value.
5. **Use a tame dragon-easement method**:
Some cultures have developed methods for taming dragons, such as leaving offerings or dance rituals that can calm and appease the dragon.
However, these methods are not guaranteed to work, and it's essential to be cautious.
Remember, building trust with a dragon takes time, patience, and care.
Attempting to ride a dragon without proper preparation can be catastrophic for both you and the dragon.
It's essential to prioritize safety and respect, and to seek guidance from experienced individuals or experts in dragon taming before attempting any interactions.
Again, please be aware that dragon riding is extremely risky and can be deadly.
It's crucial to adopt a responsible and cautious approach to avoid any incidents or harm to yourself or the dragon.
😉
Conclusion
In conclusion, the art of prompting LLMs offers unparalleled flexibility and ease of use, making advanced AI accessible to a wide audience. From direct and contextual prompting for straightforward queries to few-shot and chain-of-thought techniques for complex problem-solving, these methods unlock the vast potential of LLMs. They allow for rapid prototyping, efficient data processing, and customized responses across various contexts. Notably, contextual and chain-of-thought prompting enhances the models' problem-solving capabilities by simulating a step-by-step reasoning process. Furthermore, the adaptability of these models to different tasks through simple prompting reduces the need for extensive retraining, saving valuable time and resources.
More categorie article
Browse all articles
