📖 第1章：NLP基础概念¶

# 音韵层：tā bǎ píngguǒ chī le
# 词法层：他/把/苹果/吃/了
# 句法层：主语(他) + 把字句(把苹果) + 谓语(吃了)
# 语义层：动作执行者是"他"，动作是"吃"，对象是"苹果"
# 语用层：这是一个陈述事实的句子

import re

def eliza_response(user_input):
    """简单的ELIZA风格对话系统"""
    rules = [
        (r"我觉得(.*)", ["为什么你觉得{0}？", "你能详细说说吗？"]),
        (r"我是(.*)", ["你为什么说你是{0}？", "做{0}是什么感觉？"]),
        (r"(.*)(难过|伤心|不开心)(.*)", ["很抱歉听到你不开心，能说说原因吗？"]),
        (r"(.*)(高兴|开心|快乐)(.*)", ["真好！是什么让你这么高兴？"]),
        (r"为什么(.*)", ["你觉得为什么呢？", "这个问题很好，你怎么想？"]),
        (r"(.*)", ["请继续说", "嗯嗯，然后呢？", "有意思，能详细说说吗？"]),
    ]

    import random
    for pattern, responses in rules:
        match = re.search(pattern, user_input)  # re.search在字符串中搜索匹配模式
        if match:
            response = random.choice(responses)
            # 填充匹配的内容
            for i, group in enumerate(match.groups()):  # enumerate同时获取索引和元素
                response = response.replace(f"{{{i}}}", group if group else "")
            return response

    return "我不太明白，能换个说法吗？"

# 测试
test_inputs = [
    "我觉得今天天气不错",
    "我是一个学生",
    "最近很难过",
    "为什么要学NLP",
]

for inp in test_inputs:
    print(f"用户：{inp}")
    print(f"ELIZA：{eliza_response(inp)}")
    print()

from collections import Counter, defaultdict
import math

class NaiveBayesClassifier:
    """朴素贝叶斯文本分类器 - 统计NLP时代的经典算法"""

    def __init__(self):
        self.class_counts = Counter()  # Counter统计元素出现次数
        self.word_counts = defaultdict(Counter)  # defaultdict访问不存在的键时返回默认值
        self.vocab = set()
        self.total_docs = 0

    def train(self, documents, labels):
        """训练朴素贝叶斯模型"""
        self.total_docs = len(documents)
        for doc, label in zip(documents, labels):  # zip按位置配对
            self.class_counts[label] += 1
            words = doc.split()
            for word in words:
                self.word_counts[label][word] += 1
                self.vocab.add(word)

    def predict(self, document):
        """预测文档类别"""
        words = document.split()
        best_label = None
        best_score = float('-inf')

        for label in self.class_counts:
            # log P(class)
            score = math.log(self.class_counts[label] / self.total_docs)

            # log P(word|class) with Laplace smoothing
            total_words = sum(self.word_counts[label].values())
            for word in words:
                count = self.word_counts[label].get(word, 0)
                score += math.log((count + 1) / (total_words + len(self.vocab)))

            if score > best_score:
                best_score = score
                best_label = label

        return best_label

# 示例：简单情感分类
docs = [
    "这部电影太好看了 强烈推荐",
    "非常喜欢 剧情很精彩",
    "拍得真好 演技在线",
    "太难看了 浪费时间",
    "剧情太差 不推荐",
    "很无聊 看了一半就关了",
]
labels = ["正面", "正面", "正面", "负面", "负面", "负面"]

nb = NaiveBayesClassifier()
nb.train(docs, labels)

test_docs = ["这部电影很好看", "太无聊了 不推荐"]
for doc in test_docs:
    print(f"'{doc}' → {nb.predict(doc)}")

import numpy as np

def softmax(x):
    """Softmax函数 - 注意力机制的核心组件"""
    exp_x = np.exp(x - np.max(x))
    return exp_x / exp_x.sum()

def self_attention(Q, K, V):
    """
    自注意力机制简化实现
    Q, K, V: shape = (seq_len, d_model)
    """
    d_k = K.shape[-1]  # [-1]负索引取最后元素
    # 计算注意力分数
    scores = np.dot(Q, K.T) / np.sqrt(d_k)  # np.dot矩阵/向量点乘
    # 归一化
    attention_weights = np.array([softmax(s) for s in scores])  # np.array创建NumPy数组
    # 加权求和
    output = np.dot(attention_weights, V)
    return output, attention_weights

# 示例：3个词，维度为4的自注意力
np.random.seed(42)
seq_len, d_model = 3, 4
X = np.random.randn(seq_len, d_model)

# 简化版：Q=K=V=X
output, weights = self_attention(X, X, X)
print("输入形状:", X.shape)
print("输出形状:", output.shape)
print("注意力权重:\n", np.round(weights, 3))

import jieba

# 中文分词
text = "自然语言处理是人工智能皇冠上的明珠"
words = jieba.lcut(text)
print("分词结果:", "/".join(words))
# 输出: 自然语言/处理/是/人工智能/皇冠/上/的/明珠

# 英文分词（相对简单）
en_text = "Natural language processing is a fascinating field."
en_words = en_text.split()
print("英文分词:", en_words)

import jieba.posseg as pseg

text = "小明在北京大学学习计算机科学"
words = pseg.lcut(text)
for word, flag in words:
    print(f"{word}/{flag}", end=" ")
# 输出: 小明/nr 在/p 北京大学/nt 学习/v 计算机/n 科学/n

# 使用简单规则演示NER的基本概念
import re

def simple_ner(text):
    """简单的规则式NER"""
    entities = []

    # 日期识别
    date_pattern = r'\d{4}年\d{1,2}月\d{1,2}日'
    for match in re.finditer(date_pattern, text):
        entities.append(("DATE", match.group(), match.start()))

    # 金额识别
    money_pattern = r'\d+(?:\.\d+)?[万亿]?元'
    for match in re.finditer(money_pattern, text):
        entities.append(("MONEY", match.group(), match.start()))

    return entities

text = "2024年3月15日，阿里巴巴发布了一款价值299元的新产品"
entities = simple_ner(text)
for etype, value, pos in entities:
    print(f"[{etype}] {value} (位置: {pos})")

# 使用SpaCy进行句法分析（需安装中文模型）
# pip install spacy
# python -m spacy download zh_core_web_sm

try:  # try/except捕获异常
    import spacy
    nlp = spacy.load("zh_core_web_sm")

    doc = nlp("自然语言处理技术发展迅速")
    for token in doc:
        print(f"{token.text} --{token.dep_}--> {token.head.text}")
except OSError:
    print("请先安装中文SpaCy模型: python -m spacy download zh_core_web_sm")

# 文本蕴含示例
examples = [
    {
        "premise": "所有的猫都是动物",
        "hypothesis": "我的猫是动物",
        "label": "蕴含(Entailment)"
    },
    {
        "premise": "今天下雨了",
        "hypothesis": "今天是晴天",
        "label": "矛盾(Contradiction)"
    },
    {
        "premise": "他去了超市",
        "hypothesis": "他买了很多东西",
        "label": "中立(Neutral)"
    },
]

for ex in examples:
    print(f"前提: {ex['premise']}")
    print(f"假设: {ex['hypothesis']}")
    print(f"关系: {ex['label']}")
    print("---")

# 文本分类的多种场景

classification_tasks = {
    "情感分析": {
        "输入": "这家餐厅的服务态度太差了",
        "输出": "负面",
        "类别": ["正面", "负面", "中性"]
    },
    "主题分类": {
        "输入": "央行宣布下调存款准备金率0.5个百分点",
        "输出": "财经",
        "类别": ["财经", "科技", "体育", "娱乐", "政治"]
    },
    "意图识别": {
        "输入": "帮我订一张明天去北京的机票",
        "输出": "订票",
        "类别": ["查询", "订票", "退票", "改签", "闲聊"]
    },
    "垃圾检测": {
        "输入": "恭喜你中了100万大奖，点击链接领取",
        "输出": "垃圾信息",
        "类别": ["正常", "垃圾信息"]
    },
}

for task_name, info in classification_tasks.items():
    print(f"📌 {task_name}")
    print(f"   输入: {info['输入']}")
    print(f"   输出: {info['输出']}")
    print(f"   候选类别: {info['类别']}")
    print()

传统NLP技术栈 = {
    "特征提取": {
        "词袋模型": "Bag of Words",
        "TF-IDF": "词频-逆文档频率",
        "N-gram": "N元语法模型",
    },
    "经典模型": {
        "朴素贝叶斯": "文本分类",
        "SVM": "文本分类、情感分析",
        "HMM": "序列标注",
        "CRF": "命名实体识别",
        "LDA": "主题模型",
    },
    "工具库": ["NLTK", "jieba", "SnowNLP", "HanLP"],
}

深度学习NLP技术栈 = {
    "词向量": {
        "静态词向量": ["Word2Vec", "GloVe", "FastText"],
        "上下文词向量": ["ELMo", "BERT embeddings"],
    },
    "基础模型": {
        "CNN": "TextCNN (文本分类)",
        "RNN/LSTM/GRU": "序列建模",
        "Seq2Seq + Attention": "翻译、摘要",
        "Transformer": "通用架构",
    },
    "预训练模型": {
        "编码器": ["BERT", "RoBERTa", "ALBERT", "ERNIE"],
        "解码器": ["GPT", "GPT-2", "GPT-3"],
        "编码器-解码器": ["T5", "BART", "mT5"],
    },
    "工具框架": ["Transformers", "PyTorch", "SpaCy"],
}

大模型时代技术栈 = {
    "模型": {
        "闭源": ["GPT-4", "Claude", "Gemini"],
        "开源": ["LLaMA", "Mistral", "ChatGLM", "Qwen"],
    },
    "技术": {
        "Prompt Engineering": "设计高效提示词",
        "RAG": "检索增强生成",
        "Fine-tuning": ["LoRA", "QLoRA", "全参数微调"],
        "RLHF/RLAIF": "人类反馈对齐",
        "Agent": "智能体框架",
    },
    "工具": {
        "模型服务": ["vLLM", "TGI", "Ollama"],
        "应用框架": ["LangChain", "LlamaIndex", "Dify"],
        "向量数据库": ["Milvus", "Chroma", "FAISS"],
    },
}

# 同一个词在不同语境下含义不同
ambiguity_examples = {
    "苹果": [
        "我吃了一个苹果",        # 水果
        "苹果公司发布了新产品",   # 公司名
    ],
    "开": [
        "他开了门",              # 打开
        "他开了一家店",          # 创办
        "花儿开了",              # 绽放
        "他开了一个玩笑",        # 讲述
    ],
    "打": [
        "打篮球",    # 进行运动
        "打电话",    # 拨打
        "打酱油",    # 买/不关心
        "打雷了",    # 发出
    ],
}

for word, examples in ambiguity_examples.items():
    print(f"「{word}」的多义:")
    for ex in examples:
        print(f"  - {ex}")
    print()

# 同一个意思的多种表达
same_meaning = [
    "这部电影很好看",
    "这片子真不错",
    "强烈推荐这个电影",
    "看完觉得值了",
    "难得的好片",
    "这是近几年最好的电影之一",
    "五星好评 yyds",
    "爆好看！！！",
    "🔥🔥🔥",
]

print("以下表达都是正面情感：")
for expr in same_meaning:
    print(f"  ✓ {expr}")

中文特有挑战 = {
    "分词问题": "中文没有天然的空格分隔 → '结婚的和尚未结婚的'",
    "字词关系": "字和词的边界模糊 → '研究' vs '研' + '究'",
    "新词发现": "网络新词层出不穷 → '内卷', 'YYDS', '摆烂'",
    "简繁体": "简体和繁体的统一处理",
    "拼音歧义": "同音字多 → shi可以对应几十个字",
    "文言文": "古文和现代文的差异巨大",
    "方言": "不同方言区的语言差异",
}

for challenge, description in 中文特有挑战.items():
    print(f"📌 {challenge}: {description}")

# 智能客服系统的NLP模块示意
class SmartCustomerService:
    def __init__(self):
        self.intent_classifier = None  # 意图分类
        self.entity_recognizer = None  # 实体识别
        self.dialog_manager = None     # 对话管理
        self.response_generator = None # 回复生成

    def process(self, user_input):
        """处理用户输入"""
        # Step 1: 意图识别
        intent = self.classify_intent(user_input)
        # "我想退货" → intent: "退货申请"

        # Step 2: 实体抽取
        entities = self.extract_entities(user_input)
        # "我昨天买的iPhone 15想退货" → {商品: "iPhone 15", 时间: "昨天"}

        # Step 3: 对话管理
        action = self.manage_dialog(intent, entities)
        # 判断是否需要补充信息

        # Step 4: 生成回复
        response = self.generate_response(action)

        return response

    def classify_intent(self, text):
        """意图分类"""
        intents = {
            "退货": ["退货", "退款", "不想要了"],
            "查询订单": ["订单", "到哪了", "快递"],
            "投诉": ["投诉", "差评", "态度差"],
            "咨询": ["多少钱", "有没有", "推荐"],
        }
        for intent, keywords in intents.items():
            if any(kw in text for kw in keywords):  # any()任一为True则返回True
                return intent
        return "其他"

    def extract_entities(self, text):
        return {}

    def manage_dialog(self, intent, entities):
        return {"intent": intent, "entities": entities}

    def generate_response(self, action):
        return "好的，我来帮您处理。"

# 测试
service = SmartCustomerService()
queries = [
    "我想退货",
    "我的订单到哪了",
    "有什么好的手机推荐吗",
]

for q in queries:
    intent = service.classify_intent(q)
    print(f"用户: {q} → 意图: {intent}")

应用场景 = {
    "🔍 搜索推荐": ["查询理解", "语义匹配", "个性化推荐"],
    "💬 智能对话": ["智能客服", "聊天机器人", "语音助手"],
    "📝 内容创作": ["自动写作", "文本摘要", "标题生成"],
    "🌍 机器翻译": ["文档翻译", "实时对话翻译", "字幕翻译"],
    "📊 商业智能": ["舆情分析", "竞品分析", "用户画像"],
    "⚖️ 法律": ["合同审查", "案例检索", "法律问答"],
    "🏥 医疗": ["病历分析", "医学文献挖掘", "辅助诊断"],
    "💰 金融": ["新闻情感分析", "研报摘要", "风控建模"],
    "🎓 教育": ["作文评分", "智能批改", "知识问答"],
    "🛡️ 安全": ["内容审核", "虚假新闻检测", "网络诈骗检测"],
}

for category, tasks in 应用场景.items():
    print(f"{category}: {', '.join(tasks)}")

import numpy as np

def compute_classification_metrics(y_true, y_pred):
    """计算分类指标"""
    # 简化版：假设是二分类
    tp = sum(1 for t, p in zip(y_true, y_pred) if t == 1 and p == 1)
    fp = sum(1 for t, p in zip(y_true, y_pred) if t == 0 and p == 1)
    fn = sum(1 for t, p in zip(y_true, y_pred) if t == 1 and p == 0)
    tn = sum(1 for t, p in zip(y_true, y_pred) if t == 0 and p == 0)

    accuracy = (tp + tn) / (tp + fp + fn + tn)
    precision = tp / (tp + fp) if (tp + fp) > 0 else 0
    recall = tp / (tp + fn) if (tp + fn) > 0 else 0
    f1 = 2 * precision * recall / (precision + recall) if (precision + recall) > 0 else 0

    return {
        "Accuracy": accuracy,
        "Precision": precision,
        "Recall": recall,
        "F1-Score": f1,
    }

# 示例
y_true = [1, 1, 1, 0, 0, 1, 0, 1, 1, 0]
y_pred = [1, 1, 0, 0, 0, 1, 1, 1, 0, 0]

metrics = compute_classification_metrics(y_true, y_pred)
for name, value in metrics.items():
    print(f"{name}: {value:.4f}")

def compute_ner_metrics(true_entities, pred_entities):
    """
    NER评估：基于实体级别的P/R/F1
    true_entities: [("PER", 0, 2), ("LOC", 5, 7), ...]
    pred_entities: [("PER", 0, 2), ("LOC", 5, 8), ...]
    """
    true_set = set(true_entities)
    pred_set = set(pred_entities)

    tp = len(true_set & pred_set)
    precision = tp / len(pred_set) if pred_set else 0
    recall = tp / len(true_set) if true_set else 0
    f1 = 2 * precision * recall / (precision + recall) if (precision + recall) > 0 else 0

    return {"Precision": precision, "Recall": recall, "F1": f1}

# 示例：NER结果 (类型, 起始位置, 结束位置)
true_entities = [("PER", 0, 2), ("LOC", 5, 7), ("ORG", 10, 14)]
pred_entities = [("PER", 0, 2), ("LOC", 5, 8), ("ORG", 10, 14)]

metrics = compute_ner_metrics(true_entities, pred_entities)
print("NER评估结果:")
for name, value in metrics.items():
    print(f"  {name}: {value:.4f}")

from collections import Counter
import math

def compute_bleu(reference, candidate, max_n=4):
    """BLEU分数简化计算"""
    scores = []
    for n in range(1, max_n + 1):
        # 生成n-gram
        ref_ngrams = Counter()
        for i in range(len(reference) - n + 1):
            ref_ngrams[tuple(reference[i:i+n])] += 1

        cand_ngrams = Counter()
        for i in range(len(candidate) - n + 1):
            cand_ngrams[tuple(candidate[i:i+n])] += 1

        # 计算匹配
        match = 0
        for ngram, count in cand_ngrams.items():
            match += min(count, ref_ngrams.get(ngram, 0))

        total = max(len(candidate) - n + 1, 1)
        scores.append(match / total if total > 0 else 0)

    # 几何平均
    if min(scores) > 0:
        log_avg = sum(math.log(s) for s in scores) / len(scores)
        bleu = math.exp(log_avg)
    else:
        bleu = 0

    # 简短惩罚
    bp = min(1, math.exp(1 - len(reference) / max(len(candidate), 1)))

    return bleu * bp

# 示例
reference = "the cat is on the mat".split()
candidate = "the cat is on the mat".split()
print(f"完美匹配 BLEU: {compute_bleu(reference, candidate):.4f}")

candidate2 = "the cat on mat".split()
print(f"部分匹配 BLEU: {compute_bleu(reference, candidate2):.4f}")

"""
实验一：构建一个完整的NLP处理流水线
包含分词、词频统计、关键词提取
"""

import re
from collections import Counter

class SimpleNLPPipeline:
    """简单的NLP处理流水线"""

    def __init__(self):
        # 停用词列表（简化版）
        self.stopwords = set([
            "的", "了", "在", "是", "我", "有", "和", "就",
            "不", "人", "都", "一", "一个", "上", "也", "很",
            "到", "说", "要", "去", "你", "会", "着", "没有",
            "看", "好", "自己", "这", "他", "她", "它",
        ])

    def clean_text(self, text):
        """文本清洗"""
        # 去除特殊字符
        text = re.sub(r'[^\u4e00-\u9fa5a-zA-Z0-9\s]', '', text)
        # 去除多余空格
        text = re.sub(r'\s+', ' ', text).strip()
        return text

    def simple_tokenize(self, text):
        """简单的基于字符的分词（实际应用中使用jieba等工具）"""
        # 这里使用简单的逐字分割（演示用）
        # 实际项目中应使用jieba
        tokens = list(text)
        return [t for t in tokens if t.strip()]

    def remove_stopwords(self, tokens):
        """去除停用词"""
        return [t for t in tokens if t not in self.stopwords]

    def word_frequency(self, tokens):
        """词频统计"""
        return Counter(tokens)

    def process(self, text):
        """完整处理流程"""
        print(f"原始文本: {text[:50]}...")  # 切片操作，取前n个元素

        # Step 1: 清洗
        cleaned = self.clean_text(text)
        print(f"清洗后: {cleaned[:50]}...")

        # Step 2: 分词
        tokens = self.simple_tokenize(cleaned)
        print(f"分词结果(前10): {tokens[:10]}")

        # Step 3: 去停用词
        filtered = self.remove_stopwords(tokens)
        print(f"去停用词后(前10): {filtered[:10]}")

        # Step 4: 词频统计
        freq = self.word_frequency(filtered)
        print(f"高频词Top10: {freq.most_common(10)}")

        return {
            "cleaned_text": cleaned,
            "tokens": tokens,
            "filtered_tokens": filtered,
            "word_frequency": freq,
        }

# 测试
pipeline = SimpleNLPPipeline()
text = """自然语言处理是人工智能领域中最重要的研究方向之一。
自然语言处理的目标是让计算机能够理解和生成人类语言。
近年来，随着深度学习技术的发展，自然语言处理取得了巨大进步。
特别是Transformer架构的提出，彻底改变了自然语言处理的研究范式。"""

result = pipeline.process(text)

"""
实验二：基于关键词的简单情感分析
"""

class SimpleSentimentAnalyzer:
    """基于词典的情感分析（baseline方法）"""

    def __init__(self):
        self.positive_words = set([
            "好", "棒", "美", "喜欢", "开心", "满意", "优秀",
            "推荐", "不错", "赞", "精彩", "完美", "出色",
            "厉害", "高兴", "快乐", "感动", "温暖", "惊喜",
            "有趣", "好看", "好听", "好吃", "舒服", "方便",
        ])

        self.negative_words = set([
            "差", "烂", "讨厌", "失望", "难过", "糟糕", "垃圾",
            "难看", "难吃", "无聊", "坑", "恶心", "后悔",
            "浪费", "差劲", "不好", "难受", "生气", "愤怒",
            "可怕", "丑", "慢", "贵", "假", "骗",
        ])

        self.negation_words = set([
            "不", "没", "无", "别", "莫", "非", "未",
        ])

    def analyze(self, text):
        """分析文本情感"""
        positive_count = 0
        negative_count = 0

        chars = list(text)
        for i, char in enumerate(chars):
            # 检查是否有否定词在前面
            is_negated = False
            if i > 0 and chars[i-1] in self.negation_words:
                is_negated = True

            if char in self.positive_words:
                if is_negated:
                    negative_count += 1
                else:
                    positive_count += 1
            elif char in self.negative_words:
                if is_negated:
                    positive_count += 1
                else:
                    negative_count += 1

        # 也检查双字词
        for i in range(len(chars) - 1):
            word = chars[i] + chars[i+1]
            if word in self.positive_words:
                positive_count += 1
            elif word in self.negative_words:
                negative_count += 1

        # 判断情感
        if positive_count > negative_count:
            sentiment = "正面 😊"
        elif negative_count > positive_count:
            sentiment = "负面 😞"
        else:
            sentiment = "中性 😐"

        return {
            "sentiment": sentiment,
            "positive_count": positive_count,
            "negative_count": negative_count,
            "score": positive_count - negative_count,
        }

# 测试
analyzer = SimpleSentimentAnalyzer()
test_texts = [
    "这部电影太精彩了，强烈推荐！",
    "服务态度太差了，非常失望",
    "产品质量还行，价格有点贵",
    "今天心情不错，天气也很好",
    "这个餐厅不好吃，也不便宜",
]

for text in test_texts:
    result = analyzer.analyze(text)
    print(f"文本: {text}")
    print(f"  情感: {result['sentiment']} (分数: {result['score']})")
    print()

"""
实验三：基于词袋模型的文本相似度计算
"""
import math
from collections import Counter

def text_to_vector(text):
    """将文本转为词频向量"""
    words = list(text)  # 简单的按字分割
    return Counter(words)

def cosine_similarity(vec1, vec2):
    """计算余弦相似度"""
    # 获取所有词
    all_words = set(vec1.keys()) | set(vec2.keys())

    # 计算点积
    dot_product = sum(vec1.get(w, 0) * vec2.get(w, 0) for w in all_words)

    # 计算模长
    norm1 = math.sqrt(sum(v**2 for v in vec1.values()))
    norm2 = math.sqrt(sum(v**2 for v in vec2.values()))

    if norm1 == 0 or norm2 == 0:
        return 0.0

    return dot_product / (norm1 * norm2)

# 测试文本相似度
texts = [
    "自然语言处理是人工智能的重要分支",
    "自然语言处理属于人工智能领域",
    "深度学习推动了计算机视觉的发展",
    "今天天气很好适合出去玩",
]

print("文本相似度矩阵：")
print("-" * 60)
for i in range(len(texts)):
    for j in range(len(texts)):
        vec_i = text_to_vector(texts[i])
        vec_j = text_to_vector(texts[j])
        sim = cosine_similarity(vec_i, vec_j)
        print(f"{sim:.3f}", end="  ")
    print()

print()
print("文本内容：")
for i, t in enumerate(texts):
    print(f"  [{i}] {t}")

def jaccard_similarity(text1, text2):
    """
    计算两段文本的Jaccard相似度
    提示：Jaccard = |A ∩ B| / |A ∪ B|
    """
    # 你的代码
    pass

# 测试
text1 = "自然语言处理是人工智能的核心"
text2 = "自然语言处理是人工智能的重要分支"
print(f"Jaccard相似度: {jaccard_similarity(text1, text2)}")