Upload 4 files

eagleblend.db

@@ -1,3 +1,3 @@
 version https://git-lfs.github.com/spec/v1
-oid sha256:a8300999f2674af7455b937bb6105f7b126790b5c6a4ce2cc27ec0b9c13a9151
+oid sha256:38cccc7257ad01d8d5ca0ac26a68090f4ac7c26fd2c3a76544fb27cfadb344e4
 size 3096576

inference.py

@@ -0,0 +1,209 @@
+import pandas as pd
+import numpy as np
+import torch
+import joblib
+import argparse
+import os
+import glob
+from sklearn.multioutput import MultiOutputRegressor
+from tabpfn_extensions.post_hoc_ensembles.sklearn_interface import AutoTabPFNRegressor
+
+class TabPFNEnsemblePredictor:
+	"""
+	A class to load an ensemble of TabPFN models and generate averaged predictions.
+
+	This class is designed to find and load all k-fold models from a specified
+	directory, handle the necessary feature engineering, and produce a single,
+	ensembled prediction from various input types (DataFrame, numpy array, or CSV file path).
+
+	Attributes:
+		model_paths (list): A list of file paths for the loaded models.
+		models (list): A list of the loaded model objects.
+		target_cols (list): The names of the target columns for the output DataFrame.
+	"""
+	
+	def __init__(self, model_dir: str, model_pattern: str = "Fold_*_best_model.tabpfn_fit"):
+		"""
+		Initializes the predictor by finding and loading the ensemble of models.
+
+		Args:
+			model_dir (str): The directory containing the saved .tabpfn_fit model files.
+			model_pattern (str, optional): The glob pattern to find model files. 
+										   Defaults to "Fold_*_best_model.tabpfn_fit".
+		
+		Raises:
+			FileNotFoundError: If no models matching the pattern are found in the directory.
+		"""
+		print("Initializing the TabPFN Ensemble Predictor...")
+		self.model_paths = sorted(glob.glob(os.path.join(model_dir, model_pattern)))
+		if not self.model_paths:
+			raise FileNotFoundError(
+				f"Error: No models found in '{model_dir}' matching the pattern '{model_pattern}'"
+			)
+		
+		print(f"Found {len(self.model_paths)} models to form the ensemble.")
+		self.models = self._load_models()
+		self.target_cols = [f"BlendProperty{i}" for i in range(1, 11)]
+
+	def _load_models(self) -> list:
+		"""
+		Loads the TabPFN models from the specified paths and moves them to the CPU.
+		
+		This is a private method called during initialization.
+		"""
+		loaded_models = []
+		for model_path in self.model_paths:
+			print(f"Loading model: {os.path.basename(model_path)}...")
+			try:
+				# Move model components to CPU for inference to avoid potential CUDA errors
+				# and ensure compatibility on machines without a GPU.
+				if not torch.cuda.is_available():
+					print("Cuda not available using cpu")
+					model = joblib.load(model_path)
+					for estimator in model.estimators_:
+						if hasattr(estimator, "predictor_") and hasattr(estimator.predictor_, "predictors"):
+							for p in estimator.predictor_.predictors:
+								p.to("cpu")
+				else:
+					print("Cuda is available")
+					model = joblib.load(model_path)
+				
+				loaded_models.append(model)
+				print(f"Successfully loaded {os.path.basename(model_path)}")
+			except Exception as e:
+				print(f"Warning: Could not load model from {model_path}. Skipping. Error: {e}")
+		return loaded_models
+
+	@staticmethod
+	def _feature_engineering(df: pd.DataFrame) -> pd.DataFrame:
+		"""
+		Applies feature engineering to the input dataframe. This is a static method
+		as it does not depend on the state of the class instance.
+
+		Args:
+			df (pd.DataFrame): The input dataframe.
+
+		Returns:
+			pd.DataFrame: The dataframe with new engineered features.
+		"""
+		components = ['Component1', 'Component2', 'Component3', 'Component4', 'Component5']
+		properties = [f'Property{i}' for i in range(1, 11)]
+		df_featured = df.copy()
+
+		for prop in properties:
+			df_featured[f'Weighted_{prop}'] = sum(
+				df_featured[f'{comp}_fraction'] * df_featured[f'{comp}_{prop}'] for comp in components
+			)
+			cols = [f'{comp}_{prop}' for comp in components]
+			df_featured[f'{prop}_variance'] = df_featured[cols].var(axis=1)
+			df_featured[f'{prop}_range'] = df_featured[cols].max(axis=1) - df_featured[cols].min(axis=1)
+			
+		return df_featured
+
+	def predict(self, input_data: pd.DataFrame or np.ndarray or str) -> (np.ndarray, pd.DataFrame):
+		"""
+		Generates ensembled predictions for the given input data.
+
+		This method takes input data, preprocesses it if necessary, generates a
+		prediction from each model in the ensemble, and returns the averaged result.
+
+		Args:
+			input_data (pd.DataFrame or np.ndarray or str): The input data for prediction. 
+				Can be a pandas DataFrame, a numpy array (must be pre-processed), 
+				or a string path to a CSV file.
+
+		Returns:
+			tuple: A tuple containing:
+				- np.ndarray: The averaged predictions as a numpy array.
+				- pd.DataFrame: The averaged predictions as a pandas DataFrame.
+		"""
+		if not self.models:
+			print("Error: No models were loaded. Cannot make predictions.")
+			return None, None
+
+		# --- Data Preparation ---
+		if isinstance(input_data, str) and os.path.isfile(input_data):
+			print(f"Loading and processing data from CSV: {input_data}")
+			test_df = pd.read_csv(input_data)
+			processed_df = self._feature_engineering(test_df)
+		elif isinstance(input_data, pd.DataFrame):
+			print("Processing input DataFrame...")
+			processed_df = self._feature_engineering(input_data)
+		elif isinstance(input_data, np.ndarray):
+			print("Using input numpy array directly (assuming it's pre-processed).")
+			sub = input_data
+		else:
+			raise TypeError("Input data must be a pandas DataFrame, a numpy array, or a path to a CSV file.")
+
+		if isinstance(input_data, (str, pd.DataFrame)):
+			if "ID" in processed_df.columns:
+				sub = processed_df.drop(columns=["ID"]).values
+			else:
+				sub = processed_df.values
+		
+		# --- Prediction Loop ---
+		all_fold_predictions = []
+		print("\nGenerating predictions from the model ensemble...")
+		for i, model in enumerate(self.models):
+			try:
+				y_sub = model.predict(sub)
+				all_fold_predictions.append(y_sub)
+				print(f"  - Prediction from model {i+1} completed.")
+			except Exception as e:
+				print(f"  - Warning: Could not predict with model {i+1}. Skipping. Error: {e}")
+		
+		if not all_fold_predictions:
+			print("\nError: No predictions were generated from any model.")
+			return None, None
+
+		# --- Averaging ---
+		print("\nAveraging predictions from all models...")
+		averaged_preds_array = np.mean(all_fold_predictions, axis=0)
+		averaged_preds_df = pd.DataFrame(averaged_preds_array, columns=self.target_cols)
+		print("Ensemble prediction complete.")
+
+		return averaged_preds_array, averaged_preds_df
+
+# This block allows the script to be run directly from the command line
+if __name__ == "__main__":
+	parser = argparse.ArgumentParser(
+		description="""
+		Command-line interface for the TabPFNEnsemblePredictor.
+		
+		Example Usage:
+		python inference.py --model_dir ./saved_models/ --input_path ./test_data.csv --output_path ./final_preds.csv
+		""",
+		formatter_class=argparse.RawTextHelpFormatter
+	)
+	
+	parser.add_argument("--model_dir", type=str, required=True, 
+						help="Directory containing the saved .tabpfn_fit model files.")
+	parser.add_argument("--input_path", type=str, required=True, 
+						help="Path to the input CSV file for prediction.")
+	parser.add_argument("--output_path", type=str, default="predictions_ensembled.csv",
+						help="Path to save the final ensembled predictions CSV file.")
+
+	args = parser.parse_args()
+
+	if not os.path.isdir(args.model_dir):
+		print(f"Error: Model directory not found at {args.model_dir}")
+	elif not os.path.exists(args.input_path):
+		print(f"Error: Input file not found at {args.input_path}")
+	else:
+		try:
+			# 1. Instantiate the predictor class
+			predictor = TabPFNEnsemblePredictor(model_dir=args.model_dir)
+
+			# 2. Call the predict method
+			preds_array, preds_df = predictor.predict(args.input_path)
+
+			# 3. Save the results
+			if preds_df is not None:
+				preds_df.to_csv(args.output_path, index=False)
+				print(f"\nEnsembled predictions successfully saved to {args.output_path}")
+				print("\n--- Sample of Final Averaged Predictions ---")
+				print(preds_df.head())
+				print("------------------------------------------")
+
+		except Exception as e:
+			print(f"\nAn error occurred during the process: {e}")

predictor.py

@@ -45,7 +45,7 @@ from scipy.special import comb
 
 
 class EagleBlendPredictor:
-    def __init__(self, model_sources = './Models'):
+    def __init__(self, model_sources = 'Models'):
         """
         model_sources: Dict[str, Any]
             A dictionary where keys are 'BlendProperty1', ..., 'BlendProperty10'
@@ -121,7 +121,7 @@ class EagleBlendPredictor:
         self.model_10 = joblib.load(os.path.join(self.home, self.saved_files_map[10]["model"]))
         self.poly_10 = joblib.load(os.path.join(self.home, self.saved_files_map[10]["transform"]))
 
-        self.model_3489 = TabPFNEnsemblePredictor(model_dir="Models")
+        self.model_3489 = TabPFNEnsemblePredictor(model_dir=self.home)
         pass
 
 
@@ -260,6 +260,39 @@ class EagleBlendPredictor:
         return predictions_df
 
 
+    def predict_fast(self, df: pd.DataFrame) -> pd.DataFrame:
+        """
+        Generates predictions for the faster blend properties using the individual prediction methods.
+
+        Args:
+            df: Input DataFrame containing the features.
+
+        Returns:
+            DataFrame with predicted blend properties for 1,2,5,6,7,10.
+        """
+        predictions_list = []
+
+        # Predict individual properties
+        predictions_list.append(self.predict_BlendProperty1(df, full=True))
+        predictions_list.append(self.predict_BlendProperty2(df, full=True))
+
+        predictions_list.append(self.predict_BlendProperty5(df, full=True))
+        predictions_list.append(self.predict_BlendProperty6(df, full=True))
+        predictions_list.append(self.predict_BlendProperty7(df, full=True))
+
+        predictions_list.append(self.predict_BlendProperty10(df, full=True))
+
+
+        # Concatenate the list of single-column DataFrames into a single DataFrame
+        predictions_df = pd.concat(predictions_list, axis=1)
+
+        # Ensure columns are in the desired order
+        ordered_cols = [f'BlendProperty{i}' for i in [1,2,5,6,7,10]]
+        # Reindex to ensure columns are in order, dropping any not generated (though all should be)
+        predictions_df = predictions_df.reindex(columns=ordered_cols)
+
+
+        return predictions_df
 
 
 

test_app.py

@@ -10,7 +10,8 @@ from typing import Optional, Dict, Any
 from datetime import datetime, timedelta
 import re
 from pathlib import Path
-# from blend_logic import run_dummy_prediction
+from predictor import EagleBlendPredictor
+
 
 ##---- fucntions ------
 # Load fuel data from CSV (create this file if it doesn't exist)
@@ -64,7 +65,14 @@ st.markdown("""
         background-color: #f8f5f0;
         overflow: visible;
         padding-top: 0
-           
+
+        /* --- ADD THIS CSS FOR THE NEW HELP BUTTONS --- */
+    #help-toggle-insights:checked ~ .help-panel-insights,
+    #help-toggle-registry:checked ~ .help-panel-registry,
+    #help-toggle-comparison:checked ~ .help-panel-comparison {
+        opacity: 1; visibility: visible; transform: translateY(0);
+    }
+                 
     }
         /* Remove unnecessary space at the top */     
    /* Remove any fixed headers */
@@ -264,7 +272,19 @@ st.markdown("""
     }
 
     
-
+    /* --- Add this CSS class for the spinner --- */
+    @keyframes spin {
+        0% { transform: rotate(0deg); }
+        100% { transform: rotate(360deg); }
+    }
+    .spinner {
+        border: 4px solid rgba(0,0,0,0.1);
+        border-left-color: #8B4513;
+        border-radius: 50%;
+        width: 24px;
+        height: 24px;
+        animation: spin 1s linear infinite;
+    }
             
     
     /* Color scale adjustments */
@@ -836,8 +856,6 @@ with tabs[0]:
 #                                                            Blend Designer Tab                                                  
 # ----------------------------------------------------------------------------------------------------------------------------------------------
 
-from inference import EagleBlendPredictor # Add this import at the top of your main script
-
 # --- Add these new functions to your functions section ---
 
 @st.cache_data
@@ -919,8 +937,11 @@ with tabs[1]:
         
         # 4. Run prediction
         predictor = st.session_state.predictor
-        results = predictor.predict_all(df_model.drop(columns=['blend_name']))
-        st.session_state.prediction_results = results[0]  # Get the first (and only) row of results
+        # results = predictor.predict_all(df_model.drop(columns=['blend_name']))
+        # st.session_state.prediction_results = results[0]  # Get the first (and only) row of results
+        # --- FIX: Handles DataFrame output and converts it to an array for single prediction ---
+        results_df = predictor.predict_all(df_model.drop(columns=['blend_name']))
+        st.session_state.prediction_results = results_df.iloc[0].values
         
         # --- Conditional cost calculation ---
         # 5. Calculate cost only if all unit costs are provided and greater than zero
@@ -974,12 +995,74 @@ with tabs[1]:
     with col_header[1]:
         batch_blend = st.checkbox("Batch Blend Mode", value=False, key="batch_blend_mode")
 
+    # --- This is the new, fully functional batch mode block ---
     if batch_blend:
         st.subheader("📤 Batch Processing")
-        uploaded_file = st.file_uploader("Upload CSV File", type=["csv"], key="Batch_upload")
-        if uploaded_file:
-            st.info("Batch processing functionality can be implemented here.")
-            # Add batch processing logic here
+        st.markdown("Upload a CSV file with blend recipes to predict their properties in bulk. The file must contain the 55 feature columns required by the model.")
+
+        # Provide a template for download
+        # NOTE: You will need to create a dummy CSV file named 'batch_template.csv'
+        # with the 55 required column headers for this to work.
+        try:
+            with open("assets/batch_template.csv", "rb") as f:
+                st.download_button(
+                    label="📥 Download Batch Template (CSV)",
+                    data=f,
+                    file_name="batch_template.csv",
+                    mime="text/csv"
+                )
+        except FileNotFoundError:
+            st.warning("Batch template file not found. Please create 'assets/batch_template.csv'.")
+
+
+        uploaded_file = st.file_uploader("Upload your CSV file", type=["csv"], key="batch_upload")
+
+        if uploaded_file is not None:
+            try:
+                input_df = pd.read_csv(uploaded_file)
+                st.markdown("##### Uploaded Data Preview")
+                st.dataframe(input_df.head())
+
+                if st.button("🧪 Run Batch Prediction", use_container_width=True, type="primary"):
+                    # Basic validation: check for at least the fraction columns
+                    required_cols = [f'Component{i+1}_fraction' for i in range(5)]
+                    if not all(col in input_df.columns for col in required_cols):
+                        st.error(f"Invalid file format. The uploaded CSV is missing one or more required columns like: {', '.join(required_cols)}")
+                    else:
+                        with st.spinner("Running batch prediction... This may take a moment."):
+                            # Run prediction on the entire DataFrame
+                            predictor = st.session_state.predictor
+                            results_df = predictor.predict_all(input_df)
+                            
+                            # Combine original data with the results
+                            # Ensure column names for results are clear
+                            results_df.columns = [f"BlendProperty{i+1}" for i in range(results_df.shape[1])]
+                            
+                            # Combine input and output dataframes
+                            final_df = pd.concat([input_df.reset_index(drop=True), results_df.reset_index(drop=True)], axis=1)
+                            
+                            st.session_state['batch_results'] = final_df
+                            st.success("Batch prediction complete!")
+
+            except Exception as e:
+                st.error(f"An error occurred while processing the file: {e}")
+
+        # Display results and download button if they exist in the session state
+        if 'batch_results' in st.session_state:
+            st.markdown("---")
+            st.subheader("✅ Batch Prediction Results")
+            
+            results_to_show = st.session_state['batch_results']
+            st.dataframe(results_to_show)
+
+            csv_data = results_to_show.to_csv(index=False).encode('utf-8')
+            st.download_button(
+                label="📥 Download Full Results (CSV)",
+                data=csv_data,
+                file_name="batch_prediction_results.csv",
+                mime="text/csv",
+                use_container_width=True
+            )
     else:
         # --- Manual Blend Designer UI ---
         all_components_df = get_components_from_db()
@@ -1202,72 +1285,291 @@ with tabs[1]:
 #                                                   Optimization Engine Tab
 # ----------------------------------------------------------------------------------------------------------------------------------------------
 
-with tabs[2]:
-    st.subheader("⚙️ Optimization Engine")
+import time # Add this import to the top of your script
+
+# --- Add this new function to your functions section ---
+def dummy_optimization_function(targets, fixed_targets, components_data):
+    """
+    Placeholder for your actual optimization algorithm.
+    This function simulates a multi-objective optimization.
     
-    # Pareto frontier demo
-    st.markdown("#### Cost vs Performance Trade-off")
-    np.random.seed(42)
-    optimization_data = pd.DataFrame({
-        'Cost ($/ton)': np.random.uniform(100, 300, 50),
-        'Performance Score': np.random.uniform(70, 95, 50)
-    })
+    Returns:
+        A list of dictionaries, where each dictionary represents a solution.
+    """
+    print("--- Running Dummy Optimization ---")
+    print("Targets:", targets)
+    print("Fixed Targets:", fixed_targets)
+    print("---------------------------------")
     
-    fig3 = px.scatter(
-        optimization_data,
-        x='Cost ($/ton)',
-        y='Performance Score',
-        title="Potential Blend Formulations",
-        color='Performance Score',
-        color_continuous_scale='YlOrBr'
-    )
+    # Simulate a process that takes a few seconds
+    time.sleep(3)
     
-    # Add dummy pareto frontier
-    x_pareto = np.linspace(100, 300, 10)
-    y_pareto = 95 - 0.1*(x_pareto-100)
-    fig3.add_trace(px.line(
-        x=x_pareto,
-        y=y_pareto,
-        color_discrete_sequence= ['#8B4513', '#CFB53B', '#654321']
-    ).data[0])
+    # Generate 3 dummy solutions
+    solutions = []
+    for i in range(3):
+        # Create slightly different results for each solution
+        base_frac = 0.2 + (i * 0.05)
+        fractions = np.random.rand(5)
+        fractions = fractions / fractions.sum() # Normalize to sum to 1
+        
+        blend_properties = [val + np.random.uniform(-0.5, 0.5) for val in targets.values()]
+        
+        # Ensure fixed targets are met in the dummy result
+        for prop, val in fixed_targets.items():
+            prop_index = int(prop.replace('Property', '')) - 1
+            blend_properties[prop_index] = val
+
+        solution = {
+            "component_fractions": fractions,
+            "blend_properties": np.array(blend_properties),
+            "optimized_cost": 150.0 - (i * 10),
+            "error": 0.05 + (i * 0.02) # Dummy error for the Pareto plot
+        }
+        solutions.append(solution)
+        
+    return solutions
     
-    fig3.update_layout(
-        showlegend=False,
-        annotations=[
-            dict(
-                x=200,
-                y=88,
-                text="Pareto Frontier",
-                showarrow=True,
-                arrowhead=1,
-                ax=-50,
-                ay=-30
-            )
-        ]
-    )
-    st.plotly_chart(fig3, use_container_width=True)
+
+with tabs[2]:
+    st.subheader("⚙️ Optimization Engine")
+    st.markdown("Define your property goals, select base components, and run the optimizer to find the ideal blend recipe.")
+
+    # --- State Initialization ---
+    if 'optimization_running' not in st.session_state:
+        st.session_state.optimization_running = False
+    if 'optimization_results' not in st.session_state:
+        st.session_state.optimization_results = None
+    if 'optimization_time' not in st.session_state:
+        st.session_state.optimization_time = 0.0
+
+    # --- Optimization Goals ---
+    st.markdown("#### 1. Define Optimization Goals")
     
-    # Blend optimization history
-    st.markdown("#### Optimization Progress")
-    iterations = np.arange(20)
-    performance = np.concatenate([np.linspace(70, 85, 10), np.linspace(85, 89, 10)])
+    # Using a container to group the goal inputs
+    with st.container(border=True):
+        cols_row1 = st.columns(5)
+        cols_row2 = st.columns(5)
+        
+        for i in range(1, 11):
+            col = cols_row1[(i-1)] if i <= 5 else cols_row2[(i-6)]
+            with col:
+                st.number_input(f"Property {i}", key=f"opt_target_{i}", value=0.0, step=0.01, format="%.4f")
+                st.toggle("Fix Target", key=f"opt_fix_{i}", help=f"Toggle on to make Property {i} a fixed constraint.")
+
+    # --- Component Selection (Copied and Adapted) ---
+    st.markdown("#### 2. Select Initial Components")
+    all_components_df_opt = get_components_from_db() # Use a different variable to avoid conflicts
     
-    fig4 = px.line(
-        x=iterations,
-        y=performance,
-        title="Best Performance by Iteration",
-        markers=True
-    )
-    fig4.update_traces(
-        line_color='#1d3b58',
-        marker_color='#2c5282',
-        line_width=2.5
-    )
-    fig4.update_layout(
-        yaxis_title="Performance Score",
-        xaxis_title="Iteration"
-    )
-    st.plotly_chart(fig4, use_container_width=True)
+    main_cols = st.columns(2)
+    with main_cols[0]: # Left side for first 3 components
+        for i in range(3):
+            with st.expander(f"**Component {i+1}**", expanded=(i==0)):
+                # Auto-population and input fields logic (reused from Blend Designer)
+                # Note: Keys are prefixed with 'opt_' to ensure they are unique to this tab
+                select_key, name_key, frac_key, cost_key = f"opt_c{i}_select", f"opt_c{i}_name", f"opt_c{i}_fraction", f"opt_c{i}_cost"
+                
+                # Auto-population logic...
+                if select_key in st.session_state and st.session_state[select_key] != "---":
+                    selected_name = st.session_state[select_key]
+                    comp_data = all_components_df_opt[all_components_df_opt['component_name'] == selected_name].iloc[0]
+                    st.session_state[name_key] = comp_data['component_name']
+                    st.session_state[frac_key] = comp_data.get('component_fraction', 0.2)
+                    cost_val = comp_data.get('unit_cost', 0.0)
+                    st.session_state[cost_key] = 0.0 if pd.isna(cost_val) else float(cost_val)
+                    for j in range(1, 11):
+                        st.session_state[f"opt_c{i}_prop{j}"] = comp_data.get(f'property{j}', 0.0)
+                    st.session_state[select_key] = "---"
+
+                # UI for component
+                component_options = ["---"] + all_components_df_opt['component_name'].tolist()
+                st.selectbox("Load from Registry", options=component_options, key=select_key)
+                c1, c2, c3 = st.columns([1.5, 2, 2])
+                with c1:
+                    st.text_input("Component Name", key=name_key)
+                    st.number_input("Unit Cost ($)", min_value=0.0, step=0.01, key=cost_key, format="%.2f")
+                with c2:
+                    for j in range(1, 6): st.number_input(f"Property {j}", key=f"opt_c{i}_prop{j}", format="%.4f")
+                with c3:
+                    for j in range(6, 11): st.number_input(f"Property {j}", key=f"opt_c{i}_prop{j}", format="%.4f")
+
+    with main_cols[1]: # Right side for last 2 components and controls
+        for i in range(3, 5):
+             with st.expander(f"**Component {i+1}**", expanded=False):
+                # Auto-population and input fields logic...
+                select_key, name_key, frac_key, cost_key = f"opt_c{i}_select", f"opt_c{i}_name", f"opt_c{i}_fraction", f"opt_c{i}_cost"
+                if select_key in st.session_state and st.session_state[select_key] != "---":
+                    selected_name = st.session_state[select_key]
+                    comp_data = all_components_df_opt[all_components_df_opt['component_name'] == selected_name].iloc[0]
+                    st.session_state[name_key] = comp_data['component_name']
+                    st.session_state[frac_key] = comp_data.get('component_fraction', 0.2)
+                    cost_val = comp_data.get('unit_cost', 0.0)
+                    st.session_state[cost_key] = 0.0 if pd.isna(cost_val) else float(cost_val)
+                    for j in range(1, 11):
+                        st.session_state[f"opt_c{i}_prop{j}"] = comp_data.get(f'property{j}', 0.0)
+                    st.session_state[select_key] = "---"
+                component_options = ["---"] + all_components_df_opt['component_name'].tolist()
+                st.selectbox("Load from Registry", options=component_options, key=select_key)
+                c1, c2, c3 = st.columns([1.5, 2, 2])
+                with c1:
+                    st.text_input("Component Name", key=name_key)
+                    st.number_input("Unit Cost ($)", min_value=0.0, step=0.01, key=cost_key, format="%.2f")
+                with c2:
+                    for j in range(1, 6): st.number_input(f"Property {j}", key=f"opt_c{i}_prop{j}", format="%.4f")
+                with c3:
+                    for j in range(6, 11): st.number_input(f"Property {j}", key=f"opt_c{i}_prop{j}", format="%.4f")
+
+        # --- Optimization Controls ---
+        with st.container(border=True):
+            st.markdown("##### 3. Configure & Run")
+            st.checkbox("Include Cost in Optimization", value=True, key="opt_include_cost")
+            
+            # Run button and spinner logic
+            run_button_col, spinner_col = st.columns([3, 1])
+            with run_button_col:
+                if st.button("🚀 Run Optimization", use_container_width=True, type="primary", disabled=st.session_state.optimization_running):
+                    st.session_state.optimization_running = True
+                    start_time = time.time()
+                    
+                    # Gather data for the optimization function
+                    targets = {f"Property{i}": st.session_state[f"opt_target_{i}"] for i in range(1, 11)}
+                    fixed_targets = {f"Property{i}": targets[f"Property{i}"] for i in range(1, 11) if st.session_state[f"opt_fix_{i}"]}
+                    components_data = [] # You would gather component data similarly if your function needs it
+                    
+                    # Call the (dummy) optimization function
+                    st.session_state.optimization_results = dummy_optimization_function(targets, fixed_targets, components_data)
+                    st.session_state.optimization_time = time.time() - start_time
+                    st.session_state.optimization_running = False
+                    st.rerun() # Rerun to display results
+
+            with spinner_col:
+                if st.session_state.optimization_running:
+                    st.markdown('<div class="spinner"></div>', unsafe_allow_html=True)
+
+            if st.session_state.optimization_time > 0:
+                st.success(f"Optimization complete in {st.session_state.optimization_time:.2f} seconds.")
+
+    # --- Results Section ---
+    if st.session_state.optimization_results:
+        st.markdown('<hr class="custom-divider">', unsafe_allow_html=True)
+        st.subheader("🏆 Optimization Results")
+
+        results = st.session_state.optimization_results
+        
+        # Dropdown to select which result to view
+        result_options = {i: f"Solution {i+1}" for i in range(len(results))}
+        selected_idx = st.selectbox("View Solution", options=list(result_options.keys()), format_func=lambda x: result_options[x])
+        
+        selected_solution = results[selected_idx]
+
+        # Display best fractions and properties
+        res_cols = st.columns([3, 2])
+        with res_cols[0]:
+            st.markdown("##### Optimal Component Fractions")
+            frac_cols = st.columns(5)
+            for i, frac in enumerate(selected_solution["component_fractions"]):
+                with frac_cols[i]:
+                    comp_name = st.session_state.get(f"opt_c{i}_name", f"Component {i+1}")
+                    st.markdown(f"""
+                    <div class="metric-card" style="padding: 0.8rem;">
+                        <div class="metric-label" style="font-size: 0.8rem;">{comp_name}</div>
+                        <div class="metric-value" style="font-size: 1.5rem;">{frac*100:.2f}%</div>
+                    </div>
+                    """, unsafe_allow_html=True)
+
+        # --- FIX: New, readable KPI cards for blend properties ---
+        with res_cols[1]:
+            st.markdown("##### Resulting Blend Properties")
+            prop_kpi_cols = st.columns(5)
+            for i, prop_val in enumerate(selected_solution["blend_properties"]):
+                col = prop_kpi_cols[i % 5]
+                with col:
+                    st.markdown(f"""
+                    <div class="metric-card" style="margin-bottom: 10px; padding: 0.5rem;">
+                        <div class="metric-label" style="font-size: 0.7rem;">Property {i+1}</div>
+                        <div class="metric-value" style="font-size: 1.1rem;">{prop_val:.4f}</div>
+                    </div>
+                    """, unsafe_allow_html=True)
+        
+        # Expander for full results table
+        with st.expander("Show Full Results Table"):
+            table_data = []
+            for i in range(5):
+                row = {
+                    "Composition": st.session_state.get(f"opt_c{i}_name", f"C{i+1}"),
+                    "Fraction": selected_solution["component_fractions"][i],
+                    "Unit Cost": st.session_state.get(f"opt_c{i}_cost", 0.0)
+                }
+                for j in range(1, 11):
+                    row[f"Property {j}"] = st.session_state.get(f"opt_c{i}_prop{j}", 0.0)
+                table_data.append(row)
+            
+            # Add blend row
+            blend_row = {"Composition": "Optimized Blend", "Fraction": 1.0, "Unit Cost": selected_solution["optimized_cost"]}
+            for i, prop in enumerate(selected_solution["blend_properties"]):
+                blend_row[f"Property {i+1}"] = prop
+            table_data.append(blend_row)
+            
+            st.dataframe(pd.DataFrame(table_data), use_container_width=True)
+
+        # Pareto Plot and Save Section
+        pareto_col, save_col = st.columns([2, 1])
+        with pareto_col:
+            st.markdown("##### Pareto Front: Cost vs. Error")
+            pareto_df = pd.DataFrame({
+                'Cost': [r['optimized_cost'] for r in results],
+                'Error': [r['error'] for r in results],
+                'Solution': [f'Sol {i+1}' for i in range(len(results))]
+            })
+            # --- FIX: Inverted the axes to show Error vs. Cost ---
+            fig_pareto = px.scatter(
+                pareto_df, x='Error', y='Cost', text='Solution', title="<b>Pareto Front: Error vs. Cost</b>"
+            )
+            fig_pareto.update_traces(textposition='top center', marker=dict(size=12, color='#8B4513'))
+            st.plotly_chart(fig_pareto, use_container_width=True)
+
+        with save_col:
+            st.markdown("##### Save Result")
+            st.text_input("Save as Blend Name", value=f"Optimized_Blend_{selected_idx+1}", key="opt_save_name")
+            if st.button("💾 Save to Database", use_container_width=True):
+                st.info("Save functionality can be implemented here.") # Placeholder for save logic
+            
+            # Placeholder for download button logic
+            st.download_button("📥 Download All Solutions (CSV)", data="dummy_csv_data", file_name="optimization_results.csv", use_container_width=True)
+            
+    # --- Floating Help Button ---
+    # (Using a different key to avoid conflict with other tabs)
+    # --- FIX: Complete working version of the help button ---
+    st.markdown("""
+        <style>
+            #help-toggle-optimizer { display: none; }
+            #help-toggle-optimizer:checked ~ .help-panel-optimizer {
+                opacity: 1; visibility: visible; transform: translateY(0);
+            }
+            .help-panel-optimizer {
+                position:fixed; right:25px; bottom:100px; z-index:9998;
+                width:520px; max-height:70vh; overflow-y:auto;
+                background: linear-gradient(135deg, #FFFDF5 0%, #F8EAD9 100%);
+                border:1px solid #CFB53B; border-radius:12px; padding:20px;
+                box-shadow:0 14px 34px rgba(0,0,0,0.22);
+                color:#4a2f1f; transform: translateY(12px); opacity:0;
+                visibility:hidden; transition: all .22s ease-in-out;
+            }
+        </style>
+        <input id="help-toggle-optimizer" type="checkbox" />
+        <label for="help-toggle-optimizer" class="help-button">💬 Help</label>
+        <div class="help-panel help-panel-optimizer"> <div class="head">
+                <div class="title">How to Use the Optimizer</div>
+                <label for="help-toggle-optimizer" class="help-close">Close</label>
+            </div>
+            <div class="help-body">
+                <p><b>1. Define Goals:</b> Enter your desired target values for each of the 10 blend properties. Use the 'Fix Target' toggle for any property that must be met exactly.</p>
+                <p><b>2. Select Components:</b> Choose up to 5 base components. You can load them from the registry to auto-fill their data or enter them manually.</p>
+                <p><b>3. Configure & Run:</b> Decide if cost should be a factor in the optimization, then click 'Run Optimization'. A spinner will appear while the process runs.</p>
+                <p><b>4. Analyze Results:</b> After completion, the best solution is shown by default. You can view other potential solutions from the dropdown. The results include optimal component fractions and the final blend properties.</p>
+                <p><b>5. Save & Download:</b> Give your chosen solution a name and save it to the blends database for future use in the Comparison tab.</p>
+            </div>
+        </div>
+    """, unsafe_allow_html=True)
 
 # -----------------------------------------------------------------------------------------------------------------------------------------------------------------------
 #                                                   Blend Comparison Tab
@@ -1503,6 +1805,40 @@ with tabs[3]:
             )
             st.plotly_chart(fig_composite, use_container_width=True)
 
+    # --- ADD: Floating Help Button for Blend Comparison ---
+    st.markdown("""
+        <style>
+            #help-toggle-comparison { display: none; }
+            #help-toggle-comparison:checked ~ .help-panel-comparison {
+                opacity: 1; visibility: visible; transform: translateY(0);
+            }
+            .help-panel-comparison {
+                position:fixed; right:25px; bottom:100px; z-index:9998;
+                width:520px; max-height:70vh; overflow-y:auto;
+                background: linear-gradient(135deg, #FFFDF5 0%, #F8EAD9 100%);
+                border:1px solid #CFB53B; border-radius:12px; padding:20px;
+                box-shadow:0 14px 34px rgba(0,0,0,0.22);
+                color:#4a2f1f; transform: translateY(12px); opacity:0;
+                visibility:hidden; transition: all .22s ease-in-out;
+            }
+        </style>
+        <input id="help-toggle-comparison" type="checkbox" />
+        <label for="help-toggle-comparison" class="help-button">💬 Help</label>
+        <div class="help-panel help-panel-comparison">
+            <div class="head">
+                <div class="title">Using the Blend Comparison Tool</div>
+                <label for="help-toggle-comparison" class="help-close">Close</label>
+            </div>
+            <div class="help-body">
+                <p>This tab allows you to perform a side-by-side analysis of up to three saved blends.</p>
+                <p><b>1. Select Scenarios:</b> Use the three dropdown menus at the top to select the saved blends you wish to compare.</p>
+                <p><b>2. Review Overviews:</b> Key information for each selected blend, including its composition and final properties, will be displayed in summary cards.</p>
+                <p><b>3. Analyze Charts:</b> The charts provide a deep dive into how the blends compare on cost, property profiles, quality, and composition.</p>
+                <p><b>4. Export:</b> Click the 'Export to PDF' button to generate a downloadable report containing all the charts and data for your selected comparison.</p>
+            </div>
+        </div>
+    """, unsafe_allow_html=True)
+
 # ----------------------------------------------------------------------------------------------------------------------------------------------
 #                                                   Fuel Registry Tab
 # ---------------------------------------------------------------------------------------------------------------------------------------------
@@ -1713,6 +2049,39 @@ with tabs[4]:
                 else:
                     del st.session_state.blends
                 st.rerun()
+
+    # --- ADD: Floating Help Button for Fuel Registry ---
+    st.markdown("""
+        <style>
+            #help-toggle-registry { display: none; }
+            #help-toggle-registry:checked ~ .help-panel-registry {
+                opacity: 1; visibility: visible; transform: translateY(0);
+            }
+            .help-panel-registry {
+                position:fixed; right:25px; bottom:100px; z-index:9998;
+                width:520px; max-height:70vh; overflow-y:auto;
+                background: linear-gradient(135deg, #FFFDF5 0%, #F8EAD9 100%);
+                border:1px solid #CFB53B; border-radius:12px; padding:20px;
+                box-shadow:0 14px 34px rgba(0,0,0,0.22);
+                color:#4a2f1f; transform: translateY(12px); opacity:0;
+                visibility:hidden; transition: all .22s ease-in-out;
+            }
+        </style>
+        <input id="help-toggle-registry" type="checkbox" />
+        <label for="help-toggle-registry" class="help-button">💬 Help</label>
+        <div class="help-panel help-panel-registry">
+            <div class="head">
+                <div class="title">Using the Fuel Registry</div>
+                <label for="help-toggle-registry" class="help-close">Close</label>
+            </div>
+            <div class="help-body">
+                <p>This tab is your central database for managing all blend components and saved blends.</p>
+                <p><b>1. Add Components/Blends:</b> You can add a single component manually using the form or upload a CSV file for batch additions of components or blends. Download the templates to ensure your file format is correct.</p>
+                <p><b>2. View & Manage Data:</b> Use the dropdown to switch between viewing 'Components' and 'Blends'. The table shows all saved records.</p>
+                <p><b>3. Search & Delete:</b> Use the search bar to filter the table. To delete records, check the 'Select' box next to the desired rows and click the 'Delete Selected' button that appears.</p>
+            </div>
+        </div>
+    """, unsafe_allow_html=True)
     
 
 # ----------------------------------------------------------------------------------------------------------------------------------------------
@@ -1776,27 +2145,60 @@ with tabs[5]:
     </style>
     """, unsafe_allow_html=True)
 
-    # --- Floating "How to Use" Button and Panel ---
+    # # --- Floating "How to Use" Button and Panel ---
+    # st.markdown("""
+    # <input id="help-toggle" type="checkbox" />
+    # <label for="help-toggle" class="help-button">💬 Help</label>
+
+    # <div class="help-panel" aria-hidden="true">
+    #     <div class="head">
+    #         <div class="title">Interpreting Model Insights</div>
+    #         <label for="help-toggle" class="help-close">Close</label>
+    #     </div>
+    #     <div class="help-body">
+    #         <p><b>KPI Cards:</b> These four cards give you a quick summary of the model's overall health.</p>
+    #         <ul>
+    #             <li><b>Overall R² Score:</b> Think of this as the model's accuracy grade. A score of 92.4% means the model's predictions are highly accurate.</li>
+    #             <li><b>MSE (Mean Squared Error):</b> This measures the average size of the model's mistakes. A smaller number is better.</li>
+    #             <li><b>MAPE (Mean Absolute % Error):</b> This tells you the average error in percentage terms. A value of 0.112 means predictions are off by about 11.2% on average.</li>
+    #         </ul>
+    #         <p><b>R² Score by Blend Property Chart:</b> This chart shows how well the model predicts each specific property.</p>
+    #         <p>A <b>longer bar</b> means the model is very good at predicting that property. A <b>shorter bar</b> indicates a property that is harder for the model to predict accurately. This helps you trust predictions for some properties more than others.</p>
+    #     </div>
+    # </div>
+    # """, unsafe_allow_html=True)
+
+        # --- FIX: Complete working version of the help button ---
+# --- FIX: Complete working version of the help button ---
     st.markdown("""
-    <input id="help-toggle" type="checkbox" />
-    <label for="help-toggle" class="help-button">💬 Help</label>
-
-    <div class="help-panel" aria-hidden="true">
-        <div class="head">
-            <div class="title">Interpreting Model Insights</div>
-            <label for="help-toggle" class="help-close">Close</label>
-        </div>
-        <div class="help-body">
-            <p><b>KPI Cards:</b> These four cards give you a quick summary of the model's overall health.</p>
-            <ul>
-                <li><b>Overall R² Score:</b> Think of this as the model's accuracy grade. A score of 92.4% means the model's predictions are highly accurate.</li>
-                <li><b>MSE (Mean Squared Error):</b> This measures the average size of the model's mistakes. A smaller number is better.</li>
-                <li><b>MAPE (Mean Absolute % Error):</b> This tells you the average error in percentage terms. A value of 0.112 means predictions are off by about 11.2% on average.</li>
-            </ul>
-            <p><b>R² Score by Blend Property Chart:</b> This chart shows how well the model predicts each specific property.</p>
-            <p>A <b>longer bar</b> means the model is very good at predicting that property. A <b>shorter bar</b> indicates a property that is harder for the model to predict accurately. This helps you trust predictions for some properties more than others.</p>
+        <style>
+            /* Styles for the help panel and button */
+            #help-toggle-insights { display: none; }
+            #help-toggle-insights:checked ~ .help-panel-insights {
+                opacity: 1; visibility: visible; transform: translateY(0);
+            }
+            .help-panel-insights {
+                position:fixed; right:25px; bottom:100px; z-index:9998;
+                width:520px; max-height:70vh; overflow-y:auto;
+                background: linear-gradient(135deg, #FFFDF5 0%, #F8EAD9 100%);
+                border:1px solid #CFB53B; border-radius:12px; padding:20px;
+                box-shadow:0 14px 34px rgba(0,0,0,0.22);
+                color:#4a2f1f; transform: translateY(12px); opacity:0;
+                visibility:hidden; transition: all .22s ease-in-out;
+            }
+        </style>
+        <input id="help-toggle-insights" type="checkbox" />
+        <label for="help-toggle-insights" class="help-button">💬 Help</label>
+        <div class="help-panel help-panel-insights">
+            <div class="head">
+                <div class="title">Interpreting Model Insights</div>
+                <label for="help-toggle-insights" class="help-close">Close</label>
+            </div>
+            <div class="help-body">
+                <p><b>KPI Cards:</b> These cards give a quick summary of the model's health. <b>R² Score</b> is its accuracy grade, while <b>MSE</b> and <b>MAPE</b> measure the average size of its errors.</p>
+                <p><b>R² Score by Blend Property Chart:</b> This chart shows how well the model predicts each specific property. A longer bar means the model is very good at predicting that property.</p>
+            </div>
         </div>
-    </div>
     """, unsafe_allow_html=True)
 
     # --- Main Title ---