Spaces:
Sleeping
Sleeping
| import gradio as gr | |
| from pathlib import Path | |
| from pipeline.process import process_texts | |
| from pipeline.visualize import generate_visualizations, generate_word_count_chart | |
| from pipeline.llm_service import LLMService | |
| import logging | |
| import pandas as pd | |
| from datetime import datetime | |
| from dotenv import load_dotenv | |
| # Load environment variables from .env file | |
| from theme import tibetan_theme | |
| load_dotenv() | |
| logger = logging.getLogger(__name__) | |
| def main_interface(): | |
| with gr.Blocks( | |
| theme=tibetan_theme, | |
| title="Tibetan Text Metrics Web App", | |
| css=tibetan_theme.get_css_string() + ".metric-description, .step-box { padding: 1.5rem !important; }" | |
| ) as demo: | |
| gr.Markdown( | |
| """# Tibetan Text Metrics Web App | |
| <span style='font-size:18px;'>A user-friendly web application for analyzing textual similarities and variations in Tibetan manuscripts, providing a graphical interface to the core functionalities of the [Tibetan Text Metrics (TTM)](https://github.com/daniel-wojahn/tibetan-text-metrics) project. Powered by advanced language models via OpenRouter for in-depth text analysis.</span> | |
| """, | |
| elem_classes="gr-markdown", | |
| ) | |
| with gr.Row(elem_id="steps-row"): | |
| with gr.Column(scale=1, elem_classes="step-column"): | |
| with gr.Group(elem_classes="step-box"): | |
| gr.Markdown( | |
| """ | |
| ## Step 1: Upload Your Tibetan Text Files | |
| <span style='font-size:16px;'>Upload one or more `.txt` files. Each file should contain Unicode Tibetan text, segmented into chapters/sections if possible using the marker '༈' (<i>sbrul shad</i>).</span> | |
| """, | |
| elem_classes="gr-markdown", | |
| ) | |
| file_input = gr.File( | |
| label="Upload Tibetan .txt files", | |
| file_types=[".txt"], | |
| file_count="multiple", | |
| ) | |
| gr.Markdown( | |
| "<small>Note: Maximum file size: 10MB per file. For optimal performance, use files under 1MB.</small>", | |
| elem_classes="gr-markdown" | |
| ) | |
| with gr.Column(scale=1, elem_classes="step-column"): | |
| with gr.Group(elem_classes="step-box"): | |
| gr.Markdown( | |
| """## Step 2: Configure and run the analysis | |
| <span style='font-size:16px;'>Choose your analysis options and click the button below to compute metrics and view results. For meaningful analysis, ensure your texts are segmented by chapter or section using the marker '༈' (<i>sbrul shad</i>). The tool will split files based on this marker.</span> | |
| """, | |
| elem_classes="gr-markdown", | |
| ) | |
| semantic_toggle_radio = gr.Radio( | |
| label="Compute semantic similarity? (Experimental)", | |
| choices=["Yes", "No"], | |
| value="No", | |
| info="Semantic similarity will be time-consuming. Choose 'No' to speed up analysis if these metrics are not required.", | |
| elem_id="semantic-radio-group", | |
| ) | |
| model_dropdown = gr.Dropdown( | |
| choices=[ | |
| "sentence-transformers/LaBSE", | |
| "Facebook FastText (Pre-trained)" | |
| ], | |
| label="Select Embedding Model", | |
| value="sentence-transformers/LaBSE", | |
| info="Select the embedding model to use for semantic similarity analysis. LaBSE v1.0 or FastText v1.0." | |
| ) | |
| with gr.Accordion("Advanced Options", open=False): | |
| batch_size_slider = gr.Slider( | |
| minimum=1, | |
| maximum=64, | |
| value=8, | |
| step=1, | |
| label="Batch Size (for Hugging Face models)", | |
| info="Adjust based on your hardware (VRAM). Lower this if you encounter memory issues." | |
| ) | |
| progress_bar_checkbox = gr.Checkbox( | |
| label="Show Embedding Progress Bar", | |
| value=False, | |
| info="Display a progress bar during embedding generation. Useful for large datasets." | |
| ) | |
| stopwords_dropdown = gr.Dropdown( | |
| label="Stopword Filtering", | |
| choices=[ | |
| "None (No filtering)", | |
| "Standard (Common particles only)", | |
| "Aggressive (All function words)" | |
| ], | |
| value="Standard (Common particles only)", # Default | |
| info="Choose how aggressively to filter out common Tibetan particles and function words when calculating similarity. This helps focus on meaningful content words." | |
| ) | |
| process_btn = gr.Button( | |
| "Run Analysis", elem_id="run-btn", variant="primary" | |
| ) | |
| gr.Markdown( | |
| """## Results | |
| """, | |
| elem_classes="gr-markdown", | |
| ) | |
| # The heatmap_titles and metric_tooltips dictionaries are defined here | |
| # heatmap_titles = { ... } | |
| # metric_tooltips = { ... } | |
| csv_output = gr.File(label="Download CSV Results") | |
| metrics_preview = gr.Dataframe( | |
| label="Similarity Metrics Preview", interactive=False, visible=True | |
| ) | |
| # LLM Interpretation components | |
| with gr.Row(): | |
| with gr.Column(): | |
| gr.Markdown( | |
| "## AI Analysis\n*The AI will analyze your text similarities and provide insights into patterns and relationships.*", | |
| elem_classes="gr-markdown" | |
| ) | |
| # Add the interpret button | |
| with gr.Row(): | |
| interpret_btn = gr.Button( | |
| "Help Interpret Results", | |
| variant="primary", | |
| elem_id="interpret-btn" | |
| ) | |
| # Create a placeholder message with proper formatting and structure | |
| initial_message = """ | |
| ## Analysis of Tibetan Text Similarity Metrics | |
| <small>*Click the 'Help Interpret Results' button above to generate an AI-powered analysis of your similarity metrics.*</small> | |
| """ | |
| interpretation_output = gr.Markdown( | |
| value=initial_message, | |
| elem_id="llm-analysis" | |
| ) | |
| # Heatmap tabs for each metric | |
| heatmap_titles = { | |
| "Jaccard Similarity (%)": "Jaccard Similarity (%): Higher scores (darker) mean more shared unique words.", | |
| "Normalized LCS": "Normalized LCS: Higher scores (darker) mean longer shared sequences of words.", | |
| "Semantic Similarity": "Semantic Similarity (using word embeddings/experimental): Higher scores (darker) mean more similar meanings.", | |
| "Word Counts": "Word Counts: Bar chart showing the number of words in each segment after tokenization.", | |
| } | |
| metric_tooltips = { | |
| "Jaccard Similarity (%)": """ | |
| ### Jaccard Similarity (%) | |
| This metric quantifies the lexical overlap between two text segments by comparing their sets of *unique* words, optionally filtering out common Tibetan stopwords. | |
| It essentially answers the question: 'Of all the distinct words found across these two segments, what proportion of them are present in both?' It is calculated as `(Number of common unique words) / (Total number of unique words in both texts combined) * 100`. | |
| Jaccard Similarity is insensitive to word order and word frequency; it only cares whether a unique word is present or absent. A higher percentage indicates a greater overlap in the vocabularies used in the two segments. | |
| **Stopword Filtering**: When enabled (via the "Filter Stopwords" checkbox), common Tibetan particles and function words are filtered out before comparison. This helps focus on meaningful content words rather than grammatical elements. | |
| """, | |
| "Normalized LCS": """ | |
| ### Normalized LCS (Longest Common Subsequence) | |
| This metric measures the length of the longest sequence of words that appears in *both* text segments, maintaining their original relative order. | |
| Importantly, these words do not need to be directly adjacent (contiguous) in either text. | |
| For example, if Text A is '<u>the</u> quick <u>brown</u> fox <u>jumps</u>' and Text B is '<u>the</u> lazy cat and <u>brown</u> dog <u>jumps</u> high', the LCS is 'the brown jumps'. | |
| The length of this common subsequence is then normalized (in this tool, by dividing by the length of the longer of the two segments) to provide a score, which is then presented as a percentage. | |
| A higher Normalized LCS score suggests more significant shared phrasing, direct textual borrowing, or strong structural parallelism, as it reflects similarities in how ideas are ordered and expressed sequentially. | |
| **No Stopword Filtering.** Unlike metrics such as Jaccard Similarity or TF-IDF Cosine Similarity (which typically filter out common stopwords to focus on content-bearing words), the LCS calculation in this tool intentionally uses the raw, unfiltered sequence of tokens from your texts. This design choice allows LCS to capture structural similarities and the flow of language, including the use of particles and common words that contribute to sentence construction and narrative sequence. By not removing stopwords, LCS can reveal similarities in phrasing and textual structure that might otherwise be obscured, making it a valuable complement to metrics that focus purely on lexical overlap of keywords. | |
| **Note on Interpretation**: It is possible for Normalized LCS to be higher than Jaccard Similarity. This often happens when texts share a substantial 'narrative backbone' or common ordered phrases (leading to a high LCS), even if they use varied surrounding vocabulary or introduce many unique words not part of these core sequences (which would lower the Jaccard score). LCS highlights this sequential, structural similarity, while Jaccard focuses on the overall shared vocabulary regardless of its arrangement. | |
| """, | |
| "Semantic Similarity": """ | |
| ### Semantic Similarity | |
| This metric measures the similarity in meaning between text segments by converting them into high-dimensional vectors (embeddings) and calculating the cosine similarity between them. A score closer to 1 indicates a higher degree of semantic overlap. You can choose from two types of models: | |
| **1. Hugging Face Transformer Models (e.g., LaBSE, E5-base-v2)**: | |
| - **Context-Aware**: These are state-of-the-art models that understand the context in which words appear, allowing them to capture nuanced meanings, relationships, and idiomatic expressions. | |
| - **Sentence-Level Embeddings**: They are specifically designed to create a single, high-quality vector representation for an entire text segment. | |
| - **Recommended for General Use**: These models often provide superior performance for capturing the overall thematic and semantic similarity between passages. | |
| **2. FastText Model**: | |
| - **Word-Based**: This model generates embeddings for individual words and then averages them (using TF-IDF weighting) to create a representation for the entire segment. | |
| - **Strong for Lexical Analysis**: It excels at understanding the meaning of individual words, including rare or specialized Tibetan vocabulary, as it can generate vectors for out-of-vocabulary words from their sub-word units. | |
| - **Optimized for Tibetan**: Uses `botok` tokenization and TF-IDF weighting to focus on the most significant words in a segment. | |
| **Stopword Filtering**: When enabled, common Tibetan particles and function words are filtered out before computing embeddings. This helps focus on meaningful content words and is recommended for most analyses. | |
| """, | |
| "TF-IDF Cosine Sim": """ | |
| ### TF-IDF Cosine Similarity | |
| This metric calculates Term Frequency-Inverse Document Frequency (TF-IDF) scores for each word in each text segment, optionally filtering out common Tibetan stopwords. | |
| TF-IDF gives higher weight to words that are frequent within a particular segment but relatively rare across the entire collection of segments. This helps identify terms that are characteristic or discriminative for a segment. When stopword filtering is enabled, the TF-IDF scores better reflect genuinely significant terms by excluding common particles and function words. | |
| Each segment is represented as a vector of these TF-IDF scores, and the cosine similarity is computed between these vectors. A score closer to 1 indicates that the two segments share more important, distinguishing terms, suggesting they cover similar specific topics or themes. | |
| **Stopword Filtering**: When enabled (via the "Filter Stopwords" checkbox), common Tibetan particles and function words are filtered out. This can be toggled on/off to compare results with and without stopwords. | |
| """, | |
| } | |
| heatmap_tabs = {} | |
| gr.Markdown("## Detailed Metric Analysis", elem_classes="gr-markdown") | |
| with gr.Tabs(elem_id="heatmap-tab-group"): | |
| # Structural Analysis Tab | |
| with gr.Tab("Structural Analysis"): | |
| gr.Markdown(""" | |
| ### Structural Analysis for Tibetan Legal Manuscripts | |
| This tab provides detailed chapter-level structural analysis for Tibetan legal manuscript comparison. | |
| **Features:** | |
| - **Differential Highlighting**: Highlights significant textual variations | |
| - **Per-Chapter Analysis**: Detailed comparison for each chapter pair | |
| **Usage:** | |
| Results appear automatically when texts are processed. Use the export buttons to save detailed reports for philological analysis. | |
| """) | |
| # Structural analysis outputs | |
| structural_heatmap = gr.Plot(label="Structural Changes Summary", show_label=False, elem_classes="structural-heatmap") | |
| structural_report = gr.HTML(label="Differential Analysis Report") | |
| structural_export = gr.File(label="Export Structural Analysis Report", file_types=[".html", ".md", ".json"]) | |
| # Process metrics excluding TF-IDF | |
| metrics_to_display = {k: v for k, v in heatmap_titles.items() if k != "TF-IDF Cosine Sim"} | |
| for metric_key, descriptive_title in metrics_to_display.items(): | |
| with gr.Tab(metric_key): | |
| # Set CSS class based on metric type | |
| if metric_key == "Jaccard Similarity (%)": | |
| css_class = "metric-info-accordion jaccard-info" | |
| accordion_title = "Understanding Vocabulary Overlap" | |
| elif metric_key == "Normalized LCS": | |
| css_class = "metric-info-accordion lcs-info" | |
| accordion_title = "Understanding Sequence Patterns" | |
| elif metric_key == "Semantic Similarity": | |
| css_class = "metric-info-accordion semantic-info" | |
| accordion_title = "Understanding Meaning Similarity" | |
| elif metric_key == "Word Counts": | |
| css_class = "metric-info-accordion wordcount-info" | |
| accordion_title = "Understanding Text Length" | |
| else: | |
| css_class = "metric-info-accordion" | |
| accordion_title = f"About {metric_key}" | |
| # Create the accordion with appropriate content | |
| with gr.Accordion(accordion_title, open=False, elem_classes=css_class): | |
| if metric_key == "Word Counts": | |
| gr.Markdown(""" | |
| ### Word Counts per Segment | |
| This chart displays the number of words in each segment of your texts after tokenization. | |
| """) | |
| elif metric_key in metric_tooltips: | |
| gr.Markdown(value=metric_tooltips[metric_key], elem_classes="metric-description") | |
| else: | |
| gr.Markdown(value=f"### {metric_key}\nDescription not found.") | |
| # Add the appropriate plot | |
| if metric_key == "Word Counts": | |
| word_count_plot = gr.Plot(label="Word Counts per Segment", show_label=False, scale=1, elem_classes="metric-description") | |
| else: | |
| heatmap_tabs[metric_key] = gr.Plot(label=f"Heatmap: {metric_key}", show_label=False, elem_classes="metric-heatmap") | |
| # The outputs in process_btn.click should use the short metric names as keys for heatmap_tabs | |
| # e.g., heatmap_tabs["Jaccard Similarity (%)"] | |
| # Ensure the plot is part of the layout. This assumes plots are displayed sequentially | |
| # within the current gr.Tab("Results"). If they are in specific TabItems, this needs adjustment. | |
| # For now, this modification focuses on creating the plot object and making it an output. | |
| # The visual placement depends on how Gradio renders children of gr.Tab or if there's another container. | |
| warning_box = gr.Markdown(visible=False) | |
| def run_pipeline(files, enable_semantic, model_name, stopwords_option, batch_size, show_progress, progress=gr.Progress()): | |
| """Run the text analysis pipeline on the uploaded files. | |
| Args: | |
| files: List of uploaded files | |
| enable_semantic: Whether to compute semantic similarity | |
| model_name: Name of the embedding model to use | |
| stopwords_option: Stopword filtering level (None, Standard, or Aggressive) | |
| progress: Gradio progress indicator | |
| Returns: | |
| Tuple of (metrics_df, heatmap_jaccard, heatmap_lcs, heatmap_semantic, heatmap_tfidf, word_count_fig) | |
| """ | |
| # Initialize progress tracking | |
| try: | |
| progress_tracker = gr.Progress() | |
| except Exception as e: | |
| logger.warning(f"Could not initialize progress tracker: {e}") | |
| progress_tracker = None | |
| # Initialize all return values to ensure defined paths for all outputs | |
| csv_path_res = None | |
| metrics_preview_df_res = None # Can be a DataFrame or a string message | |
| word_count_fig_res = None | |
| jaccard_heatmap_res = None | |
| lcs_heatmap_res = None | |
| semantic_heatmap_res = None | |
| warning_update_res = gr.update(value="", visible=False) # Default: no warning | |
| structural_heatmap_res = None | |
| structural_report_res = None | |
| structural_export_res = None | |
| """ | |
| Processes uploaded files, computes metrics, generates visualizations, and prepares outputs for the UI. | |
| Args: | |
| files (List[FileStorage]): A list of file objects uploaded by the user. | |
| Returns: | |
| tuple: A tuple containing the following elements in order: | |
| - csv_path (str | None): Path to the generated CSV results file, or None on error. | |
| - metrics_preview_df (pd.DataFrame | str | None): DataFrame for metrics preview, error string, or None. | |
| - word_count_fig (matplotlib.figure.Figure | None): Plot of word counts, or None on error. | |
| - jaccard_heatmap (matplotlib.figure.Figure | None): Jaccard similarity heatmap, or None. | |
| - lcs_heatmap (matplotlib.figure.Figure | None): LCS heatmap, or None. | |
| - semantic_heatmap (matplotlib.figure.Figure | None): Semantic similarity heatmap, or None. | |
| - warning_update (gr.update): Gradio update for the warning box. | |
| """ | |
| # Check if files are provided | |
| if not files: | |
| return ( | |
| None, | |
| "Please upload files to analyze.", | |
| None, # word_count_plot | |
| None, # jaccard_heatmap | |
| None, # lcs_heatmap | |
| None, # semantic_heatmap | |
| None, # tfidf_heatmap | |
| gr.update(value="Please upload files.", visible=True), | |
| ) | |
| # Check file size limits (10MB per file) | |
| for file in files: | |
| file_size_mb = Path(file.name).stat().st_size / (1024 * 1024) | |
| if file_size_mb > 10: | |
| return ( | |
| None, | |
| f"File '{Path(file.name).name}' exceeds the 10MB size limit (size: {file_size_mb:.2f}MB).", | |
| None, None, None, None, None, | |
| gr.update(value=f"Error: File '{Path(file.name).name}' exceeds the 10MB size limit.", visible=True), | |
| ) | |
| try: | |
| if progress_tracker is not None: | |
| try: | |
| progress_tracker(0.1, desc="Preparing files...") | |
| except Exception as e: | |
| logger.warning(f"Progress update error (non-critical): {e}") | |
| # Get filenames and read file contents | |
| filenames = [ | |
| Path(file.name).name for file in files | |
| ] # Use Path().name to get just the filename | |
| text_data = {} | |
| # Read files with progress updates | |
| for i, file in enumerate(files): | |
| file_path = Path(file.name) | |
| filename = file_path.name | |
| if progress_tracker is not None: | |
| try: | |
| progress_tracker(0.1 + (0.1 * (i / len(files))), desc=f"Reading file: {filename}") | |
| except Exception as e: | |
| logger.warning(f"Progress update error (non-critical): {e}") | |
| try: | |
| text_data[filename] = file_path.read_text(encoding="utf-8-sig") | |
| except UnicodeDecodeError: | |
| # Try with different encodings if UTF-8 fails | |
| try: | |
| text_data[filename] = file_path.read_text(encoding="utf-16") | |
| except UnicodeDecodeError: | |
| return ( | |
| None, | |
| f"Error: Could not decode file '{filename}'. Please ensure it contains valid Tibetan text in UTF-8 or UTF-16 encoding.", | |
| None, None, None, None, None, | |
| gr.update(value=f"Error: Could not decode file '{filename}'.", visible=True), | |
| ) | |
| # Configure semantic similarity | |
| enable_semantic_bool = enable_semantic == "Yes" | |
| if progress_tracker is not None: | |
| try: | |
| progress_tracker(0.2, desc="Loading model..." if enable_semantic_bool else "Processing text...") | |
| except Exception as e: | |
| logger.warning(f"Progress update error (non-critical): {e}") | |
| # Process texts with selected model | |
| # Convert stopword option to appropriate parameters | |
| use_stopwords = stopwords_option != "None (No filtering)" | |
| use_lite_stopwords = stopwords_option == "Standard (Common particles only)" | |
| # Map UI model name to internal model ID | |
| # The UI model_name is "Facebook FastText (Pre-trained)" | |
| # This mapping ensures the backend receives the correct identifier. | |
| if model_name == "Facebook FastText (Pre-trained)": | |
| internal_model_id = "facebook-fasttext-pretrained" | |
| else: | |
| # For Hugging Face models, the UI value is the correct model ID | |
| internal_model_id = model_name | |
| df_results, word_counts_df_data, warning_raw = process_texts( | |
| text_data, | |
| filenames, | |
| enable_semantic=enable_semantic_bool, | |
| model_name=internal_model_id, | |
| use_stopwords=use_stopwords, | |
| use_lite_stopwords=use_lite_stopwords, | |
| progress_callback=progress_tracker, | |
| batch_size=batch_size, | |
| show_progress_bar=show_progress | |
| ) | |
| if df_results.empty: | |
| warning_md = f"**⚠️ Warning:** {warning_raw}" if warning_raw else "" | |
| warning_message = ( | |
| "No common chapters found or results are empty. " + warning_md | |
| ) | |
| metrics_preview_df_res = warning_message | |
| warning_update_res = gr.update(value=warning_message, visible=True) | |
| # Results for this case are set, then return | |
| else: | |
| # Generate visualizations | |
| if progress_tracker is not None: | |
| try: | |
| progress_tracker(0.8, desc="Generating visualizations...") | |
| except Exception as e: | |
| logger.warning(f"Progress update error (non-critical): {e}") | |
| # heatmap_titles is already defined in the outer scope of main_interface | |
| heatmaps_data = generate_visualizations( | |
| df_results, descriptive_titles=heatmap_titles | |
| ) | |
| # Generate word count chart | |
| if progress_tracker is not None: | |
| try: | |
| progress_tracker(0.9, desc="Creating word count chart...") | |
| except Exception as e: | |
| logger.warning(f"Progress update error (non-critical): {e}") | |
| word_count_fig_res = generate_word_count_chart(word_counts_df_data) | |
| # Generate structural analysis | |
| if progress_tracker is not None: | |
| try: | |
| progress_tracker(0.92, desc="Generating structural analysis...") | |
| except Exception as e: | |
| logger.warning(f"Progress update error (non-critical): {e}") | |
| # Create structural analysis | |
| from pipeline.differential_viz import create_differential_heatmap, create_change_detection_report | |
| # Create structural heatmap | |
| try: | |
| structural_heatmap_res = create_differential_heatmap( | |
| text_data, "all_chapters", df_results | |
| ) | |
| except Exception as e: | |
| logger.warning(f"Could not generate structural heatmap: {e}") | |
| structural_heatmap_res = None | |
| # Create structural report | |
| try: | |
| structural_report_res = create_change_detection_report( | |
| text_data, "all_chapters", "html" | |
| ) | |
| except Exception as e: | |
| logger.warning(f"Could not generate structural report: {e}") | |
| structural_report_res = "<p>Could not generate structural analysis report.</p>" | |
| # Save structural analysis report | |
| try: | |
| report_path = "structural_analysis_report.html" | |
| with open(report_path, 'w', encoding='utf-8') as f: | |
| f.write(structural_report_res if isinstance(structural_report_res, str) else "") | |
| structural_export_res = report_path | |
| except Exception as e: | |
| logger.warning(f"Could not save structural report: {e}") | |
| structural_export_res = None | |
| # Save results to CSV | |
| if progress_tracker is not None: | |
| try: | |
| progress_tracker(0.95, desc="Saving results...") | |
| except Exception as e: | |
| logger.warning(f"Progress update error (non-critical): {e}") | |
| csv_path_res = "results.csv" | |
| df_results.to_csv(csv_path_res, index=False) | |
| # Prepare final output | |
| warning_md = f"**⚠️ Warning:** {warning_raw}" if warning_raw else "" | |
| metrics_preview_df_res = df_results.head(10) | |
| jaccard_heatmap_res = heatmaps_data.get("Jaccard Similarity (%)") | |
| lcs_heatmap_res = heatmaps_data.get("Normalized LCS") | |
| semantic_heatmap_res = heatmaps_data.get( | |
| "Semantic Similarity" | |
| ) | |
| _ = heatmaps_data.get("TF-IDF Cosine Sim") # TF-IDF removed | |
| warning_update_res = gr.update( | |
| visible=bool(warning_raw), value=warning_md | |
| ) | |
| except Exception as e: | |
| logger.error(f"Error in run_pipeline: {e}", exc_info=True) | |
| # metrics_preview_df_res and warning_update_res are set here. | |
| # Other plot/file path variables will retain their initial 'None' values set at function start. | |
| metrics_preview_df_res = f"Error: {str(e)}" | |
| warning_update_res = gr.update(value=f"Error: {str(e)}", visible=True) | |
| return ( | |
| csv_path_res, | |
| metrics_preview_df_res, | |
| word_count_fig_res, | |
| jaccard_heatmap_res, | |
| lcs_heatmap_res, | |
| semantic_heatmap_res, | |
| warning_update_res, | |
| structural_heatmap_res, | |
| structural_report_res, | |
| structural_export_res | |
| ) | |
| # Function to interpret results using LLM | |
| def interpret_results(csv_path, progress=gr.Progress()): | |
| try: | |
| if not csv_path or not Path(csv_path).exists(): | |
| return "Please run the analysis first to generate results." | |
| # Read the CSV file | |
| df_results = pd.read_csv(csv_path) | |
| # Show detailed progress messages with percentages | |
| progress(0, desc="Preparing data for analysis...") | |
| progress(0.1, desc="Analyzing similarity patterns...") | |
| progress(0.2, desc="Connecting to Mistral 7B via OpenRouter...") | |
| # Get interpretation from LLM (using OpenRouter API) | |
| progress(0.3, desc="Generating scholarly interpretation (this may take 20-40 seconds)...") | |
| llm_service = LLMService() | |
| interpretation = llm_service.analyze_similarity(df_results) | |
| # Simulate completion steps | |
| progress(0.9, desc="Formatting results...") | |
| progress(0.95, desc="Applying scholarly formatting...") | |
| # Completed | |
| progress(1.0, desc="Analysis complete!") | |
| # Add a timestamp to the interpretation | |
| timestamp = datetime.now().strftime("%Y-%m-%d %H:%M") | |
| interpretation = f"{interpretation}\n\n<small>Analysis generated on {timestamp}</small>" | |
| return interpretation | |
| except Exception as e: | |
| logger.error(f"Error in interpret_results: {e}", exc_info=True) | |
| return f"Error interpreting results: {str(e)}" | |
| process_btn.click( | |
| fn=run_pipeline, | |
| inputs=[file_input, semantic_toggle_radio, model_dropdown, stopwords_dropdown, batch_size_slider, progress_bar_checkbox], | |
| outputs=[ | |
| csv_output, | |
| metrics_preview, | |
| word_count_plot, | |
| heatmap_tabs["Jaccard Similarity (%)"], | |
| heatmap_tabs["Normalized LCS"], | |
| heatmap_tabs["Semantic Similarity"], | |
| warning_box, | |
| structural_heatmap, | |
| structural_report, | |
| structural_export, | |
| ] | |
| ) | |
| # Connect the interpret button | |
| interpret_btn.click( | |
| fn=interpret_results, | |
| inputs=[csv_output], | |
| outputs=interpretation_output | |
| ) | |
| return demo | |
| if __name__ == "__main__": | |
| demo = main_interface() | |
| demo.launch() |