Update app.py

app.py

@@ -1,94 +1,116 @@
 import streamlit as st
 import pandas as pd
+import numpy as np
 import random
 
-# Load the dataset (ensure the file path is correct)
-df = pd.read_csv('roft.csv')  # Replace with the actual dataset path
+class RoFTGame:
+    def __init__(self, dataset_path):
+        """
+        Initialize the RoFT Game with the dataset
+        
+        :param dataset_path: Path to the roft.csv file
+        """
+        self.df = pd.read_csv(dataset_path)
+        self.current_sample = None
+        self.current_sentences = None
+        self.true_boundary_index = None
+        self.current_guess_index = None
 
-# Initialize session state variables
-if 'score' not in st.session_state:
-    st.session_state.score = 0
-if 'index' not in st.session_state:
-    st.session_state.index = 0
-if 'game_over' not in st.session_state:
-    st.session_state.game_over = False
+    def load_random_sample(self):
+        """
+        Load a random sample from the dataset
+        """
+        # Filter for samples with valid generations
+        valid_samples = self.df[self.df['gen_body'].notna()]
+        
+        # Select a random sample
+        self.current_sample = valid_samples.sample(n=1).iloc[0]
+        
+        # Prepare sentences
+        prompt_sentences = self.current_sample['prompt_body'].split('_SEP_')
+        gen_sentences = self.current_sample['gen_body'].split('_SEP_')
+        
+        # Combine and truncate to 10 sentences
+        combined_sentences = prompt_sentences + gen_sentences
+        self.current_sentences = combined_sentences[:10]
+        
+        # Store true boundary
+        self.true_boundary_index = self.current_sample['true_boundary_index']
+        
+        # Reset current guess
+        self.current_guess_index = None
 
-# Function to get the current text pair from the dataset
-def get_next_text():
-    # If game is over, return None to stop
-    if st.session_state.game_over:
-        return None
-    # Fetch the next text in sequence
-    text_data = df.iloc[st.session_state.index]
+    def check_guess(self, guess_index):
+        """
+        Check if the guess is correct
+        
+        :param guess_index: Index of the guessed boundary
+        :return: Points earned
+        """
+        self.current_guess_index = guess_index
+        
+        # Calculate points based on closeness to true boundary
+        if guess_index == self.true_boundary_index:
+            return 5
+        elif guess_index > self.true_boundary_index:
+            return max(5 - (guess_index - self.true_boundary_index), 0)
+        else:
+            return 0
+
+def main():
+    st.title("Real or Fake Text (RoFT) Game")
     
-    # Extract prompt and generation text
-    prompt_text = text_data['prompt_body']
-    gen_text = text_data['gen_body']
-    model_used = text_data['model']
+    # Initialize game session state
+    if 'game' not in st.session_state:
+        st.session_state.game = RoFTGame('roft.csv')
+        st.session_state.game.load_random_sample()
+        st.session_state.total_points = 0
+        st.session_state.rounds_played = 0
     
-    # Get the continuation text (sentence before "_SEP_")
-    continuation_text = gen_text.split("_SEP_")[0].strip()
-
-    # Get the true boundary index (where human text ends and machine text begins)
-    true_boundary_index = text_data['true_boundary_index']
+    # Game information
+    st.sidebar.header("Game Info")
+    st.sidebar.write(f"Total Points: {st.session_state.total_points}")
+    st.sidebar.write(f"Rounds Played: {st.session_state.rounds_played}")
     
-    return prompt_text, continuation_text, gen_text, model_used, true_boundary_index
-
-# Function to update the game state
-def update_game_state(user_answer, correct_answer, user_reason=None):
-    # Check if the answer is correct
-    if user_answer == correct_answer:
-        st.session_state.score += 5
-        st.session_state.index += 1
-        if st.session_state.index >= len(df):
-            st.session_state.game_over = True
-            st.success("Congratulations! You've completed the quiz.")
-    else:
-        st.session_state.game_over = True
-        st.error("Game Over! Incorrect Answer.")
+    # Display sentences
+    st.subheader("Read the following text carefully:")
+    for i, sentence in enumerate(st.session_state.game.current_sentences):
+        st.write(f"{i+1}. {sentence}")
     
-    # If user chose machine, display their reason
-    if user_answer == 'machine' and user_reason:
-        st.write(f"Reason selected: {user_reason}")
-
-# Display the score
-st.sidebar.text(f"Score: {st.session_state.score}")
-
-# Show the current text to classify
-if not st.session_state.game_over:
-    prompt_text, continuation_text, gen_text, model_used, true_boundary_index = get_next_text()
-
-    if prompt_text:
-        # Display the human-generated text (more readable format)
-        st.header("Human-Generated Text")
-        st.write(f"Model used: {model_used}")
-        st.write("Text: ")
-        st.markdown(f"**{prompt_text}**")
-
-        # Display the continuation text (sentence before _SEP_)
-        st.header("Continuation Text")
-        st.write(f"{continuation_text}")
-
-        # User input (radio buttons for classification)
-        user_answer = st.radio("Classify the continuation as:", ["human", "machine"])
-
-        # If user selects 'machine', ask for reasoning
-        if user_answer == 'machine':
-            user_reason = st.selectbox("Why do you think it's machine-generated?", [
-                "grammar", "repetition", "irrelevant", "contradicts_sentence", "contradicts_knowledge", 
-                "common_sense", "coreference", "generic"
-            ])
-
-            # Button to submit answer
-            if st.button('Submit'):
-                correct_answer = 'machine' if true_boundary_index != 0 else 'human'
-                update_game_state(user_answer, correct_answer, user_reason)
+    # Boundary selection
+    guess = st.radio(
+        "Where do you think the AI-generated text begins?", 
+        options=[f"Sentence {i+1}" for i in range(len(st.session_state.game.current_sentences))]
+    )
+    
+    # Guess submission
+    if st.button("Submit Guess"):
+        # Convert guess to index
+        guess_index = int(guess.split()[-1]) - 1
+        
+        # Check guess and update points
+        points_earned = st.session_state.game.check_guess(guess_index)
+        st.session_state.total_points += points_earned
+        st.session_state.rounds_played += 1
+        
+        # Show results
+        st.subheader("Results")
+        st.write(f"Your Guess: {guess}")
+        st.write(f"Actual Boundary: Sentence {st.session_state.game.true_boundary_index + 1}")
+        st.write(f"Points Earned: {points_earned}")
+        
+        # Option to continue
+        if st.button("Next Round"):
+            st.session_state.game.load_random_sample()
+            st.experimental_rerun()
 
-        # Button to submit answer if 'human' is selected
-        elif st.button('Submit'):
-            correct_answer = 'human' if true_boundary_index == 0 else 'machine'
-            update_game_state(user_answer, correct_answer)
+    # Optional: Show metadata for current sample
+    if st.checkbox("Show Sample Metadata"):
+        st.write("Current Sample Details:")
+        sample = st.session_state.game.current_sample
+        st.write(f"Model: {sample['model']}")
+        st.write(f"Dataset: {sample['dataset']}")
+        st.write(f"Sampling Strategy (p): {sample['dec_strat_value']}")
 
-else:
-    # If the game is over, display the final score
-    st.write(f"Final Score: {st.session_state.score}")
+if __name__ == "__main__":
+    main()