DEV Community: Liam Tobei

First Prompt Template

Liam Tobei — Wed, 10 May 2023 20:10:22 +0000

Prompts being input to LLMs are often structured in different ways so that we can get different results. For Q&A, we could take a user’s question and reformat it for different Q&A styles, like conventional Q&A, a bullet list of answers, or even a summary of problems relevant to the given question.

Creating Prompts in LangChain
Let’s put together a simple question-answering prompt template. We first need to install the langchain library.

!pip install langchain

From here, we import the PromptTemplate class and initialize a template like so:

from langchain import PromptTemplate

template = """Question: {question}

Answer: """
prompt = PromptTemplate(
        template=template,
    input_variables=['question']
)

# user question
question = "Which NFL team won the Super Bowl in the 2010 season?"

When using these prompt template with the given question we will get:

Question: Which NFL team won the Super Bowl in the 2010 season? Answer:

For now, that’s all we need. We’ll use the same prompt template across both Hugging Face Hub and OpenAI LLM generations.

Hugging Face Hub LLM

The Hugging Face Hub endpoint in LangChain connects to the Hugging Face Hub and runs the models via their free inference endpoints. We need a Hugging Face account and API key to use these endpoints.

Once you have an API key, we add it to the HUGGINGFACEHUB_API_TOKEN environment variable. We can do this with Python like so:

import os

os.environ['HUGGINGFACEHUB_API_TOKEN'] = 'HF_API_KEY'

Next, we must install the huggingface_hub library via Pip.

!pip install huggingface_hub

Now we can generate text using a Hub model. We’ll use google/flan-t5-x1.

from langchain import HuggingFaceHub, LLMChain

# initialize Hub LLM
hub_llm = HuggingFaceHub(
        repo_id='google/flan-t5-xl',
    model_kwargs={'temperature':1e-10}
)

# create prompt template > LLM chain
llm_chain = LLMChain(
    prompt=prompt,
    llm=hub_llm
)

# ask the user question about NFL 2010
print(llm_chain.run(question))

For this question, we get the correct answer of "green bay packers".

Asking Multiple Questions

If we’d like to ask multiple questions, we can try two approaches:

Iterate through all questions using the generate method, answering them one at a time.
Place all questions into a single prompt for the LLM; this will only work for more advanced LLMs.

Starting with option (1), let’s see how to use the generate method:

qs = [
    {'question': "Which NFL team won the Super Bowl in the 2010 season?"},
    {'question': "If I am 6 ft 4 inches, how tall am I in centimeters?"},
    {'question': "Who was the 12th person on the moon?"},
    {'question': "How many eyes does a blade of grass have?"}
]
res = llm_chain.generate(qs)
res

Here we get bad results except for the first question. This is simply a limitation of the LLM being used.

If the model cannot answer individual questions accurately, grouping all queries into a single prompt is unlikely to work. However, for the sake of experimentation, let’s try it.

multi_template = """Answer the following questions one at a time.

Questions:
{questions}

Answers:
"""
long_prompt = PromptTemplate(template=multi_template, input_variables=["questions"])

llm_chain = LLMChain(
    prompt=long_prompt,
    llm=flan_t5
)

qs_str = (
    "Which NFL team won the Super Bowl in the 2010 season?\n" +
    "If I am 6 ft 4 inches, how tall am I in centimeters?\n" +
    "Who was the 12th person on the moon?" +
    "How many eyes does a blade of grass have?"
)

print(llm_chain.run(qs_str))

As expected, the results are not helpful. We’ll see later that more powerful LLMs can do this.

Building a Question-Answering App with LangChain

Liam Tobei — Wed, 26 Apr 2023 08:18:06 +0000

Let’s build a question-answering app using LangChain in five easy steps:

Step 1 – Setting Up the Development Environment
Before we get coding, let’s set up the development environment. I assume you already have Python installed in your working environment.

You can now install the LangChain library using pip:

pip install langchain

As we’ll be using OpenAI’s language models, we need to install the OpenAI SDK as well:

pip install openai

Step 2 – Setting the OPENAI_API_KEY as an Environment Variable

Next, sign into your OpenAI account. Navigate to account settings > View API Keys. Generate a secret key and copy it.

In your Python script, use the os module and tap into the dictionary of environment variables, os.environ. Set the "OPENAI_API_KEY" to your to the secret API key that you just copied:

import os
os.environ["OPENAI_API_KEY"] = "your-api-key-here"

Step 3 – Simple LLM Call Using LangChain

Now that we’ve installed the required libraries, let's see how to make a simple LLM call using LangChain.

To do so, let’s import the OpenAI wrapper. In this example, we’ll use the text-davinci-003 model:

from langchain.llms import OpenAI
llm = OpenAI(model_name="text-davinci-003")

Let's define a question string and generate a response:

question = "Which is the best programming language to learn in 2023?"
print(llm(question))

Output >>
It is difficult to predict which programming language will be the most popular in 2023. However, the most popular programming languages today are JavaScript, Python, Java, C++, and C#, so these are likely to remain popular for the foreseeable future. Additionally, newer languages such as Rust, Go, and TypeScript are gaining traction and could become popular choices in the future.

Step 4 – Creating a Prompt Template

Let's ask another question on the top resources to learn a new programming language, say, Golang:

question = "What are the top 4 resources to learn Golang in 2023?"
print(llm(question))

Output >>

1. The Go Programming Language by Alan A. A. Donovan and Brian W. Kernighan
2. Go in Action by William Kennedy, Brian Ketelsen and Erik St. Martin
3. Learn Go Programming by John Hoover
4. Introducing Go: Build Reliable, Scalable Programs by Caleb Doxsey

While this works fine for starters, it quickly becomes repetitive when we’re trying to curate a list of resources to learn a list of programming languages and tech stacks.

Here’s where prompt templates come in handy. You can create a template that can be formatted using one or more input variables.

We can create a simple template to get the top k resources to learn any tech stack. Here, we use the k and this as input_variables:

from langchain import PromptTemplate
template = "What are the top {k} resources to learn {this} in 2023?"
prompt = PromptTemplate(template=template,input_variables=['k','this'])

Step 5 – Running Our First LLM Chain

We now have an LLM and a prompt template that we can reuse across multiple LLM calls.

llm = OpenAI(model_name="text-davinci-003")
prompt = PromptTemplate(template=template,input_variables=['k','this'])

Let’s go ahead and create an LLMChain:
from langchain import LLMChain
chain = LLMChain(llm=llm,prompt=prompt)

You can now pass in the inputs as a dictionary and run the LLM chain as shown:

input = {'k':3,'this':'Rust'}
print(chain.run(input))

Output >>

1. Rust By Example - Rust By Example is a great resource for learning Rust as it provides a series of interactive exercises that teach you how to use the language and its features.

2. Rust Book - The official Rust Book is a comprehensive guide to the language, from the basics to the more advanced topics.

3. Rustlings - Rustlings is a great way to learn Rust quickly, as it provides a series of small exercises that help you learn the language step-by-step.

What can ChatGPT do?

Liam Tobei — Tue, 25 Apr 2023 02:06:15 +0000

ChatGPT is a natural language processing tool that uses advanced machine learning algorithms to understand and respond to human language. It has gained a lot of popularity in recent years due to its ability to perform a wide range of tasks related to natural language processing. In this article, we will explore some of the things that ChatGPT can do.

Language Translation
ChatGPT can be used for language translation, which is the process of converting text from one language to another. ChatGPT’s language model is capable of understanding the nuances of different languages, which enables it to accurately translate text between different languages. This can be useful for businesses that operate in multiple countries and need to communicate with clients or customers in different languages.

Chatbots
One of the most popular uses of ChatGPT is for building chatbots. A chatbot is a computer program that is designed to simulate human conversation, and ChatGPT is an ideal tool for building chatbots due to its natural language processing capabilities. Chatbots can be used for a variety of tasks such as customer support, lead generation, and even for entertainment purposes.

Content Generation
ChatGPT can be used for generating content such as articles, blog posts, and product descriptions. By providing a prompt or a topic, ChatGPT can generate high-quality content that is both informative and engaging. This can be particularly useful for businesses that need to create a large amount of content on a regular basis.

Sentiment Analysis
Sentiment analysis is the process of determining the emotional tone of a piece of text. ChatGPT can be used for sentiment analysis to analyze the sentiment of customer feedback, social media posts, and other forms of user-generated content. This information can be used by businesses to improve their products or services and to better understand their customers.

Text Classification
ChatGPT can be used for text classification, which is the process of categorizing text into different categories. This can be useful for businesses that need to organize large amounts of data such as customer feedback or social media posts. ChatGPT’s language model is capable of understanding the nuances of different types of text, which enables it to accurately classify text into different categories.

Question Answering
ChatGPT can be used for question answering, which is the process of answering questions based on a given set of information. By providing a prompt or a set of information, ChatGPT can generate accurate and relevant answers to questions. This can be useful for businesses that need to provide support to customers or for educational purposes.

Language Modeling
Language modeling is the process of predicting the next word or sequence of words in a sentence. ChatGPT’s language model is capable of predicting the next word or sequence of words with high accuracy, which makes it useful for applications such as auto-completion and predictive text.

Conclusion
In conclusion, ChatGPT is a powerful tool that can be used for a wide range of tasks related to natural language processing. Its ability to understand and respond to human language makes it an ideal tool for building chatbots, generating content, performing sentiment analysis, text classification, question answering, and language modeling.

As natural language processing continues to evolve, ChatGPT is sure to play an increasingly important role in helping businesses and individuals to communicate more effectively.