Skip to content
Snippets Groups Projects
Select Git revision
  • af5d2ee6d7d5b4c3109bdc005531f8d8df7205f9
  • main default protected
2 results

metrics.py

Blame
  • metrics.py 4.58 KiB
    #!/usr/bin/python3.10
    # -*-coding:Utf-8 -*
    
    """
    ontoScorer: Ontology Scoring Module
    ------------------------------------------------------------------------------
    This module provides metrics to evaluate and compare different ontologies. It 
    calculates precision, recall, and F1 score for various ontology elements such 
    as classes, object properties, data properties, restrictions, individuals, and 
    annotations. The comparison is performed between a reference ontology and a 
    generated ontology, allowing users to evaluate how well the generated ontology 
    matches the reference.
    """
    
    from ontoScorer.ontology import Ontology
    from ontoScorer.metric_score import Score
    
    
    class Metrics:
        """
        Metrics class provides functionalities to compute scores for ontology
        elements based on a reference and generated ontology.
        """
        
        #--------------------------------------------------------------------------
        # Constructor(s)
        #--------------------------------------------------------------------------
        
        def __init__(self):
            self.scores = {
                "entities": {
                    "classes": Score(),
                    "object_properties": Score(),
                    "individuals": Score(),
                    "synthesis": Score()  # Synthesis score for entities axis
                },
                "taxonomic_relations": {
                    "subclass": Score(),
                    "instanciation": Score(),
                    "synthesis": Score()  # Synthesis score for taxonomic relations axis
                },
                "non_taxonomic_relations": {
                    "object_properties": Score(),
                    "data_properties": Score(),
                    "domains": Score(),
                    "ranges": Score(),
                    "synthesis": Score()  # Synthesis score for non-taxonomic relations axis
                },
                "axioms": {
                    "restriction_axioms": Score(),
                    "synthesis": Score()  # Synthesis score for axioms axis
                }
            }
    
    
    
        #--------------------------------------------------------------------------
        # Computing Method(s)
        #--------------------------------------------------------------------------
        
        @staticmethod
        def deduplicate_elements(elements, comparison_function):
            unique_elements = []
            for elem in elements:
                if not any([comparison_function(elem, unique_elem) for unique_elem in unique_elements]):
                    unique_elements.append(elem)
            return unique_elements
        
        def compute_entity_scores(self, reference_ontology, generated_ontology):
            entity_methods = {
                "classes": ("get_classes", Ontology.compare_entity_names),
                "object_properties": ("get_object_properties", Ontology.compare_entity_names),
                "individuals": ("get_individuals", Ontology.compare_entity_names)
            }
        
            y_true_overall = []
            y_pred_overall = []
        
            for score_name, (method_name, comparison_function) in entity_methods.items():
                reference_elements_raw = getattr(reference_ontology, method_name)()
                generated_elements_raw = getattr(generated_ontology, method_name)()
                
                reference_elements = Metrics.deduplicate_elements(reference_elements_raw, comparison_function)
                generated_elements = Metrics.deduplicate_elements(generated_elements_raw, comparison_function)
        
                all_elements = list(set(reference_elements + generated_elements))
                all_elements = Metrics.deduplicate_elements(all_elements, comparison_function)
                y_true = [1 if any([comparison_function(elem, ref_elem) for ref_elem in reference_elements]) else 0 for elem in all_elements]
                y_pred = [1 if any([comparison_function(elem, gen_elem) for gen_elem in generated_elements]) else 0 for elem in all_elements]
        
                self.scores["entities"][score_name].compute(y_true, y_pred)
        
                y_true_overall.extend(y_true)
                y_pred_overall.extend(y_pred)
        
            self.scores["entities"]["synthesis"].compute(y_true_overall, y_pred_overall)
    
    
    
        #--------------------------------------------------------------------------
        # Printing Method(s)
        #--------------------------------------------------------------------------
        
        def print_scores(self):
            """
            Prints the scores (precision, recall, f1) for each ontology element category.
            """
            entity_scores = self.scores["entities"]
            for element, score in entity_scores.items():
                print(f"Metrics for {element.capitalize()} (Entity axis):")
                print(score)
                print("----------------------------")