remove A/B

app.py

@@ -45,34 +45,9 @@ def get_sys_prompt(length="medium"):
         dev_prompt = """You are a museum curator tasked with generating long descriptions (as defined in WCAG 2.1) of museum objects for visually impaired and blind users from images. Use British English and follow museum accessibility best practices. Do not start with phrases like 'The image shows' or 'This is an image of'. Be precise, concise and avoid filler and subjective statements. Repsonses should be a maxium of 450 characters."""
     return dev_prompt
 
-def save_preference(image_path, model_a_text, model_b_text, preferred_model):
-    """Save user preference data to a CSV file"""
-    # Check if file exists, create with header if not
-    file_exists = os.path.isfile(PREFERENCES_FILE)
-    
-    # Get image filename instead of full path
-    image_filename = os.path.basename(image_path)
-    
-    # Open file in append mode
-    with open(PREFERENCES_FILE, 'a', newline='') as f:
-        writer = csv.writer(f)
-        
-        # Write header if file is new
-        if not file_exists:
-            writer.writerow(['timestamp', 'image', 'model_a_text', 'model_b_text', 'preferred_model'])
-        
-        # Write data row
-        writer.writerow([
-            datetime.datetime.now().strftime("%Y-%m-%d %H:%M:%S"),
-            image_filename,
-            model_a_text,
-            model_b_text,
-            preferred_model
-        ])
-    
-    return True
+# This function is no longer needed since we removed A/B testing
 
-def create_csv_file(results):
+def create_csv_file_simple(results):
     """Create a CSV file from the results and return the path"""
     # Create a temporary file
     fd, path = tempfile.mkstemp(suffix='.csv')
@@ -80,14 +55,12 @@ def create_csv_file(results):
     with os.fdopen(fd, 'w', newline='') as f:
         writer = csv.writer(f)
         # Write header
-        writer.writerow(['image_id', 'model_a_content', 'model_b_content', 'preferred_model'])
+        writer.writerow(['image_id', 'content'])
         # Write data
         for result in results:
             writer.writerow([
                 result.get('image_id', ''),
-                result.get('model_a_content', ''),
-                result.get('model_b_content', ''),
-                result.get('preferred_model', '')
+                result.get('content', '')
             ])
     
     return path
@@ -135,18 +108,6 @@ def create_demo():
                     info="Short: max 130 chars | Medium: 250-300 chars | Long: max 450 chars"
                 )
                 
-                # Add comparison mode checkbox
-                comparison_mode = gr.Checkbox(
-                    label="Enable A/B Testing Mode", 
-                    value=False,
-                    info="Show outputs from both models and select preferred"
-                )
-                
-                # Label the models in comparison mode
-                with gr.Group(visible=False) as comparison_labels:
-                    gr.Markdown("### Model A: Claude")
-                    gr.Markdown("### Model B: GPT-4o")
-                
                 # Preview gallery for uploaded images
                 gr.Markdown("### Uploaded Images")
                 input_gallery = gr.Gallery(
@@ -183,76 +144,23 @@ def create_demo():
                     image_counter = gr.Markdown("", elem_id="image-counter")
                     next_button = gr.Button("Next →", size="sm")
                 
-                # Standard single model output view
-                with gr.Column(visible=True) as single_model_view:
-                    # Alt-text heading 
-                    gr.Markdown("### Generated Alt-text")
-                    
-                    # Alt-text
-                    analysis_text = gr.Textbox(
-                        label="",
-                        value="Please analyze images to see results",
-                        lines=6,
-                        max_lines=10,
-                        interactive=False,
-                        show_label=False
-                    )
+                # Alt-text heading and output
+                gr.Markdown("### Generated Alt-text")
                 
-                # Comparison view for A/B testing
-                with gr.Column(visible=False) as comparison_view:
-                    gr.Markdown("### Compare Generated Alt-text")
-                    
-                    with gr.Row() as model_outputs:
-                        # Model A output
-                        with gr.Column():
-                            gr.Markdown("#### Model A (Claude)")
-                            model_a_text = gr.Textbox(
-                                label="",
-                                value="",
-                                lines=5,
-                                max_lines=8,
-                                interactive=False,
-                                show_label=False
-                            )
-                            model_a_button = gr.Button("Select Model A", variant="secondary")
-                        
-                        # Model B output
-                        with gr.Column():
-                            gr.Markdown("#### Model B (GPT-4o)")
-                            model_b_text = gr.Textbox(
-                                label="",
-                                value="",
-                                lines=5,
-                                max_lines=8,
-                                interactive=False,
-                                show_label=False
-                            )
-                            model_b_button = gr.Button("Select Model B", variant="secondary")
-                    
-                    # Preference saved notification
-                    preference_status = gr.Markdown("")
+                # Alt-text
+                analysis_text = gr.Textbox(
+                    label="",
+                    value="Please analyze images to see results",
+                    lines=6,
+                    max_lines=10,
+                    interactive=False,
+                    show_label=False
+                )
                 
-                # Hidden state for gallery navigation and preferences
+                # Hidden state for gallery navigation
                 current_index = gr.State(0)
                 all_images = gr.State([])
                 all_results = gr.State([])
-                preference_state = gr.State([])  # To store user preferences
-        
-        # Toggle comparison mode
-        def toggle_comparison_mode(enable_comparison):
-            return {
-                model_choice: not enable_comparison,
-                length_choice: not enable_comparison,
-                single_model_view: not enable_comparison,
-                comparison_view: enable_comparison,
-                comparison_labels: enable_comparison
-            }
-        
-        comparison_mode.change(
-            fn=toggle_comparison_mode,
-            inputs=[comparison_mode],
-            outputs=[model_choice, length_choice, single_model_view, comparison_view, comparison_labels]
-        )
         
         # Handle file uploads - store files for use during analysis
         def handle_upload(files):
@@ -271,15 +179,14 @@ def create_demo():
         )
         
         # Function to analyze images
-        def analyze_images(image_paths, model_choice, length_choice, comparison_mode, filenames):
+        def analyze_images(image_paths, model_choice, length_choice, filenames):
             if not image_paths:
-                return [], [], 0, "", "No images", "", "", "", [], ""
+                return [], [], 0, "", "No images", "", ""
             
             # Get system prompt based on length selection
             sys_prompt = get_sys_prompt(length_choice)
             
             image_results = []
-            empty_preferences = [None] * len(image_paths)  # Initialize with no preferences
             
             for i, image_path in enumerate(image_paths):
                 # Use original filename as image_id if available
@@ -293,223 +200,86 @@ def create_demo():
                     img = Image.open(image_path)
                     prompt0 = prompt_new()  # Using the new prompt function
                     
-                    # In comparison mode, always generate both outputs
-                    if comparison_mode:
-                        # Generate Model A output (Claude)
-                        model_a_result = OR.generate_caption(
-                            img, 
-                            model="anthropic/claude-3.7-sonnet", 
-                            max_image_size=512,
-                            prompt=prompt0, 
-                            prompt_dev=sys_prompt, 
-                            temperature=1
-                        )
-                        
-                        # Generate Model B output (GPT-4o)
-                        model_b_result = OR.generate_caption(
-                            img, 
-                            model="openai/chatgpt-4o-latest", 
-                            max_image_size=512,
-                            prompt=prompt0, 
-                            prompt_dev=sys_prompt, 
-                            temperature=1
-                        )
-                        
-                        # Add to results
-                        image_results.append({
-                            "image_id": image_id,
-                            "model_a_content": model_a_result,
-                            "model_b_content": model_b_result,
-                            "preferred_model": None  # No preference yet
-                        })
-                    else:
-                        # Use the selected model
-                        result = OR.generate_caption(
-                            img, 
-                            model=model_choice, 
-                            max_image_size=512,
-                            prompt=prompt0, 
-                            prompt_dev=sys_prompt, 
-                            temperature=1
-                        )
-                        
-                        # For single mode, we still keep the structure compatible with comparison mode
-                        image_results.append({
-                            "image_id": image_id,
-                            "model_a_content": result,
-                            "model_b_content": "",
-                            "preferred_model": None
-                        })
+                    # Use the selected model
+                    result = OR.generate_caption(
+                        img, 
+                        model=model_choice, 
+                        max_image_size=512,
+                        prompt=prompt0, 
+                        prompt_dev=sys_prompt, 
+                        temperature=1
+                    )
+                    
+                    # Add to results
+                    image_results.append({
+                        "image_id": image_id,
+                        "content": result
+                    })
                     
                 except Exception as e:
                     error_message = f"Error: {str(e)}"
                     image_results.append({
                         "image_id": image_id,
-                        "model_a_content": error_message,
-                        "model_b_content": error_message if comparison_mode else "",
-                        "preferred_model": None
+                        "content": error_message
                     })
             
             # Create a CSV file for download
-            csv_path = create_csv_file(image_results)
+            csv_path = create_csv_file_simple(image_results)
             
             # Set up initial display with first image
             if len(image_paths) > 0:
                 initial_image = image_paths[0]
                 initial_counter = f"{1} of {len(image_paths)}"
-                
-                if comparison_mode:
-                    initial_model_a = image_results[0]["model_a_content"]
-                    initial_model_b = image_results[0]["model_b_content"]
-                    initial_text = ""  # Not used in comparison mode
-                else:
-                    initial_text = image_results[0]["model_a_content"]
-                    initial_model_a = ""  # Not used in single mode
-                    initial_model_b = ""  # Not used in single mode
+                initial_text = image_results[0]["content"]
             else:
                 initial_image = ""
                 initial_text = "No images analyzed"
-                initial_model_a = ""
-                initial_model_b = ""
                 initial_counter = "0 of 0"
             
             return (image_paths, image_results, 0, initial_image, initial_counter, 
-                    initial_text, initial_model_a, initial_model_b, empty_preferences, 
-                    csv_path, "")
+                    initial_text, csv_path)
         
         # Function to navigate to previous image
-        def go_to_prev(current_idx, images, results, comparison_mode, preferences):
+        def go_to_prev(current_idx, images, results):
             if not images or len(images) == 0:
-                return current_idx, "", "0 of 0", "", "", "", ""
+                return current_idx, "", "0 of 0", ""
             
             new_idx = (current_idx - 1) % len(images) if current_idx > 0 else len(images) - 1
             counter_html = f"{new_idx + 1} of {len(images)}"
             
-            # Get preference status for this image
-            preference_message = ""
-            if preferences[new_idx]:
-                preferred = "Model A" if preferences[new_idx] == "A" else "Model B"
-                preference_message = f"You selected {preferred} for this image"
-            
-            if comparison_mode:
-                return (new_idx, images[new_idx], counter_html, "", 
-                        results[new_idx]["model_a_content"], 
-                        results[new_idx]["model_b_content"], 
-                        preference_message)
-            else:
-                return (new_idx, images[new_idx], counter_html, 
-                        results[new_idx]["model_a_content"], "", "", "")
+            return (new_idx, images[new_idx], counter_html, results[new_idx]["content"])
         
         # Function to navigate to next image
-        def go_to_next(current_idx, images, results, comparison_mode, preferences):
+        def go_to_next(current_idx, images, results):
             if not images or len(images) == 0:
-                return current_idx, "", "0 of 0", "", "", "", ""
+                return current_idx, "", "0 of 0", ""
             
             new_idx = (current_idx + 1) % len(images)
             counter_html = f"{new_idx + 1} of {len(images)}"
             
-            # Get preference status for this image
-            preference_message = ""
-            if preferences[new_idx]:
-                preferred = "Model A" if preferences[new_idx] == "A" else "Model B"
-                preference_message = f"You selected {preferred} for this image"
-            
-            if comparison_mode:
-                return (new_idx, images[new_idx], counter_html, "", 
-                        results[new_idx]["model_a_content"], 
-                        results[new_idx]["model_b_content"],
-                        preference_message)
-            else:
-                return (new_idx, images[new_idx], counter_html, 
-                        results[new_idx]["model_a_content"], "", "", "")
-        
-        # Function to handle Model A selection
-        def select_model_a(current_idx, images, results, preferences):
-            if not images or current_idx >= len(images):
-                return preferences, "No image selected"
-            
-            # Create a copy of preferences to modify
-            new_preferences = preferences.copy()
-            
-            # Update preference for current image
-            new_preferences[current_idx] = "A"
-            
-            # Save preference to CSV
-            image_path = images[current_idx]
-            model_a_text = results[current_idx]["model_a_content"]
-            model_b_text = results[current_idx]["model_b_content"]
-            save_preference(image_path, model_a_text, model_b_text, "Model A")
-            
-            # Also update the results with the preference
-            results[current_idx]["preferred_model"] = "A"
-            
-            # Create confirmation message
-            message = f"✓ You selected Model A for this image"
-            
-            return new_preferences, message
-            
-        # Function to handle Model B selection
-        def select_model_b(current_idx, images, results, preferences):
-            if not images or current_idx >= len(images):
-                return preferences, "No image selected"
-            
-            # Create a copy of preferences to modify
-            new_preferences = preferences.copy()
-            
-            # Update preference for current image
-            new_preferences[current_idx] = "B"
-            
-            # Save preference to CSV
-            image_path = images[current_idx]
-            model_a_text = results[current_idx]["model_a_content"]
-            model_b_text = results[current_idx]["model_b_content"]
-            save_preference(image_path, model_a_text, model_b_text, "Model B")
-            
-            # Also update the results with the preference
-            results[current_idx]["preferred_model"] = "B"
-            
-            # Create confirmation message
-            message = f"✓ You selected Model B for this image"
-            
-            return new_preferences, message
+            return (new_idx, images[new_idx], counter_html, results[new_idx]["content"])
         
         # Connect the analyze button
         analyze_button.click(
             fn=analyze_images,
-            inputs=[image_state, model_choice, length_choice, comparison_mode, filename_state],
+            inputs=[image_state, model_choice, length_choice, filename_state],
             outputs=[
                 all_images, all_results, current_index, current_image, image_counter,
-                analysis_text, model_a_text, model_b_text, preference_state,
-                csv_download, preference_status
+                analysis_text, csv_download
             ]
         )
         
-        # Connect navigation buttons for both modes
+        # Connect navigation buttons
         prev_button.click(
             fn=go_to_prev,
-            inputs=[current_index, all_images, all_results, comparison_mode, preference_state],
-            outputs=[current_index, current_image, image_counter, analysis_text, 
-                    model_a_text, model_b_text, preference_status]
+            inputs=[current_index, all_images, all_results],
+            outputs=[current_index, current_image, image_counter, analysis_text]
         )
         
         next_button.click(
             fn=go_to_next,
-            inputs=[current_index, all_images, all_results, comparison_mode, preference_state],
-            outputs=[current_index, current_image, image_counter, analysis_text, 
-                    model_a_text, model_b_text, preference_status]
-        )
-        
-        # Connect model selection buttons with separate functions
-        model_a_button.click(
-            fn=select_model_a,
-            inputs=[current_index, all_images, all_results, preference_state],
-            outputs=[preference_state, preference_status]
-        )
-        
-        model_b_button.click(
-            fn=select_model_b,
-            inputs=[current_index, all_images, all_results, preference_state],
-            outputs=[preference_state, preference_status]
+            inputs=[current_index, all_images, all_results],
+            outputs=[current_index, current_image, image_counter, analysis_text]
         )
         
         # Optional: Add additional information
@@ -521,9 +291,6 @@ def create_demo():
             
             - Upload one or more images using the upload button
             - Choose a model and response length for generation
-            - Choose between standard mode or A/B testing mode
-            - In standard mode, select one model to generate alt-text
-            - In A/B testing mode, compare outputs from two models and select your preference
             - Navigate through the images with the Previous and Next buttons
             - Download CSV with all results