Status: True
Assertion
Tomatoes are vegetables.
Results
<|assistant|> – True
support=The statement can be classified as “True” based on the provided assumptions and information. The nutritional data does show that tomatoes contain a significant amount of Vitamin C, accurate measurement methods have been used to determine this content, adequate intake levels for Vitamin C are established by health organizations, and cooking can affect Vitamin C content but consuming raw or lightly-cooked tomatoes is still beneficial. Therefore, the statement aligns with known facts about tomatoes’ nutritional value.
Assumptions
* Assumption 1: Tomatoes have a significant amount of Vitamin C. This assumption is supported by nutritional data that shows varying levels of vitamins in different foods, including tomatoes.
* Assumption 2: The measurement of Vitamin C content has been accurately determined for tomatoes. This relies on reliable and validated testing methods to assess the nutrient profile of tomatoes.
* Assumption 3: Adequate intake levels are established by authoritative health organizations, such as the World Health Organization or the National Institutes of Health. These institutions define recommended daily allowances (RDA) for various vitamins and minerals, including Vitamin C.
* Assumption 4: The statement considers tomatoes to be consumed in a form that retains their nutritional value. While cooking can affect the nutrient content of foods, raw or lightly-cooked tomatoes are generally considered to contain high levels of Vitamin C.
* Assumption 5: Consuming tomatoes provides an appreciable contribution towards meeting daily Vitamin C requirements. This depends on factors like serving size and individual dietary needs but is supported by the
Fact Checker Output
<|assistant|> * True – Assumption 1: Nutritional data does show that tomatoes contain a significant amount of Vitamin C (around 30-45 mg per 100 grams). This is consistent with the information provided by various food composition databases and scientific literature, which document nutrient content in many types of foods.
* True – Assumption 2: The measurement of Vitamin C content has been accurately determined for tomatoes using validated methods such as high-performance liquid chromatography (HPLC) or spectrophotometric assays. These methods are widely accepted and used by researchers to quantify nutrient levels in foods.
* True – Assumption 3: Adequate intake levels for Vitamin C have been established by authoritative health organizations such as the World Health Organization (WHO) and the National Institutes of Health (NIH). They provide guidelines on recommended daily allowances based on scientific evidence to help individuals meet their nutritional needs.
* True – Assumption 4: While cooking can indeed affect the Vitamin C content in tomatoes, consuming them raw or lightly-cooked is generally
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