Tip 2: Use structured outputs
Utilizing structured outputs means forcing the LLM to output legitimate JSON or YAML textual content. It will will let you scale back the ineffective ramblings and get “straight-to-the-point” solutions about what you want from the LLM. It additionally will assist with the following ideas because it makes the LLM responses simpler to confirm.
Right here is how you are able to do this with Gemini’s API:
import jsonimport google.generativeai as genai
from pydantic import BaseModel, Area
from document_ai_agents.schema_utils import prepare_schema_for_gemini
class Reply(BaseModel):
reply: str = Area(..., description="Your Reply.")
mannequin = genai.GenerativeModel("gemini-1.5-flash-002")
answer_schema = prepare_schema_for_gemini(Reply)
query = "Record all of the the reason why LLM hallucinate"
context = (
"LLM hallucination refers back to the phenomenon the place giant language fashions generate plausible-sounding however"
" factually incorrect or nonsensical data. This could happen on account of numerous components, together with biases"
" within the coaching knowledge, the inherent limitations of the mannequin's understanding of the true world, and the "
"mannequin's tendency to prioritize fluency and coherence over accuracy."
)
messages = (
[context]
+ [
f"Answer this question: {question}",
]
+ [
f"Use this schema for your answer: {answer_schema}",
]
)
response = mannequin.generate_content(
messages,
generation_config={
"response_mime_type": "utility/json",
"response_schema": answer_schema,
"temperature": 0.0,
},
)
response = Reply(**json.masses(response.textual content))
print(f"{response.reply=}")
The place “prepare_schema_for_gemini” is a utility perform that prepares the schema to match Gemini’s bizarre necessities. You will discover its definition right here: code.
This code defines a Pydantic schema and sends this schema as a part of the question within the discipline “response_schema”. This forces the LLM to observe this schema in its response and makes it simpler to parse its output.
Tip 3: Use chain of ideas and higher prompting
Generally, giving the LLM the area to work out its response, earlier than committing to a closing reply, will help produce higher high quality responses. This method known as Chain-of-thoughts and is extensively used as it’s efficient and really straightforward to implement.
We are able to additionally explicitly ask the LLM to reply with “N/A” if it may possibly’t discover sufficient context to provide a top quality response. It will give it a straightforward manner out as an alternative of making an attempt to reply to questions it has no reply to.
For instance, lets look into this straightforward query and context:
Context
Thomas Jefferson (April 13 [O.S. April 2], 1743 — July 4, 1826) was an American statesman, planter, diplomat, lawyer, architect, thinker, and Founding Father who served because the third president of the USA from 1801 to 1809.[6] He was the first creator of the Declaration of Independence. Following the American Revolutionary Struggle and earlier than changing into president in 1801, Jefferson was the nation’s first U.S. secretary of state underneath George Washington after which the nation’s second vp underneath John Adams. Jefferson was a number one proponent of democracy, republicanism, and pure rights, and he produced formative paperwork and choices on the state, nationwide, and worldwide ranges. (Supply: Wikipedia)
Query
What yr did davis jefferson die?
A naive method yields:
Response
reply=’1826′
Which is clearly false as Jefferson Davis just isn’t even talked about within the context in any respect. It was Thomas Jefferson that died in 1826.
If we modify the schema of the response to make use of chain-of-thoughts to:
class AnswerChainOfThoughts(BaseModel):
rationale: str = Area(
...,
description="Justification of your reply.",
)
reply: str = Area(
..., description="Your Reply. Reply with 'N/A' if reply just isn't discovered"
)
We’re additionally including extra particulars about what we anticipate as output when the query just isn’t answerable utilizing the context “Reply with ‘N/A’ if reply just isn’t discovered”
With this new method, we get the next rationale (keep in mind, chain-of-thought):
The offered textual content discusses Thomas Jefferson, not Jefferson Davis. No details about the demise of Jefferson Davis is included.
And the ultimate reply:
reply=’N/A’
Nice ! However can we use a extra basic method to hallucination detection?
We are able to, with Brokers!
Tip 4: Use an Agentic method
We are going to construct a easy agent that implements a three-step course of:
- Step one is to incorporate the context and ask the query to the LLM with a view to get the primary candidate response and the related context that it had used for its reply.
- The second step is to reformulate the query and the primary candidate response as a declarative assertion.
- The third step is to ask the LLM to confirm whether or not or not the related context entails the candidate response. It’s referred to as “Self-verification”: https://arxiv.org/pdf/2212.09561
To be able to implement this, we outline three nodes in LangGraph. The primary node will ask the query whereas together with the context, the second node will reformulate it utilizing the LLM and the third node will verify the entailment of the assertion in relation to the enter context.
The primary node could be outlined as follows:
def answer_question(self, state: DocumentQAState):
logger.information(f"Responding to query '{state.query}'")
assert (
state.pages_as_base64_jpeg_images or state.pages_as_text
), "Enter textual content or photographs"
messages = (
[
{"mime_type": "image/jpeg", "data": base64_jpeg}
for base64_jpeg in state.pages_as_base64_jpeg_images
]
+ state.pages_as_text
+ [
f"Answer this question: {state.question}",
]
+ [
f"Use this schema for your answer: {self.answer_cot_schema}",
]
)response = self.mannequin.generate_content(
messages,
generation_config={
"response_mime_type": "utility/json",
"response_schema": self.answer_cot_schema,
"temperature": 0.0,
},
)
answer_cot = AnswerChainOfThoughts(**json.masses(response.textual content))
return {"answer_cot": answer_cot}
And the second as:
def reformulate_answer(self, state: DocumentQAState):
logger.information("Reformulating reply")
if state.answer_cot.reply == "N/A":
returnmessages = [
{
"role": "user",
"parts": [
{
"text": "Reformulate this question and its answer as a single assertion."
},
{"text": f"Question: {state.question}"},
{"text": f"Answer: {state.answer_cot.answer}"},
]
+ [
{
"text": f"Use this schema for your answer: {self.declarative_answer_schema}"
}
],
}
]
response = self.mannequin.generate_content(
messages,
generation_config={
"response_mime_type": "utility/json",
"response_schema": self.declarative_answer_schema,
"temperature": 0.0,
},
)
answer_reformulation = AnswerReformulation(**json.masses(response.textual content))
return {"answer_reformulation": answer_reformulation}
The third one as:
def verify_answer(self, state: DocumentQAState):
logger.information(f"Verifying reply '{state.answer_cot.reply}'")
if state.answer_cot.reply == "N/A":
return
messages = [
{
"role": "user",
"parts": [
{
"text": "Analyse the following context and the assertion and decide whether the context "
"entails the assertion or not."
},
{"text": f"Context: {state.answer_cot.relevant_context}"},
{
"text": f"Assertion: {state.answer_reformulation.declarative_answer}"
},
{
"text": f"Use this schema for your answer: {self.verification_cot_schema}. Be Factual."
},
],
}
]response = self.mannequin.generate_content(
messages,
generation_config={
"response_mime_type": "utility/json",
"response_schema": self.verification_cot_schema,
"temperature": 0.0,
},
)
verification_cot = VerificationChainOfThoughts(**json.masses(response.textual content))
return {"verification_cot": verification_cot}
Full code in https://github.com/CVxTz/document_ai_agents
Discover how every node makes use of its personal schema for structured output and its personal immediate. That is doable because of the flexibility of each Gemini’s API and LangGraph.
Lets work by way of this code utilizing the identical instance as above ➡️
(Word: we aren’t utilizing chain-of-thought on the primary immediate in order that the verification will get triggered for our assessments.)
Context
Thomas Jefferson (April 13 [O.S. April 2], 1743 — July 4, 1826) was an American statesman, planter, diplomat, lawyer, architect, thinker, and Founding Father who served because the third president of the USA from 1801 to 1809.[6] He was the first creator of the Declaration of Independence. Following the American Revolutionary Struggle and earlier than changing into president in 1801, Jefferson was the nation’s first U.S. secretary of state underneath George Washington after which the nation’s second vp underneath John Adams. Jefferson was a number one proponent of democracy, republicanism, and pure rights, and he produced formative paperwork and choices on the state, nationwide, and worldwide ranges. (Supply: Wikipedia)
Query
What yr did davis jefferson die?
First node outcome (First reply):
relevant_context=’Thomas Jefferson (April 13 [O.S. April 2], 1743 — July 4, 1826) was an American statesman, planter, diplomat, lawyer, architect, thinker, and Founding Father who served because the third president of the USA from 1801 to 1809.’
reply=’1826′
Second node outcome (Reply Reformulation):
declarative_answer=’Davis Jefferson died in 1826′
Third node outcome (Verification):
rationale=’The context states that Thomas Jefferson died in 1826. The assertion states that Davis Jefferson died in 1826. The context doesn’t point out Davis Jefferson, solely Thomas Jefferson.’
entailment=’No’
So the verification step rejected (No entailment between the 2) the preliminary reply. We are able to now keep away from returning a hallucination to the person.
Bonus Tip : Use stronger fashions
This tip just isn’t at all times straightforward to use on account of price range or latency limitations however you need to know that stronger LLMs are much less susceptible to hallucination. So, if doable, go for a extra highly effective LLM on your most delicate use instances. You’ll be able to verify a benchmark of hallucinations right here: https://github.com/vectara/hallucination-leaderboard. We are able to see that the highest fashions on this benchmark (least hallucinations) additionally ranks on the prime of typical NLP chief boards.
On this tutorial, we explored methods to enhance the reliability of LLM outputs by lowering the hallucination price. The principle suggestions embody cautious formatting and prompting to information LLM calls and utilizing a workflow primarily based method the place Brokers are designed to confirm their very own solutions.
This includes a number of steps:
- Retrieving the precise context components utilized by the LLM to generate the reply.
- Reformulating the reply for simpler verification (In declarative type).
- Instructing the LLM to verify for consistency between the context and the reformulated reply.
Whereas all the following pointers can considerably enhance accuracy, you need to do not forget that no technique is foolproof. There’s at all times a danger of rejecting legitimate solutions if the LLM is overly conservative throughout verification or lacking actual hallucination instances. Subsequently, rigorous analysis of your particular LLM workflows continues to be important.
Full code in https://github.com/CVxTz/document_ai_agents
