Update app.py

app.py

@@ -41,7 +41,14 @@ class HybridNERManager:
     def __init__(self):
         self.gliner_model = None
         self.spacy_model = None
+        self.flair_models = {}
         self.all_entity_colors = {}
+        self.model_names = [
+            'spacy_en_core_web_sm',
+            'flair_ner-ontonotes-large', 
+            'flair_ner-large',
+            'gliner_medium-v2.1'
+        ]
 
     def load_gliner_model(self):
         """Load GLiNER model for custom entities"""
@@ -55,12 +62,24 @@ class HybridNERManager:
                 return None
         return self.gliner_model
 
+    def load_model(self, model_name):
+        """Load the specified model"""
+        try:
+            if model_name == 'spacy_en_core_web_sm':
+                return self.load_spacy_model()
+            elif 'flair' in model_name:
+                return self.load_flair_model(model_name)
+            elif 'gliner' in model_name:
+                return self.load_gliner_model()
+        except Exception as e:
+            print(f"Error loading {model_name}: {str(e)}")
+            return None
+
     def load_spacy_model(self):
         """Load spaCy model for standard NER"""
         if self.spacy_model is None:
             try:
                 import spacy
-                # Try to load the transformer model first, fallback to smaller model
                 try:
                     self.spacy_model = spacy.load("en_core_web_sm")
                     print("✓ spaCy model loaded successfully")
@@ -72,6 +91,46 @@ class HybridNERManager:
                 return None
         return self.spacy_model
 
+    def load_flair_model(self, model_name):
+        """Load Flair models"""
+        if model_name not in self.flair_models:
+            try:
+                from flair.models import SequenceTagger
+                if 'ontonotes' in model_name:
+                    model = SequenceTagger.load("flair/ner-english-ontonotes-large")
+                else:
+                    model = SequenceTagger.load("flair/ner-english-large")
+                self.flair_models[model_name] = model
+                print(f"✓ {model_name} loaded successfully")
+            except Exception as e:
+                print(f"Error loading {model_name}: {str(e)}")
+                return None
+        return self.flair_models[model_name]
+
+    def extract_spacy_entities(self, text, entity_types):
+        """Extract entities using spaCy"""
+        model = self.load_spacy_model()
+        if model is None:
+            return []
+
+        try:
+            doc = model(text)
+            entities = []
+            for ent in doc.ents:
+                if ent.label_ in entity_types:
+                    entities.append({
+                        'text': ent.text,
+                        'label': ent.label_,
+                        'start': ent.start_char,
+                        'end': ent.end_char,
+                        'confidence': 1.0,  # spaCy doesn't provide confidence scores
+                        'source': 'spaCy'
+                    })
+            return entities
+        except Exception as e:
+            print(f"Error with spaCy extraction: {str(e)}")
+            return []
+
     def assign_colors(self, standard_entities, custom_entities):
         """Assign colors to all entity types"""
         self.all_entity_colors = {}
@@ -90,28 +149,52 @@ class HybridNERManager:
 
         return self.all_entity_colors
 
-    def extract_spacy_entities(self, text, entity_types):
-        """Extract entities using spaCy"""
-        model = self.load_spacy_model()
+    def extract_entities_by_model(self, text, entity_types, model_name, threshold=0.3):
+        """Extract entities using the specified model"""
+        if model_name == 'spacy_en_core_web_sm':
+            return self.extract_spacy_entities(text, entity_types)
+        elif 'flair' in model_name:
+            return self.extract_flair_entities(text, entity_types, model_name)
+        elif 'gliner' in model_name:
+            return self.extract_gliner_entities(text, entity_types, threshold, is_custom=False)
+        else:
+            return []
+
+    def extract_flair_entities(self, text, entity_types, model_name):
+        """Extract entities using Flair"""
+        model = self.load_flair_model(model_name)
         if model is None:
             return []
 
         try:
-            doc = model(text)
+            from flair.data import Sentence
+            sentence = Sentence(text)
+            model.predict(sentence)
             entities = []
-            for ent in doc.ents:
-                if ent.label_ in entity_types:
+            for entity in sentence.get_spans('ner'):
+                # Map Flair labels to our standard set
+                label = entity.tag
+                if label == 'PERSON':
+                    label = 'PER'
+                elif label == 'ORGANIZATION':
+                    label = 'ORG'
+                elif label == 'LOCATION':
+                    label = 'LOC'
+                elif label == 'MISCELLANEOUS':
+                    label = 'MISC'
+
+                if label in entity_types:
                     entities.append({
-                        'text': ent.text,
-                        'label': ent.label_,
-                        'start': ent.start_char,
-                        'end': ent.end_char,
-                        'confidence': 1.0,  # spaCy doesn't provide confidence scores
-                        'source': 'spaCy'
+                        'text': entity.text,
+                        'label': label,
+                        'start': entity.start_position,
+                        'end': entity.end_position,
+                        'confidence': entity.score,
+                        'source': f'Flair-{model_name.split("-")[-1]}'
                     })
             return entities
         except Exception as e:
-            print(f"Error with spaCy extraction: {str(e)}")
+            print(f"Error with Flair extraction: {str(e)}")
             return []
 
     def extract_gliner_entities(self, text, entity_types, threshold=0.3, is_custom=True):
@@ -138,13 +221,13 @@ class HybridNERManager:
             return []
 
 def find_overlapping_entities(entities):
-    """Find and merge overlapping entities"""
+    """Find and share overlapping entities"""
     if not entities:
         return []
 
     # Sort entities by start position
     sorted_entities = sorted(entities, key=lambda x: x['start'])
-    merged_entities = []
+    shared_entities = []
 
     i = 0
     while i < len(sorted_entities):
@@ -165,19 +248,19 @@ def find_overlapping_entities(entities):
             else:
                 j += 1
 
-        # Create merged entity
+        # Create shared entity
         if len(overlapping_entities) == 1:
-            merged_entities.append(overlapping_entities[0])
+            shared_entities.append(overlapping_entities[0])
         else:
-            merged_entity = merge_entities(overlapping_entities)
-            merged_entities.append(merged_entity)
+            shared_entity = share_entities(overlapping_entities)
+            shared_entities.append(shared_entity)
 
         i += 1
 
-    return merged_entities
+    return shared_entities
 
-def merge_entities(entity_list):
-    """Merge multiple overlapping entities into one"""
+def share_entities(entity_list):
+    """Share multiple overlapping entities into one"""
     if len(entity_list) == 1:
         return entity_list[0]
 
@@ -196,7 +279,7 @@ def merge_entities(entity_list):
         'labels': labels,
         'sources': sources,
         'confidences': confidences,
-        'is_merged': True,
+        'is_shared': True,
         'entity_count': len(entity_list)
     }
 
@@ -205,11 +288,11 @@ def create_highlighted_html(text, entities, entity_colors):
     if not entities:
         return f"<div style='padding: 15px; border: 1px solid #ddd; border-radius: 5px; background-color: #fafafa;'><p>{text}</p></div>"
 
-    # Find and merge overlapping entities
-    merged_entities = find_overlapping_entities(entities)
+    # Find and share overlapping entities
+    shared_entities = find_overlapping_entities(entities)
 
     # Sort by start position
-    sorted_entities = sorted(merged_entities, key=lambda x: x['start'])
+    sorted_entities = sorted(shared_entities, key=lambda x: x['start'])
 
     # Create HTML with highlighting
     html_parts = []
@@ -219,9 +302,9 @@ def create_highlighted_html(text, entities, entity_colors):
         # Add text before entity
         html_parts.append(text[last_end:entity['start']])
 
-        if entity.get('is_merged', False):
-            # Handle merged entity with multiple colors
-            html_parts.append(create_merged_entity_html(entity, entity_colors))
+        if entity.get('is_shared', False):
+            # Handle shared entity with multiple colors
+            html_parts.append(create_shared_entity_html(entity, entity_colors))
         else:
             # Handle single entity
             html_parts.append(create_single_entity_html(entity, entity_colors))
@@ -253,8 +336,8 @@ def create_single_entity_html(entity, entity_colors):
             f'title="{label} ({source}) - confidence: {confidence:.2f}">'
             f'{entity["text"]}</span>')
 
-def create_merged_entity_html(entity, entity_colors):
-    """Create HTML for a merged entity with multiple colors"""
+def create_shared_entity_html(entity, entity_colors):
+    """Create HTML for a shared entity with multiple colors"""
     labels = entity['labels']
     sources = entity['sources']
     confidences = entity['confidences']
@@ -287,22 +370,22 @@ def create_merged_entity_html(entity, entity_colors):
     return (f'<span style="background: {gradient}; padding: 2px 4px; '
             f'border-radius: 3px; margin: 0 1px; '
             f'border: 2px solid #333; color: white; font-weight: bold;" '
-            f'title="MERGED: {tooltip}">'
+            f'title="SHARED: {tooltip}">'
             f'{entity["text"]} 🔗</span>')
 
 def create_entity_table_html(entities, entity_colors):
-    """Create HTML table of entities"""
+    """Create HTML table with tabbed interface like the original"""
     if not entities:
         return "<p>No entities found.</p>"
 
-    # Merge overlapping entities
-    merged_entities = find_overlapping_entities(entities)
+    # Share overlapping entities
+    shared_entities = find_overlapping_entities(entities)
 
     # Group entities by type
     entity_groups = {}
-    for entity in merged_entities:
-        if entity.get('is_merged', False):
-            key = 'MERGED_ENTITIES'
+    for entity in shared_entities:
+        if entity.get('is_shared', False):
+            key = 'SHARED_ENTITIES'
         else:
             key = entity['label']
         
@@ -310,54 +393,162 @@ def create_entity_table_html(entities, entity_colors):
             entity_groups[key] = []
         entity_groups[key].append(entity)
 
-    # Create HTML table
-    html = "<div style='margin: 15px 0;'>"
-    
-    for entity_type, entities_of_type in entity_groups.items():
-        if entity_type == 'MERGED_ENTITIES':
+    if not entity_groups:
+        return "<p>No entities found.</p>"
+
+    # Create tabbed interface
+    tab_html = "<div style='margin: 20px 0;'>"
+
+    # Tab headers
+    tab_html += "<div style='border-bottom: 2px solid #ddd; margin-bottom: 20px;'>"
+    tab_headers = []
+
+    for i, entity_type in enumerate(sorted(entity_groups.keys())):
+        count = len(entity_groups[entity_type])
+
+        if entity_type == 'SHARED_ENTITIES':
+            color = '#666666'
+            icon = "🔗"
+            display_name = "SHARED"
+        else:
+            color = entity_colors.get(entity_type.upper(), '#f0f0f0')
+            # Determine if it's standard or custom
+            is_standard = entity_type in STANDARD_ENTITIES
+            icon = "🎯" if is_standard else "✨"
+            display_name = entity_type
+
+        active_style = f"background-color: #f8f9fa; border-bottom: 3px solid {color};" if i == 0 else "background-color: #fff;"
+        tab_headers.append(f"""
+        <button onclick="showTab('{entity_type}')" id="tab-{entity_type}" 
+                style="padding: 12px 24px; margin-right: 5px; border: 1px solid #ddd;
+                       border-bottom: none; cursor: pointer; font-weight: bold; {active_style}">
+            {icon} {display_name} ({count})
+        </button>
+        """)
+
+    tab_html += ''.join(tab_headers)
+    tab_html += "</div>"
+
+    # Tab content
+    for i, entity_type in enumerate(sorted(entity_groups.keys())):
+        entities_of_type = entity_groups[entity_type]
+        display_style = "display: block;" if i == 0 else "display: none;"
+
+        if entity_type == 'SHARED_ENTITIES':
             color = '#666666'
-            header = f"🔗 Merged Entities ({len(entities_of_type)})"
+            header_text = f"🔗 Shared Entities ({len(entities_of_type)} found)"
         else:
-            color = entity_colors.get(entity_type.upper(), '#CCCCCC')
-            header = f"{entity_type} ({len(entities_of_type)})"
-
-        html += f"""
-        <h4 style="color: {color}; margin: 15px 0 10px 0;">{header}</h4>
-        <table style="width: 100%; border-collapse: collapse; margin-bottom: 20px; border: 1px solid #ddd;">
-            <thead>
-                <tr style="background-color: {color}; color: white;">
-                    <th style="padding: 10px; text-align: left; border: 1px solid #ddd;">Entity Text</th>
-                    <th style="padding: 10px; text-align: left; border: 1px solid #ddd;">Label(s)</th>
-                    <th style="padding: 10px; text-align: left; border: 1px solid #ddd;">Source(s)</th>
-                    <th style="padding: 10px; text-align: left; border: 1px solid #ddd;">Confidence</th>
-                </tr>
-            </thead>
-            <tbody>
+            color = entity_colors.get(entity_type.upper(), '#f0f0f0')
+            source_type = entities_of_type[0].get('source', 'Unknown')
+            is_standard = entity_type in STANDARD_ENTITIES
+            source_icon = "🎯 Standard NER" if is_standard else "✨ Custom GLiNER"
+            header_text = f"{source_icon} - {entity_type} Entities ({len(entities_of_type)} found)"
+
+        tab_html += f"""
+        <div id="content-{entity_type}" style="{display_style}">
+            <h4 style="color: {color}; margin-bottom: 15px;">{header_text}</h4>
+            <table style="width: 100%; border-collapse: collapse; margin-bottom: 20px;">
+                <thead>
         """
 
-        for entity in entities_of_type:
-            if entity.get('is_merged', False):
+        if entity_type == 'SHARED_ENTITIES':
+            tab_html += f"""
+                    <tr style="background-color: {color}; color: white;">
+                        <th style="padding: 12px; text-align: left; border: 1px solid #ddd;">Entity Text</th>
+                        <th style="padding: 12px; text-align: left; border: 1px solid #ddd;">All Labels</th>
+                        <th style="padding: 12px; text-align: left; border: 1px solid #ddd;">Sources</th>
+                        <th style="padding: 12px; text-align: left; border: 1px solid #ddd;">Count</th>
+                    </tr>
+                </thead>
+                <tbody>
+            """
+
+            for entity in entities_of_type:
                 labels_text = " | ".join(entity['labels'])
                 sources_text = " | ".join(entity['sources'])
-                conf_text = " | ".join([f"{c:.2f}" for c in entity['confidences']])
-            else:
-                labels_text = entity['label']
-                sources_text = entity['source']
-                conf_text = f"{entity['confidence']:.2f}"
-
-            html += f"""
-                <tr style="background-color: #fff;">
-                    <td style="padding: 8px; border: 1px solid #ddd; font-weight: bold;">{entity['text']}</td>
-                    <td style="padding: 8px; border: 1px solid #ddd;">{labels_text}</td>
-                    <td style="padding: 8px; border: 1px solid #ddd;">{sources_text}</td>
-                    <td style="padding: 8px; border: 1px solid #ddd;">{conf_text}</td>
-                </tr>
+
+                tab_html += f"""
+                        <tr style="background-color: #fff;">
+                            <td style="padding: 10px; border: 1px solid #ddd; font-weight: bold;">{entity['text']}</td>
+                            <td style="padding: 10px; border: 1px solid #ddd;">{labels_text}</td>
+                            <td style="padding: 10px; border: 1px solid #ddd;">{sources_text}</td>
+                            <td style="padding: 10px; border: 1px solid #ddd; text-align: center;">
+                                <span style='background-color: #28a745; color: white; padding: 2px 6px; border-radius: 10px; font-size: 11px;'>
+                                    {entity['entity_count']}
+                                </span>
+                            </td>
+                        </tr>
+                """
+        else:
+            tab_html += f"""
+                    <tr style="background-color: {color}; color: white;">
+                        <th style="padding: 12px; text-align: left; border: 1px solid #ddd;">Entity Text</th>
+                        <th style="padding: 12px; text-align: left; border: 1px solid #ddd;">Confidence</th>
+                        <th style="padding: 12px; text-align: left; border: 1px solid #ddd;">Type</th>
+                        <th style="padding: 12px; text-align: left; border: 1px solid #ddd;">Source</th>
+                    </tr>
+                </thead>
+                <tbody>
             """
 
-        html += "</tbody></table>"
+            # Sort by confidence score
+            entities_of_type.sort(key=lambda x: x.get('confidence', 0), reverse=True)
+
+            for entity in entities_of_type:
+                confidence = entity.get('confidence', 0.0)
+                confidence_color = "#28a745" if confidence > 0.7 else "#ffc107" if confidence > 0.4 else "#dc3545"
+                source = entity.get('source', 'Unknown')
+                source_badge = f"<span style='background-color: #007bff; color: white; padding: 2px 6px; border-radius: 10px; font-size: 11px;'>{source}</span>"
+
+                tab_html += f"""
+                        <tr style="background-color: #fff;">
+                            <td style="padding: 10px; border: 1px solid #ddd; font-weight: bold;">{entity['text']}</td>
+                            <td style="padding: 10px; border: 1px solid #ddd;">
+                                <span style="color: {confidence_color}; font-weight: bold;">
+                                    {confidence:.3f}
+                                </span>
+                            </td>
+                            <td style="padding: 10px; border: 1px solid #ddd;">{entity['label']}</td>
+                            <td style="padding: 10px; border: 1px solid #ddd;">{source_badge}</td>
+                        </tr>
+                """
+
+        tab_html += """
+                </tbody>
+            </table>
+        </div>
+        """
+
+    # JavaScript for tab switching
+    tab_html += """
+    <script>
+    function showTab(entityType) {
+        // Hide all content
+        var contents = document.querySelectorAll('[id^="content-"]');
+        contents.forEach(function(content) {
+            content.style.display = 'none';
+        });
+
+        // Reset all tab styles
+        var tabs = document.querySelectorAll('[id^="tab-"]');
+        tabs.forEach(function(tab) {
+            tab.style.backgroundColor = '#fff';
+            tab.style.borderBottom = 'none';
+        });
+
+        // Show selected content
+        document.getElementById('content-' + entityType).style.display = 'block';
+
+        // Highlight selected tab
+        var activeTab = document.getElementById('tab-' + entityType);
+        activeTab.style.backgroundColor = '#f8f9fa';
+        activeTab.style.borderBottom = '3px solid #4ECDC4';
+    }
+    </script>
+    """
 
-    html += "</div>"
-    return html
+    tab_html += "</div>"
+    return tab_html
 
 def create_legend_html(entity_colors, standard_entities, custom_entities):
     """Create a legend showing entity colors"""
@@ -391,7 +582,7 @@ def create_legend_html(entity_colors, standard_entities, custom_entities):
 # Initialize the NER manager
 ner_manager = HybridNERManager()
 
-def process_text(text, standard_entities, custom_entities_str, confidence_threshold, use_spacy, use_gliner_standard):
+def process_text(text, standard_entities, custom_entities_str, confidence_threshold, selected_model):
     """Main processing function for Gradio interface"""
     if not text.strip():
         return "❌ Please enter some text to analyze", "", ""
@@ -409,17 +600,12 @@ def process_text(text, standard_entities, custom_entities_str, confidence_thresh
 
     all_entities = []
 
-    # Extract standard entities
-    if selected_standard:
-        if use_spacy:
-            spacy_entities = ner_manager.extract_spacy_entities(text, selected_standard)
-            all_entities.extend(spacy_entities)
-        
-        if use_gliner_standard:
-            gliner_standard_entities = ner_manager.extract_gliner_entities(text, selected_standard, confidence_threshold, is_custom=False)
-            all_entities.extend(gliner_standard_entities)
+    # Extract standard entities using selected model
+    if selected_standard and selected_model:
+        standard_entities_results = ner_manager.extract_entities_by_model(text, selected_standard, selected_model, confidence_threshold)
+        all_entities.extend(standard_entities_results)
 
-    # Extract custom entities
+    # Extract custom entities using GLiNER
     if custom_entities:
         custom_entity_results = ner_manager.extract_gliner_entities(text, custom_entities, confidence_threshold, is_custom=True)
         all_entities.extend(custom_entity_results)
@@ -435,17 +621,17 @@ def process_text(text, standard_entities, custom_entities_str, confidence_thresh
     highlighted_html = create_highlighted_html(text, all_entities, entity_colors)
     table_html = create_entity_table_html(all_entities, entity_colors)
 
-    # Create summary
+    # Create summary with shared entities terminology
     total_entities = len(all_entities)
-    merged_entities = find_overlapping_entities(all_entities)
-    final_count = len(merged_entities)
-    merged_count = sum(1 for e in merged_entities if e.get('is_merged', False))
+    shared_entities = find_overlapping_entities(all_entities)
+    final_count = len(shared_entities)
+    shared_count = sum(1 for e in shared_entities if e.get('is_shared', False))
 
     summary = f"""
     ## 📊 Analysis Summary
     - **Total entities found:** {total_entities}
     - **Final entities displayed:** {final_count}
-    - **Merged entities:** {merged_count}
+    - **Shared entities:** {shared_count}
     - **Average confidence:** {sum(e.get('confidence', 0) for e in all_entities) / total_entities:.3f}
     """
 
@@ -459,14 +645,15 @@ def create_interface():
         
         Combine standard NER categories with your own custom entity types! This tool uses both traditional NER models and GLiNER for comprehensive entity extraction.
         
-        ## 🔗 NEW: Overlapping entities are automatically merged with split-color highlighting!
+        ## 🔗 NEW: Overlapping entities are automatically shared with split-color highlighting!
         
         ### How to use:
         1. **📝 Enter your text** in the text area below
-        2. **🎯 Select standard entities** you want to find (PER, ORG, LOC, etc.)
-        3. **✨ Add custom entities** (comma-separated) like "relationships, occupations, skills"
-        4. **⚙️ Choose models** and adjust confidence threshold
-        5. **🔍 Click "Analyze Text"** to see results
+        2. **🎯 Select a model** from the dropdown for standard entities
+        3. **☑️ Select standard entities** you want to find (PER, ORG, LOC, etc.)
+        4. **✨ Add custom entities** (comma-separated) like "relationships, occupations, skills"
+        5. **⚙️ Adjust confidence threshold** 
+        6. **🔍 Click "Analyze Text"** to see results with tabbed output
         """)
         
         with gr.Row():
@@ -490,15 +677,40 @@ def create_interface():
         with gr.Row():
             with gr.Column():
                 gr.Markdown("### 🎯 Standard Entity Types")
+                
+                # Model selector
+                model_dropdown = gr.Dropdown(
+                    choices=ner_manager.model_names,
+                    value=ner_manager.model_names[0],
+                    label="Select Model for Standard Entities",
+                    info="Choose which model to use for standard NER"
+                )
+                
+                # Standard entities with select all functionality
                 standard_entities = gr.CheckboxGroup(
                     choices=STANDARD_ENTITIES,
                     value=['PER', 'ORG', 'LOC', 'MISC'],  # Default selection
                     label="Select Standard Entities"
                 )
                 
+                # Select/Deselect All button
                 with gr.Row():
-                    use_spacy = gr.Checkbox(label="Use spaCy", value=True)
-                    use_gliner_standard = gr.Checkbox(label="Use GLiNER for Standard", value=False)
+                    select_all_btn = gr.Button("🔘 Deselect All", size="sm")
+                    
+                # Function for select/deselect all
+                def toggle_all_entities(current_selection):
+                    if len(current_selection) > 0:
+                        # If any are selected, deselect all
+                        return [], "☑️ Select All"
+                    else:
+                        # If none selected, select all
+                        return STANDARD_ENTITIES, "🔘 Deselect All"
+                
+                select_all_btn.click(
+                    fn=toggle_all_entities,
+                    inputs=[standard_entities],
+                    outputs=[standard_entities, select_all_btn]
+                )
             
             with gr.Column():
                 gr.Markdown("### ✨ Custom Entity Types")
@@ -510,8 +722,9 @@ def create_interface():
                 gr.Markdown("""
                 **Examples:**
                 - relationships, occupations, skills
-                - emotions, actions, objects
+                - emotions, actions, objects  
                 - medical conditions, treatments
+                - financial terms, business roles
                 """)
         
         analyze_btn = gr.Button("🔍 Analyze Text", variant="primary", size="lg")
@@ -524,7 +737,7 @@ def create_interface():
             highlighted_output = gr.HTML(label="Highlighted Text")
         
         with gr.Row():
-            table_output = gr.HTML(label="Detailed Results")
+            table_output = gr.HTML(label="Detailed Results (Tabbed)")
         
         # Connect the button to the processing function
         analyze_btn.click(
@@ -534,8 +747,7 @@ def create_interface():
                 standard_entities,
                 custom_entities,
                 confidence_threshold,
-                use_spacy,
-                use_gliner_standard
+                model_dropdown
             ],
             outputs=[summary_output, highlighted_output, table_output]
         )
@@ -548,16 +760,21 @@ def create_interface():
                     ["PER", "ORG", "LOC", "DATE"],
                     "relationships, occupations, educational background",
                     0.3,
-                    True,
-                    False
+                    "spacy_en_core_web_sm"
                 ],
                 [
                     "The meeting between CEO Jane Doe and the board of directors at Microsoft headquarters in Seattle discussed the Q4 financial results and the new AI strategy for 2024.",
                     ["PER", "ORG", "LOC", "DATE"],
                     "corporate roles, business events, financial terms",
                     0.4,
-                    True,
-                    True
+                    "flair_ner-ontonotes-large"
+                ],
+                [
+                    "Dr. Emily Watson published a research paper on machine learning algorithms at MIT. She collaborates with her colleague Prof. David Chen on natural language processing projects.",
+                    ["PER", "ORG", "WORK_OF_ART"],
+                    "academic titles, research topics, collaborations",
+                    0.3,
+                    "gliner_medium-v2.1"
                 ]
             ],
             inputs=[
@@ -565,8 +782,7 @@ def create_interface():
                 standard_entities,
                 custom_entities,
                 confidence_threshold,
-                use_spacy,
-                use_gliner_standard
+                model_dropdown
             ]
         )