Hands-On Large Language Models

from datasets import load_dataset

# load the well-known 'rotten_tomatoes' dataset for sentiment analysis
data = load_dataset("rotten_tomatoes")

# determine the device to use for computation (GPU if available, otherwise CPU)
import torch
dev = 'cuda' if torch.cuda.is_available() else 'cpu'

from transformers import pipeline

# specify the path to the pre-trained Twitter-RoBERTa-base for Sentiment Analysis model
model_path = "cardiffnlp/twitter-roberta-base-sentiment-latest"
# load the pre-trained sentiment analysis model into a pipeline for easy inference
pipe = pipeline(
    model=model_path,
    tokenizer=model_path,
    return_all_scores=True, # return the scores for all sentiment labels
    device=dev, # specify the device to run the pipeline on
)

import numpy as np
from tqdm import tqdm # for progress bar during inference
from transformers.pipelines.pt_utils import KeyDataset # utility to feed data to the pipeline

# run inference on the test dataset
y_pred = [] # list to store the predicted sentiment labels
for output in tqdm(
    # iterate through the 'text' column of the test dataset
    pipe(KeyDataset(data["test"], "text")), total=len(data["test"])
):
    # extract the negative sentiment score
    negative_score = output[0]["score"]
    # extract the positive sentiment score (assuming labels are ordered: negative, neutral, positive)
    positive_score = output[2]["score"]
    # predict the sentiment based on the highest score (0 for negative, 1 for positive)
    assignment = np.argmax([negative_score, positive_score])
    # add the predicted label to the list
    y_pred.append(assignment)

from sklearn.metrics import classification_report


def evaluate_performance(y_true, y_pred):
    '''Create and print the classification report comparing true and predicted labels'''
    performance = classification_report(
        y_true, y_pred, target_names=["Negative Review", "Positive Review"]
    )
    print(performance)


# evaluate the performance of the sentiment analysis model on the test set
evaluate_performance(data["test"]["label"], y_pred) # compare the true labels with the predicted labels

                 precision    recall  f1-score   support

Negative Review       0.76      0.88      0.81       533
Positive Review       0.86      0.72      0.78       533

       accuracy                           0.80      1066
      macro avg       0.81      0.80      0.80      1066
   weighted avg       0.81      0.80      0.80      1066

from datasets import load_dataset

# load the well-known 'rotten_tomatoes' dataset for sentiment analysis
data = load_dataset('rotten_tomatoes')

import torch

# determine the device to use for computation (GPU if available, otherwise CPU)
dev = 'cuda' if torch.cuda.is_available() else 'cpu'

from transformers import pipeline

# specify the path to the pre-trained FLAN-T5-small model for text-to-text generation
model_path = 'google/flan-t5-small'
# load the pre-trained text-to-text generation model into a pipeline for easy inference
pipe = pipeline(
    'text2text-generation',
    model=model_path,
    device=dev,
)

# prepare our data by creating a prompt and combining it with the text
prompt = 'Is the following sentence positive or negative? '
# apply the prompt to each example in the dataset's 'text' column to create a new 't5' column
data = data.map(lambda example: {'t5': prompt + example['text']})
# data # uncomment to inspect the modified dataset

from tqdm import tqdm  # for progress bar during inference
from transformers.pipelines.pt_utils import (
    KeyDataset,
)  # utility to feed data to the pipeline

# Run inference
y_pred = []
# iterate through the test dataset using the pipeline for text generation
for output in tqdm(
    pipe(KeyDataset(data['test'], 't5')), total=len(data['test'])
):
    # extract the generated text from the pipeline's output
    text = output[0]['generated_text']
    # classify the generated text as 0 (negative) if it equals 'negative', otherwise 1 (positive)
    y_pred.append(0 if text == 'negative' else 1)

from sklearn.metrics import classification_report


def evaluate_performance(y_true, y_pred):
    '''Create and print the classification report comparing true and predicted labels'''
    performance = classification_report(
        y_true, y_pred, target_names=['Negative Review', 'Positive Review']
    )
    print(performance)


# evaluate the performance of the model by comparing the true labels with the predicted labels
evaluate_performance(data['test']['label'], y_pred)

                 precision    recall  f1-score   support

Negative Review       0.83      0.85      0.84       533
Positive Review       0.85      0.83      0.84       533

       accuracy                           0.84      1066
      macro avg       0.84      0.84      0.84      1066
   weighted avg       0.84      0.84      0.84      1066

import openai

# create client for interacting with OpenAI API
client = openai.OpenAI(api_key='YOUR_KEY_HERE')


def chatgpt_generation(prompt, document, model='gpt-3.5-turbo-0125'):
    '''Generate an output based on a prompt and an input document using ChatGPT.'''
    # define the message structure for the OpenAI API
    messages = [
        {'role': 'system', 'content': 'You are a helpful assistant.'},
        {'role': 'user', 'content': prompt.replace('[DOCUMENT]', document)},
    ]
    # call the OpenAI Chat Completions API to get a response
    chat_completion = client.chat.completions.create(
        messages=messages, model=model, temperature=0 # temperature=0 for deterministic output
    )
    # return the content of the first choice's message
    return chat_completion.choices[0].message.content


# define a prompt template as a base for sentiment classification
prompt = '''Predict whether the following document is a positive or negative
movie review:
[DOCUMENT]
If it is positive return 1 and if it is negative return 0. Do not give any
other answers.
'''

# predict the target for a single document using GPT
document = 'unpretentious , charming , quirky , original'
chatgpt_generation(prompt, document)



from datasets import load_dataset

# load the well-known 'rotten_tomatoes' dataset for sentiment analysis
data = load_dataset('rotten_tomatoes')

from tqdm import tqdm

# generate predictions for all documents in the test set
predictions = [
    chatgpt_generation(prompt, doc) for doc in tqdm(data['test']['text'])
]

# convert the string predictions ('0' or '1') to integers
y_pred = [int(pred) for pred in predictions]

from sklearn.metrics import classification_report


def evaluate_performance(y_true, y_pred):
    '''Create and print the classification report comparing true and predicted labels'''
    performance = classification_report(
        y_true, y_pred, target_names=['Negative Review', 'Positive Review']
    )
    print(performance)


# evaluate the performance of ChatGPT on the test set
evaluate_performance(data['test']['label'], y_pred)

from sentence_transformers import SentenceTransformer

# create an embedding model using a pre-trained Sentence Transformer model
embedding_model = SentenceTransformer('thenlper/gte-small') (1)

# generate embeddings for each abstract in the 'abstracts' list
embeddings = embedding_model.encode(abstracts, show_progress_bar=True)

# check the dimensions (shape) of the resulting embeddings
embeddings.shape # (44949, 384) (2)

# prompt components
persona = 'You are an expert in Large Language models. You excel at breaking down complex papers into digestible summaries.\n'
instruction = 'Summarize the key findings of the paper provided.\n'
context = 'Your summary should extract the most crucial points that can help researchers quickly understand the most vital information of the paper.\n'
data_format = 'Create a bullet-point summary that outlines the method. Follow this up with a concise paragraph that encapsulates the main results.\n'
audience = 'The summary is designed for busy researchers that quickly need to grasp the newest trends in Large Language Models.\n'
tone = 'The tone should be professional and clear.\n'
text = 'MY TEXT TO SUMMARIZE'
data = f'Text to summarize: {text}'

# the full prompt - remove and add pieces to view its impact on the generated output
query = persona + instruction + context + data_format + audience + tone + data

# use a single example of using the made-up word in a sentence
one_shot_prompt = [
    {
        'role': 'user',
        'content': 'A \'Gigamuru\' is a type of Japanese musical instrument. An example of a sentence that uses the word Gigamuru is:',
    },
    {
        'role': 'assistant',
        'content': 'I have a Gigamuru that my uncle gave me as a gift. I love to play it at home.',
    },
    {
        'role': 'user',
        'content': 'To \'screeg\' something is to swing a sword at it. An example of a sentence that uses the word screeg is:',
    },
]
print(tokenizer.apply_chat_template(one_shot_prompt, tokenize=False))

<|user|>A 'Gigamuru' is a type of Japanese musical instrument. An example of a sentence that uses the word Gigamuru is:<|end|><|assistant|>I have a Gigamuru that my uncle gave me as a gift. I love to play it at home.<|end|><|user|>To 'screeg' something is to swing a sword at it. An example of a sentence that uses the word screeg is:<|end|><|endoftext|>

# generate the output
outputs = pipe(one_shot_prompt)
print(outputs[0]["generated_text"])

In the medieval fantasy novel, the knight would screeg his enemies with his gleaming sword.

# create name and slogan for a product
product_prompt = [
    {
        "role": "user",
        "content": "Create a name and slogan for a chatbot that leverages LLMs.",
    }
]
outputs = pipe(product_prompt)
product_description = outputs[0]["generated_text"]
print(product_description)

# based on a name and slogan for a product, generate a sales pitch
sales_prompt = [
    {
        "role": "user",
        "content": f"Generate a very short sales pitch for the following product: '{product_description}'",
    }
]
outputs = pipe(sales_prompt)
sales_pitch = outputs[0]["generated_text"]
print(sales_pitch)

Name: LexiBot

Slogan: "Unlock the Power of Language with LexiBot – Your AI Conversation Partner!"

Discover the future of communication with LexiBot – your AI conversation partner. Say goodbye to language barriers and hello to seamless, intelligent interactions. LexiBot is here to unlock the power of language, making every conversation more engaging and productive. Embrace the power of AI with LexiBot today!

# zero-shot chain-of-thought prompt
zeroshot_cot_prompt = [
    {
        "role": "user",
        "content": "The cafeteria had 23 apples. If they used 20 to make lunch and bought 6 more, how many apples do they have? Let's think step-by-step.",
    }
]

# self-consistency settings
num_samples = 3
temperature = [0.3, 0.5, 0.7]
top_p = [0.8, 0.85, 0.9]


# extract final numerical answers
def extract_answer(text):
    numbers = re.findall(r"\d+", text)  # find all numbers in the output
    return (
        numbers[-1] if numbers else None
    )  # take the last number as the final answer


# generate multiple answers
answers = []
for i in range(num_samples):
    outputs = pipe(
        zeroshot_cot_prompt,
        do_sample=True,
        temperature=temperature[i % len(temperature)],
        top_p=top_p[i % len(top_p)],
    )
    response = outputs[0]["generated_text"].strip()
    print(f'\n{response}'
    final_answer = extract_answer(response)
    if final_answer:
        answers.append(final_answer)

# perform majority voting on numerical answers
most_common_answer, count = Counter(answers).most_common(1)[0]

print("\ngenerated answers:")
for i, ans in enumerate(answers, 1):
    print(f"{i}. {ans}")

print(f"\nfinal answer (majority vote): {most_common_answer}")

Sure, let's break it down step-by-step:

1. The cafeteria starts with 23 apples.
2. They use 20 apples to make lunch.
3. After using 20 apples, they have:
   23 apples - 20 apples = 3 apples left.
4. They then buy 6 more apples.
5. Adding the 6 apples to the 3 apples they have left gives:
   3 apples + 6 apples = 9 apples.

So, the cafeteria

Sure, let's break it down step-by-step:

1. The cafeteria starts with 23 apples.
2. They use 20 apples to make lunch.
3. After using 20 apples, they have:
   23 apples - 20 apples = 3 apples left.
4. They then buy 6 more apples.
5. Adding the 6 new apples to the 3 apples they have left, they now have:
   3 apples + 6 apples = 9 apples.

Sure, let's break it down step by step:

1. The cafeteria starts with 23 apples.
2. They use 20 apples to make lunch.
   - 23 apples - 20 apples = 3 apples remaining.
3. They then buy 6 more apples.
   - 3 apples + 6 apples = 9 apples.

So, after these transactions, the cafeteria has 9 apples.

generated answers:
1. 9
2. 9
3. 9

final answer (majority vote): 9

# zero-shot tree-of-thought prompt
zeroshot_tot_prompt = [
    {
        'role': 'user',
        'content': "Imagine three different experts are answering this question. All experts will write down 1 step of their thinking, then share it with the group. Then all experts will go on to the next step, etc. If any expert realizes they're wrong at any point then they leave. The question is 'The cafeteria had 23 apples. If they used 20 to make lunch and bought 6 more, how many apples do they have?' Make sure to discuss the results.",
    }
]

# generate the output
outputs = pipe(zeroshot_tot_prompt)
print(outputs[0]['generated_text'])

**Expert 1:**
Step 1: Start with the initial number of apples, which is 23.

**Expert 2:**
Step 1: Subtract the apples used for lunch, which is 20, from the initial 23 apples. This leaves 3 apples.

**Expert 3:**
Step 1: Add the 6 apples that were bought to the remaining 3 apples. This results in 9 apples.

**Discussion:**
All three experts agree on the final result. The cafeteria started with 23 apples, used 20 for lunch, leaving them with 3 apples. Then, they bought 6 more apples, bringing the total to 9 apples. Therefore, the cafeteria now has 9 apples.

# zero-shot learning: providing no in-context examples
zeroshot_prompt = [
    {
        'role': 'user',
        'content': 'Create a character profile for an RPG game in JSON format.',
    }
]

# generate the output
outputs = pipe(zeroshot_prompt)
print(outputs[0]['generated_text'])

# one-shot learning: providing a single in-context example of the desired output structure
one_shot_template = '''Create a short character profile for an RPG game. Make
sure to only use this format:
{
  "description": "A SHORT DESCRIPTION",
  "name": "THE CHARACTER'S NAME",
  "armor": "ONE PIECE OF ARMOR",
  "weapon": "ONE OR MORE WEAPONS"
}
'''
one_shot_prompt = [{'role': 'user', 'content': one_shot_template}]

# generate the output
outputs = pipe(one_shot_prompt)
print(outputs[0]['generated_text'])

{
  "name": "Eldrin Shadowbane",
  "class": "Rogue",
  "level": 10,
  "race": "Elf",
  "background": "Eldrin was born into a noble family in the elven city of Luminara. He was trained in the arts of stealth and combat from a young age. However, Eldrin always felt a deep connection to the shadows and the mysteries of the night. He left his family to become a rogue
{
  "description": "A skilled archer with a mysterious past, known for their agility and precision.",
  "name": "Lyra Swiftarrow",
  "armor": "Leather bracers and a lightweight leather tunic",
  "weapon": "Longbow, throwing knives"
}

from llama_cpp.llama import Llama

# load the Phi-3 language model using the llama-cpp-python library
llm = Llama.from_pretrained(
    repo_id="microsoft/Phi-3-mini-4k-instruct-gguf",
    filename="*fp16.gguf",
    n_gpu_layers=-1,
    n_ctx=2048,
    verbose=False,
)

# generate output using the loaded language model for a chat completion task
output = llm.create_chat_completion(
    messages=[
        {
            "role": "user",
            "content": "Create a warrior for an RPG in JSON for mat.",
        },
    ],
    response_format={"type": "json_object"}, # specify the response_format as a JSON
    temperature=0,
)['choices'][0]['message']["content"]

import json

# check whether the output actually is JSON
json_output = json.dumps(json.loads(output), indent=4)
print(json_output)

{
    "warrior": {
        "name": "Aldarion the Brave",
        "class": "Warrior",
        "level": 10,
        "attributes": {
            "strength": 18,
            "dexterity": 10,
            "constitution": 16,
            "intelligence": 8,
            "wisdom": 10,
            "charisma": 12
        },