Subgraph-Ontology Similarity Score

The problem

It is difficult to determine how well a piece of complex data fits into a specific organized structure or category.

What it does

It compares a set of data labels against a structured map to calculate a similarity score.

Why it matters

It provides a clear way to measure how well information aligns with a predefined organizational framework.

Validation

It was run in the sandbox and it failed. run output shows an error/traceback — the artifact does NOT run clean.

$ python3 subgraph_ontology_similarity.py
Traceback (most recent call last):
  File "/work/subgraph_ontology_similarity.py", line 69, in <module>
    score = simulator.calculate_similarity_score('tyrosine kinase')
            ^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^
  File "/work/subgraph_ontology_similarity.py", line 44, in calculate_similarity_score
    subgraph = self.extract_subgraph(query_node)
               ^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^
  File "/work/subgraph_ontology_similarity.py", line 27, in extract_subgraph
    similar_nodes = {node: self._calculate_similarity(node_labels[node], query_node)}
                     ^^^^
NameError: name 'node' is not defined. Did you mean: 'None'?

No screenshot — there is nothing working to show. This is recorded as an unfinished sketch so the attempt stays visible instead of being quietly dropped.

The code

All of it — 70 lines, one file, standard library only.

from collections import defaultdict
import json
from typing import Dict, List, Tuple

class SubgraphOntologySimularity:
    def __init__(self, node_labels: Dict[str, str], ontology_schema: Dict):
        self.node_labels = node_labels
        self.ontology_schema = ontology_schema
        self.hierarchy = self._build_hierarchy(ontology_schema)
        self.similarity_graph = defaultdict(dict)

    def _build_hierarchy(self, schema: Dict) -> Dict:
        # Build ontology hierarchy from schema
        hierarchy = defaultdict(list)
        for class_name, class_def in schema.items():
            if 'parents' in class_def:
                hierarchy[class_def['parents'][0]].append(class_name)
        return hierarchy

    def _calculate_similarity(self, node1: str, node2: str) -> float:
        # Simple string similarity (can be replaced with more advanced metrics)
        common = set(node1.lower().split()).intersection(set(node2.lower().split()))
        return len(common) / max(len(set(node1.lower().split())), len(set(node2.lower().split())))

    def extract_subgraph(self, query_node: str) -> Dict:
        # SimGRAG-inspired similarity-based subgraph extraction
        similar_nodes = {node: self._calculate_similarity(node_labels[node], query_node)}
        # Filter nodes with similarity > 0.5 as example threshold
        subgraph = {node: label for node, label in self.node_labels.items() if similar_nodes[node] > 0.5}
        return subgraph

    def map_to_ontology(self, subgraph: Dict) -> Dict:
        # OntologyRAG-inspired hierarchical mapping
        mapped = {}
        for node, label in subgraph.items():
            # Find best matching class in ontology
            best_match = max(self.ontology_schema.keys(), key=lambda k: self._calculate_similarity(label, k), default=None)
            if best_match:
                mapped[node] = best_match
        return mapped

    def calculate_similarity_score(self, query_node: str) -> float:
        # Combine SimGRAG and OntologyRAG scores
        subgraph = self.extract_subgraph(query_node)
        mapped = self.map_to_ontology(subgraph)
        
        # Simple scoring combining both aspects
        structure_score = len(mapped) / len(self.node_labels)
        hierarchy_score = sum(self.ontology_schema[match]['depth'] for match in mapped.values() if 'depth' in self.ontology_schema[match]) / len(mapped) if mapped else 0
        return (structure_score + hierarchy_score) / 2

# Example usage
if __name__ == "__main__":
    # Example inputs
    node_labels = {
        'n1': 'protein kinase',
        'n2': 'receptor tyrosine kinase',
        'n3': 'enzyme'
    }

    ontology_schema = {
        'Protein': {'parents': ['Molecule'], 'depth': 1},
        'Kinase': {'parents': ['Protein'], 'depth': 2},
        'Enzyme': {'parents': ['Protein'], 'depth': 2},
        'Receptor': {'parents': ['Protein'], 'depth': 2}
    }

    simulator = SubgraphOntologySimularity(node_labels, ontology_schema)
    score = simulator.calculate_similarity_score('tyrosine kinase')
    print(f'Subgraph-Ontology Similarity Score: {score:.2f}')