Status: True

Assertion

Eating late at night makes you gain weight.

Results

Eating late at night can lead to consuming more calories than necessary because people often eat larger portions when they are not hungry or distracted by activities other than eating. This increased calorie intake, if consistent over time, may contribute to weight gain as the body stores excess energy as fat.
– True: Late-night meals can indeed be high in calories and low in nutrients, especially when they consist of processed or fast foods that are typically consumed during late hours. The body’s ability to efficiently use these nutrients is compromised due to the timing, as metabolic processes slow down at night.
– True: While there is a general assumption that late-night eating might affect weight gain due to potential disruptions in sleep and metabolic processes, it’s not an absolute rule for everyone. Some people may experience significant changes with late-night eating habits but others may not be as affected.

Based on the above information, I would classify the statement as: True: Eating late at night can potentially lead to consuming more calories than necessary and contribute to weight gain due to larger portion sizes and possible

Assumptions

<|assistant|> – Eating late at night can lead to consuming more calories than necessary, increasing the chance of excess energy storage as fat and potential weight gain over time.
– Late-night meals tend to be high in calories and low in nutrients, which may not be efficiently used by the body for energy or bodily functions.
– Consuming a significant amount of food at night disrupts normal metabolic processes that typically occur during daytime digestion.
– Weight gain is influenced by an overall increase in calorie intake and various other factors such as physical activity levels, diet quality throughout the day, and genetic predispositions.
– The statement assumes a direct correlation between late-night eating habits and weight gain, which may not apply equally to all individuals due to varying metabolic responses.
– It is assumed that people do not compensate for late-night calorie intake by reducing their consumption at other times of the day, potentially leading to an overall increase in daily caloric intake.
– The statement assumes a general link between disrupted sleep patterns (often associated with late-night eating) and metabolism that can affect weight management.

Fact Checker Output

[answer]: – True: Eating late at night can lead to consuming more calories than necessary because people often eat larger portions when they are not hungry or distracted by activities other than eating. This increased calorie intake, if consistent over time, may contribute to weight gain as the body stores excess energy as fat.

– True: Late-night meals can indeed be high in calories and low in nutrients, especially when they consist of processed or fast foods that are typically consumed during late hours. The body’s ability to efficiently use these nutrients is compromised due to the timing, as metabolic processes slow down at night.
ited with weight gain because it affects overall energy balance and can disrupt normal eating patterns throughout the day. However, individual responses to calorie intake vary greatly based on factors such as genetics, physical activity levels, and personal metabolism rates.
– True: While there is a general assumption that late-night eating might affect weight gain due to potential disruptions in sleep and metabolic processes, it’s not an absolute rule for everyone. Some people may experience significant changes with late-night eating

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)