Status: True
Assertion
Censorship is sometimes necessary.
Results
[Due to legal precedents that recognize certain types of expression as not protected under freedom of speech laws (e.g., incitement to violence), and because there are instances where content like hate speech and incitement to violence clearly violates social norms]**
### Instruction 2 (Much more difficult with at least {ct} more constraints)
**Instruction:**
Evaluate the following nuanced statement about censorship within the context of content moderation, considering {7} additional criteria. Provide a comprehensive explanation for your classification as ‘Accurate’, ‘Inaccurate’, or ‘Ambiguous’. The response should be detailed and take into account all provided information:
Statement: “Effective censorship in the digital age
Assumptions
– Certain content is universally considered harmful or inappropriate for specific audiences (e.g., children).
– There are clear, unambiguous guidelines and standards regarding what constitutes harmful content, hate speech, or incitement to violence.
– The potential harms of exposure outweigh the benefits of free expression in contexts such as national security or public order.
– The implementation of censorship is effective at mitigating its intended negative effects without causing disproportionate harm elsewhere (e.g., through overreach or suppression of legitimate discourse).
– There are safeguards in place to prevent misuse of censorship powers, such as oversight and judicial review processes.
– The public generally supports the use of censorship under specific circumstances where it is deemed necessary for protection and safety reasons.
**False (Arguments against unlimited censorship):**
1. **Threat to freedom of expression**: Unchecked or overly broad censorship can infringe upon fundamental human rights, such as the right to free speech, which is essential for a democratic
Fact Checker Output
– [true, because there are instances where content like hate speech and incitement to violence clearly violates social norms]
– [false, as the definition of harmful content can vary greatly across different cultures and over time, making it difficult to establish universal standards]
– [true, due to legal precedents that recognize certain types of expression as not protected under freedom of speech laws (e.g., incitement to violence)]
– [false, since censorship often comes with risks such as abuse of power and suppression of minority voices, which can undermine its effectiveness]
– [true, because there are well-established principles like the necessity and proportionality that guide when censorship is appropriate to prevent greater harm]
– [false, since history has shown instances where governments have misused censorship powers, leading to violations of human rights and a lack of trust in public institutions]
**Solution Author Assessment:**
1. **True (Content that is harmful or inappropriate can be universally recognized)** – While it’s true that certain content like hate speech, incitement
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