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
        },

from langchain_core.prompts import PromptTemplate

# create a prompt template with a placeholder for the user's input
template = """<s><|user|> {input_prompt}<|end|> <|assistant|>"""
prompt = PromptTemplate(
    template=template,
    input_variables=["input_prompt"],
)

# create a simple chain with the prompt template and the language model
basic_chain = prompt | llm

# invoke the chain with the input for the prompt template
output = basic_chain.invoke(
    {
        "input_prompt": "Hi! My name is Maarten. What is 1 + 1?",
    }
)

# the 'output' variable now contains the generated text
print(output)

Hello Maarten! The answer to 1 + 1 is 2.

import json
from langchain_core.prompts import PromptTemplate
from langchain_core.runnables import RunnablePassthrough, RunnableLambda
from langchain.schema import StrOutputParser
from langchain_openai import ChatOpenAI

llm = ChatOpenAI(
    model='qwen2.5:0.5b-instruct',
    temperature=0.7,
    max_tokens=100,
    timeout=30,
    max_retries=2,
    base_url='http://localhost:11434/v1', # Ollama API
    api_key='API-KEY',
    verbose=True,
)

title_prompt = PromptTemplate.from_template(
    "<s><|user|>"
    "Create a title for a story about {summary}."
    "Only return the title."
    "<|end|> <|assistant|>"
)
character_prompt = PromptTemplate.from_template(
    "<s><|user|>"
    "Describe the main character of a story about {summary} with the title {title}. "
    "Use only two sentences."
    "<|end|><|assistant|>"
)
story_prompt = PromptTemplate.from_template(
    "<s><|user|>"
    "Create a story about {summary} with the title {title}."
    "The main character is: {character}. "
    "Only return the story and it cannot be longer than one paragraph."
    "<|end|><|assistant|>"
)

# LCEL-style chain using Runnables
title_chain = (
    {"summary": RunnablePassthrough()} | title_prompt | llm | StrOutputParser()
)

character_chain = (
    {"summary": RunnablePassthrough(), "title": title_chain}
    | character_prompt
    | llm
    | StrOutputParser()
)

story_chain = (
    {
        "summary": RunnablePassthrough(),
        "title": title_chain,
        "character": character_chain,
    }
    | story_prompt
    | llm
    | StrOutputParser()
)

aggregate_chain = RunnableLambda(
    lambda inputs: {
        "summary": inputs["summary"],
        "title": inputs["title"],
        "character": inputs["character"],
        "story": inputs["story"],
    }
)

final_chain = {
    "summary": RunnablePassthrough(),
    "title": title_chain,
    "character": character_chain,
    "story": story_chain,
} | aggregate_chain

output = final_chain.invoke({"summary": "a girl that lost her mother"})
print(json.dumps(output, indent=2))

{
  "summary": {
    "summary": "a girl that lost her mother"
  },
  "title": "\"Lost Mother Girl\"",
  "character": "In the story, the main character named Lily, who was born to an ordinary family, unexpectedly finds herself the daughter of a rich individual after losing her mother. She navigates this new reality with courage and strength, learning valuable lessons about empathy, perseverance, and the power of resilience.",
  "story": "In the quiet village where Linxue lived, her mother had been gone for many years. As an only child, she often felt distant from the other children in the village. One day,

from langchain_core.prompts import PromptTemplate

template = """<s><|user|>Current conversation:{chat_history}

{input}<|end|>
<|assistant|>"""
prompt = PromptTemplate.from_template(template)

from langchain.memory import ConversationBufferMemory

memory = ConversationBufferMemory(memory_key="chat_history")

from langchain.chains.llm import LLMChain

llm_chain = LLMChain(prompt=prompt, llm=llm, memory=memory)

llm_chain.invoke({"input": "Hi! My name is Maarten. What is 1 + 1?"})

{'input': 'Hi! My name is Maarten. What is 1 + 1?',
 'chat_history': '',
 'text': 'Nice to meet you, Maarten!\n\nThe answer to 1 + 1 is... 2!'}

llm_chain.invoke({"input": "What is my name?"})

{'input': 'What is my name?',
 'chat_history': 'Human: Hi! My name is Maarten. What is 1 + 1?\nAI: Nice to meet you, Maarten!\n\nThe answer to 1 + 1 is... 2!',
 'text': 'Nice to meet you too, Maarten! Your name is indeed Maarten. Would you like to ask another question or have a conversation?'}

from langchain_core.prompts import PromptTemplate

template = """<s><|user|>Current conversation:{chat_history}

{input}<|end|>
<|assistant|>"""
prompt = PromptTemplate.from_template(template)

from langchain.memory import ConversationBufferWindowMemory

memory = ConversationBufferWindowMemory(k=2, memory_key="chat_history")

from langchain.chains.llm import LLMChain

llm_chain = LLMChain(prompt=prompt, llm=llm, memory=memory)

llm_chain.invoke(
    input="Hi! My name is Maarten and I am 33 years old. What is 1 + 1?"
)
llm_chain.invoke(input="What is 3 + 3?")
llm_chain.invoke({"input": "What is my name?"})
llm_chain.invoke({"input": "What is my age?"})

from langchain_core.prompts import PromptTemplate

template = """<s><|user|>Current conversation:{chat_history}

{input}<|end|>
<|assistant|>"""
prompt = PromptTemplate.from_template(template)

from langchain.memory import ConversationSummaryMemory

# prepare a summarization template as the summarization prompt
summary_prompt_template = """<s><|user|>Summarize the conversations and update
with the new lines.
Current summary:
{summary}
new lines of conversation:
{new_lines}
New summary:<|end|>
<|assistant|>"""
summary_prompt = PromptTemplate.from_template(template=summary_prompt_template)

memory = ConversationSummaryMemory(
    llm=llm, memory_key="chat_history", prompt=summary_prompt
)

from langchain.chains.llm import LLMChain

llm_chain = LLMChain(prompt=prompt, llm=llm, memory=memory)

llm_chain.invoke({"input": "Hi! My name is Maarten. What is 1 + 1?"})

{'input': 'Hi! My name is Maarten. What is 1 + 1?',
 'chat_history': '',
 'text': 'Hi Maarten!\n\nThe answer to 1 + 1 is 2.'}

llm_chain.invoke({"input": "What is my name?"})

{'input': 'What is my name?',
 'chat_history': "Here is the updated summary:\n\nCurrent summary:\n\n* Human: Hi! My name is Maarten. What is 1 + 1?\n* AI: Hi Maarten!\n* Answer: The answer to 1 + 1 is 2.\n\nNew lines of conversation:\nHuman: That's correct, what's 2 * 2?\nAI: Let me calculate... The answer to 2 * 2 is 4.",
 'text': 'Hi Maarten! Your name was mentioned earlier in our conversation. You said "Hi! My name is Maarten." What can I help you with next?'}

llm_chain.invoke({"input": "What was the first question I asked?"})

{'input': 'What was the first question I asked?',
 'chat_history': 'Here\'s the updated summary:\n\nCurrent summary:\n\n* Human: Hi! My name is Maarten. What is 1 + 1?\n* AI: Hi Maarten!\n* Answer: The answer to 1 + 1 is 2.\n* Human: That\'s correct, what\'s 2 * 2?\n* AI: Let me calculate... The answer to 2 * 2 is 4.\n* Human: What is my name?\n* AI: Hi Maarten! Your name was mentioned earlier in our conversation. You said "Hi! My name is Maarten." What can I help you with next?',
 'text': 'The first question you asked was: "what\'s 1 + 1?"'}

# check what the summary is thus far
memory.load_memory_variables({})

{'chat_history': 'Here is the updated summary:\n\nCurrent summary:\n\n* Human: Hi! My name is Maarten. What is 1 + 1?\n* AI: Hi Maarten!\n* Answer: The answer to 1 + 1 is 2.\n* Human: That\'s correct, what\'s 2 * 2?\n* AI: Let me calculate... The answer to 2 * 2 is 4.\n* Human: What is my name?\n* AI: Hi Maarten! Your name was mentioned earlier in our conversation. You said "Hi! My name is Maarten." What can I help you with next?\n* Human: What was the first question I asked?\n* AI: The first question you asked was: "what\'s 1 + 1?"'}

from langchain_openai import ChatOpenAI

llm = ChatOpenAI(
    model="gpt-4o",
    temperature=0,
    max_tokens=100,
    timeout=30,
    max_retries=2,
)

llm.invoke('What is LangChain?')

from langchain_core.prompts import PromptTemplate

prompt_template = PromptTemplate.from_template("Tell me a joke about {topic}")
prompt = prompt_template.format(**{"topic": "cats"})
print(prompt)
# Tell me a joke about cats

from langchain_core.prompts import ChatPromptTemplate

prompt_template = ChatPromptTemplate([
    ("system", "You are a helpful assistant"),
    ("user", "Tell me a joke about {topic}")
])
prompt = prompt_template.format(**{"topic": "cats"})
print(prompt)
# System: You are a helpful assistant
# Human: Tell me a joke about cats

from langchain_core.prompts import ChatPromptTemplate, MessagesPlaceholder
from langchain_core.messages import HumanMessage

prompt_template = ChatPromptTemplate([
    ("system", "You are a helpful assistant"),
    MessagesPlaceholder("msgs")
])
prompt = prompt_template.format(**{"msgs": [HumanMessage(content="hi!")]})
print(prompt)
# System: You are a helpful assistant
# Human: hi!

# alternatively
prompt_template = ChatPromptTemplate([
    ("system", "You are a helpful assistant"),
    ("placeholder", "{msgs}") # <-- This is the changed part
])
prompt = prompt_template.format(**{"msgs": [HumanMessage(content="hi!")]})
print(prompt)
# System: You are a helpful assistant
# Human: hi!

# parse text from message objects
from langchain_core.output_parsers import StrOutputParser

chain = llm | StrOutputParser()

output = chain.invoke('What is 2 + 2 ?')
print(output)

# 2 + 2 equals 4.

# use output parsers to parse an LLM response into structured format
from langchain_core.output_parsers import PydanticOutputParser
from langchain_core.prompts import PromptTemplate
from pydantic import BaseModel, Field, model_validator

class Joke(BaseModel):
    setup: str = Field(description="question to set up a joke")
    punchline: str = Field(description="answer to resolve the joke")

parser = PydanticOutputParser(pydantic_object=Joke)

prompt = PromptTemplate(
    template="Answer the user query.\n{format_instructions}\n{query}\n",
    input_variables=["query"],
    partial_variables={"format_instructions": parser.get_format_instructions()},
)

chain = prompt | llm | parser
output = chain.invoke({"query": "Tell me a joke."})
print(output.model_dump_json(indent=2))

# {
#   "setup": "Why did the tomato turn red?",
#   "punchline": "Because it saw the salad dressing!"
# }

# parse JSON output
from langchain_core.output_parsers import JsonOutputParser
from langchain_core.prompts import PromptTemplate
from pydantic import BaseModel, Field

class Joke(BaseModel):
    setup: str = Field(description="question to set up a joke")
    punchline: str = Field(description="answer to resolve the joke")

parser = JsonOutputParser(pydantic_object=Joke)

instructions = parser.get_format_instructions()
print(f'\n{instructions}\n---------------')

prompt = PromptTemplate(
    template="Answer the user query.\n{format_instructions}\n{query}\n",
    input_variables=["query"],
    partial_variables={"format_instructions": parser.get_format_instructions()},
)

chain = prompt | llm | parser

output = chain.invoke({"query": "Tell me a joke."})
print(output)

# The output should be formatted as a JSON instance that conforms to the JSON schema below.
#
# As an example, for the schema {"properties": {"foo": {"title": "Foo", "description": "a list of strings", "type": "array", "items": {"type": "string"}}}, "required": ["foo"]}
# the object {"foo": ["bar", "baz"]} is a well-formatted instance of the schema. The object {"properties": {"foo": ["bar", "baz"]}} is not well-formatted.
#
# Here is the output schema:
# ```
# {"properties": {"setup": {"description": "question to set up a joke", "title": "Setup", "type": "string"}, "punchline": {"description": "answer to resolve the joke", "title": "Punchline", "type": "string"}}, "required": ["setup", "punchline"]}
# ```
# ---------------
# {'setup': 'Why did the tomato turn red?', 'punchline': 'Because it saw the salad dressing!'}

from langchain_huggingface import HuggingFaceEmbeddings

embeddings = HuggingFaceEmbeddings(model_name="sentence-transformers/all-MiniLM-L6-v2")

from langchain_core.vectorstores import InMemoryVectorStore

# initialize with an embedding model
vector_store = InMemoryVectorStore(embedding=embeddings)

# add documents
from langchain_core.documents import Document

document_1 = Document(
    page_content="I had chocalate chip pancakes and scrambled eggs for breakfast this morning.",
    metadata={"source": "tweet"},
)

document_2 = Document(
    page_content="The weather forecast for tomorrow is cloudy and overcast, with a high of 62 degrees.",
    metadata={"source": "news"},
)

documents = [document_1, document_2]

vector_store.add_documents(documents=documents)
# ['df0f6926-c824-4114-a2c5-2b19d9d8740c', 'fa105761-9dd6-4c1c-860a-28e3e4ba181a']

# provide IDs for the documents to the vector store
vector_store.add_documents(documents=documents, ids=["doc1", "doc2"])
# ['doc1', 'doc2']

# delete documents
vector_store.delete(ids=["doc1"])

# similarity search
query = "my query"
docs = vectorstore.similarity_search(query)
print(docs[0].page_content)

# simple and fast text extraction

from langchain_community.document_loaders import PyPDFLoader

file_path = "./books/llm-book.pdf"

loader = PyPDFLoader(file_path)
pages = []
for page in loader.lazy_load():
    pages.append(page)

print(f"{pages[0].metadata}\n")
print(pages[0].page_content)

{'source': './books/llm-book.pdf', 'page': 0, 'page_label': 'Cover'}

Hands-On
Large Language
Models
Language Understanding
and Generation
Jay Alammar &
Maarten Grootendorst

# vector search over PDFs
from langchain_core.vectorstores import InMemoryVectorStore
from langchain_huggingface import HuggingFaceEmbeddings

embeddings = HuggingFaceEmbeddings(
    model_name="sentence-transformers/all-MiniLM-L6-v2"
)

vector_store = InMemoryVectorStore.from_documents(pages, embeddings)
docs = vector_store.similarity_search("What is Prompt Engineering?", k=2)
for doc in docs:
    print(f'Page {doc.metadata["page"]}: {doc.page_content[:300]}\n')

Page 194: Intro to Prompt Engineering
An essential part of working with text-generative LLMs is prompt engineering. By
carefully designing our prompts we can guide the LLM to generate desired responses.
Whether the prompts are questions, statements, or instructions, the main goal of
prompt engineering is to e

Page 219: Summary
In this chapter, we explored the basics of using generative models through prompt
engineering and output verification. We focused on the creativity and potential com‐
plexity that comes with prompt engineering. These components of a prompt are key
in generating and optimizing output appropri

from langchain_text_splitters import RecursiveCharacterTextSplitter

text_splitter = RecursiveCharacterTextSplitter(
    chunk_size=100,
    chunk_overlap=20,
    length_function=len,
    is_separator_regex=False,
)

with open("state_of_the_union.txt") as f:
    state_of_the_union = f.read()

texts = text_splitter.split_text(state_of_the_union)
print(texts[0])
print(texts[1])

Madam Speaker, Madam Vice President, our First Lady and Second Gentleman. Members of Congress and
of Congress and the Cabinet. Justices of the Supreme Court. My fellow Americans.

from langchain_community.document_loaders.text import TextLoader

loader = TextLoader("state_of_the_union.txt")
documents = loader.load()
split_documents = text_splitter.split_documents(documents)
print(split_documents[0])
print(split_documents[1])

page_content='Madam Speaker, Madam Vice President, our First Lady and Second Gentleman. Members of Congress and' metadata={'source': 'state_of_the_union.txt'}
page_content='of Congress and the Cabinet. Justices of the Supreme Court. My fellow Americans.' metadata={'source': 'state_of_the_union.txt'}

from langchain_community.document_loaders import PyPDFLoader

loader = PyPDFLoader("./books/llm-book.pdf")
documents = loader.load()
split_documents = text_splitter.split_documents(documents)
print(split_documents[0])
print(split_documents[1])