Update app/streamlit_app.py

app/streamlit_app.py

@@ -666,11 +666,6 @@ st.markdown(f"""
             grid-template-columns: 1fr;
         }}
     }}
-
-    /* Nuclear option - if containers still persist */
-    div[class*="css-"], div[data-baseweb] {{
-        background-color: transparent !important;
-    }}
 </style>
 """, unsafe_allow_html=True)
 
@@ -895,17 +890,19 @@ def main():
     with tab1:
         st.markdown('<h2 class="section-header">🎯 Single Text Analysis</h2>', unsafe_allow_html=True)
 
-        # Input methods with professional styling
+        # Input methods with custom styling wrapper
         col1, col2 = st.columns([3, 1])
         with col1:
             st.markdown('<h3 class="subsection-header">Input Method</h3>', unsafe_allow_html=True)
         with col2:
+            st.markdown('<div style="background: transparent; padding: 0;">', unsafe_allow_html=True)
             input_method = st.radio(
                 "Choose input method:",
                 ["Type Text", "Upload File"],
                 horizontal=True,
                 label_visibility="collapsed"
             )
+            st.markdown('</div>', unsafe_allow_html=True)
 
         user_text = ""
 
@@ -1961,7 +1958,7 @@ def render_system_status_tab():
     st.markdown("---")
     render_validation_quality_report()
 
-    # Model information
+    # Model information with enhanced detection
     st.markdown("---")
     st.markdown('<h3 class="subsection-header">🎯 Model Information</h3>', unsafe_allow_html=True)
     
@@ -1972,7 +1969,47 @@ def render_system_status_tab():
         col1, col2 = st.columns(2)
         
         with col1:
-            key_metrics = ['model_version', 'test_accuracy', 'test_f1', 'model_type']
+            # Enhanced model type detection
+            model_type = metadata.get('model_type', 'Unknown')
+            
+            # Check if it's actually an ensemble by looking at the training method or other indicators
+            training_method = metadata.get('training_method', '')
+            model_version = metadata.get('model_version', '')
+            
+            # Try to detect ensemble from metadata or check actual model files
+            if 'ensemble' in training_method.lower() or 'ensemble' in model_version.lower():
+                display_model_type = 'Ensemble Model'
+            elif model_type == 'logistic_regression_pipeline':
+                # Try to load and inspect the actual model to see if it's an ensemble
+                try:
+                    import joblib
+                    pipeline_path = path_manager.get_pipeline_path()
+                    if pipeline_path.exists():
+                        pipeline = joblib.load(pipeline_path)
+                        # Check if the model component is an ensemble
+                        if hasattr(pipeline, 'named_steps') and 'model' in pipeline.named_steps:
+                            model_component = pipeline.named_steps['model']
+                            model_class_name = model_component.__class__.__name__
+                            
+                            # Check for ensemble indicators
+                            if 'voting' in model_class_name.lower() or 'ensemble' in model_class_name.lower():
+                                display_model_type = f'Ensemble ({model_class_name})'
+                            elif hasattr(model_component, 'estimators_'):
+                                # Has multiple estimators - likely ensemble
+                                estimator_types = [est.__class__.__name__ for est in model_component.estimators_]
+                                display_model_type = f'Ensemble ({", ".join(set(estimator_types))})'
+                            else:
+                                display_model_type = f'Single Model ({model_class_name})'
+                        else:
+                            display_model_type = model_type
+                    else:
+                        display_model_type = model_type
+                except Exception as e:
+                    display_model_type = f'{model_type} (inspection failed)'
+            else:
+                display_model_type = model_type
+            
+            key_metrics = ['model_version', 'test_accuracy', 'test_f1']
             for key in key_metrics:
                 if key in metadata:
                     display_key = key.replace('_', ' ').title()
@@ -1981,6 +2018,9 @@ def render_system_status_tab():
                         st.metric(display_key, f"{value:.4f}")
                     else:
                         st.metric(display_key, str(value))
+            
+            # Display the enhanced model type
+            st.metric("Model Type", display_model_type)
         
         with col2:
             info_fields = ['train_size', 'timestamp', 'environment']
@@ -1995,6 +2035,20 @@ def render_system_status_tab():
                         except:
                             pass
                     st.write(f"**{display_key}:** {value}")
+            
+            # Add ensemble composition if detected
+            if 'Ensemble' in display_model_type and 'inspection failed' not in display_model_type:
+                try:
+                    pipeline_path = path_manager.get_pipeline_path()
+                    if pipeline_path.exists():
+                        import joblib
+                        pipeline = joblib.load(pipeline_path)
+                        if hasattr(pipeline, 'named_steps') and 'model' in pipeline.named_steps:
+                            model_component = pipeline.named_steps['model']
+                            if hasattr(model_component, 'estimators_'):
+                                st.write(f"**Ensemble Size:** {len(model_component.estimators_)} models")
+                except:
+                    pass
     else:
         st.markdown(f"""
         <div class="warning-message">