After the whole ChatGPT thing, we noticed a division amongst the users. Some believed that LLMs are good enough to take people’s job while others thought it has a long way to go. Well, I have learned that LLMs are a tool to perform tasks and the effectiveness, or their accuracy lies in the hands of the person asking them to perform these tasks. This is nothing but prompt engineering where a person effectively asks the model to execute certain tasks. The response of the model is directly affected by the prompts that it receives. An inaccurate or confused prompt will lead to an inaccurate response.
With these series of articles on prompt engineering, I am going to share some of the best practices for prompting that will help developers in quickly building software applications by leveraging the power of LLM APIs.
We will cover (with code) the following topics.
1. Prompting best practices for software development
2. Some common use cases such as
a. Summarizing
b. Inferring
c. Transforming
d. Expanding
3. Building a chatbot using an LLM
Note — these best practices are focused on Instruction tuned LLMs, such as GPT — 3.5 turbo
Before we start — This series of articles on prompt engineering is compiled from a recently launched course by Andrew Ng and Isa Fulford, you can find all the resources and the course here.
Let’s have a look at the setup.
Setup
Get your Open AI API key from here.
Let’s Begin!!
In the first part, let’s discuss the two basic principles, we will be using these throughout the series.
Principle 1. Write clear and specific instructions.
You should express what you want a model to do by providing instructions that are as clear and specific as you can possibly make them. This will guide the model towards the desired output and reduce the chance that you get irrelevant or incorrect responses. Don’t confuse writing a clear prompt with writing a short prompt, because in many cases, longer prompts actually provide more clarity and context for the model, which can actually lead to more detailed and relevant outputs.
Below are some of the tactics which will help you put this principle in action.
1. Use delimiters to clearly indicate distinct parts of the input. These could be triple backticks ```, triple quotes “””, XML tags <tag> </tags>, angle brackets < >, etc. anything that makes this clear to the model that this is a separate section. Using delimiters is also a helpful technique to try and avoid prompt injections. Prompt injection is, if a user is allowed to add some input into your prompt, they might give conflicting instructions to the model that might make it follow the user’s instructions rather than doing what you want it to do.
Output
2. Ask for a structured output.
To make parsing the model outputs easier, it can be helpful to ask for a structured output like HTML or JSON. This output can be directly read into dictionary or list using python.
Output
3. Ask the model to check whether conditions are satisfied. Check assumptions required to do the task.
In this example, we will ask the model to check if the text provided has a set of instructions or not. if it contains instructions then we are going to ask the model to rewrite these instructions in more readable fashion.
The first text contains instructions of making a tea.
Output
The second piece of text describes a sunny day and has no instructions.
Output
The model determined that there were no instructions in the text.
4. Few-shot prompting — Give successful examples of completing tasks then ask model to perform the task.
By this tactic, we’re telling the model that its task is to answer in a consistent style. The style used here is a conversation between a child and a grandparent where the child is asks a question and the grandparent answers with metaphors.
Next we feed this conversation to the model and see how the model replicates the style of the grandparent to answer the next question.
Output
These are some simple examples of how we can give the model a clear and specific instruction. Now, let’s move on to our second principle
Principle 2. Give the model time to think.
Generally, if a model is making reasoning errors by rushing to an incorrect conclusion, you should try reframing the query to request a chain or series of relevant reasoning before the model provides its final answer.
In other words, if you give a model a task that’s too complex for it to do in a short amount of time or in a small number of words, it may make up a guess which is likely to be incorrect.
The same thing would happen with a person too, if they are asked to solve a complex problem in a short amount of time, chances are, they will make mistakes.
To solve such issues and get the maximum outcome from a model’s intelligence, you can instruct the model to think longer about a problem which means it will spend more computational effort on the task to reach the right conclusion/answer.
So, let’s see some tactics and examples around our second principle.
1. Specify the steps required to complete a task.
In this example, we have used a text and we are going to specify multiple steps that the model will follow on the text.
Output
Next, we may use earlier tactic and ask for the output to be in a specified format on the same text.
Output
2. Instruct the model to work out its own solution before rushing to a conclusion.
Let’s ask our model to evaluate a math solution, if it is correct or not.
The below prompt is a math question followed by a solution and the model is directly asked (in the beginning) to determine if the solution is correct or not.
Output
Please solve the problem and you’ll find that the student’s solution is actually not correct and to fix this, we will instruct the model to work out its own solution first and then compare the two results. Note that, when we are instructing the model, we are actually giving it the necessary time to think through the solution.
Below is the updated prompt.
Output
As we give the model enough time to think with specific instructions, the model successfully evaluates the solution and identifies the student’s answer as correct or incorrect.
Bonus principle — Model Limitations: Hallucinations Boie is a real company, the product name is not real.
While developing applications based on Large Language Models, one should always know the limitations of these models. If the model is being exposed to a vast amount of knowledge during its training process, it has not perfectly memorized the information it’s seen, and hence it doesn’t know the boundary of its knowledge very well. This means that the model might try to answer questions about obscure topics and can make things up that sound plausible but are not actually true and these fabricated ideas are called as Hallucinations.
Let’s see with the help of an example of a case where the model will hallucinate something. This is an example of where the model confabulates a description of a made-up product name from a real toothbrush company.
When we give the below prompt as input to our model, it gives us a realistic sounding description of a fictitious product.
Output
this is quite dangerous as the output generated looks very much realistic while it is completely false information.
So, make sure to use the techniques that we’ve gone through in this blog to try to avoid this when you’re building your own applications. This is a known weakness of LLMs and engineers are actively working on combating.
Reducing Hallucinations — First find relevant information, then answer the question based on the relevant information.
In the case that you want the model to generate answers based on a text, first ask the model to find any relevant quotes from the text, then ask it to use those quotes to answer questions and have a way to trace the answer back to the source document.
This tactic is often pretty helpful to reduce these hallucinations.
That’s it, we are done with the basic guidelines, principles and tactics for prompt engineering, in the next article, we will see some common use cases such as summarizing and inferring.
— Author: Rishi Khandelwal
.avif)
