1. Introduction
2. Many, Few, & Zero-Shot Prompts
3. Define Constraints
4. Iterative Reasoning
5. In Practice
6. Roleplay
7. Conclusion

Introduction

---

Understanding machine learning and language models can seem like a daunting task, but it doesn’t have to be. Imagine you’re trying to teach a child how to recognize different fruits. You show them many examples of apples, bananas, and oranges, explaining the differences each time. In a similar way, machine learning algorithms learn by being fed large amounts of data and identifying patterns. These patterns help the algorithms make predictions or decisions based on new data they encounter.

Training a model involves feeding it data and allowing it to learn from that data. It’s like teaching a dog new tricks by rewarding it each time it performs the trick correctly. The model gets better with practice, adjusting its internal parameters to improve its performance. Over time, it becomes proficient at making accurate predictions based on the data it was trained on.

Many, Few, & Zero-Shot Prompts

---

In the realm of prompt engineering, understanding the different types of prompts is crucial. Before we break them down, just note that zero-shot prompts are generally what consumer-facing Large Language Models (LLMs) strive for (and an expectation with sufficient context).  Let’s break them down:

• Many-shot prompt: This involves providing the model with numerous examples before asking it to perform a task. Fine-Tuning is a keyword used in relation to AI with machine learning. In which case, if you’re trying to train a model to identify patterns in procurement contracts, you might provide it with multiple examples of what contracts look like & their metadata. Through vectorization, a model is able to see patterns and make associations in the deconstructed data such that a dog and a cat are both animals. 

• Few-shot prompt: Here, the model is given only a few examples. This type of prompt is useful when you have limited data but still need the model to understand the task or extrapolate upon the topic. For instance, you might provide a couple of examples of contract SLAs or Supplier Key Performance Indicators with a prompt soliciting a brainstorm for more. 

• Zero-shot prompt: In this scenario, a model is given no examples and must rely solely on its pre-trained knowledge. This is particularly useful for well-defined tasks that the model has likely encountered during its training. For example, asking the model to summarize a procurement report without providing any prior examples. Functionally recently iterated upon in the form of Assistants or CustomGPTs.

Example: In a many-shot prompt, you might show the model several user contact records and ask it to identify valid emails from the undeliverable using rules & natural language conventions to process the request. In a zero-shot prompt, you could simply ask the model to generate a report without any examples.

Define Constraints

Controlling the output from a language model involves defining clear constraints. This ensures the responses are relevant and formatted correctly.

• Desired length of output: The targeted output length can be specified in terms of the count of words, sentences, paragraphs, bullet points, etc.
  • Note however that instructing a model to generate a specific number of words does not work with high precision. The model can more reliably generate outputs with a specific number of paragraphs or bullet points.
• Define format & syntax: Specify the structure of the output. For example, if you need a procurement summary, you could define sections such as ‘Introduction’, ‘Key Findings’, ‘Recommendations’, etc.
• Explicit exclusions: Clearly state what should be avoided in the response. For instance, if you’re generating a vendor evaluation report, you might exclude any mention of vendors that do not meet certain compliance standards. 

Example: Explain like I’m Five, or ELI5, is an uncommon way to ask for a simple explanation of a topic. Under the lens of a prompt, it’s how a language module filters out the verbiage and range of information adequate for a five-year-old.

Iterative Reasoning

Iterative reasoning involves refining prompts and your context to achieve the desired output. Before we get into detail, we will preface that iterative prompts are an effort to reduce our Perplexity.

Prompt perplexity: This refers to the complexity and ambiguity of the prompt. Lower perplexity ensures clearer and more precise responses.

A zero-shot prompt is ideal in nearly all cases, but it will never exceed the quality of a nurtured response using the strategies below:

1. Chain of Thought prompting: This technique involves breaking down the reasoning process into smaller, manageable steps. For example, when generating a deployment strategy, the prompt might first ask the model to identify key objectives, followed by potential risks, and finally recommended actions.
2. Summarize the Dialogue: Since models have a fixed context length, dialogue between a user and an assistant in which the entire conversation is included in the context window cannot continue indefinitely.
3. Recursive Summarization: The balancing act around context length prevails as a model cannot be used to summarize a text longer than the context length minus the length of the generated summary in a single query. We work around this limitation by breaking down source/text material into chunks until we can aggregate a summary of summaries.
4. Enable Affirmative Dialogue: Generative AI is still another manifestation of a computer program that needs to be tasked with something. All of our prompts are variations of such tasks, but we can also task a model with asking clarifying questions to gain a better understanding before producing a response.

In Practice

In the example pictured above, the original attachment was a simple process flow spelling out not-so-obvious instructions on staging data for import (leading & trailing spaces, null values, etc.).

As detailed as it may or may-not have been, not all pictures are worth even 50 words.

By signaling chain of thought reasoning in tandem with a requirement for absolute understanding in my prompt, this conversation underwent a very thorough discovery of the document and its process. 

Compartmentalizing the dialogue into the various ‘chapters’ enabled a callback for our model to assemble a summary of summaries.

The resulting output wasn’t so much a ‘ready to go’ standard operating procedure document, but a viable framework to populate, personalize, and refine. A significant head starts in comparison to demystifying online templates or starting from scratch.

Roleplay

Jokes aside, roleplaying can significantly enhance the efficacy of a language model. By defining a persona, you can yield more nuanced and contextually appropriate responses:

• Defining background and experience: This is essentially creating your own subject matter expert. Be mindful that associating years of experience further simplifies (or expands) the realm of keywords and verbs when responding to a prompt.
  • For instance, defining the model as a procurement expert with years of experience in vendor negotiations can help generate more insightful and strategic responses that lean functional in nature. 
  • Conversely, defining a model as a SaaS Implementation expert can yield responses that are more technical and reflect elements of the SDLC.

• Defining personality and flavor: It doesn’t take significant amount of experience generating and parsing AI content to ascertain the minimal variance in tone that’s unique to generative content.
  • Saving temperature as a topic for another day, defining your persona is also an opportunity to incorporate simplicity or even humor into responses. The thick skinned among us may even enjoy chaosGPT.

Conclusion

In conclusion, mastering prompt engineering can vastly improve efficiency and effectiveness in the procurement field. Whether it’s generating detailed reports, drafting contracts, or developing strategic plans, the right prompts can leverage AI to save time and enhance productivity. Many of the themes covered are a picturesque segue into Assistants or CustomGPTs. I challenge you to extrapolate the philosophies around prompt engineering to create your own.

• Print
• LinkedIn
• ShareCopied to clipboard