Status: True
Assertion
Penguins are mammals.
Results
Penguins share some characteristics with mammals, such as endothermy; however, they are primarily classified under the class Aves due to other defining features. The statement is true in highlighting commonalities but does not fit exclusively within the mammalian classification.
– [response]: – Debatable: While it’s true that penguins share some characteristics with mammals, such as endothermy and metabolic processes, they are primarily classified under the class Aves (birds). The statement is partially correct but does not encompass the full classification of penguins. However, considering their unique features, it’s debatable whether this classification alone captures all aspects of their biology.
Assumptions
<|assistant|> – Penguins belong to the class Aves (birds) based on their distinctive physical and behavioral characteristics, such as feathers, beaks, laying eggs, and possessing wings adapted for swimming rather than flying.
– Mammals share certain features with penguins, like being endothermic or warm-blooded, which allows them to maintain a constant body temperature despite environmental fluctuations through metabolic processes.
– Female penguins typically incubate their eggs internally until hatching; however, in most species of penguins, the male takes on this role instead of the female. This behavior is similar to that seen in mammals but differs from typical patterns observed in birds or other animals.
– Penguins display some features that are more common among mammals than other types of animals, such as their ability to maintain a constant body temperature and certain aspects of their physiology related to metabolic processes.
– The classification of penguins based on shared characteristics with both birds and mammals is not mutually exclusive but rather an acknowledgment of the unique adaptations that allow them to thrive in their specific habitats, such as
Fact Checker Output
Solution:
1. True – Penguins belong to the class Aves (birds) due to features like feathers, beaks, laying eggs, and swimming-adapted wings. However, they also share some characteristics with mammals, as mentioned in other points.
2. True – Both penguins and mammals are endothermic (warm-blooded), which allows them to maintain a stable body temperature regardless of the external environment through metabolic processes. This is one shared feature between these two groups.
3. False – In most species of penguins, it’s typically the male that incubates the egg internally until hatching. However, there are exceptions to this pattern in some cases (e.g., Emperor Penguins have a unique role reversal where males take care of eggs during extreme cold conditions).
4. True – The ability for penguins to maintain a constant body temperature and specific physiological aspects related to metabolic processes are shared features with mammals, as discussed in the other points. However, this doesn’t mean they fit exclusively into the mammalian classification but rather
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