uploaded other sizes to test and improved plot

app.py

@@ -16,12 +16,12 @@ def style_feasible_column(val):
         return 'color:white;background-color: lightcoral'
     return ''
 
-def style_size_column(val):
+def style_size_column(val, target_size=3.0):
     """Style for the Size column based on proximity to target"""
     try:
         val_float = float(val)
         
-        distance = val_float - 3.0  # Signed distance from target
+        distance = val_float - target_size  # Signed distance from target
         abs_distance = abs(distance)
         
         # Calculate width percentage based on distance
@@ -86,18 +86,25 @@ exp_record_df['Size (um)'] = Y_init[:, 0]
 exp_record_df['Solvent'] = ['DMAc' if x == 0 else 'CHCl3' for x in exp_record_df['Solvent']]
 exp_record_df['Feasible?'] = ['Success' if x == 1 else 'Failed' for x in Y_init[:, 1]]
 
-# Apply each styling function to its specific column
-prior_experiments_display = exp_record_df.style\
-    .map(style_feasible_column, subset=['Feasible?'])\
-    .map(style_size_column, subset=['Size (um)'])\
-    .format(precision=3)
+# Replace the static prior_experiments_display with a function
+def generate_prior_experiments_display(target_size=3.0):
+    """Generate styled prior experiments display based on target size"""
+    return exp_record_df.style\
+        .map(style_feasible_column, subset=['Feasible?'])\
+        .map(lambda x: style_size_column(x, target_size), subset=['Size (um)'])\
+        .format(precision=3)
+
 
 # Functions for data processing and visualization
-def import_results():
+def import_results(target_size=3):
     strategies = ['qEI', 'qEI_vi_mixed_con', 'qEICF_vi_mixed_con', 'rnd']
-    
-    # Load results from pickle file
-    with open('best_distances.pkl', 'rb') as f:
+    file_name_dict = {
+        '0.5': 'best_distances_0_5.pkl',
+        '3': 'best_distances_3_0.pkl',
+        '22': 'best_distances_22_0.pkl'
+    }
+    # Load results from pickle file based on target size
+    with open(file_name_dict[str(target_size)], 'rb') as f:
         best_distances = pickle.load(f)
 
     # vstack all values in best_distances
@@ -110,14 +117,13 @@ def import_results():
     best_distances_df_long = pd.melt(best_distances_all_trials_df, id_vars=['strategy', 'trial'], var_name='iteration', value_name='regret')
     return best_distances_df_long
 
-def calc_human_performance(df):
+def calc_human_performance(df, target_size=3.0):
     # Make a copy of the dataframe to avoid modifying the original
     df_copy = df.copy()
     
     # convert back solvent to 0 and 1
     df_copy['Solvent'] = [0 if x == 'DMAc' else 1 for x in df_copy['Solvent']]
     
-    TARGET_SIZE = 3.0  # Example target size
     ROUNDS = len(df_copy) // 2
 
     # Ensure all values are numeric
@@ -133,7 +139,7 @@ def calc_human_performance(df):
     best_human_distance = []
 
     for iter in range(ROUNDS + 1):
-        Y_distance = -np.abs(Y_human_init[:, 0] - TARGET_SIZE)
+        Y_distance = -np.abs(Y_human_init[:, 0] - target_size)
         best_human_distance.append(np.ma.masked_array(Y_distance, mask=~Y_human_init[:, 1].astype(bool)).max())
         
         # Check if we have more data for this iteration
@@ -147,12 +153,12 @@ def calc_human_performance(df):
 
     return -np.array(best_human_distance)
 
-def plot_results(exp_data_df):
+def plot_results(exp_data_df, target_size=3.0):
     # Extract human performance
-    best_human_distance = calc_human_performance(exp_data_df)
+    best_human_distance = calc_human_performance(exp_data_df, target_size)
     
     # Import results
-    best_distances_df_long = import_results()
+    best_distances_df_long = import_results(target_size)
     
     fig = go.Figure()
     
@@ -161,9 +167,12 @@ def plot_results(exp_data_df):
     for strategy in strategies:
         strategy_data = best_distances_df_long[best_distances_df_long['strategy'] == strategy]
         
-        # Calculate mean and standard deviation
+        # Calculate mean and standard error
         mean_regret = strategy_data.groupby('iteration')['regret'].mean()
         std_regret = strategy_data.groupby('iteration')['regret'].std()
+        # Calculate standard error (SE = SD/√n)
+        n_trials = strategy_data.groupby('iteration')['regret'].count()
+        se_regret = std_regret / np.sqrt(n_trials)
         
         iterations = mean_regret.index
         color = px.colors.qualitative.Set2[strategies.tolist().index(strategy)]
@@ -178,15 +187,15 @@ def plot_results(exp_data_df):
         )
         fig.add_trace(mean_trace)
         
-        # Add trace for shaded area (standard deviation)
+        # Add trace for shaded area (standard error)
         fig.add_trace(go.Scatter(
             x=list(iterations) + list(iterations[::-1]),
-            y=list(mean_regret + std_regret) + list((mean_regret - std_regret)[::-1]),
+            y=list(mean_regret + se_regret) + list((mean_regret - se_regret)[::-1]),
             fill='toself',
             fillcolor=mean_trace.line.color.replace('rgb', 'rgba').replace(')', ',0.2)'),
             line=dict(color='rgba(255,255,255,0)'),
             showlegend=False,
-            name=f'{strategy} (std dev)'
+            name=f'{strategy} (standard error)'
         ))
     # Add trace for human performance
     fig.add_trace(go.Scatter(
@@ -226,7 +235,7 @@ def calculate_auc(human_performance_values):
     return round(auc_value, 4)
 
 # Prediction function - simplified signature by removing unnecessary text params
-def predict(state, conc1, flow_rate1, voltage1, solvent1, conc2, flow_rate2, voltage2, solvent2):
+def predict(state, target_size, conc1, flow_rate1, voltage1, solvent1, conc2, flow_rate2, voltage2, solvent2):
     # Get current results storage from state or initialize if None
     if state is None:
         results_storage = pd.DataFrame(columns=['Concentration (%w/v)', 'Flow Rate (mL/h)', 'Voltage (kV)', 'Solvent', 'Size (um)', 'Feasible?'])
@@ -256,7 +265,7 @@ def predict(state, conc1, flow_rate1, voltage1, solvent1, conc2, flow_rate2, vol
     # Apply each styling function to its specific column
     results_display = results_storage.style\
         .map(style_feasible_column, subset=['Feasible?'])\
-        .map(style_size_column, subset=['Size (um)'])\
+        .map(lambda x: style_size_column(x, target_size), subset=['Size (um)'])\
         .format(precision=3)
    
     # Check if user has completed 5 rounds (10 experiments)
@@ -268,65 +277,79 @@ def predict(state, conc1, flow_rate1, voltage1, solvent1, conc2, flow_rate2, vol
     
     if completed:
         # Calculate AUC
-        human_performance = calc_human_performance(results_storage)
+        human_performance = calc_human_performance(results_storage, target_size)
         auc_value = calculate_auc(human_performance)
-        # beginner = 2.62, intermediate = 1.60, expert = 1.03
-        if auc_value > 4.10:
+
+        # Set CCBO value based on target size
+        if target_size == 3.0:
+            ccbo_value = 1.40
+        elif target_size == 0.5:
+            ccbo_value = 0.92
+        else:
+            ccbo_value = 8.51
+        
+        # Calculate performance as a percentage of CCBO value
+        performance_percentage = (auc_value / ccbo_value) * 100
+
+        if performance_percentage > 300:
             usr_level = "randomly playing!"
-        elif auc_value > 1.80:
+        elif performance_percentage > 150:
             usr_level = "a beginner."
-        elif auc_value > 1.30:
+        elif performance_percentage > 100:
             usr_level = "an intermediate user."
-        elif auc_value > 0.90:
+        elif performance_percentage > 65:
             usr_level = "an advanced user."
         else:
             usr_level = "... come on, you must have cheated (or you are extremely lucky)!"
 
-        message = f"🎉 Congratulations! You've completed all 5 rounds.Your performance AUC is ** {auc_value:.2f} ** and CCBO was ** 1.40 **. You seems to be {usr_level} Now you can download your results or try again!"
+
+        message = f"🎉 Congratulations! You've completed all 5 rounds. Your performance AUC is ** {auc_value:.2f} ** and CCBO was ** {ccbo_value} **. You seems to be {usr_level} Now you can download your results or click reset to try again!"
     
     # Return updated state and UI updates
     return (
         results_storage, 
-        gr.DataFrame(value=prior_experiments_display, label="Prior Experiments"),
+        gr.DataFrame(value=generate_prior_experiments_display(target_size), label="Prior Experiments"),
         gr.DataFrame(value=results_display, label="Your Results"), 
-        plot_results(results_storage),
+        plot_results(results_storage, target_size),
         gr.update(visible=completed),  # Show download button when completed
         gr.update(value=message, visible=completed),  # Show message when completed
         gr.update(value=auc_value),  # Update AUC value
-        gr.update(visible=completed)  # Show result file component
+        gr.update(visible=completed),  # Show result file component
+        gr.update(interactive=False if completed else True)  # Disable target selection once completed
     )
 
 # Reset results function
-def reset_results(state):
+def reset_results(state, target_size):
     results_storage = pd.DataFrame(columns=['Concentration (%w/v)', 'Flow Rate (mL/h)', 'Voltage (kV)', 'Solvent', 'Size (um)', 'Feasible?'])
     # Generate the plot for empty results
-    empty_plot = plot_results(results_storage)
+    empty_plot = plot_results(results_storage, target_size)
     
     # Apply each styling function to its specific column
     styled_results = results_storage.style\
         .map(style_feasible_column, subset=['Feasible?'])\
-        .map(style_size_column, subset=['Size (um)'])\
+        .map(lambda x: style_size_column(x, target_size), subset=['Size (um)'])\
         .format(precision=3)
     
     return (
         results_storage,  # results_state 
-        gr.DataFrame(value=prior_experiments_display, label="Prior Experiments"),  # prior_experiments
+        gr.DataFrame(value=generate_prior_experiments_display(target_size), label="Prior Experiments"),  # prior_experiments
         gr.DataFrame(value=styled_results, label="Your Results"),  # results_df
         empty_plot,  # perf_plot
         gr.update(visible=False),  # download_btn visibility
         gr.update(value="", visible=False),  # completion_message
         gr.update(value=0),  # auc_state
-        gr.update(visible=False)  # result_file visibility
+        gr.update(visible=False),  # result_file visibility
+        gr.update(interactive=True)  # Enable target selection
     )
 
 # Function to prepare results for download
-def prepare_results_for_download(results):
+def prepare_results_for_download(results, target_size):
     """Prepare results dataframe for download and save to CSV"""
     if results is None or len(results) == 0:
         return None
     
     # Calculate human performance
-    human_performance = calc_human_performance(results)
+    human_performance = calc_human_performance(results, target_size)
     auc_value = calculate_auc(human_performance)
     
     # Add a summary row with AUC
@@ -341,16 +364,17 @@ def prepare_results_for_download(results):
     
     # Combine results with summary
     combined_df = pd.concat([results, summary_df], ignore_index=True)
+    combined_df = pd.concat([pd.DataFrame([{"Concentration (%w/v)": f"Target size: {target_size} μm"}]), combined_df], ignore_index=True)
     
     # Save to temporary file
     temp_dir = tempfile.gettempdir()
-    output_path = os.path.join(temp_dir, "electrospray_results.csv")
+    output_path = os.path.join(temp_dir, f"electrospray_results_{str(target_size).replace('.', '_')}.csv")
     combined_df.to_csv(output_path, index=False)
     
     return output_path
 
 # Application description
-description = "<h3>Welcome, challenger! 🎉</h3><p> If you think you may perform better than <strong>CCBO</strong>, try this interactive game to optimize electrospray!</p><p> Rules are simple:</p> <ul><li>🔍 Examine! The initial experiments are on the right (or below on your phone), remember, your target size is <u><i><strong>3.000 um</strong></i></u></li><li>⚠️ Be aware! Experiment may <u><i><strong>fail</strong></i></u> due to incompatible parameters. You want to avoid those conditions.</li><li>💡 Propose! Set your parameters, you have <strong>2</strong> chances in each round, use them wisely!</li><li>🚀  <strong>Submit</strong> to see the results, reflect and improve your selection!</li><li>🔄 Repeat! Run the process for <strong>5</strong> rounds to see if you can beat CCBO!</li></ul></p><p>Your data will not be stored, so feel free to play again, good luck! 🍀</p><p>Impressed by CCBO? Check our <a href='https://github.com/FrankWanger/CCBO'>implementation</a> and <a href='https://arxiv.org/abs/2411.10471'>paper!</a></p>"
+description = "<h3>Welcome, challenger! 🎉</h3><p> If you think you may perform better than <strong>CCBO</strong>, try this interactive game to optimize electrospray!</p><p> Rules are simple:</p> <ul><li>🔍 Examine! The initial experiments are on the right (or below on your phone), remember, your target size is shown at the top</li><li>⚠️ Be aware! Experiment may <u><i><strong>fail</strong></i></u> due to incompatible parameters. You want to avoid those conditions.</li><li>💡 Propose! Set your parameters, you have <strong>2</strong> chances in each round, use them wisely!</li><li>🚀  <strong>Submit</strong> to see the results, reflect and improve your selection!</li><li>🔄 Repeat! Run the process for <strong>5</strong> rounds to see if you can beat CCBO!</li></ul></p><p>Your data will not be stored, so feel free to play again, good luck! 🍀</p><p>Impressed by CCBO? Check our <a href='https://github.com/FrankWanger/CCBO'>implementation</a> and <a href='https://arxiv.org/abs/2411.10471'>paper!</a></p>"
 
 # Create Gradio interface
 with gr.Blocks() as demo:
@@ -362,6 +386,14 @@ with gr.Blocks() as demo:
         with gr.Column():
             gr.Markdown("## Human vs CCBO Campaign - Optimize Electrospray")
             gr.Markdown(description)
+            
+            # Add target size selection with new 22.0 option
+            target_size = gr.Radio(
+                [3.0, 0.5, 22.0], 
+                label="🎯 Select Target Size (μm)", 
+                value=3.0,
+                info="Choose the particle size you want to optimize for"
+            )
 
             with gr.Row():
                 with gr.Column():
@@ -383,16 +415,16 @@ with gr.Blocks() as demo:
                 submit_btn = gr.Button("🚀 Submit", variant="primary")
                 reset_btn = gr.Button("Reset")
                 download_btn = gr.Button("📥 Download Results", visible=False)
-                
-            # Moved file output component below the buttons
-            result_file = gr.File(label="Download Results CSV", visible=False)
             
             # Add notification component (initially hidden)
             completion_message = gr.Markdown(visible=False)
-        
+            
+            # File output component 
+            result_file = gr.File(label="Download Results CSV", visible=False)
+            
         # Results display column
         with gr.Column():
-            prior_experiments = gr.DataFrame(value=prior_experiments_display, label="Prior Experiments")
+            prior_experiments = gr.DataFrame(value=generate_prior_experiments_display(target_size), label="Prior Experiments")
             results_df = gr.DataFrame(label="Your Results")
             perf_plot = gr.Plot(label="Performance Comparison")
 
@@ -401,30 +433,44 @@ with gr.Blocks() as demo:
         fn=predict,
         inputs=[
             results_state, 
+            target_size,
             conc1, flow_rate1, voltage1, solvent1,
             conc2, flow_rate2, voltage2, solvent2
         ],
         outputs=[
             results_state, prior_experiments, results_df, perf_plot, 
-            download_btn, completion_message, auc_state, result_file
+            download_btn, completion_message, auc_state, result_file,
+            target_size
         ]
     )
     
     # Connect the reset button to the reset_results function
     reset_btn.click(
         fn=reset_results,
-        inputs=[results_state],
+        inputs=[results_state, target_size],
         outputs=[
             results_state, prior_experiments, results_df, perf_plot, 
-            download_btn, completion_message, auc_state, result_file
+            download_btn, completion_message, auc_state, result_file,
+            target_size
         ]
     )
     
     # Connect download button to file download
     download_btn.click(
         fn=prepare_results_for_download,
-        inputs=[results_state],
+        inputs=[results_state, target_size],
         outputs=[result_file]
     )
 
+    # When target size changes, reset the application
+    target_size.change(
+        fn=reset_results,
+        inputs=[results_state, target_size],
+        outputs=[
+            results_state, prior_experiments, results_df, perf_plot, 
+            download_btn, completion_message, auc_state, result_file,
+            target_size
+        ]
+    )
+
 demo.launch()

best_distances_0_5.pkl

@@ -0,0 +1,3 @@
+version https://git-lfs.github.com/spec/v1
+oid sha256:7eaf04440bd96df457d83d2b72e9a2a355b175b1a36fe8958ceef654a94ade07
+size 4153

best_distances_22_0.pkl

@@ -0,0 +1,3 @@
+version https://git-lfs.github.com/spec/v1
+oid sha256:3a2360b4669f64295fa30e268a303f2966b4fb7bbdc2fe9ec734ec661835977d
+size 4153