spaCy

graph TD
    A[spaCy] --> B[Language Models]
    A --> C[Text Processing]
    A --> D[Linguistic Features]
    A --> E[Machine Learning]
    A --> F[Training & Customization]
    A --> G[Visualization]
    A --> H[Integration]

    B --> B1[Pre-trained Models]
    B --> B2[Multi-language Support]
    B --> B3[Model Zoo]
    B --> B4[Transfer Learning]

    C --> C1[Tokenization]
    C --> C2[Sentence Segmentation]
    C --> C3[Text Normalization]
    C --> C4[Pipeline Processing]

    D --> D1[Part-of-Speech Tagging]
    D --> D2[Dependency Parsing]
    D --> D3[Named Entity Recognition]
    D --> D4[Morphological Analysis]

    E --> E1[Word Vectors]
    E --> E2[Similarity Computation]
    E --> E3[Text Classification]
    E --> E4[Rule-based Matching]

    F --> F1[Model Training]
    F --> F2[Custom Pipelines]
    F --> F3[Data Augmentation]
    F --> F4[Evaluation]

    G --> G1[Dependency Visualization]
    G --> G2[Entity Visualization]
    G --> G3[Interactive Display]
    G --> G4[Displacy]

    H --> H1[API Integration]
    H --> H2[Production Deployment]
    H --> H3[Cloud Services]
    H --> H4[Microservices]

    style A fill:#009688,stroke:#333
    style B fill:#4CAF50,stroke:#333
    style C fill:#2196F3,stroke:#333
    style D fill:#9C27B0,stroke:#333
    style E fill:#FF9800,stroke:#333
    style F fill:#F44336,stroke:#333
    style G fill:#673AB7,stroke:#333
    style H fill:#795548,stroke:#333

# Basic spaCy example
import spacy
import matplotlib.pyplot as plt
from spacy import displacy

print("Basic spaCy Example...")

# Load English language model
print("\nLoading English language model...")
try:
    nlp = spacy.load("en_core_web_sm")
    print("Model loaded successfully")
except OSError:
    print("Model not found. Please install with: python -m spacy download en_core_web_sm")
    # Create a minimal example for demonstration
    class MockDoc:
        def __init__(self, text):
            self.text = text
            self.ents = []
            self.sents = [MockSent(text)]
            self.tokens = [MockToken(word, i) for i, word in enumerate(text.split())]

        def __iter__(self):
            return iter(self.tokens)

    class MockSent:
        def __init__(self, text):
            self.text = text

    class MockToken:
        def __init__(self, text, i):
            self.text = text
            self.i = i
            self.pos_ = "NOUN"
            self.tag_ = "NN"
            self.dep_ = "nsubj"
            self.head = self
            self.lemma_ = text.lower()

        def __str__(self):
            return self.text

    def mock_nlp(text):
        return MockDoc(text)

    nlp = mock_nlp
    print("Using mock NLP for demonstration")

# 1. Basic text processing
print("\n1. Basic Text Processing...")
text = "Natural Language Processing (NLP) is a subfield of artificial intelligence. It focuses on the interaction between computers and humans through natural language."

doc = nlp(text)
print(f"Original text: {text}")
print(f"Number of tokens: {len(doc)}")
print(f"Number of sentences: {len(list(doc.sents))}")

# 2. Token attributes
print("\n2. Token Attributes...")
print(f"{'Token':<15} {'Lemma':<10} {'POS':<10} {'Tag':<10} {'Dependency':<15} {'Head':<15}")
print("-" * 70)
for token in doc[:10]:  # First 10 tokens
    print(f"{token.text:<15} {token.lemma_:<10} {token.pos_:<10} {token.tag_:<10} {token.dep_:<15} {token.head.text:<15}")

# 3. Named Entity Recognition
print("\n3. Named Entity Recognition...")
ner_text = "Apple Inc. is planning to open a new store in Paris next month. Tim Cook will be attending the event."
ner_doc = nlp(ner_text)

print(f"Text: {ner_text}")
print("Named Entities:")
for ent in ner_doc.ents:
    print(f"{ent.text:<20} {ent.label_:<15} {spacy.explain(ent.label_)}")

# 4. Visualization with displacy
print("\n4. Visualization with displacy...")
# Visualize dependency parse
if hasattr(displacy, 'render'):
    displacy.render(doc, style="dep", jupyter=False)
    # Note: In a real environment, this would display an interactive visualization

    # Visualize named entities
    displacy.render(ner_doc, style="ent", jupyter=False)

# 5. Sentence segmentation
print("\n5. Sentence Segmentation...")
for i, sent in enumerate(doc.sents):
    print(f"Sentence {i+1}: {sent.text}")

# 6. Part-of-speech statistics
print("\n6. Part-of-Speech Statistics...")
pos_counts = {}
for token in doc:
    pos = token.pos_
    pos_counts[pos] = pos_counts.get(pos, 0) + 1

print("POS counts:")
for pos, count in sorted(pos_counts.items(), key=lambda x: x[1], reverse=True):
    print(f"{pos:<15} {count:<5} {spacy.explain(pos) if hasattr(spacy, 'explain') else ''}")

# Plot POS distribution
plt.figure(figsize=(10, 6))
plt.bar(pos_counts.keys(), pos_counts.values())
plt.title('Part-of-Speech Distribution')
plt.xlabel('POS Tag')
plt.ylabel('Count')
plt.xticks(rotation=45)
plt.tight_layout()
plt.show()

# 7. Dependency parsing
print("\n7. Dependency Parsing...")
for token in doc[:10]:  # First 10 tokens
    print(f"{token.text:<10} {token.dep_:<15} {token.head.text:<10} {token.head.pos_:<10}")

# 8. Word vectors and similarity
print("\n8. Word Vectors and Similarity...")
if hasattr(doc, 'has_vector') and doc.has_vector:
    # Get words with vectors
    words_with_vectors = [token for token in doc if token.has_vector]

    if words_with_vectors:
        print("Word similarities:")
        for i, token1 in enumerate(words_with_vectors[:3]):  # First 3 words
            for token2 in words_with_vectors[i+1:i+4]:  # Next 3 words
                similarity = token1.similarity(token2)
                print(f"{token1.text} - {token2.text}: {similarity:.4f}")
    else:
        print("No words with vectors in this model")
else:
    print("Word vectors not available in this model")

# 9. Lemmatization
print("\n9. Lemmatization...")
print(f"{'Original':<15} {'Lemma':<15}")
print("-" * 30)
for token in doc[:10]:  # First 10 tokens
    print(f"{token.text:<15} {token.lemma_:<15}")

# 10. Stop words
print("\n10. Stop Words...")
stop_words = [token.text for token in doc if token.is_stop]
print(f"Stop words: {stop_words}")
print(f"Total stop words: {len(stop_words)}")
print(f"Total tokens: {len(doc)}")
print(f"Stop word ratio: {len(stop_words)/len(doc):.4f}")

# Named Entity Recognition example with spaCy
import spacy
from collections import Counter
import matplotlib.pyplot as plt

print("\nNamed Entity Recognition Example...")

# Load model
try:
    nlp = spacy.load("en_core_web_sm")
except OSError:
    print("Using mock NLP for demonstration")
    nlp = None

# Sample texts for NER
texts = [
    "Apple Inc. is planning to open a new store in Paris next month. Tim Cook, the CEO, will be attending the event.",
    "Microsoft Corporation was founded by Bill Gates and Paul Allen in 1975 in Albuquerque, New Mexico.",
    "Elon Musk announced that Tesla will release a new electric vehicle next year in San Francisco.",
    "The United Nations held a conference in Geneva last week to discuss climate change with world leaders.",
    "Amazon.com is expanding its operations in Seattle and plans to hire 10,000 new employees by 2025.",
    "Google LLC, headquartered in Mountain View, California, is developing new AI technologies for healthcare.",
    "The European Union announced new regulations that will affect tech companies operating in Brussels.",
    "NASA is planning a mission to Mars in 2030 with international partners from the European Space Agency.",
    "The World Health Organization declared a global health emergency for the new virus outbreak in Asia.",
    "Sony Pictures released a new movie directed by Steven Spielberg that will premiere in Los Angeles next week."
]

# 1. Process texts and extract entities
print("1. Processing texts and extracting entities...")
all_entities = []

if nlp:
    for text in texts:
        doc = nlp(text)
        entities = [(ent.text, ent.label_, ent.label) for ent in doc.ents]
        all_entities.extend(entities)
        print(f"\nText: {text}")
        print("Entities:")
        for ent in doc.ents:
            print(f"  {ent.text:<30} {ent.label_:<15} {spacy.explain(ent.label_)}")
else:
    # Mock data for demonstration
    mock_entities = [
        ("Apple Inc.", "ORG", "ORG"), ("Paris", "GPE", "GPE"), ("Tim Cook", "PERSON", "PERSON"),
        ("Microsoft Corporation", "ORG", "ORG"), ("Bill Gates", "PERSON", "PERSON"), ("Paul Allen", "PERSON", "PERSON"),
        ("1975", "DATE", "DATE"), ("Albuquerque", "GPE", "GPE"), ("New Mexico", "GPE", "GPE"),
        ("Elon Musk", "PERSON", "PERSON"), ("Tesla", "ORG", "ORG"), ("San Francisco", "GPE", "GPE"),
        ("United Nations", "ORG", "ORG"), ("Geneva", "GPE", "GPE"), ("Amazon.com", "ORG", "ORG"),
        ("Seattle", "GPE", "GPE"), ("2025", "DATE", "DATE"), ("Google LLC", "ORG", "ORG"),
        ("Mountain View", "GPE", "GPE"), ("California", "GPE", "GPE"), ("European Union", "ORG", "ORG"),
        ("Brussels", "GPE", "GPE"), ("NASA", "ORG", "ORG"), ("Mars", "GPE", "GPE"), ("2030", "DATE", "DATE"),
        ("European Space Agency", "ORG", "ORG"), ("World Health Organization", "ORG", "ORG"),
        ("Asia", "GPE", "GPE"), ("Sony Pictures", "ORG", "ORG"), ("Steven Spielberg", "PERSON", "PERSON"),
        ("Los Angeles", "GPE", "GPE")
    ]
    all_entities = mock_entities
    for i, text in enumerate(texts):
        print(f"\nText: {text}")
        print("Entities:")
        for ent in mock_entities[i*3:(i+1)*3]:
            print(f"  {ent[0]:<30} {ent[1]:<15} {ent[2]}")

# 2. Entity statistics
print("\n2. Entity Statistics...")
entity_counter = Counter([ent[1] for ent in all_entities])
print("Entity type counts:")
for entity_type, count in entity_counter.most_common():
    print(f"{entity_type:<15} {count}")

# Plot entity distribution
plt.figure(figsize=(10, 6))
entity_counter_most_common = entity_counter.most_common(10)
plt.bar([x[0] for x in entity_counter_most_common], [x[1] for x in entity_counter_most_common])
plt.title('Entity Type Distribution')
plt.xlabel('Entity Type')
plt.ylabel('Count')
plt.xticks(rotation=45)
plt.tight_layout()
plt.show()

# 3. Entity value analysis
print("\n3. Entity Value Analysis...")
entity_values = Counter([ent[0] for ent in all_entities])
print("Most common entities:")
for entity, count in entity_values.most_common(10):
    print(f"{entity:<30} {count}")

# 4. Entity co-occurrence
print("\n4. Entity Co-occurrence...")
# Find entities that appear together in the same text
co_occurrence = {}

if nlp:
    for text in texts:
        doc = nlp(text)
        entities_in_text = list(set([ent.label_ for ent in doc.ents]))
        for i, ent1 in enumerate(entities_in_text):
            for ent2 in entities_in_text[i+1:]:
                key = tuple(sorted((ent1, ent2)))
                co_occurrence[key] = co_occurrence.get(key, 0) + 1
else:
    # Mock co-occurrence data
    mock_co_occurrence = {
        ('ORG', 'GPE'): 8,
        ('ORG', 'PERSON'): 5,
        ('GPE', 'DATE'): 4,
        ('ORG', 'DATE'): 3,
        ('PERSON', 'GPE'): 3
    }
    co_occurrence = mock_co_occurrence

print("Entity co-occurrence:")
for (ent1, ent2), count in sorted(co_occurrence.items(), key=lambda x: x[1], reverse=True):
    print(f"{ent1} - {ent2}: {count}")

# 5. Entity context analysis
print("\n5. Entity Context Analysis...")
# Analyze the context in which entities appear
entity_context = {}

if nlp:
    for text in texts:
        doc = nlp(text)
        for ent in doc.ents:
            context = " ".join([token.text for token in ent.sent if token.i < ent.start or token.i >= ent.end])
            entity_type = ent.label_
            if entity_type not in entity_context:
                entity_context[entity_type] = []
            entity_context[entity_type].append((ent.text, context))
else:
    # Mock context data
    mock_context = {
        'ORG': [
            ("Apple Inc.", "is planning to open a new store in"),
            ("Microsoft Corporation", "was founded by"),
            ("Tesla", "will release a new electric vehicle next year in")
        ],
        'GPE': [
            ("Paris", "Apple Inc. is planning to open a new store in"),
            ("Albuquerque", "Microsoft Corporation was founded in"),
            ("San Francisco", "Tesla will release a new electric vehicle in")
        ]
    }
    entity_context = mock_context

print("Entity context examples:")
for entity_type, examples in entity_context.items():
    print(f"\n{entity_type}:")
    for entity, context in examples[:3]:  # First 3 examples
        print(f"  {entity}: {context}...")

# 6. Entity relationship extraction
print("\n6. Entity Relationship Extraction...")
# Extract relationships between entities in the same sentence
relationships = []

if nlp:
    for text in texts:
        doc = nlp(text)
        for sent in doc.sents:
            sent_ents = list(sent.ents)
            if len(sent_ents) >= 2:
                for i, ent1 in enumerate(sent_ents):
                    for ent2 in sent_ents[i+1:]:
                        # Simple relationship extraction based on dependency parse
                        rel = f"{ent1.text} ({ent1.label_}) - {ent2.text} ({ent2.label_})"
                        relationships.append(rel)
else:
    # Mock relationships
    mock_relationships = [
        "Apple Inc. (ORG) - Paris (GPE)",
        "Tim Cook (PERSON) - Apple Inc. (ORG)",
        "Microsoft Corporation (ORG) - Bill Gates (PERSON)",
        "Microsoft Corporation (ORG) - Paul Allen (PERSON)",
        "Microsoft Corporation (ORG) - 1975 (DATE)",
        "Elon Musk (PERSON) - Tesla (ORG)",
        "Tesla (ORG) - San Francisco (GPE)",
        "United Nations (ORG) - Geneva (GPE)",
        "Amazon.com (ORG) - Seattle (GPE)",
        "Google LLC (ORG) - Mountain View (GPE)"
    ]
    relationships = mock_relationships

print("Extracted relationships:")
for rel in relationships[:10]:  # First 10 relationships
    print(f"  {rel}")

# 7. Entity visualization
print("\n7. Entity Visualization...")
# In a real environment, this would display an interactive visualization
print("Entity visualization would be displayed here in a real environment")
print("Using displacy to render entity visualization...")

# 8. Entity resolution
print("\n8. Entity Resolution...")
# Identify different mentions of the same entity
entity_mentions = {}

if nlp:
    for text in texts:
        doc = nlp(text)
        for ent in doc.ents:
            if ent.text not in entity_mentions:
                entity_mentions[ent.text] = []
            entity_mentions[ent.text].append((ent.label_, text[:50] + "..."))
else:
    # Mock entity mentions
    mock_mentions = {
        "Apple Inc.": [("ORG", "Apple Inc. is planning to open a new store...")],
        "Microsoft Corporation": [("ORG", "Microsoft Corporation was founded by...")],
        "Tesla": [("ORG", "Elon Musk announced that Tesla will release...")],
        "Elon Musk": [("PERSON", "Elon Musk announced that Tesla will release...")],
        "San Francisco": [
            ("GPE", "Elon Musk announced that Tesla will release..."),
            ("GPE", "The event will take place in San Francisco...")
        ]
    }
    entity_mentions = mock_mentions

print("Entity mentions:")
for entity, mentions in entity_mentions.items():
    if len(mentions) > 1:
        print(f"\n{entity}:")
        for label, context in mentions:
            print(f"  {label}: {context}")

# Dependency parsing example with spaCy
import spacy
import networkx as nx
import matplotlib.pyplot as plt

print("\nDependency Parsing Example...")

# Load model
try:
    nlp = spacy.load("en_core_web_sm")
except OSError:
    print("Using mock NLP for demonstration")
    nlp = None

# Sample sentences for dependency parsing
sentences = [
    "The quick brown fox jumps over the lazy dog.",
    "Natural language processing is a fascinating field of study.",
    "She bought a beautiful dress from the new boutique.",
    "The company announced record profits for the last quarter.",
    "Artificial intelligence and machine learning are transforming industries.",
    "Despite the rain, they decided to go for a walk in the park.",
    "The book that I borrowed from the library was excellent.",
    "After finishing his homework, he went to play soccer with his friends.",
    "The scientist published a groundbreaking paper on climate change.",
    "Although she was tired, she continued working on her project."
]

# 1. Basic dependency parsing
print("1. Basic Dependency Parsing...")
if nlp:
    for sentence in sentences:
        doc = nlp(sentence)
        print(f"\nSentence: {sentence}")
        print(f"{'Token':<10} {'Dep':<10} {'Head':<10} {'Head POS':<10}")
        print("-" * 45)
        for token in doc:
            print(f"{token.text:<10} {token.dep_:<10} {token.head.text:<10} {token.head.pos_:<10}")
else:
    # Mock dependency data
    mock_deps = [
        [("The", "det", "fox", "NOUN"), ("quick", "amod", "fox", "NOUN"), ("brown", "amod", "fox", "NOUN"),
         ("fox", "nsubj", "jumps", "VERB"), ("jumps", "ROOT", "jumps", "VERB"), ("over", "prep", "jumps", "VERB"),
         ("the", "det", "dog", "NOUN"), ("lazy", "amod", "dog", "NOUN"), ("dog", "pobj", "over", "ADP"), (".", "punct", "jumps", "VERB")],

        [("Natural", "amod", "processing", "NOUN"), ("language", "compound", "processing", "NOUN"),
         ("processing", "nsubj", "is", "VERB"), ("is", "ROOT", "is", "VERB"), ("a", "det", "field", "NOUN"),
         ("fascinating", "amod", "field", "NOUN"), ("field", "attr", "is", "VERB"), ("of", "prep", "field", "NOUN"),
         ("study", "pobj", "of", "ADP"), (".", "punct", "is", "VERB")]
    ]

    for i, sentence in enumerate(sentences[:2]):  # First 2 sentences
        print(f"\nSentence: {sentence}")
        print(f"{'Token':<10} {'Dep':<10} {'Head':<10} {'Head POS':<10}")
        print("-" * 45)
        for dep in mock_deps[i]:
            print(f"{dep[0]:<10} {dep[1]:<10} {dep[2]:<10} {dep[3]:<10}")

# 2. Dependency tree visualization
print("\n2. Dependency Tree Visualization...")
def plot_dependency_tree(doc):
    """Plot dependency tree using networkx"""
    edges = []
    labels = {}

    for token in doc:
        edges.append((token.head.text, token.text))
        labels[token.text] = f"{token.text}\n{token.dep_}"

    plt.figure(figsize=(12, 8))
    G = nx.DiGraph()
    G.add_edges_from(edges)

    pos = nx.spring_layout(G)
    nx.draw(G, pos, with_labels=False, node_size=2000, node_color="skyblue", arrows=True)
    nx.draw_networkx_labels(G, pos, labels, font_size=10)

    plt.title("Dependency Parse Tree")
    plt.show()

if nlp:
    doc = nlp("The quick brown fox jumps over the lazy dog.")
    plot_dependency_tree(doc)
else:
    print("Dependency tree visualization would be displayed here in a real environment")

# 3. Syntactic structure analysis
print("\n3. Syntactic Structure Analysis...")
def analyze_syntactic_structure(doc):
    """Analyze syntactic structure of a sentence"""
    analysis = {
        "noun_phrases": [],
        "verb_phrases": [],
        "subjects": [],
        "objects": [],
        "prepositional_phrases": []
    }

    for token in doc:
        # Find noun phrases
        if token.dep_ in ("nsubj", "dobj", "pobj", "attr", "oprd"):
            np = [token.text]
            # Include modifiers
            for child in token.children:
                if child.dep_ in ("det", "amod", "compound", "nummod"):
                    np.insert(0, child.text)
            analysis["noun_phrases"].append(" ".join(np))

        # Find verb phrases
        if token.pos_ == "VERB":
            vp = [token.text]
            # Include auxiliaries and modifiers
            for child in token.children:
                if child.dep_ in ("aux", "neg", "advmod"):
                    vp.insert(0, child.text)
            analysis["verb_phrases"].append(" ".join(vp))

        # Find subjects
        if token.dep_ == "nsubj":
            analysis["subjects"].append(token.text)

        # Find objects
        if token.dep_ in ("dobj", "pobj", "attr"):
            analysis["objects"].append(token.text)

        # Find prepositional phrases
        if token.dep_ == "prep":
            pp = [token.text]
            for child in token.children:
                if child.dep_ == "pobj":
                    pp.append(child.text)
            analysis["prepositional_phrases"].append(" ".join(pp))

    return analysis

if nlp:
    for sentence in sentences[:3]:  # First 3 sentences
        doc = nlp(sentence)
        analysis = analyze_syntactic_structure(doc)
        print(f"\nSentence: {sentence}")
        print("Syntactic Analysis:")
        for key, values in analysis.items():
            if values:
                print(f"  {key.replace('_', ' ').title()}: {', '.join(values)}")
else:
    # Mock analysis
    mock_analysis = [
        {
            "noun_phrases": ["The quick brown fox", "the lazy dog"],
            "verb_phrases": ["jumps"],
            "subjects": ["fox"],
            "objects": ["dog"],
            "prepositional_phrases": ["over the lazy dog"]
        },
        {
            "noun_phrases": ["Natural language processing", "a fascinating field", "study"],
            "verb_phrases": ["is"],
            "subjects": ["processing"],
            "objects": ["field"],
            "prepositional_phrases": ["of study"]
        }
    ]

    for i, sentence in enumerate(sentences[:2]):
        print(f"\nSentence: {sentence}")
        print("Syntactic Analysis:")
        for key, values in mock_analysis[i].items():
            if values:
                print(f"  {key.replace('_', ' ').title()}: {', '.join(values)}")

# 4. Dependency path analysis
print("\n4. Dependency Path Analysis...")
def find_dependency_path(doc, token1, token2):
    """Find the dependency path between two tokens"""
    # Find path from token1 to root
    path1 = []
    current = token1
    while current != current.head:
        path1.append(current)
        current = current.head
    path1.append(current)  # Add root

    # Find path from token2 to root
    path2 = []
    current = token2
    while current != current.head:
        path2.append(current)
        current = current.head
    path2.append(current)  # Add root

    # Find lowest common ancestor
    lca = None
    for t1, t2 in zip(reversed(path1), reversed(path2)):
        if t1 == t2:
            lca = t1
        else:
            break

    # Build path
    path = []
    # From token1 to LCA
    for token in reversed(path1):
        if token == lca:
            break
        path.append((token, "up"))

    # From LCA to token2
    found_lca = False
    for token in path2:
        if token == lca:
            found_lca = True
            continue
        if found_lca:
            path.append((token, "down"))

    return path, lca

if nlp:
    doc = nlp("The quick brown fox jumps over the lazy dog.")
    fox = doc[3]  # "fox"
    dog = doc[7]  # "dog"

    path, lca = find_dependency_path(doc, fox, dog)
    print(f"Path from '{fox.text}' to '{dog.text}':")
    print(f"  {fox.text} -> ", end="")
    for token, direction in path:
        print(f"{token.text} ({direction}) -> ", end="")
    print(f"{dog.text}")
    print(f"Lowest Common Ancestor: {lca.text}")
else:
    print("Dependency path: fox -> jumps (up) -> over (down) -> dog")
    print("Lowest Common Ancestor: jumps")

# 5. Grammatical relations analysis
print("\n5. Grammatical Relations Analysis...")
def analyze_grammatical_relations(doc):
    """Analyze grammatical relations in a sentence"""
    relations = {
        "subjects": [],
        "direct_objects": [],
        "indirect_objects": [],
        "prepositional_objects": [],
        "adjectival_modifiers": [],
        "adverbial_modifiers": [],
        "conjunctions": [],
        "negations": []
    }

    for token in doc:
        if token.dep_ == "nsubj":
            relations["subjects"].append((token.text, token.head.text))
        elif token.dep_ == "dobj":
            relations["direct_objects"].append((token.text, token.head.text))
        elif token.dep_ == "iobj":
            relations["indirect_objects"].append((token.text, token.head.text))
        elif token.dep_ == "pobj":
            relations["prepositional_objects"].append((token.text, token.head.text))
        elif token.dep_ == "amod":
            relations["adjectival_modifiers"].append((token.text, token.head.text))
        elif token.dep_ == "advmod":
            relations["adverbial_modifiers"].append((token.text, token.head.text))
        elif token.dep_ == "conj":
            relations["conjunctions"].append((token.text, token.head.text))
        elif token.dep_ == "neg":
            relations["negations"].append((token.text, token.head.text))

    return relations

if nlp:
    for sentence in sentences[:3]:  # First 3 sentences
        doc = nlp(sentence)
        relations = analyze_grammatical_relations(doc)
        print(f"\nSentence: {sentence}")
        print("Grammatical Relations:")
        for rel_type, rels in relations.items():
            if rels:
                print(f"  {rel_type.replace('_', ' ').title()}:")
                for dep, head in rels:
                    print(f"    {dep} -> {head}")
else:
    # Mock relations
    mock_relations = [
        {
            "subjects": [("fox", "jumps")],
            "direct_objects": [("dog", "over")],
            "adjectival_modifiers": [("quick", "fox"), ("brown", "fox"), ("lazy", "dog")],
            "prepositional_objects": [("dog", "over")]
        },
        {
            "subjects": [("processing", "is")],
            "direct_objects": [],
            "adjectival_modifiers": [("Natural", "processing"), ("language", "processing"), ("fascinating", "field")],
            "prepositional_objects": [("study", "of")]
        }
    ]

    for i, sentence in enumerate(sentences[:2]):
        print(f"\nSentence: {sentence}")
        print("Grammatical Relations:")
        for rel_type, rels in mock_relations[i].items():
            if rels:
                print(f"  {rel_type.replace('_', ' ').title()}:")
                for dep, head in rels:
                    print(f"    {dep} -> {head}")

# 6. Sentence complexity analysis
print("\n6. Sentence Complexity Analysis...")
def analyze_sentence_complexity(doc):
    """Analyze the complexity of a sentence"""
    metrics = {
        "token_count": len(doc),
        "sentence_count": len(list(doc.sents)),
        "avg_token_length": sum(len(token.text) for token in doc) / len(doc),
        "unique_tokens": len(set(token.text.lower() for token in doc)),
        "lexical_diversity": len(set(token.text.lower() for token in doc)) / len(doc),
        "pos_diversity": len(set(token.pos_ for token in doc)) / len(doc),
        "dependency_types": len(set(token.dep_ for token in doc)),
        "clause_count": sum(1 for token in doc if token.dep_ == "ccomp" or token.dep_ == "xcomp" or token.pos_ == "VERB"),
        "coordination_count": sum(1 for token in doc if token.dep_ == "conj"),
        "subordination_count": sum(1 for token in doc if token.dep_ in ("advcl", "relcl", "ccomp", "xcomp"))
    }

    return metrics

if nlp:
    for sentence in sentences:
        doc = nlp(sentence)
        metrics = analyze_sentence_complexity(doc)
        print(f"\nSentence: {sentence}")
        print("Complexity Metrics:")
        for metric, value in metrics.items():
            if isinstance(value, float):
                print(f"  {metric.replace('_', ' ').title()}: {value:.4f}")
            else:
                print(f"  {metric.replace('_', ' ').title()}: {value}")
else:
    # Mock metrics
    mock_metrics = [
        {
            "token_count": 9,
            "sentence_count": 1,
            "avg_token_length": 3.78,
            "unique_tokens": 8,
            "lexical_diversity": 0.89,
            "pos_diversity": 0.56,
            "dependency_types": 6,
            "clause_count": 1,
            "coordination_count": 0,
            "subordination_count": 0
        },
        {
            "token_count": 11,
            "sentence_count": 1,
            "avg_token_length": 4.55,
            "unique_tokens": 10,
            "lexical_diversity": 0.91,
            "pos_diversity": 0.64,
            "dependency_types": 7,
            "clause_count": 1,
            "coordination_count": 0,
            "subordination_count": 1
        }
    ]

    for i, sentence in enumerate(sentences[:2]):
        print(f"\nSentence: {sentence}")
        print("Complexity Metrics:")
        for metric, value in mock_metrics[i].items():
            if isinstance(value, float):
                print(f"  {metric.replace('_', ' ').title()}: {value:.4f}")
            else:
                print(f"  {metric.replace('_', ' ').title()}: {value}")

# 7. Dependency-based features for ML
print("\n7. Dependency-based Features for Machine Learning...")
def extract_dependency_features(doc):
    """Extract dependency-based features for machine learning"""
    features = []

    for token in doc:
        token_features = {
            "token": token.text.lower(),
            "pos": token.pos_,
            "tag": token.tag_,
            "dep": token.dep_,
            "is_alpha": token.is_alpha,
            "is_stop": token.is_stop,
            "is_punct": token.is_punct,
            "is_digit": token.is_digit,
            "prefix": token.text[:3].lower(),
            "suffix": token.text[-3:].lower(),
            "shape": token.shape_,
            "head_pos": token.head.pos_,
            "head_tag": token.head.tag_,
            "head_dep": token.head.dep_,
            "head_text": token.head.text.lower(),
            "dependency_distance": abs(token.i - token.head.i),
            "left_children_count": sum(1 for child in token.children if child.i < token.i),
            "right_children_count": sum(1 for child in token.children if child.i > token.i),
            "children_count": len(list(token.children))
        }
        features.append(token_features)

    return features

if nlp:
    doc = nlp("Natural language processing is fascinating.")
    features = extract_dependency_features(doc)
    print(f"Features for sentence: {' '.join([token.text for token in doc])}")
    print(f"{'Token':<10} {'POS':<5} {'Dep':<10} {'Head':<10} {'Features'}")
    print("-" * 60)
    for i, token in enumerate(doc):
        feat = features[i]
        print(f"{token.text:<10} {feat['pos']:<5} {feat['dep']:<10} {feat['head_text']:<10} "
              f"children={feat['children_count']}, dist={feat['dependency_distance']}")
else:
    print("Features for sentence: Natural language processing is fascinating.")
    print(f"{'Token':<10} {'POS':<5} {'Dep':<10} {'Head':<10} {'Features'}")
    print("-" * 60)
    mock_features = [
        ("natural", "ADJ", "amod", "processing", "children=0, dist=1"),
        ("language", "NOUN", "compound", "processing", "children=0, dist=1"),
        ("processing", "NOUN", "nsubj", "is", "children=2, dist=1"),
        ("is", "VERB", "ROOT", "is", "children=2, dist=0"),
        ("fascinating", "ADJ", "acomp", "is", "children=0, dist=1"),
        (".", "PUNCT", "punct", "is", "children=0, dist=1")
    ]
    for token, pos, dep, head, features in mock_features:
        print(f"{token:<10} {pos:<5} {dep:<10} {head:<10} {features}")

# Text classification example with spaCy
import spacy
from spacy.training import Example
from spacy.util import minibatch
import random
import matplotlib.pyplot as plt

print("\nText Classification Example...")

# Load model
try:
    nlp = spacy.load("en_core_web_sm")
    # Create a blank text classifier
    textcat = nlp.add_pipe("textcat")
    textcat.add_label("POSITIVE")
    textcat.add_label("NEGATIVE")
except OSError:
    print("Using mock NLP for demonstration")
    nlp = None

# Sample training data
train_data = [
    ("This movie was absolutely fantastic! The acting was superb.", {"cats": {"POSITIVE": 1.0, "NEGATIVE": 0.0}}),
    ("I hated every minute of this film. The dialogue was terrible.", {"cats": {"POSITIVE": 0.0, "NEGATIVE": 1.0}}),
    ("It was okay, not great but not terrible either.", {"cats": {"POSITIVE": 0.5, "NEGATIVE": 0.5}}),
    ("The cinematography was beautiful and the story was compelling.", {"cats": {"POSITIVE": 1.0, "NEGATIVE": 0.0}}),
    ("Waste of time and money. I want my money back!", {"cats": {"POSITIVE": 0.0, "NEGATIVE": 1.0}}),
    ("The performances were outstanding and the direction was excellent.", {"cats": {"POSITIVE": 1.0, "NEGATIVE": 0.0}}),
    ("Boring, predictable, and poorly executed.", {"cats": {"POSITIVE": 0.0, "NEGATIVE": 1.0}}),
    ("A masterpiece that will stay with you long after watching.", {"cats": {"POSITIVE": 1.0, "NEGATIVE": 0.0}}),
    ("The plot was confusing and the characters were underdeveloped.", {"cats": {"POSITIVE": 0.0, "NEGATIVE": 1.0}}),
    ("Engaging from start to finish with brilliant performances.", {"cats": {"POSITIVE": 1.0, "NEGATIVE": 0.0}}),
    ("I've seen better acting in high school plays.", {"cats": {"POSITIVE": 0.0, "NEGATIVE": 1.0}}),
    ("A visually stunning film with a powerful message.", {"cats": {"POSITIVE": 1.0, "NEGATIVE": 0.0}}),
    ("The pacing was slow and the story dragged on too long.", {"cats": {"POSITIVE": 0.0, "NEGATIVE": 1.0}}),
    ("One of the best films I've seen this year.", {"cats": {"POSITIVE": 1.0, "NEGATIVE": 0.0}}),
    ("The special effects were cheap and the acting was wooden.", {"cats": {"POSITIVE": 0.0, "NEGATIVE": 1.0}})
]

# 1. Training preparation
print("1. Training Preparation...")
if nlp:
    # Disable other pipeline components during training
    other_pipes = [pipe for pipe in nlp.pipe_names if pipe != "textcat"]
    with nlp.disable_pipes(*other_pipes):
        optimizer = nlp.begin_training()

        # Convert training data to Example objects
        examples = []
        for text, annotations in train_data:
            example = Example.from_dict(nlp.make_doc(text), annotations)
            examples.append(example)

        print(f"Prepared {len(examples)} training examples")
else:
    print(f"Prepared {len(train_data)} training examples (mock)")

# 2. Training loop
print("\n2. Training Loop...")
if nlp:
    losses = {}
    epochs = 10
    batch_size = 2

    print("Training text classifier...")
    for epoch in range(epochs):
        random.shuffle(examples)
        batches = minibatch(examples, size=batch_size)

        for batch in batches:
            nlp.update(batch, drop=0.2, losses=losses, sgd=optimizer)

        print(f"Epoch {epoch + 1}/{epochs} - Losses: {losses}")

    print("Training completed!")
else:
    print("Training would occur here in a real environment")
    losses = {"textcat": 0.5}

# Plot training losses
if nlp:
    plt.figure(figsize=(10, 6))
    plt.plot([i+1 for i in range(epochs)], [losses["textcat"]] * epochs)
    plt.title('Training Loss')
    plt.xlabel('Epoch')
    plt.ylabel('Loss')
    plt.show()

# 3. Evaluation
print("\n3. Evaluation...")
test_data = [
    ("This film was amazing and I highly recommend it.", {"POSITIVE": 1.0, "NEGATIVE": 0.0}),
    ("Terrible movie with awful acting and a predictable plot.", {"POSITIVE": 0.0, "NEGATIVE": 1.0}),
    ("It was an average film, nothing special but not bad either.", {"POSITIVE": 0.5, "NEGATIVE": 0.5}),
    ("The visuals were stunning and the story was emotionally powerful.", {"POSITIVE": 1.0, "NEGATIVE": 0.0}),
    ("I fell asleep halfway through and regretted watching it.", {"POSITIVE": 0.0, "NEGATIVE": 1.0})
]

if nlp:
    correct = 0
    total = len(test_data)

    for text, true_labels in test_data:
        doc = nlp(text)
        pred_labels = doc.cats

        # Get predicted class
        pred_class = max(pred_labels, key=lambda x: pred_labels[x])
        true_class = max(true_labels, key=lambda x: true_labels[x])

        print(f"\nText: {text}")
        print(f"True: {true_labels}, Predicted: {pred_labels}")
        print(f"Predicted class: {pred_class}, True class: {true_class}")

        if pred_class == true_class:
            correct += 1

    accuracy = correct / total
    print(f"\nAccuracy: {accuracy:.4f}")
else:
    print("Evaluation would occur here in a real environment")
    print("Mock evaluation results:")
    for text, true_labels in test_data:
        print(f"\nText: {text}")
        print(f"True: {true_labels}")
        # Mock predictions
        if "amazing" in text or "stunning" in text:
            pred = {"POSITIVE": 0.9, "NEGATIVE": 0.1}
        elif "terrible" in text or "awful" in text:
            pred = {"POSITIVE": 0.1, "NEGATIVE": 0.9}
        else:
            pred = {"POSITIVE": 0.5, "NEGATIVE": 0.5}
        print(f"Predicted: {pred}")

# 4. Classification of new text
print("\n4. Classification of New Text...")
new_texts = [
    "This movie exceeded all my expectations and was truly brilliant.",
    "The plot was nonsensical and the acting was laughably bad.",
    "It was an enjoyable film with some good moments but also some slow parts.",
    "Visually spectacular with a moving story that touched my heart.",
    "I've seen better films made by students for a class project."
]

if nlp:
    for text in new_texts:
        doc = nlp(text)
        pred_labels = doc.cats
        pred_class = max(pred_labels, key=lambda x: pred_labels[x])

        print(f"\nText: {text}")
        print(f"Predicted sentiment: {pred_class}")
        print(f"Confidence: POSITIVE={pred_labels['POSITIVE']:.4f}, NEGATIVE={pred_labels['NEGATIVE']:.4f}")

        # Visualize confidence
        plt.figure(figsize=(6, 4))
        plt.bar(pred_labels.keys(), pred_labels.values())
        plt.title(f'Sentiment Analysis: {pred_class}')
        plt.ylabel('Confidence')
        plt.ylim(0, 1)
        plt.show()
else:
    print("Classification of new text (mock results):")
    for text in new_texts:
        print(f"\nText: {text}")
        if "brilliant" in text or "spectacular" in text or "moving" in text:
            pred = {"POSITIVE": 0.95, "NEGATIVE": 0.05}
        elif "nonsensical" in text or "bad" in text or "better films" in text:
            pred = {"POSITIVE": 0.05, "NEGATIVE": 0.95}
        else:
            pred = {"POSITIVE": 0.6, "NEGATIVE": 0.4}
        pred_class = max(pred, key=lambda x: pred[x])
        print(f"Predicted sentiment: {pred_class}")
        print(f"Confidence: POSITIVE={pred['POSITIVE']:.4f}, NEGATIVE={pred['NEGATIVE']:.4f}")

# 5. Feature importance analysis
print("\n5. Feature Importance Analysis...")
if nlp:
    # Get the text classifier component
    textcat = nlp.get_pipe("textcat")

    # Get feature weights (this is a simplified approach)
    # In a real scenario, you would use more sophisticated methods
    print("Feature importance analysis would be performed here")

    # Mock feature importance
    print("Mock feature importance:")
    important_words = {
        "POSITIVE": ["amazing", "brilliant", "excellent", "outstanding", "beautiful", "stunning", "powerful", "masterpiece"],
        "NEGATIVE": ["terrible", "awful", "boring", "predictable", "poorly", "waste", "bad", "nonsensical"]
    }

    for sentiment, words in important_words.items():
        print(f"{sentiment}: {', '.join(words)}")
else:
    print("Feature importance analysis (mock):")
    important_words = {
        "POSITIVE": ["amazing", "brilliant", "excellent", "outstanding", "beautiful"],
        "NEGATIVE": ["terrible", "awful", "boring", "predictable", "poorly"]
    }

    for sentiment, words in important_words.items():
        print(f"{sentiment}: {', '.join(words)}")

# 6. Model interpretation
print("\n6. Model Interpretation...")
if nlp:
    print("Model interpretation would be performed here")

    # Mock interpretation
    print("Mock model interpretation:")
    print("The model learns to associate certain words with positive or negative sentiment.")
    print("Words like 'amazing', 'brilliant', and 'excellent' strongly predict positive sentiment.")
    print("Words like 'terrible', 'awful', and 'boring' strongly predict negative sentiment.")
    print("Neutral words and mixed reviews result in more balanced predictions.")
else:
    print("Model interpretation (mock):")
    print("The model would learn patterns from the training data:")
    print("- Positive reviews contain words like: amazing, brilliant, excellent")
    print("- Negative reviews contain words like: terrible, awful, boring")
    print("- Neutral reviews contain a mix or neutral language")

# Batch processing example with spaCy
import spacy
import time
import matplotlib.pyplot as plt

print("\nBatch Processing Example...")

# Load model
try:
    nlp = spacy.load("en_core_web_sm")
except OSError:
    print("Using mock NLP for demonstration")
    nlp = None

# Sample texts for processing
texts = [
    "Natural language processing is a fascinating field of study.",
    "Machine learning and artificial intelligence are transforming industries.",
    "The quick brown fox jumps over the lazy dog.",
    "Data science combines statistics, programming, and domain expertise.",
    "Computer vision enables machines to interpret visual information.",
    "Deep learning models can achieve state-of-the-art performance.",
    "Python is a popular programming language for NLP tasks.",
    "Transformers have revolutionized natural language understanding.",
    "Named entity recognition extracts structured information from text.",
    "Dependency parsing reveals the grammatical structure of sentences."
] * 10  # Duplicate to create more data

print(f"Processing {len(texts)} texts...")

# 1. Sequential processing
print("\n1. Sequential Processing...")
if nlp:
    start_time = time.time()
    results_seq = []

    for text in texts:
        doc = nlp(text)
        results_seq.append({
            "text": text,
            "tokens": len(doc),
            "entities": len(doc.ents),
            "noun_chunks": len(list(doc.noun_chunks))
        })

    seq_time = time.time() - start_time
    print(f"Sequential processing time: {seq_time:.4f} seconds")
    print(f"Average time per text: {seq_time/len(texts):.6f} seconds")
else:
    seq_time = 0.5
    print(f"Sequential processing time: {seq_time:.4f} seconds (mock)")

# 2. Batch processing
print("\n2. Batch Processing...")
if nlp:
    start_time = time.time()
    results_batch = []

    # Process in batches
    batch_size = 10
    for i in range(0, len(texts), batch_size):
        batch = texts[i:i+batch_size]
        docs = list(nlp.pipe(batch))

        for doc in docs:
            results_batch.append({
                "text": doc.text,
                "tokens": len(doc),
                "entities": len(doc.ents),
                "noun_chunks": len(list(doc.noun_chunks))
            })

    batch_time = time.time() - start_time
    print(f"Batch processing time: {batch_time:.4f} seconds")
    print(f"Average time per text: {batch_time/len(texts):.6f} seconds")
    print(f"Speedup: {seq_time/batch_time:.2f}x")
else:
    batch_time = 0.2
    print(f"Batch processing time: {batch_time:.4f} seconds (mock)")
    print(f"Speedup: {seq_time/batch_time:.2f}x")

# 3. Performance comparison
print("\n3. Performance Comparison...")
if nlp:
    # Verify results are the same
    for i, (res_seq, res_batch) in enumerate(zip(results_seq, results_batch)):
        if (res_seq["tokens"] != res_batch["tokens"] or
            res_seq["entities"] != res_batch["entities"] or
            res_seq["noun_chunks"] != res_batch["noun_chunks"]):
            print(f"Results differ for text {i}")
            break
    else:
        print("All results match between sequential and batch processing")

    # Plot performance comparison
    plt.figure(figsize=(10, 6))
    plt.bar(["Sequential", "Batch"], [seq_time, batch_time], color=['blue', 'green'])
    plt.title('Processing Time Comparison')
    plt.ylabel('Time (seconds)')
    plt.show()
else:
    print("Performance comparison (mock):")
    plt.figure(figsize=(10, 6))
    plt.bar(["Sequential", "Batch"], [seq_time, batch_time], color=['blue', 'green'])
    plt.title('Processing Time Comparison (Mock)')
    plt.ylabel('Time (seconds)')
    plt.show()

# 4. Batch size optimization
print("\n4. Batch Size Optimization...")
if nlp:
    batch_sizes = [1, 2, 5, 10, 20, 50, 100]
    times = []

    for size in batch_sizes:
        start_time = time.time()

        for i in range(0, len(texts), size):
            batch = texts[i:i+size]
            list(nlp.pipe(batch))

        times.append(time.time() - start_time)
        print(f"Batch size {size}: {times[-1]:.4f} seconds")

    # Plot batch size vs performance
    plt.figure(figsize=(10, 6))
    plt.plot(batch_sizes, times, marker='o')
    plt.title('Batch Size vs Processing Time')
    plt.xlabel('Batch Size')
    plt.ylabel('Time (seconds)')
    plt.grid(True)
    plt.show()

    # Find optimal batch size
    optimal_idx = times.index(min(times))
    print(f"Optimal batch size: {batch_sizes[optimal_idx]} with time {times[optimal_idx]:.4f} seconds")
else:
    print("Batch size optimization would be performed here")
    print("Mock optimal batch size: 10")

# 5. Pipeline optimization
print("\n5. Pipeline Optimization...")
if nlp:
    # Measure full pipeline performance
    start_time = time.time()
    for text in texts[:10]:  # Just first 10 for demo
        doc = nlp(text)
    full_pipeline_time = time.time() - start_time
    print(f"Full pipeline time for 10 texts: {full_pipeline_time:.4f} seconds")

    # Disable components and measure performance
    components = ["tok2vec", "tagger", "parser", "ner", "attribute_ruler", "lemmatizer"]

    for component in components:
        if component in nlp.pipe_names:
            # Disable all components except the current one
            other_components = [c for c in nlp.pipe_names if c != component]
            with nlp.disable_pipes(*other_components):
                start_time = time.time()
                for text in texts[:10]:  # Just first 10 for demo
                    doc = nlp(text)
                component_time = time.time() - start_time
                print(f"Only {component} time: {component_time:.4f} seconds")
else:
    print("Pipeline optimization would be performed here")
    print("Mock pipeline component times:")
    components = ["tok2vec", "tagger", "parser", "ner"]
    times = [0.1, 0.2, 0.3, 0.25]
    for component, time_val in zip(components, times):
        print(f"Only {component} time: {time_val:.4f} seconds")

# GPU acceleration example with spaCy
import spacy
import time
import torch

print("\nGPU Acceleration Example...")

# Check if GPU is available
gpu_available = torch.cuda.is_available()
print(f"GPU available: {gpu_available}")

if gpu_available:
    print(f"GPU device: {torch.cuda.get_device_name(0)}")
else:
    print("No GPU available, using CPU")

# Load model
try:
    nlp = spacy.load("en_core_web_sm")
    print("Model loaded successfully")
except OSError:
    print("Using mock NLP for demonstration")
    nlp = None

# Sample texts for processing
texts = [
    "Natural language processing with spaCy is fast and efficient.",
    "GPU acceleration can significantly improve performance for NLP tasks.",
    "Deep learning models benefit from parallel processing capabilities.",
    "The quick brown fox jumps over the lazy dog.",
    "Machine learning and artificial intelligence are transforming industries."
] * 20  # Duplicate to create more data

print(f"Processing {len(texts)} texts...")

# 1. CPU processing
print("\n1. CPU Processing...")
if nlp:
    # Ensure we're using CPU
    if hasattr(nlp, 'pipe'):
        nlp.to_disk("cpu_model")  # Save current model
        nlp = spacy.load("cpu_model")  # Reload to ensure CPU

    start_time = time.time()
    for text in texts:
        doc = nlp(text)
    cpu_time = time.time() - start_time
    print(f"CPU processing time: {cpu_time:.4f} seconds")
    print(f"Average time per text: {cpu_time/len(texts):.6f} seconds")
else:
    cpu_time = 1.5
    print(f"CPU processing time: {cpu_time:.4f} seconds (mock)")

# 2. GPU processing (if available)
if gpu_available and nlp:
    print("\n2. GPU Processing...")
    try:
        # Load model for GPU
        nlp = spacy.load("en_core_web_sm")
        nlp.to_device("cuda")  # Move model to GPU

        start_time = time.time()
        for text in texts:
            doc = nlp(text)
        gpu_time = time.time() - start_time
        print(f"GPU processing time: {gpu_time:.4f} seconds")
        print(f"Average time per text: {gpu_time/len(texts):.6f} seconds")
        print(f"Speedup: {cpu_time/gpu_time:.2f}x")

        # Move model back to CPU
        nlp.to_device("cpu")
    except Exception as e:
        print(f"GPU processing failed: {e}")
        gpu_time = cpu_time * 0.7  # Mock faster time
        print(f"GPU processing time: {gpu_time:.4f} seconds (mock)")
        print(f"Speedup: {cpu_time/gpu_time:.2f}x")
else:
    if not gpu_available:
        print("\n2. GPU Processing not available")
    gpu_time = cpu_time * 0.7  # Mock faster time
    print(f"GPU processing time: {gpu_time:.4f} seconds (mock)")
    print(f"Speedup: {cpu_time/gpu_time:.2f}x")

# 3. Batch processing with GPU
if gpu_available and nlp:
    print("\n3. Batch Processing with GPU...")
    try:
        nlp.to_device("cuda")  # Move model to GPU

        start_time = time.time()
        batch_size = 10
        for i in range(0, len(texts), batch_size):
            batch = texts[i:i+batch_size]
            list(nlp.pipe(batch))
        gpu_batch_time = time.time() - start_time
        print(f"GPU batch processing time: {gpu_batch_time:.4f} seconds")
        print(f"Average time per text: {gpu_batch_time/len(texts):.6f} seconds")
        print(f"Speedup vs CPU: {cpu_time/gpu_batch_time:.2f}x")
        print(f"Speedup vs GPU single: {gpu_time/gpu_batch_time:.2f}x")

        # Move model back to CPU
        nlp.to_device("cpu")
    except Exception as e:
        print(f"GPU batch processing failed: {e}")
        gpu_batch_time = gpu_time * 0.8  # Mock faster time
        print(f"GPU batch processing time: {gpu_batch_time:.4f} seconds (mock)")
        print(f"Speedup vs CPU: {cpu_time/gpu_batch_time:.2f}x")
else:
    print("\n3. Batch Processing with GPU not available")
    gpu_batch_time = gpu_time * 0.8  # Mock faster time
    print(f"GPU batch processing time: {gpu_batch_time:.4f} seconds (mock)")
    print(f"Speedup vs CPU: {cpu_time/gpu_batch_time:.2f}x")

# 4. Performance comparison
print("\n4. Performance Comparison...")
if nlp:
    print(f"CPU time: {cpu_time:.4f} seconds")
    print(f"GPU time: {gpu_time:.4f} seconds")
    print(f"GPU batch time: {gpu_batch_time:.4f} seconds")

    # Plot performance comparison
    import matplotlib.pyplot as plt
    plt.figure(figsize=(10, 6))
    plt.bar(["CPU", "GPU", "GPU Batch"], [cpu_time, gpu_time, gpu_batch_time], color=['blue', 'green', 'orange'])
    plt.title('Processing Time Comparison')
    plt.ylabel('Time (seconds)')
    plt.show()
else:
    print("Performance comparison (mock):")
    print(f"CPU time: {cpu_time:.4f} seconds")
    print(f"GPU time: {gpu_time:.4f} seconds")
    print(f"GPU batch time: {gpu_batch_time:.4f} seconds")

# 5. Memory usage comparison
print("\n5. Memory Usage Comparison...")
if gpu_available and nlp:
    import psutil
    import gc

    def get_memory_usage():
        """Get current memory usage in MB"""
        process = psutil.Process()
        return process.memory_info().rss / 1024 / 1024

    # CPU memory usage
    gc.collect()
    start_mem = get_memory_usage()
    for text in texts[:10]:  # Just first 10 for demo
        doc = nlp(text)
    cpu_mem = get_memory_usage() - start_mem
    print(f"CPU memory usage: {cpu_mem:.2f} MB")

    # GPU memory usage
    try:
        nlp.to_device("cuda")
        gc.collect()
        start_mem = get_memory_usage()
        for text in texts[:10]:  # Just first 10 for demo
            doc = nlp(text)
        gpu_mem = get_memory_usage() - start_mem
        print(f"GPU memory usage: {gpu_mem:.2f} MB")

        # Get actual GPU memory usage
        gpu_memory = torch.cuda.memory_allocated(0) / 1024 / 1024
        print(f"Actual GPU memory allocated: {gpu_memory:.2f} MB")

        nlp.to_device("cpu")
    except Exception as e:
        print(f"GPU memory measurement failed: {e}")
        gpu_mem = cpu_mem * 1.2  # Mock higher memory usage
        print(f"GPU memory usage: {gpu_mem:.2f} MB (mock)")
else:
    print("Memory usage comparison (mock):")
    print(f"CPU memory usage: 50.00 MB")
    print(f"GPU memory usage: 60.00 MB")