hw2

.gitignore

@@ -0,0 +1,62 @@
+# Python
+__pycache__/
+*.py[cod]
+*$py.class
+*.so
+.Python
+build/
+develop-eggs/
+dist/
+downloads/
+eggs/
+.eggs/
+lib64/
+parts/
+sdist/
+var/
+wheels/
+pip-wheel-metadata/
+share/python-wheels/
+*.egg-info/
+.installed.cfg
+*.egg
+MANIFEST
+
+# Virtual environments
+venv/
+env/
+ENV/
+.venv
+
+# IDEs
+.vscode/
+.idea/
+*.swp
+*.swo
+*~
+.DS_Store
+
+# Testing
+.pytest_cache/
+.coverage
+htmlcov/
+*.cover
+.hypothesis/
+
+# Jupyter
+.ipynb_checkpoints
+
+# Environment variables
+.env
+.env.local
+
+# macOS
+.DS_Store
+.AppleDouble
+.LSOverride
+Thumbs.db
+
+# Temporary files
+*.tmp
+*.log
+*.bak

README.md

@@ -11,3 +11,5 @@ short_description: CS5330-HW2
 ---
 
 Check out the configuration reference at https://huggingface.co/docs/hub/spaces-config-reference
+
+CS5330 - HW2

app.py

@@ -0,0 +1,254 @@
+"""
+AI vs Real Face Detection Game - Simplified Version
+
+Interactive Gradio web application that allows users to test their ability to distinguish
+between AI-generated faces and real human faces through a game-based approach.
+"""
+
+import os
+import sys
+import logging
+import argparse
+import gradio as gr
+
+# Add src directory to Python path
+sys.path.insert(0, os.path.join(os.path.dirname(__file__), 'src'))
+
+from src.image_manager import ImagePool
+from src.model_inference import FaceDetectorModel
+from src.game_logic import GameState
+from src.utils import calculate_bg_color
+
+# Configure logging
+logging.basicConfig(
+    level=logging.INFO,
+    format='%(asctime)s - %(name)s - %(levelname)s - %(message)s'
+)
+logger = logging.getLogger(__name__)
+
+
+def initialize_app():
+    """Initialize application, load model and image pool"""
+    logger.info("Starting application initialization...")
+
+    try:
+        # Load image pool
+        logger.info("Loading image pool...")
+        image_pool = ImagePool(ai_dir="image/ai", real_dir="image/real")
+        logger.info(f"Image pool loaded successfully: {image_pool.total_ai} AI images, {image_pool.total_real} real images")
+
+        # Load AI model
+        logger.info("Loading AI detection model...")
+        model = FaceDetectorModel(model_path="model/best_mobilenet_finetuned.keras")
+        logger.info("Model loaded successfully")
+
+        # Warmup model
+        logger.info("Warming up model...")
+        model.warmup()
+
+        # Create game state
+        game_state = GameState()
+        game_state.images = image_pool.create_game_set()
+        game_state.next_round()
+
+        logger.info("Application initialization complete!")
+        return image_pool, model, game_state
+
+    except Exception as e:
+        error_msg = f"Application initialization failed: {e}"
+        logger.error(error_msg)
+        raise RuntimeError(error_msg)
+
+
+def format_score(player_score, ai_score, current_round, total_rounds):
+    """Format score display"""
+    return f"""### Score
+
+            **You**: {player_score}
+
+            **AI**: {ai_score} \n
+
+            **Progress**: {current_round}/{total_rounds}
+            """
+
+
+def create_app():
+    """Create Gradio application"""
+    image_pool, model, game_state = initialize_app()
+
+    with gr.Blocks(title="AI vs Real Face Detection Game") as app:
+        gr.Markdown("# AI vs Real Face Detection Game")
+        gr.Markdown("Test your ability to distinguish AI-generated faces from real human faces!")
+
+        state = gr.State(game_state)
+
+        with gr.Tabs():
+            # ==================== Game Mode ====================
+            with gr.Tab("Game Mode"):
+                with gr.Row():
+                    with gr.Column(scale=1):
+                        score_display = gr.Markdown(
+                            value=format_score(0, 0, 1, 20)
+                        )
+                        ai_button = gr.Button("AI Generated", variant="primary", size="lg")
+                        human_button = gr.Button("Real Human", variant="secondary", size="lg")
+                        next_button = gr.Button("Next", size="lg")
+                        reset_button = gr.Button("Reset Game", size="sm")
+                        feedback_display = gr.Markdown(value="Guess if this is AI-generated or a real human?")
+
+                    with gr.Column(scale=3):
+                        image_display = gr.Image(
+                            label="Face Image",
+                            value=game_state.current_image_path
+                        )
+
+            # ==================== Detector Mode ====================
+            with gr.Tab("Detector Mode"):
+                with gr.Row():
+                    with gr.Column(scale=1):
+                        detector_result_display = gr.Markdown(value="Click button to view random image")
+                        detector_next_button = gr.Button("Next Random Image", variant="primary", size="lg")
+                        detector_confidence_display = gr.Markdown(value="")
+
+                    with gr.Column(scale=3):
+                        detector_image_display = gr.Image(label="Face Image")
+
+        # ==================== Game Mode Event Handlers ====================
+        def on_guess_ai(state_value):
+            ai_prediction, ai_confidence = model.predict(state_value.current_image_path)
+            state_value.record_guess("AI", ai_prediction, ai_confidence)
+
+            feedback = state_value.last_result
+            if state_value.game_over:
+                feedback = state_value.get_final_result()
+
+            return [
+                format_score(state_value.player_score, state_value.ai_score,
+                           state_value.current_round, state_value.total_rounds),
+                feedback,
+                gr.update(interactive=False),
+                gr.update(interactive=False),
+                gr.update(visible=not state_value.game_over),
+                state_value
+            ]
+
+        def on_guess_human(state_value):
+            ai_prediction, ai_confidence = model.predict(state_value.current_image_path)
+            state_value.record_guess("Human", ai_prediction, ai_confidence)
+
+            feedback = state_value.last_result
+            if state_value.game_over:
+                feedback = state_value.get_final_result()
+
+            return [
+                format_score(state_value.player_score, state_value.ai_score,
+                           state_value.current_round, state_value.total_rounds),
+                feedback,
+                gr.update(interactive=False),
+                gr.update(interactive=False),
+                gr.update(visible=not state_value.game_over),
+                state_value
+            ]
+
+        def on_next_picture(state_value):
+            state_value.next_round()
+            return [
+                state_value.current_image_path,
+                "",
+                gr.update(interactive=True),
+                gr.update(interactive=True),
+                gr.update(visible=False),
+                format_score(state_value.player_score, state_value.ai_score,
+                           state_value.current_round, state_value.total_rounds),
+                state_value
+            ]
+
+        def on_reset_game(state_value):
+            state_value.reset()
+            state_value.images = image_pool.create_game_set()
+            state_value.current_round = 0
+            state_value.next_round()
+
+            return [
+                state_value.current_image_path,
+                format_score(0, 0, 1, 20),
+                "New game started! Guess if this is AI-generated or a real human?",
+                gr.update(interactive=True),
+                gr.update(interactive=True),
+                gr.update(visible=False),
+                state_value
+            ]
+
+        # ==================== Detector Mode Event Handlers ====================
+        def on_detector_next():
+            import random
+            label = random.choice(["AI", "Human"])
+            image_path = image_pool.get_random_image(label)
+            prediction, confidence = model.predict(image_path)
+
+            result_text = f"### AI Prediction: {prediction}\n\n**True Label**: {label}\n\n"
+            if prediction == label:
+                result_text += "✓ Correct prediction!"
+            else:
+                result_text += "✗ Incorrect prediction"
+
+            confidence_text = f"**Confidence**: {confidence * 100:.1f}%"
+            return [image_path, result_text, confidence_text]
+
+        # Bind events
+        ai_button.click(
+            fn=on_guess_ai,
+            inputs=[state],
+            outputs=[score_display, feedback_display, ai_button, human_button, next_button, state]
+        )
+
+        human_button.click(
+            fn=on_guess_human,
+            inputs=[state],
+            outputs=[score_display, feedback_display, ai_button, human_button, next_button, state]
+        )
+
+        next_button.click(
+            fn=on_next_picture,
+            inputs=[state],
+            outputs=[image_display, feedback_display, ai_button, human_button, next_button, score_display, state]
+        )
+
+        reset_button.click(
+            fn=on_reset_game,
+            inputs=[state],
+            outputs=[image_display, score_display, feedback_display, ai_button, human_button, next_button, state]
+        )
+
+        detector_next_button.click(
+            fn=on_detector_next,
+            inputs=[],
+            outputs=[detector_image_display, detector_result_display, detector_confidence_display]
+        )
+
+    return app
+
+
+def main():
+    """Main entry function"""
+    parser = argparse.ArgumentParser(description="AI vs Real Face Detection Game")
+    parser.add_argument("--port", type=int, default=7860, help="Server port")
+    parser.add_argument("--share", action="store_true", help="Create public URL")
+    parser.add_argument("--debug", action="store_true", help="Debug mode")
+    args = parser.parse_args()
+
+    if args.debug:
+        logging.getLogger().setLevel(logging.DEBUG)
+
+    try:
+        app = create_app()
+        logger.info(f"Launching application on port: {args.port}")
+        app.launch(server_port=args.port, share=args.share)
+
+    except Exception as e:
+        logger.error(f"Application launch failed: {e}")
+        sys.exit(1)
+
+
+if __name__ == "__main__":
+    main()