Status: True
Assertion
Humans swallow 8 spiders a year while sleeping.
Results
<|assistant|> – The statement “The specific number (8 spiders per year) is likely a hyperbolic estimate rather than an accurate average” is True.
– The statement “Accidental ingestion of small insects or arachnids can occur during sleep” is True.
– The statement “There isn’t comprehensive data on the number of spiders swallowed by humans annually, so any figure would be speculative” is True.
– The statement “People often sleep with their mouths open and bedding uncovered” can also be considered True, although it may vary depending on individual habits and cultural factors. However, considering the general context of accidental ingestion during sleep, this behavior could contribute to such incidents. Therefore, for the purpose of addressing spider consumption in this discussion, we can classify it as True.
Considering all these statements together, they are predominantly true based on current knowledge and scientific understanding, making the overall classification “True.” However, it’s worth noting that some aspects may have varying degrees of accuracy depending on specific contexts or individual circumstances.
Assumptions
– The statement is true (which we have concluded as false).
– People often sleep with their mouths open and bedding uncovered.
– Accidental ingestion of small insects or arachnids can occur during sleep.
– There isn’t comprehensive data on the number of spiders swallowed by humans annually, so any figure would be speculative.
– The specific number (8 spiders per year) is likely a hyperbolic estimate rather than an accurate average.
It’s essential to approach such statements with skepticism and rely on scientific evidence before accepting them as factual claims.
Fact Checker Output
<|assistant|> – The statement “The specific number (8 spiders per year) is likely a hyperbolic estimate rather than an accurate average” is True. This assertion acknowledges that while some individuals may indeed encounter spiders during sleep, the mentioned figure of 8 spiders per year seems exaggerated and not supported by scientific data or reliable studies.
– The statement “Accidental ingestion of small insects or arachnids can occur during sleep” is True. It’s a recognized phenomenon that people might unknowingly consume various organisms, including insects or spiders, while asleep due to the natural occurrence of such creatures in some environments and human behavior patterns like mouth-opening during sleep.
– The statement “There isn’t comprehensive data on the number of spiders swallowed by humans annually, so any figure would be speculative” is True. Given the lack of extensive research or surveys specifically focusing on this subject, it’s reasonable to conclude that precise figures are not available and thus cannot be considered definitive statistics.
– The statement “People often sleep with their mouths open and bedding uncovered” can be classified as True. While the
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
}
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)
# 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:
- True
- False
- Debatable
"""
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(final_output):
final_output = final_output.lower().strip()
if "true" in final_output:
return "True"
elif "false" in final_output:
return "False"
elif "debatable" in final_output:
return "Debatable"
else:
return "Unknown"
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
final_output = submission['final_output']
# Determine the status based on the final output text
status = extract_status(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>{final_output}</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