import streamlit as st import pandas as pd import numpy as np import matplotlib.pyplot as plt import seaborn as sns import tempfile import os import sys from io import StringIO import plotly.express as px import plotly.graph_objects as go from plotly.subplots import make_subplots # Add the parent directory to sys.path to import the module sys.path.append(os.path.abspath(os.path.join(os.path.dirname(__file__), '..'))) from qualivec.data import DataLoader from qualivec.embedding import EmbeddingModel from qualivec.matching import SemanticMatcher from qualivec.classification import Classifier from qualivec.evaluation import Evaluator from qualivec.optimization import ThresholdOptimizer # Set page config st.set_page_config( page_title="QualiVec Demo", page_icon="🔍", layout="wide", initial_sidebar_state="expanded" ) # Custom CSS for better styling st.markdown(""" """, unsafe_allow_html=True) def main(): # st.markdown('
🔍 QualiVec Demo
', unsafe_allow_html=True) st.markdown("""

Qualitative Content Analysis with LLM Embeddings

""", unsafe_allow_html=True) # Sidebar for navigation st.sidebar.title("Navigation") page = st.sidebar.selectbox( "Choose a page", ["🏠 Home", "📊 Reference Vector", "🔧 Configuration", "🎯 Classification", "📈 Results"] ) # Initialize session state if 'classifier' not in st.session_state: st.session_state.classifier = None if 'reference_data' not in st.session_state: st.session_state.reference_data = None if 'labeled_data' not in st.session_state: st.session_state.labeled_data = None if 'optimization_results' not in st.session_state: st.session_state.optimization_results = None if 'evaluation_results' not in st.session_state: st.session_state.evaluation_results = None # Route to different pages if page == "🏠 Home": show_home_page() elif page == "📊 Reference Vector": show_data_upload_page() elif page == "🔧 Configuration": show_configuration_page() elif page == "🎯 Classification": show_classification_page() elif page == "📈 Results": show_results_page() def show_home_page(): st.markdown('
Welcome to QualiVec
', unsafe_allow_html=True) col1, col2, col3 = st.columns([1, 2, 1]) with col2: st.markdown(""" QualiVec is a tool that uses Large Language Model (LLM) embeddings for qualitative content analysis. It helps researchers and analysts classify text data by comparing it against reference examples. ### Key Features: - **Semantic Matching**: Uses advanced embedding models to find semantic similarity - **Threshold Optimization**: Automatically finds the best similarity threshold - **Comprehensive Evaluation**: Provides detailed metrics and visualizations - **Bootstrap Analysis**: Confidence intervals for robust evaluation ### How It Works: 1. **Upload Data**: Provide reference examples and data to classify 2. **Configure**: Set up embedding models and parameters 3. **Optimize**: Find the best threshold for classification 4. **Classify**: Apply the model to your data 5. **Evaluate**: Get detailed performance metrics ### Getting Started: Use the sidebar to navigate through the demo. Start with **Data Upload** to begin your analysis. """) # Add sample data info st.markdown('
Exemplar Templates
', unsafe_allow_html=True) col1, col2 = st.columns(2) with col1: st.markdown("**Reference Vector:**") sample_ref = pd.DataFrame({ 'tag': ['CSR1', 'CSR2', 'CSR3'], 'sentence': ['CSR reporting guidelines', 'Water conservation initiatives', 'Developing energy-efficient technologies'] }) st.dataframe(sample_ref, use_container_width=True) with col2: st.markdown("**Labeled Data Format:**") sample_labeled = pd.DataFrame({ 'sentence': ['I love this product', 'Not very good', 'Average quality'], 'Label': ['Positive', 'Negative', 'Neutral'] }) st.dataframe(sample_labeled, use_container_width=True) def show_data_upload_page(): st.markdown('
Data Upload
', unsafe_allow_html=True) col1, col2 = st.columns(2) with col1: st.markdown("### Reference Vector's Data") st.markdown("Upload a CSV file containing reference examples with columns: `tag` (class) and `sentence` (example text)") reference_file = st.file_uploader( "Choose reference data file", type=['csv'], key='reference_file' ) if reference_file is not None: try: reference_df = pd.read_csv(reference_file) st.success("Reference data loaded successfully!") st.dataframe(reference_df.head(), use_container_width=True) # Validate columns required_cols = ['tag', 'sentence'] missing_cols = [col for col in required_cols if col not in reference_df.columns] if missing_cols: st.error(f"Missing required columns: {missing_cols}") else: # Prepare reference data reference_df = reference_df.rename(columns={ 'tag': 'class', 'sentence': 'matching_node' }) st.session_state.reference_data = reference_df # Show statistics st.markdown("**Data Statistics:**") st.write(f"- Total examples: {len(reference_df)}") st.write(f"- Unique classes: {reference_df['class'].nunique()}") st.write(f"- Class distribution:") st.write(reference_df['class'].value_counts()) except Exception as e: st.error(f"Error loading reference data: {str(e)}") with col2: st.markdown("### Manually Labeled Sample") st.markdown("Upload a CSV file containing data to classify with columns: `sentence` (text) and `Label` (true class)") labeled_file = st.file_uploader( "Choose labeled data file", type=['csv'], key='labeled_file' ) if labeled_file is not None: try: labeled_df = pd.read_csv(labeled_file) st.success("Labeled data loaded successfully!") st.dataframe(labeled_df.head(), use_container_width=True) # Validate columns required_cols = ['sentence', 'Label'] missing_cols = [col for col in required_cols if col not in labeled_df.columns] if missing_cols: st.error(f"Missing required columns: {missing_cols}") else: # Prepare labeled data labeled_df = labeled_df.rename(columns={'Label': 'label'}) labeled_df['label'] = labeled_df['label'].replace('0', 'Other') st.session_state.labeled_data = labeled_df # Show statistics st.markdown("**Data Statistics:**") st.write(f"- Total samples: {len(labeled_df)}") st.write(f"- Unique labels: {labeled_df['label'].nunique()}") st.write(f"- Label distribution:") st.write(labeled_df['label'].value_counts()) except Exception as e: st.error(f"Error loading labeled data: {str(e)}") # Show data compatibility check if st.session_state.reference_data is not None and st.session_state.labeled_data is not None: st.markdown('
Data Compatibility Check
', unsafe_allow_html=True) ref_classes = set(st.session_state.reference_data['class'].unique()) labeled_classes = set(st.session_state.labeled_data['label'].unique()) # Check for unknown classes unknown_classes = labeled_classes - ref_classes if unknown_classes: st.warning(f"Warning: Labels in labeled data not found in reference data: {unknown_classes}") else: st.success("✅ Data compatibility check passed!") # Show class overlap st.markdown("**Class Overlap Analysis:**") col1, col2, col3 = st.columns(3) with col1: st.metric("Reference Classes", len(ref_classes)) with col2: st.metric("Labeled Classes", len(labeled_classes)) with col3: st.metric("Common Classes", len(ref_classes.intersection(labeled_classes))) def show_configuration_page(): st.markdown('
Model Configuration
', unsafe_allow_html=True) # Check if data is loaded if st.session_state.reference_data is None or st.session_state.labeled_data is None: st.warning("Please upload both reference and labeled data first.") return col1, col2 = st.columns(2) with col1: st.markdown("### Embedding Model") # Model type selection model_type = st.selectbox( "Choose model type", ["HuggingFace", "Gemini"], help="Select the type of embedding model to use" ) # Model selection based on type if model_type == "HuggingFace": model_options = [ "sentence-transformers/all-MiniLM-L6-v2", "sentence-transformers/all-mpnet-base-v2", "sentence-transformers/distilbert-base-nli-mean-tokens" ] selected_model = st.selectbox( "Choose HuggingFace model", model_options, help="Select the pre-trained HuggingFace model for generating embeddings" ) else: # Gemini gemini_models = [ "gemini-embedding-001", "text-embedding-004" ] selected_model = st.selectbox( "Choose Gemini model", gemini_models, help="Select the Gemini embedding model for generating embeddings" ) # Calculate total texts to process total_texts = 0 if st.session_state.reference_data is not None: total_texts += len(st.session_state.reference_data) if st.session_state.labeled_data is not None: total_texts += len(st.session_state.labeled_data) st.warning( f"⚠️ **Gemini API Rate Limits (Free Tier)**\\n\\n" f"- 1,500 requests per day\\n" f"- Each batch of 100 texts = 1 request\\n" f"- Your current dataset: ~{total_texts} texts\\n" f"- Estimated requests needed: ~{(total_texts // 100) + 1}\\n\\n" f"If you exceed quota, consider:\\n" f"1. Using a smaller dataset\\n" f"2. Switching to HuggingFace models (no limits)\\n" f"3. Upgrading to a paid API plan" ) st.info("💡 Note: Using Gemini embeddings requires GOOGLE_API_KEY environment variable to be set.") st.markdown("### Initial Threshold") initial_threshold = st.slider( "Initial similarity threshold", min_value=0.0, max_value=1.0, value=0.7, step=0.05, help="Cosine similarity threshold for classification" ) with col2: st.markdown("### Optimization Parameters") optimize_threshold = st.checkbox( "Enable threshold optimization", value=True, help="Automatically find the best threshold" ) if optimize_threshold: col2_1, col2_2 = st.columns(2) with col2_1: start_threshold = st.slider( "Start threshold", min_value=0.0, max_value=1.0, value=0.5, step=0.05 ) end_threshold = st.slider( "End threshold", min_value=0.0, max_value=1.0, value=0.9, step=0.05 ) with col2_2: step_size = st.slider( "Step size", min_value=0.005, max_value=0.05, value=0.01, step=0.005 ) optimization_metric = st.selectbox( "Optimization metric", ["f1_macro", "accuracy", "precision_macro", "recall_macro"] ) # Load models button if st.button("Initialize Models", type="primary"): with st.spinner("Loading models... This may take a few minutes."): try: # Initialize classifier classifier = Classifier(verbose=False) # Determine model type parameter model_type_param = "gemini" if model_type == "Gemini" else "huggingface" classifier.load_models( model_name=selected_model, model_type=model_type_param, threshold=initial_threshold ) # Prepare reference vectors with tempfile.NamedTemporaryFile(mode='w', suffix='.csv', delete=False) as tmp_ref: tmp_ref_path = tmp_ref.name st.session_state.reference_data.to_csv(tmp_ref_path, index=False) try: reference_data = classifier.prepare_reference_vectors( reference_path=tmp_ref_path, class_column='class', node_column='matching_node' ) finally: # Ensure file is deleted even if an error occurs try: os.unlink(tmp_ref_path) except (OSError, PermissionError): pass # File might already be deleted or locked st.session_state.classifier = classifier st.session_state.reference_vectors = reference_data st.session_state.config = { 'model_type': model_type, 'model_name': selected_model, 'initial_threshold': initial_threshold, 'optimize_threshold': optimize_threshold, 'start_threshold': start_threshold if optimize_threshold else None, 'end_threshold': end_threshold if optimize_threshold else None, 'step_size': step_size if optimize_threshold else None, 'optimization_metric': optimization_metric if optimize_threshold else None } st.success("✅ Models initialized successfully!") except Exception as e: st.error(f"Error initializing models: {str(e)}") # Show current configuration if st.session_state.classifier is not None: st.markdown('
Current Configuration
', unsafe_allow_html=True) config = st.session_state.config col1, col2, col3 = st.columns(3) with col1: st.markdown("**Model Settings:**") st.write(f"- Model type: {config['model_type']}") st.write(f"- Model: {config['model_name']}") st.write(f"- Initial threshold: {config['initial_threshold']}") with col2: st.markdown("**Optimization:**") st.write(f"- Enabled: {config['optimize_threshold']}") if config['optimize_threshold']: st.write(f"- Range: {config['start_threshold']:.2f} - {config['end_threshold']:.2f}") st.write(f"- Step: {config['step_size']:.3f}") with col3: st.markdown("**Data:**") st.write(f"- Reference examples: {len(st.session_state.reference_data)}") st.write(f"- Labeled samples: {len(st.session_state.labeled_data)}") def show_classification_page(): st.markdown('
Classification & Optimization
', unsafe_allow_html=True) # Check if models are loaded if st.session_state.classifier is None: st.warning("Please configure and initialize models first.") return # Run classification if st.button("Run Classification", type="primary"): # New: progress bar and status placeholder progress_bar = st.progress(0) status_text = st.empty() status_text.info("Starting classification...") with st.spinner("Running classification and optimization..."): try: # Save labeled data to temporary file with tempfile.NamedTemporaryFile(mode='w', suffix='.csv', delete=False) as tmp_labeled: tmp_labeled_path = tmp_labeled.name st.session_state.labeled_data.to_csv(tmp_labeled_path, index=False) try: # Run optimization if enabled if st.session_state.config['optimize_threshold']: status_text.info("Running threshold optimization...") progress_bar.progress(10) optimization_results = st.session_state.classifier.evaluate_classification( labeled_path=tmp_labeled_path, reference_data=st.session_state.reference_vectors, sentence_column='sentence', label_column='label', optimize_threshold=True, start=st.session_state.config['start_threshold'], end=st.session_state.config['end_threshold'], step=st.session_state.config['step_size'] ) st.session_state.optimization_results = optimization_results optimal_threshold = optimization_results["optimal_threshold"] # Update classifier with optimal threshold st.session_state.classifier.matcher = SemanticMatcher( threshold=optimal_threshold, verbose=False ) progress_bar.progress(40) status_text.success(f"Optimization completed. Optimal threshold: {optimal_threshold:.4f}") else: optimal_threshold = st.session_state.config['initial_threshold'] progress_bar.progress(20) status_text.info(f"Using initial threshold: {optimal_threshold:.4f}") # Run evaluation status_text.info("Generating embeddings...") progress_bar.progress(50) embedding_model = st.session_state.classifier.embedding_model data_loader = DataLoader(verbose=False) full_df = data_loader.load_labeled_data(tmp_labeled_path, label_column='label') # Generate embeddings full_embeddings = embedding_model.embed_dataframe(full_df, text_column='sentence') progress_bar.progress(70) status_text.info("Classifying with semantic matcher...") # Classify match_results = st.session_state.classifier.matcher.match( full_embeddings, st.session_state.reference_vectors ) predicted_labels = match_results["predicted_class"].tolist() true_labels = full_df['label'].tolist() progress_bar.progress(80) status_text.info("Evaluating predicted labels...") # Evaluate evaluator = Evaluator(verbose=False) eval_results = evaluator.evaluate( true_labels=true_labels, predicted_labels=predicted_labels, class_names=list(set(true_labels) | set(predicted_labels)) ) progress_bar.progress(90) status_text.info("Running bootstrap evaluation...") # Bootstrap evaluation bootstrap_results = evaluator.bootstrap_evaluate( true_labels=true_labels, predicted_labels=predicted_labels, n_iterations=100 ) progress_bar.progress(98) st.session_state.evaluation_results = eval_results st.session_state.bootstrap_results = bootstrap_results st.session_state.predictions = { 'true_labels': true_labels, 'predicted_labels': predicted_labels, 'match_results': match_results, 'full_df': full_df } finally: # Ensure temporary file is deleted try: os.unlink(tmp_labeled_path) except (OSError, PermissionError): pass # File might already be deleted or locked progress_bar.progress(100) status_text.success("Classification completed successfully!") st.success("✅ Classification completed successfully!") except Exception as e: progress_bar.empty() status_text.error(f"Error during classification: {str(e)}") st.error(f"Error during classification: {str(e)}") # Show optimization results if available if st.session_state.optimization_results is not None: st.markdown('
Optimization Results
', unsafe_allow_html=True) results = st.session_state.optimization_results col1, col2, col3, col4 = st.columns(4) with col1: st.metric( "Optimal Threshold", f"{results['optimal_threshold']:.4f}" ) with col2: st.metric( "Accuracy", f"{results['optimal_metrics']['accuracy']:.4f}" ) with col3: st.metric( "F1 Score", f"{results['optimal_metrics']['f1_macro']:.4f}" ) with col4: st.metric( "Precision", f"{results['optimal_metrics']['precision_macro']:.4f}" ) # Plot optimization curve st.markdown("### Optimization Curve") opt_results = results["results_by_threshold"] fig = make_subplots( rows=2, cols=2, subplot_titles=('Accuracy', 'F1 Score', 'Precision', 'Recall'), vertical_spacing=0.1 ) thresholds = opt_results["thresholds"] # Add traces fig.add_trace( go.Scatter(x=thresholds, y=opt_results["accuracy"], name="Accuracy"), row=1, col=1 ) fig.add_trace( go.Scatter(x=thresholds, y=opt_results["f1_macro"], name="F1 Score"), row=1, col=2 ) fig.add_trace( go.Scatter(x=thresholds, y=opt_results["precision_macro"], name="Precision"), row=2, col=1 ) fig.add_trace( go.Scatter(x=thresholds, y=opt_results["recall_macro"], name="Recall"), row=2, col=2 ) # Add optimal threshold line to each subplot using shapes optimal_thresh = results['optimal_threshold'] # Add vertical line as shapes to each subplot shapes = [] for row in range(1, 3): for col in range(1, 3): # Calculate the subplot domain xaxis = f'x{(row-1)*2 + col}' if (row-1)*2 + col > 1 else 'x' shapes.append( dict( type="line", x0=optimal_thresh, x1=optimal_thresh, y0=0, y1=1, yref=f"y{(row-1)*2 + col} domain" if (row-1)*2 + col > 1 else "y domain", xref=xaxis, line=dict(color="red", width=2, dash="dash") ) ) fig.update_layout(shapes=shapes) fig.update_layout( title="Threshold Optimization Results", showlegend=False, height=600 ) st.plotly_chart(fig, use_container_width=True) def show_results_page(): st.markdown('
Results & Evaluation
', unsafe_allow_html=True) # Check if evaluation results are available if st.session_state.evaluation_results is None: st.warning("Please run classification first to see results.") return eval_results = st.session_state.evaluation_results # Performance metrics st.markdown("### Performance Metrics") col1, col2, col3, col4 = st.columns(4) with col1: st.metric( "Overall Accuracy", f"{eval_results['accuracy']:.4f}" ) with col2: st.metric( "Macro F1 Score", f"{eval_results['f1_macro']:.4f}" ) with col3: st.metric( "Macro Precision", f"{eval_results['precision_macro']:.4f}" ) with col4: st.metric( "Macro Recall", f"{eval_results['recall_macro']:.4f}" ) # Class-wise metrics st.markdown("### Class-wise Performance") class_metrics_df = pd.DataFrame({ 'Class': list(eval_results['class_metrics']['precision'].keys()), 'Precision': list(eval_results['class_metrics']['precision'].values()), 'Recall': list(eval_results['class_metrics']['recall'].values()), 'F1-Score': list(eval_results['class_metrics']['f1'].values()), 'Support': list(eval_results['class_metrics']['support'].values()) }) st.dataframe(class_metrics_df, use_container_width=True) # Confusion Matrix st.markdown("### Confusion Matrix") cm = eval_results['confusion_matrix'] class_names = eval_results['confusion_matrix_labels'] fig = px.imshow( cm, labels=dict(x="Predicted", y="True", color="Count"), x=class_names, y=class_names, color_continuous_scale='Blues', text_auto=True, title="Confusion Matrix" ) fig.update_layout( width=600, height=600 ) st.plotly_chart(fig, use_container_width=True) # Bootstrap Results if st.session_state.bootstrap_results is not None: st.markdown("### Bootstrap Confidence Intervals") bootstrap_results = st.session_state.bootstrap_results # Debug: show available keys if 'confidence_intervals' in bootstrap_results: metrics = ['accuracy', 'precision_macro', 'recall_macro', 'f1_macro'] for metric in metrics: if metric in bootstrap_results['confidence_intervals']: ci_data = bootstrap_results['confidence_intervals'][metric] st.markdown(f"**{metric.replace('_', ' ').title()}:**") col1, col2, col3 = st.columns(3) # Check available confidence levels available_levels = list(ci_data.keys()) with col1: if '0.95' in ci_data: ci_95 = ci_data['0.95'] if isinstance(ci_95, dict): st.write(f"95% CI: [{ci_95['lower']:.4f}, {ci_95['upper']:.4f}]") elif isinstance(ci_95, (list, tuple)) and len(ci_95) >= 2: st.write(f"95% CI: [{ci_95[0]:.4f}, {ci_95[1]:.4f}]") else: st.write("95% CI: Format not recognized") elif 0.95 in ci_data: ci_95 = ci_data[0.95] if isinstance(ci_95, dict): st.write(f"95% CI: [{ci_95['lower']:.4f}, {ci_95['upper']:.4f}]") elif isinstance(ci_95, (list, tuple)) and len(ci_95) >= 2: st.write(f"95% CI: [{ci_95[0]:.4f}, {ci_95[1]:.4f}]") else: st.write("95% CI: Format not recognized") else: st.write("95% CI: Not available") with col2: if '0.99' in ci_data: ci_99 = ci_data['0.99'] if isinstance(ci_99, dict): st.write(f"99% CI: [{ci_99['lower']:.4f}, {ci_99['upper']:.4f}]") elif isinstance(ci_99, (list, tuple)) and len(ci_99) >= 2: st.write(f"99% CI: [{ci_99[0]:.4f}, {ci_99[1]:.4f}]") else: st.write("99% CI: Format not recognized") elif 0.99 in ci_data: ci_99 = ci_data[0.99] if isinstance(ci_99, dict): st.write(f"99% CI: [{ci_99['lower']:.4f}, {ci_99['upper']:.4f}]") elif isinstance(ci_99, (list, tuple)) and len(ci_99) >= 2: st.write(f"99% CI: [{ci_99[0]:.4f}, {ci_99[1]:.4f}]") else: st.write("99% CI: Format not recognized") else: st.write("99% CI: Not available") with col3: if 'point_estimates' in bootstrap_results and metric in bootstrap_results['point_estimates']: st.write(f"Point Estimate: {bootstrap_results['point_estimates'][metric]:.4f}") else: st.write("Point Estimate: Not available") else: st.info("Bootstrap confidence intervals not available.") # Bootstrap Distribution Plot st.markdown("### Bootstrap Distributions") if 'bootstrap_distribution' in bootstrap_results: fig = make_subplots( rows=2, cols=2, subplot_titles=('Accuracy', 'F1 Score', 'Precision', 'Recall') ) distributions = bootstrap_results['bootstrap_distribution'] if 'accuracy' in distributions: fig.add_trace( go.Histogram(x=distributions['accuracy'], name="Accuracy", nbinsx=30), row=1, col=1 ) if 'f1_macro' in distributions: fig.add_trace( go.Histogram(x=distributions['f1_macro'], name="F1 Score", nbinsx=30), row=1, col=2 ) if 'precision_macro' in distributions: fig.add_trace( go.Histogram(x=distributions['precision_macro'], name="Precision", nbinsx=30), row=2, col=1 ) if 'recall_macro' in distributions: fig.add_trace( go.Histogram(x=distributions['recall_macro'], name="Recall", nbinsx=30), row=2, col=2 ) fig.update_layout( title="Bootstrap Distributions", showlegend=False, height=600 ) st.plotly_chart(fig, use_container_width=True) else: st.info("Bootstrap distributions not available.") # Sample predictions if 'predictions' in st.session_state: st.markdown("### Sample Predictions") predictions = st.session_state.predictions sample_df = predictions['full_df'].copy() sample_df['predicted_class'] = predictions['predicted_labels'] sample_df['true_class'] = predictions['true_labels'] sample_df['similarity_score'] = predictions['match_results']['similarity_score'] sample_df['correct'] = sample_df['predicted_class'] == sample_df['true_class'] # Filter options col1, col2 = st.columns(2) with col1: show_correct = st.checkbox("Show correct predictions", value=True) with col2: show_incorrect = st.checkbox("Show incorrect predictions", value=True) # Filter data if show_correct and show_incorrect: filtered_df = sample_df elif show_correct: filtered_df = sample_df[sample_df['correct'] == True] elif show_incorrect: filtered_df = sample_df[sample_df['correct'] == False] else: filtered_df = pd.DataFrame() if not filtered_df.empty: # Sample random rows n_samples = min(20, len(filtered_df)) sample_rows = filtered_df.sample(n=n_samples) if len(filtered_df) > n_samples else filtered_df display_df = sample_rows[['sentence', 'true_class', 'predicted_class', 'similarity_score', 'correct']].reset_index(drop=True) st.dataframe(display_df, use_container_width=True) else: st.info("No predictions to show with current filters.") # Download results st.markdown("### Download Results") col1, col2 = st.columns(2) with col1: # Download class-wise metrics csv_metrics = class_metrics_df.to_csv(index=False) st.download_button( label="Download Class Metrics", data=csv_metrics, file_name="class_metrics.csv", mime="text/csv" ) with col2: # Download predictions if 'predictions' in st.session_state: predictions = st.session_state.predictions results_df = predictions['full_df'].copy() results_df['predicted_class'] = predictions['predicted_labels'] results_df['similarity_score'] = predictions['match_results']['similarity_score'] csv_results = results_df.to_csv(index=False) st.download_button( label="Download Predictions", data=csv_results, file_name="predictions.csv", mime="text/csv" ) if __name__ == "__main__": main()