Contextual Relationships: combining NER, dependency parsing, and rule-based extraction

December 18, 2024

Ambiguity in Contextual Relationships

When building a knowledge graph from unstructured data, ambiguity in contextual relationships refers to the difficulty of identifying precise relationships between extracted entities (e.g., issues and their causes, effects, or resolutions). In many cases, natural language contains implicit or ambiguous information, making it hard for models to extract accurate, meaningful relationships.

Challenges

Implicit Relationships:
- Contextual relationships like cause-effect are not always explicitly stated.
- For example, in “The battery stops charging after the software update,” the causal relationship between the battery issue and the software update is implied but not directly stated.
Complex Sentence Structures:
- Sentences with nested or dependent clauses can obscure relationships.
- Example: “After installing the update, the app started crashing every time I uploaded a photo.”
Ambiguous Language:
- Words like “because,” “after,” “due to,” or “when” signal relationships, but they may also introduce ambiguity.
- For example, in “The app crashes after uploading a file,” it’s unclear whether the upload causes the crash or happens coincidentally.
Polysemy and Context:
- Words with multiple meanings or vague references can confuse models.
- Example: “The screen is freezing while charging” might refer to hardware or software issues, and the context is unclear without further analysis.
Domain-Specific Knowledge:
- The relationships often require domain expertise to interpret. For instance, understanding that “overheating” is a potential cause of “battery failure” might not be obvious to a general-purpose model.

Solution: Combining NER with Dependency Parsing and Rule-Based Extraction

To resolve ambiguity and improve relationship extraction, the following multi-step approach was used:

1. Named Entity Recognition (NER) for Key Entities

Used NER to extract relevant entities from unstructured text:
- Issues: “Battery not charging,” “App crashes.”
- Potential Causes: “Software update,” “Overheating.”
- Contexts: “While charging,” “After installation.”
Example Output:
- Input: “The phone shuts down after charging overnight.”
- NER Output:
  - Issue: Phone shuts down
  - Context: Charging overnight

2. Dependency Parsing for Relationship Extraction

Dependency parsing identifies grammatical relationships between words in a sentence (e.g., subjects, objects, modifiers). Tools like spaCy or Stanford NLP were used to analyze sentence structure.

Steps:

Parse Sentence into a Dependency Tree:
- Example Sentence: “The app crashes after uploading a file.”
- Dependency Parsing Output:
  - Crashes → Root (main action)
  - App → Subject of crashes
  - After uploading → Temporal Modifier of crashes
Extract Relationship Using Dependencies:
- The dependency tree reveals that the crash occurs “after uploading,” indicating a temporal or causal relationship.
- Nodes like “after,” “because,” or “due to” were flagged as connectors.

Example Output:

Input: “The battery stopped working because of overheating.”
Dependency Parsing:
- Battery → Subject of stopped working
- Stopped working → Root
- Because of overheating → Causal Modifier
Extracted Relationship:
- Cause: Overheating
- Effect: Battery stopped working

3. Rule-Based Extraction for Specific Patterns

Domain-specific rule-based approaches were used to refine ambiguous relationships. This method complements statistical models by encoding expert knowledge about the domain.

Key Rules:

Temporal Cues: Relationships triggered by time-based keywords like “after,” “before,” “while.”
- Rule: "after X" → Indicates that X may precede or cause the issue.
Causal Keywords: Words like “because,” “due to,” “caused by” explicitly suggest cause-effect.
- Rule: "X caused by Y" → Extract cause-effect relationship: Cause = Y, Effect = X.
Conditional Statements: Relationships inferred from “if-then” patterns.
- Rule: "If X, then Y" → Capture conditional dependencies: Condition = X, Outcome = Y.

Example:

Input: “If the device overheats, the battery may fail.”
Rule Applied:
- Conditional Relationship:
  - Condition: Device overheats
  - Outcome: Battery fails

4. Combining Outputs for Disambiguation

The outputs from NER, dependency parsing, and rule-based methods were combined for better accuracy. The final relationships were validated using a knowledge base or manually curated rules.

Example Workflow:

Sentence: “The screen freezes when the battery is charging.”
- NER Output:
  - Issue: Screen freezes
  - Context: Battery charging
- Dependency Parsing:
  - Freezes → Root Action
  - When charging → Temporal Modifier
- Rule-Based Extraction:
  - Rule: "When X, Y" → Temporal Dependency
- Final Extraction:
  - Context: Battery charging
  - Effect: Screen freezes

5. Integration with Knowledge Graph

The extracted entities and relationships were stored in a graph database (e.g., Neo4j). The graph schema captured these relationships as nodes and edges:

Nodes:
- Issues: Screen Freezing, App Crashing
- Contexts: Battery Charging, Software Update
- Causes: Overheating
Edges:
- causes: Connects a cause (e.g., Overheating) to an issue (e.g., Battery Failure).
- occurs_during: Connects a context (e.g., Charging) to an issue (e.g., Screen Freezing).

Conclusion

By combining NER, dependency parsing, and rule-based extraction:

Implicit relationships like cause-effect, temporal dependencies and conditions were identified more accurately.
Domain-specific rules reduced ambiguity and made the relationships more interpretable.
These relationships were stored in a knowledge graph for downstream analytics, such as root cause analysis or issue prediction.

Below is a step-by-step implementation of combining NER, dependency parsing, and rule-based extraction to extract contextual relationships (e.g., cause-effect) from unstructured text and store them in a knowledge graph like Neo4j.

Implementation Steps

1. Required Libraries

Install the necessary libraries for NER, dependency parsing, and connecting to Neo4j:

pip install spacy neo4j

spaCy: For Named Entity Recognition (NER) and dependency parsing.
Neo4j: Python driver to interact with the graph database.

2. Load a Pre-Trained spaCy Model

We use spaCy’s pre-trained model (e.g., en_core_web_sm) for NER and dependency parsing.

import spacy

# Load spaCy's pre-trained English model
nlp = spacy.load("en_core_web_sm")

3. Define Input Text

The input text contains unstructured customer support logs.

text = """
The app crashes after uploading a file.
The battery stopped working because of overheating.
If the device overheats, the battery may fail.
"""

4. NER and Dependency Parsing

We process the input text using spaCy to extract entities and parse dependencies.

def extract_relationships(text):
    # Process the text using spaCy
    doc = nlp(text)
    
    relationships = []
    
    for sentence in doc.sents:  # Iterate over each sentence
        print(f"Processing: {sentence}")
        
        # Dependency parsing to find relationships
        for token in sentence:
            if token.dep_ in ("advcl", "prep") and token.head.pos_ == "VERB":
                # Look for causal/temporal connectors (e.g., "because", "after")
                if token.text in ["because", "after", "when", "due to"]:
                    # Extract cause-effect relationship
                    cause = " ".join([child.text for child in token.children if child.dep_ == "pobj" or child.dep_ == "dobj"])
                    effect = token.head.text
                    
                    if cause and effect:
                        relationships.append((effect, token.text, cause))
                        
    return relationships

5. Rule-Based Extraction

We use rules for specific patterns (e.g., “If X, then Y”).

def rule_based_extraction(text):
    doc = nlp(text)
    relationships = []
    
    for sentence in doc.sents:
        tokens = [token.text.lower() for token in sentence]
        
        # Example rule: "If X, then Y"
        if "if" in tokens and "then" in tokens:
            condition_index = tokens.index("if") + 1
            outcome_index = tokens.index("then") + 1
            
            condition = sentence[condition_index:outcome_index - 1]
            outcome = sentence[outcome_index:]
            
            relationships.append((condition.text, "leads to", outcome.text))
            
    return relationships

6. Combine Outputs

Extract relationships using both dependency parsing and rule-based methods.

# Combine dependency parsing and rule-based extractions
def extract_contextual_relationships(text):
    relationships = extract_relationships(text) + rule_based_extraction(text)
    return relationships

7. Sample Output

Running the combined extraction:

text = """
The app crashes after uploading a file.
The battery stopped working because of overheating.
If the device overheats, the battery may fail.
"""

relationships = extract_contextual_relationships(text)

for relationship in relationships:
    print(f"Effect: {relationship[0]}, Relation: {relationship[1]}, Cause: {relationship[2]}")

Output:

Effect: crashes, Relation: after, Cause: uploading a file
Effect: stopped, Relation: because, Cause: overheating
Condition: device overheats, Relation: leads to, Outcome: battery may fail

8. Storing in Neo4j

The extracted relationships are stored in a Neo4j knowledge graph. Each entity becomes a node, and the relationship (e.g., causes, leads to) becomes an edge.

from neo4j import GraphDatabase

# Initialize Neo4j driver
driver = GraphDatabase.driver("bolt://localhost:7687", auth=("neo4j", "password"))

# Function to insert relationships into the graph
def insert_relationship(tx, cause, relation, effect):
    query = """
    MERGE (cause:Entity {name: $cause})
    MERGE (effect:Entity {name: $effect})
    MERGE (cause)-[:RELATION {type: $relation}]->(effect)
    """
    tx.run(query, cause=cause, effect=effect, relation=relation)

# Insert all relationships into the graph
with driver.session() as session:
    for relationship in relationships:
        session.write_transaction(insert_relationship, relationship[2], relationship[1], relationship[0])

9. Querying the Knowledge Graph

You can now query the graph database for insights.

Example Query: Find the causes of all issues:

MATCH (cause:Entity)-[r:RELATION]->(effect:Entity)
WHERE r.type = "causes" OR r.type = "leads to"
RETURN cause.name AS Cause, effect.name AS Effect

Final Graph

The knowledge graph now contains nodes and edges that represent the extracted relationships:

Nodes:
- App Crashes
- Battery Stopped Working
- Overheating
Edges:
- App Crashes → caused by → Uploading a File
- Battery Stopped Working → caused by → Overheating
- Device Overheats → leads to → Battery May Fail

Improvements

Expand Rule Set: Add more rules to handle other ambiguous patterns.
Fine-Tune NER Models: Use domain-specific training data to improve entity recognition.
Automated Validation: Compare relationships with domain knowledge to verify accuracy.