Update app.py

app.py

@@ -7,13 +7,13 @@ import random
 import re
 warnings.filterwarnings('ignore')
 
-# Standard NER entity types
+# Common NER entity types
 STANDARD_ENTITIES = [
     'DATE', 'EVENT', 'FAC', 'GPE', 'LANG', 'LOC',
-    'MISC', 'NORP', 'ORG', 'PER', 'PRODUCT', 'WORK_OF_ART'
+    'MISC', 'NORP', 'ORG', 'PER', 'PRODUCT', 'Work of Art'
 ]
 
-# Color schemes
+# Colour schemes
 STANDARD_COLORS = {
     'DATE': '#FF6B6B',      # Red
     'EVENT': '#4ECDC4',     # Teal
@@ -26,10 +26,10 @@ STANDARD_COLORS = {
     'ORG': '#55A3FF',       # Light Blue
     'PER': '#00B894',       # Green
     'PRODUCT': '#E17055',   # Orange-Red
-    'WORK_OF_ART': '#DDA0DD'  # Plum
+    'WORK OF ART': '#DDA0DD'  # Plum
 }
 
-# Additional colors for custom entities
+# Additional colours for custom entities
 CUSTOM_COLOR_PALETTE = [
     '#FF9F43', '#10AC84', '#EE5A24', '#0FBC89', '#5F27CD',
     '#FF3838', '#2F3640', '#3742FA', '#2ED573', '#FFA502',
@@ -44,28 +44,16 @@ class HybridNERManager:
         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'
+            'entities_flair_ner-large',
+            'entities_spacy_en_core_web_trf', 
+            'entities_flair_ner-ontonotes-large',
+            'entities_gliner_knowledgator/modern-gliner-bi-large-v1.0'
         ]
 
-    def load_gliner_model(self):
-        """Load GLiNER model for custom entities"""
-        if self.gliner_model is None:
-            try:
-                # Use a more stable model for HF Spaces
-                self.gliner_model = GLiNER.from_pretrained("urchade/gliner_medium-v2.1")
-                print("✓ GLiNER model loaded successfully")
-            except Exception as e:
-                print(f"Error loading GLiNER model: {str(e)}")
-                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':
+            if 'spacy' in model_name:
                 return self.load_spacy_model()
             elif 'flair' in model_name:
                 return self.load_flair_model(model_name)
@@ -76,16 +64,21 @@ class HybridNERManager:
             return None
 
     def load_spacy_model(self):
-        """Load spaCy model for standard NER"""
+        """Load spaCy model for common NER"""
         if self.spacy_model is None:
             try:
                 import spacy
                 try:
-                    self.spacy_model = spacy.load("en_core_web_sm")
-                    print("✓ spaCy model loaded successfully")
+                    # Try transformer model first, fallback to small model
+                    self.spacy_model = spacy.load("en_core_web_trf")
+                    print("✓ spaCy transformer model loaded successfully")
                 except OSError:
-                    print("spaCy model not found. Using GLiNER for all entity types.")
-                    return None
+                    try:
+                        self.spacy_model = spacy.load("en_core_web_sm")
+                        print("✓ spaCy common model loaded successfully") 
+                    except OSError:
+                        print("spaCy model not found. Using GLiNER for all entity types.")
+                        return None
             except Exception as e:
                 print(f"Error loading spaCy model: {str(e)}")
                 return None
@@ -98,15 +91,66 @@ class HybridNERManager:
                 from flair.models import SequenceTagger
                 if 'ontonotes' in model_name:
                     model = SequenceTagger.load("flair/ner-english-ontonotes-large")
+                    print("✓ Flair OntoNotes model loaded successfully")
                 else:
-                    model = SequenceTagger.load("flair/ner-english-large")
+                    model = SequenceTagger.load("flair/ner-english-large") 
+                    print("✓ Flair large model loaded successfully")
                 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
+                # Fallback to GLiNER
+                return self.load_gliner_model()
         return self.flair_models[model_name]
 
+    def load_gliner_model(self):
+        """Load GLiNER model for custom entities"""
+        if self.gliner_model is None:
+            try:
+                # Try the modern GLiNER model first, fallback to stable model
+                self.gliner_model = GLiNER.from_pretrained("knowledgator/gliner-bi-large-v1.0")
+                print("✓ GLiNER knowledgator model loaded successfully")
+            except Exception as e:
+                print(f"Primary GLiNER model failed: {str(e)}")
+                try:
+                    # Fallback to stable model
+                    self.gliner_model = GLiNER.from_pretrained("urchade/gliner_medium-v2.1")
+                    print("✓ GLiNER fallback model loaded successfully")
+                except Exception as e2:
+                    print(f"Error loading GLiNER model: {str(e2)}")
+                    return None
+        return self.gliner_model
+
+    def assign_colours(self, standard_entities, custom_entities):
+        """Assign colours to all entity types"""
+        self.all_entity_colors = {}
+
+        # Assign common colours
+        for entity in standard_entities:
+            # Handle the special case of "Work of Art"
+            colour_key = "WORK OF ART" if entity == "Work of Art" else entity.upper()
+            self.all_entity_colors[entity.upper()] = STANDARD_COLORS.get(colour_key, '#CCCCCC')
+
+        # Assign custom colours
+        for i, entity in enumerate(custom_entities):
+            if i < len(CUSTOM_COLOR_PALETTE):
+                self.all_entity_colors[entity.upper()] = CUSTOM_COLOR_PALETTE[i]
+            else:
+                # Generate random colour if we run out
+                self.all_entity_colors[entity.upper()] = f"#{random.randint(0, 0xFFFFFF):06x}"
+
+        return self.all_entity_colors
+
+    def extract_entities_by_model(self, text, entity_types, model_name, threshold=0.3):
+        """Extract entities using the specified model"""
+        if 'spacy' in model_name:
+            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_spacy_entities(self, text, entity_types):
         """Extract entities using spaCy"""
         model = self.load_spacy_model()
@@ -131,35 +175,6 @@ class HybridNERManager:
             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 = {}
-
-        # Assign standard colors
-        for entity in standard_entities:
-            self.all_entity_colors[entity.upper()] = STANDARD_COLORS.get(entity, '#CCCCCC')
-
-        # Assign custom colors
-        for i, entity in enumerate(custom_entities):
-            if i < len(CUSTOM_COLOR_PALETTE):
-                self.all_entity_colors[entity.upper()] = CUSTOM_COLOR_PALETTE[i]
-            else:
-                # Generate random color if we run out
-                self.all_entity_colors[entity.upper()] = f"#{random.randint(0, 0xFFFFFF):06x}"
-
-        return self.all_entity_colors
-
-    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)
@@ -172,7 +187,7 @@ class HybridNERManager:
             model.predict(sentence)
             entities = []
             for entity in sentence.get_spans('ner'):
-                # Map Flair labels to our standard set
+                # Map Flair labels to our common set
                 label = entity.tag
                 if label == 'PERSON':
                     label = 'PER'
@@ -213,7 +228,7 @@ class HybridNERManager:
                     'start': entity['start'],
                     'end': entity['end'],
                     'confidence': entity.get('score', 0.0),
-                    'source': 'GLiNER-Custom' if is_custom else 'GLiNER-Standard'
+                    'source': 'GLiNER-Custom' if is_custom else 'GLiNER-Common'
                 })
             return result
         except Exception as e:
@@ -241,7 +256,7 @@ def find_overlapping_entities(entities):
 
             # Check if entities overlap
             if (current_entity['start'] <= next_entity['start'] < current_entity['end'] or
-                next_entity['start'] <= current_entity['start'] < next_entity['end'] or
+                next_entity['start'] <= current_entity['start'] < current_entity['end'] or
                 current_entity['text'].lower() == next_entity['text'].lower()):
                 overlapping_entities.append(next_entity)
                 sorted_entities.pop(j)
@@ -303,7 +318,7 @@ def create_highlighted_html(text, entities, entity_colors):
         html_parts.append(text[last_end:entity['start']])
 
         if entity.get('is_shared', False):
-            # Handle shared entity with multiple colors
+            # Handle shared entity with multiple colours
             html_parts.append(create_shared_entity_html(entity, entity_colors))
         else:
             # Handle single entity
@@ -326,39 +341,39 @@ def create_highlighted_html(text, entities, entity_colors):
 def create_single_entity_html(entity, entity_colors):
     """Create HTML for a single entity"""
     label = entity['label']
-    color = entity_colors.get(label.upper(), '#CCCCCC')
+    colour = entity_colors.get(label.upper(), '#CCCCCC')
     confidence = entity.get('confidence', 0.0)
     source = entity.get('source', 'Unknown')
 
-    return (f'<span style="background-color: {color}; padding: 2px 4px; '
+    return (f'<span style="background-color: {colour}; padding: 2px 4px; '
             f'border-radius: 3px; margin: 0 1px; '
-            f'border: 1px solid {color}; color: white; font-weight: bold;" '
+            f'border: 1px solid {colour}; color: white; font-weight: bold;" '
             f'title="{label} ({source}) - confidence: {confidence:.2f}">'
             f'{entity["text"]}</span>')
 
 def create_shared_entity_html(entity, entity_colors):
-    """Create HTML for a shared entity with multiple colors"""
+    """Create HTML for a shared entity with multiple colours"""
     labels = entity['labels']
     sources = entity['sources']
     confidences = entity['confidences']
 
-    # Get colors for each label
-    colors = []
+    # Get colours for each label
+    colours = []
     for label in labels:
-        color = entity_colors.get(label.upper(), '#CCCCCC')
-        colors.append(color)
+        colour = entity_colors.get(label.upper(), '#CCCCCC')
+        colours.append(colour)
 
     # Create gradient background
-    if len(colors) == 2:
-        gradient = f"linear-gradient(to right, {colors[0]} 50%, {colors[1]} 50%)"
+    if len(colours) == 2:
+        gradient = f"linear-gradient(to right, {colours[0]} 50%, {colours[1]} 50%)"
     else:
-        # For more colors, create equal segments
-        segment_size = 100 / len(colors)
+        # For more colours, create equal segments
+        segment_size = 100 / len(colours)
         gradient_parts = []
-        for i, color in enumerate(colors):
+        for i, colour in enumerate(colours):
             start = i * segment_size
             end = (i + 1) * segment_size
-            gradient_parts.append(f"{color} {start}%, {color} {end}%")
+            gradient_parts.append(f"{colour} {start}%, {colour} {end}%")
         gradient = f"linear-gradient(to right, {', '.join(gradient_parts)})"
 
     # Create tooltip
@@ -371,12 +386,12 @@ def create_shared_entity_html(entity, entity_colors):
             f'border-radius: 3px; margin: 0 1px; '
             f'border: 2px solid #333; color: white; font-weight: bold;" '
             f'title="SHARED: {tooltip}">'
-            f'{entity["text"]} 🔗</span>')
+            f'{entity["text"]} 🧩🧩</span>')
 
-def create_entity_table_html(entities, entity_colors):
-    """Create HTML table with tabbed interface like the original"""
+def create_entity_table_gradio_tabs(entities, entity_colors):
+    """Create Gradio tabs for entity results"""
     if not entities:
-        return "<p>No entities found.</p>"
+        return "No entities found."
 
     # Share overlapping entities
     shared_entities = find_overlapping_entities(entities)
@@ -394,80 +409,37 @@ def create_entity_table_html(entities, entity_colors):
         entity_groups[key].append(entity)
 
     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;"
+        return "No entities found."
 
+    # Create content for each tab
+    tab_contents = {}
+    
+    for entity_type, entities_of_type in entity_groups.items():
         if entity_type == 'SHARED_ENTITIES':
-            color = '#666666'
-            header_text = f"🔗 Shared Entities ({len(entities_of_type)} found)"
-        else:
-            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>
-        """
-
-        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>
+            colour = '#666666'
+            header = f"🧩🧩 Shared Entities ({len(entities_of_type)} found)"
+            
+            # Create table for shared entities
+            table_html = f"""
+            <div style="margin: 15px 0;">
+                <h4 style="color: {colour}; margin-bottom: 15px;">{header}</h4>
+                <table style="width: 100%; border-collapse: collapse; border: 1px solid #ddd;">
+                    <thead>
+                        <tr style="background-color: {colour}; 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'])
-
-                tab_html += f"""
+                
+                table_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>
@@ -479,32 +451,48 @@ def create_entity_table_html(entities, entity_colors):
                             </td>
                         </tr>
                 """
+            
+            table_html += "</tbody></table></div>"
+            tab_contents[f"🧩🧩 SHARED ({len(entities_of_type)})"] = table_html
+            
         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>
+            colour = entity_colors.get(entity_type.upper(), '#f0f0f0')
+            # Determine if it's common or custom
+            is_standard = entity_type in STANDARD_ENTITIES
+            icon = "🎯" if is_standard else "✨"
+            source_text = "Common NER" if is_standard else "Custom GLiNER"
+            header = f"{icon} {source_text} - {entity_type} ({len(entities_of_type)} found)"
+            
+            # Create table for this entity type
+            table_html = f"""
+            <div style="margin: 15px 0;">
+                <h4 style="color: {colour}; margin-bottom: 15px;">{header}</h4>
+                <table style="width: 100%; border-collapse: collapse; border: 1px solid #ddd;">
+                    <thead>
+                        <tr style="background-color: {colour}; 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>
             """
-
+            
             # 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"
+                confidence_colour = "#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"""
+                
+                table_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;">
+                                <span style="color: {confidence_colour}; font-weight: bold;">
                                     {confidence:.3f}
                                 </span>
                             </td>
@@ -512,46 +500,15 @@ def create_entity_table_html(entities, entity_colors):
                             <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>
-    """
-
-    tab_html += "</div>"
-    return tab_html
+            
+            table_html += "</tbody></table></div>"
+            tab_label = f"{icon} {entity_type} ({len(entities_of_type)})"
+            tab_contents[tab_label] = table_html
+    
+    return tab_contents
 
 def create_legend_html(entity_colors, standard_entities, custom_entities):
-    """Create a legend showing entity colors"""
+    """Create a legend showing entity colours"""
     if not entity_colors:
         return ""
 
@@ -560,11 +517,11 @@ def create_legend_html(entity_colors, standard_entities, custom_entities):
 
     if standard_entities:
         html += "<div style='margin-bottom: 15px;'>"
-        html += "<h5 style='margin: 0 0 8px 0;'>🎯 Standard Entities:</h5>"
+        html += "<h5 style='margin: 0 0 8px 0;'>🎯 Common Entities:</h5>"
         html += "<div style='display: flex; flex-wrap: wrap; gap: 8px;'>"
         for entity_type in standard_entities:
-            color = entity_colors.get(entity_type.upper(), '#ccc')
-            html += f"<span style='background-color: {color}; padding: 4px 8px; border-radius: 15px; color: white; font-weight: bold; font-size: 12px;'>{entity_type}</span>"
+            colour = entity_colors.get(entity_type.upper(), '#ccc')
+            html += f"<span style='background-color: {colour}; padding: 4px 8px; border-radius: 15px; color: white; font-weight: bold; font-size: 12px;'>{entity_type}</span>"
         html += "</div></div>"
 
     if custom_entities:
@@ -572,8 +529,8 @@ def create_legend_html(entity_colors, standard_entities, custom_entities):
         html += "<h5 style='margin: 0 0 8px 0;'>✨ Custom Entities:</h5>"
         html += "<div style='display: flex; flex-wrap: wrap; gap: 8px;'>"
         for entity_type in custom_entities:
-            color = entity_colors.get(entity_type.upper(), '#ccc')
-            html += f"<span style='background-color: {color}; padding: 4px 8px; border-radius: 15px; color: white; font-weight: bold; font-size: 12px;'>{entity_type}</span>"
+            colour = entity_colors.get(entity_type.upper(), '#ccc')
+            html += f"<span style='background-color: {colour}; padding: 4px 8px; border-radius: 15px; color: white; font-weight: bold; font-size: 12px;'>{entity_type}</span>"
         html += "</div></div>"
 
     html += "</div>"
@@ -582,45 +539,55 @@ 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, selected_model):
-    """Main processing function for Gradio interface"""
+def process_text(text, standard_entities, custom_entities_str, confidence_threshold, selected_model, progress=gr.Progress()):
+    """Main processing function for Gradio interface with progress tracking"""
     if not text.strip():
-        return "❌ Please enter some text to analyze", "", ""
+        return "❌ Please enter some text to analyse", "", {}
 
+    progress(0.1, desc="Initialising...")
+    
     # Parse custom entities
     custom_entities = []
     if custom_entities_str.strip():
         custom_entities = [entity.strip() for entity in custom_entities_str.split(',') if entity.strip()]
 
-    # Parse standard entities
+    # Parse common entities
     selected_standard = [entity for entity in standard_entities if entity]
 
     if not selected_standard and not custom_entities:
-        return "❌ Please select at least one standard entity type OR enter custom entity types", "", ""
+        return "❌ Please select at least one common entity type OR enter custom entity types", "", {}
 
+    progress(0.2, desc="Loading models...")
+    
     all_entities = []
 
-    # Extract standard entities using selected model
+    # Extract common entities using selected model
     if selected_standard and selected_model:
+        progress(0.4, desc="Extracting common entities...")
         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 using GLiNER
     if custom_entities:
+        progress(0.6, desc="Extracting custom entities...")
         custom_entity_results = ner_manager.extract_gliner_entities(text, custom_entities, confidence_threshold, is_custom=True)
         all_entities.extend(custom_entity_results)
 
     if not all_entities:
-        return "❌ No entities found. Try lowering the confidence threshold or using different entity types.", "", ""
+        return "❌ No entities found. Try lowering the confidence threshold or using different entity types.", "", {}
 
-    # Assign colors
-    entity_colors = ner_manager.assign_colors(selected_standard, custom_entities)
+    progress(0.8, desc="Processing results...")
+    
+    # Assign colours
+    entity_colors = ner_manager.assign_colours(selected_standard, custom_entities)
 
     # Create outputs
     legend_html = create_legend_html(entity_colors, selected_standard, custom_entities)
     highlighted_html = create_highlighted_html(text, all_entities, entity_colors)
-    table_html = create_entity_table_html(all_entities, entity_colors)
+    tab_contents = create_entity_table_gradio_tabs(all_entities, entity_colors)
 
+    progress(0.9, desc="Creating summary...")
+    
     # Create summary with shared entities terminology
     total_entities = len(all_entities)
     shared_entities = find_overlapping_entities(all_entities)
@@ -635,7 +602,9 @@ def process_text(text, standard_entities, custom_entities_str, confidence_thresh
     - **Average confidence:** {sum(e.get('confidence', 0) for e in all_entities) / total_entities:.3f}
     """
 
-    return summary, legend_html + highlighted_html, table_html
+    progress(1.0, desc="Complete!")
+    
+    return summary, legend_html + highlighted_html, tab_contents
 
 # Create Gradio interface
 def create_interface():
@@ -643,23 +612,23 @@ def create_interface():
         gr.Markdown("""
         # 🎯 Hybrid NER + Custom GLiNER Entity Recognition Tool
         
-        Combine standard NER categories with your own custom entity types! This tool uses both traditional NER models and GLiNER for comprehensive entity extraction.
+        Combine common 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 shared with split-color highlighting!
+        ## 🧩🧩 NEW: Overlapping entities are automatically shared with split-colour highlighting!
         
         ### How to use:
         1. **📝 Enter your text** in the text area below
-        2. **🎯 Select a model** from the dropdown for standard entities
-        3. **☑️ Select standard entities** you want to find (PER, ORG, LOC, etc.)
+        2. **🎯 Select a model** from the dropdown for common entities
+        3. **☑️ Select common 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
+        6. **🔍 Click "Analyse Text"** to see results with tabbed output
         """)
         
         with gr.Row():
             with gr.Column(scale=2):
                 text_input = gr.Textbox(
-                    label="📝 Text to Analyze",
+                    label="📝 Text to Analyse",
                     placeholder="Enter your text here...",
                     lines=6,
                     max_lines=10
@@ -676,21 +645,21 @@ def create_interface():
         
         with gr.Row():
             with gr.Column():
-                gr.Markdown("### 🎯 Standard Entity Types")
+                gr.Markdown("### 🎯 Common 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"
+                    label="Select Model for Common Entities",
+                    info="Choose which model to use for common NER"
                 )
                 
-                # Standard entities with select all functionality
+                # Common entities with select all functionality
                 standard_entities = gr.CheckboxGroup(
                     choices=STANDARD_ENTITIES,
                     value=['PER', 'ORG', 'LOC', 'MISC'],  # Default selection
-                    label="Select Standard Entities"
+                    label="Select Common Entities"
                 )
                 
                 # Select/Deselect All button
@@ -727,7 +696,7 @@ def create_interface():
                 - financial terms, business roles
                 """)
         
-        analyze_btn = gr.Button("🔍 Analyze Text", variant="primary", size="lg")
+        analyse_btn = gr.Button("🔍 Analyse Text", variant="primary", size="lg")
         
         # Output sections
         with gr.Row():
@@ -736,12 +705,104 @@ def create_interface():
         with gr.Row():
             highlighted_output = gr.HTML(label="Highlighted Text")
         
+        # Create dynamic tabs for results
+        results_tabs = gr.State({})
+        
+        def update_tabs(tab_contents):
+            """Update the results tabs based on the analysis"""
+            if not tab_contents or not isinstance(tab_contents, dict):
+                return {gr.HTML("No results to display"): gr.update(visible=True)}
+            
+            # Create tabs dynamically
+            tab_components = {}
+            for tab_name, content in tab_contents.items():
+                tab_components[tab_name] = gr.HTML(content)
+            
+            return tab_components
+        
+        # Results section with tabs
         with gr.Row():
-            table_output = gr.HTML(label="Detailed Results (Tabbed)")
+            with gr.Column():
+                gr.Markdown("### 📋 Detailed Results")
+                
+                # We'll update this section dynamically
+                results_container = gr.HTML(label="Results")
+        
+        # Function to process and display results
+        def process_and_display(text, standard_entities, custom_entities, confidence_threshold, selected_model):
+            # Get results from main processing function
+            summary, highlighted, tab_contents = process_text(
+                text, standard_entities, custom_entities, confidence_threshold, selected_model
+            )
+            
+            # Create tabs HTML manually since Gradio dynamic tabs are complex
+            if isinstance(tab_contents, dict) and tab_contents:
+                tabs_html = """
+                <div style="margin: 20px 0;">
+                    <div style="border-bottom: 2px solid #ddd; margin-bottom: 20px;">
+                """
+                
+                # Create tab buttons
+                tab_names = list(tab_contents.keys())
+                for i, tab_name in enumerate(tab_names):
+                    active_style = "background-color: #f8f9fa; border-bottom: 3px solid #4ECDC4;" if i == 0 else "background-color: #fff;"
+                    tabs_html += f"""
+                        <button onclick="showResultTab('{i}')" id="result-tab-{i}"
+                                style="padding: 12px 24px; margin-right: 5px; border: 1px solid #ddd;
+                                       border-bottom: none; cursor: pointer; font-weight: bold; {active_style}">
+                            {tab_name}
+                        </button>
+                    """
+                
+                tabs_html += "</div>"
+                
+                # Create tab content
+                for i, (tab_name, content) in enumerate(tab_contents.items()):
+                    display_style = "display: block;" if i == 0 else "display: none;"
+                    tabs_html += f"""
+                        <div id="result-content-{i}" style="{display_style}">
+                            {content}
+                        </div>
+                    """
+                
+                # Add JavaScript for tab switching
+                tabs_html += """
+                    <script>
+                    function showResultTab(tabIndex) {
+                        // Hide all content
+                        var contents = document.querySelectorAll('[id^="result-content-"]');
+                        contents.forEach(function(content) {
+                            content.style.display = 'none';
+                        });
+                        
+                        // Reset all tab styles
+                        var tabs = document.querySelectorAll('[id^="result-tab-"]');
+                        tabs.forEach(function(tab) {
+                            tab.style.backgroundColor = '#fff';
+                            tab.style.borderBottom = 'none';
+                        });
+                        
+                        // Show selected content
+                        document.getElementById('result-content-' + tabIndex).style.display = 'block';
+                        
+                        // Highlight selected tab
+                        var activeTab = document.getElementById('result-tab-' + tabIndex);
+                        activeTab.style.backgroundColor = '#f8f9fa';
+                        activeTab.style.borderBottom = '3px solid #4ECDC4';
+                    }
+                    </script>
+                </div>
+                """
+                
+                results_display = tabs_html
+            else:
+                results_display = str(tab_contents) if tab_contents else "No results to display"
+            
+            return summary, highlighted, results_display
         
         # Connect the button to the processing function
-        analyze_btn.click(
-            fn=process_text,
+        analyse_btn.click(
+            fn=process_and_display,
             inputs=[
                 text_input,
                 standard_entities,
@@ -749,32 +810,32 @@ def create_interface():
                 confidence_threshold,
                 model_dropdown
             ],
-            outputs=[summary_output, highlighted_output, table_output]
+            outputs=[summary_output, highlighted_output, results_container]
         )
         
         # Add examples
         gr.Examples(
             examples=[
                 [
-                    "John Smith works at Google in New York. He graduated from Stanford University in 2015 and specializes in artificial intelligence research. His wife Sarah is a doctor at Mount Sinai Hospital.",
+                    "John Smith works at Google in New York. He graduated from Stanford University in 2015 and specialises in artificial intelligence research. His wife Sarah is a doctor at Mount Sinai Hospital.",
                     ["PER", "ORG", "LOC", "DATE"],
                     "relationships, occupations, educational background",
                     0.3,
-                    "spacy_en_core_web_sm"
+                    "entities_spacy_en_core_web_trf"
                 ],
                 [
                     "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,
-                    "flair_ner-ontonotes-large"
+                    "entities_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"],
+                    ["PER", "ORG", "Work of Art"],
                     "academic titles, research topics, collaborations",
                     0.3,
-                    "gliner_medium-v2.1"
+                    "entities_gliner_knowledgator/modern-gliner-bi-large-v1.0"
                 ]
             ],
             inputs=[