Status: False
Assertion
Ostriches bury their heads in the sand.
Results
The first assumption is false because ostriches do not intentionally bury their heads to avoid danger. They lower their bodies and tuck their heads into their feathers as a self-protective measure when they feel threatened, but this behavior does not equate to deliberately hiding from threats by burying their heads in the ground. The second assumption is true because the phrase “bury one’s head in the sand” originated metaphorically based on ostriches and the misconception of their behavior. However, it’s essential to note that this depiction does not accurately represent how ostriches react when threatened. The third assumption is false as humans do not fully understand all aspects of ostrich behaviors; there may be still unknown elements about these animals that are yet to be discovered or understood by researchers. Lastly, the fourth assumption is true because misinterpretations of animal behavior can indeed lead to stereotypes and misconceptions among humans, as demonstrated in this example with ostriches.
Assumptions
<|assistant|> – Ostriches exhibit a defensive behavior when threatened or scared, often mistaken for burying their heads in the ground.
– This misconception likely stems from an exaggeration and misunderstanding of ostrich reactions.
– When feeling threatened, ostriches lower their bodies and tuck their heads into their feathers as a form of self-preservation.
– The phrase “burying one’s head in the sand” is derived metapromatically from this misconception and is used to describe avoidance behavior in humans.
– Ostriches have evolved unique behaviors for survival, which can be misunderstood or exaggerated when translated into human contexts.
– The statement aims to clarify that the common misconception about ostriches does not accurately represent their natural response to threats.
– It highlights how animal behavior can be mistakenly interpreted and anthropomorphized, leading to inaccurate beliefs or stereotypes.
– This illustration demonstrates the importance of understanding animal behaviors within their ecological context rather than imposing human interpretations on them.
Fact Checker Output
The assumptions are:
1. Ostriches intentionally bury their heads to avoid danger.
2. The phrase “bury one’s head in the sand” originated from ostrich behavior.
3. Humans have completely understood ostrich behaviors through research.
4. Misinterpretations of animal behaviors can lead to stereotypes and misconceptions among humans.
– response: 1. False – Ostriches lower their bodies and tuck their heads into their feathers as a form of self-preservation when feeling threatened, but it is not an intentional act of burying their heads in the ground to avoid danger. This behavior is more about protecting themselves rather than intentionally hiding from threats.
2. True – The phrase “bury one’s head in the sand” has its origins metaphorically linked to ostriches, even though it doesn’t accurately represent their actual behavior. It was popularized based on a misconception that ostriches bury their heads in the ground when threatened, but this is not an accurate depiction of how they react.
3. False – While humans have
Model Used
microsoft/Phi-3-mini-4k-instruct-gguf
Script Name
fact_checker_mongodb.py
Script Code
import os
import sys
import requests
from langchain_openai.llms import OpenAI
from langchain.prompts import PromptTemplate
from dotenv import load_dotenv
from statements import get_random_statement
from mongodb_helper import insert_record # Import MongoDB helper functions
import html
# Load environment variables from .env file
load_dotenv()
# Define category IDs
CATEGORY_IDS = {
"True": 2,
"False": 3,
"Debatable": 4,
"Unknown": 6
}
def create_wordpress_post(title, content, category):
data = {
"title": title,
"content": content,
"status": "publish",
"categories": [CATEGORY_IDS[category]]
}
response = requests.post(
os.getenv("WORDPRESS_POSTS_URL"),
json=data,
auth=(os.getenv("WORDPRESS_USERNAME"), os.getenv("WORDPRESS_PASSWORD"))
)
if response.status_code == 201:
print("Blog post created successfully.")
else:
print(f"Failed to create blog post: {response.status_code} - {response.text}")
def fact_check(assertion):
llm = OpenAI(temperature=0.7, model=os.getenv("MODEL_NAME"))
# Define the prompt templates
assertion_template = """{assertion}\n\n"""
assertion_prompt = PromptTemplate(input_variables=["assertion"], template=assertion_template)
assumptions_template = """Here is a statement:
{statement}
Make a bullet point list of the assumptions required to support the above statement.\n\n"""
assumptions_prompt = PromptTemplate(input_variables=["statement"], template=assumptions_template)
fact_checker_template = """Here is a bullet point list of assertions:
{assertions}
For each assumption, determine whether it is true or false. Explain your reasoning.\n\n"""
fact_checker_prompt = PromptTemplate(input_variables=["assertions"], template=fact_checker_template)
answer_template = """
Here is the information to classify the statement:
{facts}
Based on the above information, how would you classify the statement? Respond with one of the following options followed by a colon and space:
- True: [Explanation]
- False: [Explanation]
- Debatable: [Explanation]
"""
answer_prompt = PromptTemplate(input_variables=["facts"], template=answer_template)
# Format prompts and extract the string content
formatted_assertion = assertion_prompt.format_prompt(assertion=assertion).text
assertion_output = llm.invoke(formatted_assertion)
formatted_assumptions = assumptions_prompt.format_prompt(statement=assertion_output).text
assumptions_output = llm.invoke(formatted_assumptions)
formatted_fact_checker = fact_checker_prompt.format_prompt(assertions=assumptions_output).text
fact_checker_output = llm.invoke(formatted_fact_checker)
formatted_answer = answer_prompt.format_prompt(facts=fact_checker_output).text
final_output = llm.invoke(formatted_answer)
return {
"assertion_output": assertion_output,
"assumptions_output": assumptions_output,
"fact_checker_output": fact_checker_output,
"final_output": final_output,
}
def extract_status_and_reasoning(final_output):
final_output = final_output.strip()
if "True:" in final_output:
status_start = final_output.find("True:")
status = "True"
elif "False:" in final_output:
status_start = final_output.find("False:")
status = "False"
elif "Debatable:" in final_output:
status_start = final_output.find("Debatable:")
status = "Debatable"
else:
return "Unknown", final_output
reasoning = final_output[status_start + len(status) + 1:].strip()
return status, reasoning
if __name__ == "__main__":
if len(sys.argv) > 1:
assertion = sys.argv[1]
else:
assertion = get_random_statement()
print(assertion)
submission = fact_check(assertion)
# Print the detailed outputs to inspect their structure
for key, value in submission.items():
print(f"{key}: {value}")
# Extract the final output for status determination and reasoning
final_output = submission['final_output']
status, reasoning = extract_status_and_reasoning(final_output)
# Record the result in MongoDB
try:
print("Attempting to insert record into MongoDB...")
insert_record(
script_name="fact_checker_mongodb.py",
script_code=html.escape(open(__file__).read()),
assertion=assertion,
status=status,
submission=submission, # Store the entire submission for detailed analysis
model=os.getenv("MODEL_NAME")
)
print("Record inserted into MongoDB successfully.")
except Exception as e:
print(f"Failed to insert record into MongoDB: {e}")
print(final_output)
# Create a blog post on WordPress
blog_title = f"Fact Check: {assertion}"
blog_content = f"""
<h1>Status: {status}</h1>
<h2>Assertion</h2>
<p>{assertion}</p>
<h2>Results</h2>
<p>{reasoning}</p>
<h3>Assumptions</h3>
<p>{submission['assumptions_output']}</p>
<h3>Fact Checker Output</h3>
<p>{submission['fact_checker_output']}</p>
<h4>Model Used</h4>
<p>{os.getenv("MODEL_NAME")}</p>
<h4>Script Name</h4>
<p>fact_checker_mongodb.py</p>
<h4>Script Code</h4>
<pre>{html.escape(open(__file__).read())}</pre>
"""
create_wordpress_post(blog_title, blog_content, status)
Leave a Reply