spaCy从入门到精通：3.1 分词：Tokenization详解

最新推荐文章于 2026-07-14 12:58:38 发布

原创最新推荐文章于 2026-07-14 12:58:38 发布 · 889 阅读

11 ·

本内容遵循CC 4.0 BY-SA版权协议

GEO检测

收录于

spaCy从入门到精通

章节回顾与连接

在上一章（第二部分）中，我们深入学习了spaCy的三个核心对象：

Doc对象：文本的容器，包含了文本的所有处理结果
Token对象：文本的基本单位，代表文本中的一个词汇或标点符号
Span对象：文本片段，由连续的Token组成

这些核心对象构成了spaCy处理文本的基础框架。在本章中，我们将开始学习spaCy的核心功能，首先从分词（Tokenization）开始。分词是创建这些核心对象的第一步，它直接影响后续所有NLP任务的准确性。

分词的基本概念

分词（Tokenization）是自然语言处理（NLP）的基础任务，它将连续的文本序列分割成有意义的词汇单元（Token）。在spaCy中，分词是文本处理管道的第一步，它直接影响后续的词性标注、命名实体识别等任务的准确性。

一、分词的基本概念

分词是将文本转换为词汇单元序列的过程，这些词汇单元可以是：

单词
标点符号
数字
网址、电子邮件等特殊格式
表情符号

1. spaCy的分词器

spaCy的分词器是基于规则和统计模型的组合，它具有以下特点：

支持多种语言
处理速度快
能够识别复杂的词汇结构
支持自定义分词规则
能够处理特殊文本格式

二、spaCy分词的基本使用

1. 基本分词

import spacy

# 加载模型
nlp = spacy.load("en_core_web_sm")

# 处理文本
doc = nlp("spaCy is a powerful NLP library. It can process text in multiple languages.")

# 遍历Token
print("分词结果：")
for token in doc:
    print(f"{token.text:<15} {token.is_alpha:<10} {token.is_punct:<10} {token.is_digit:<10} {token.like_url:<10}")

2. 中文分词

# 加载中文模型
nlp_zh = spacy.load("zh_core_web_sm")

# 处理中文文本
zh_doc = nlp_zh("spaCy是一个强大的NLP库，它可以处理多种语言的文本。")

# 遍历Token
print("中文分词结果：")
for token in zh_doc:
    print(f"{token.text:<10} {token.is_alpha:<10} {token.is_punct:<10} {token.is_digit:<10}")

三、spaCy分词器的工作原理

spaCy的分词器执行以下步骤：

文本标准化：将文本转换为标准化形式，如处理大小写、特殊字符等
分词规则匹配：使用预定义的规则匹配特殊格式，如网址、电子邮件、数字等
统计模型预测：使用统计模型预测最佳分词位置
后处理：对分词结果进行后处理，如合并或拆分Token

1. 查看分词过程

# 查看分词过程
text = "spaCy is a powerful NLP library."
nlp = spacy.load("en_core_web_sm")
tokenizer = nlp.tokenizer

explanations = tokenizer.explain(text)
print("分词过程：")
for action, description in explanations:
    print(f"{action:<25} {description}")

四、自定义分词规则

在实际项目中，我们经常需要处理特殊的文本格式，这时可以自定义分词规则。

1. 使用特殊字符规则

from spacy.language import Language
from spacy.tokenizer import Tokenizer
from spacy.util import compile_infix_regex

# 加载模型
nlp = spacy.load("en_core_web_sm")

# 获取默认分词器配置
tokenizer = nlp.tokenizer

# 查看默认的中缀规则
infix_re = compile_infix_regex(nlp.Defaults.infixes)
print(f"默认中缀规则：{nlp.Defaults.infixes}")

# 添加自定义中缀规则
custom_infixes = tuple(list(nlp.Defaults.infixes) + [r'\+(?=[0-9])', r'\-(?=[0-9])'])
custom_infix_re = compile_infix_regex(custom_infixes)

# 更新分词器配置
tokenizer.infix_finditer = custom_infix_re.finditer

# 测试自定义分词规则
doc = nlp("spaCy 3.8.5 + Python 3.12 - NLP")
print("自定义分词结果：")
for token in doc:
    print(token.text)

2. 使用Matcher添加特殊规则

from spacy.matcher import Matcher

# 加载模型
nlp = spacy.load("en_core_web_sm")

# 创建Matcher对象
matcher = Matcher(nlp.vocab)

# 添加自定义模式
patterns = [
    [{'TEXT': 'spaCy'}, {'TEXT': '3.8.5'}],  # 合并"spaCy 3.8.5"为一个Token
    [{'TEXT': 'Python'}, {'TEXT': '3.12'}]   # 合并"Python 3.12"为一个Token
]
matcher.add("VERSION_PATTERNS", patterns)

# 处理文本
doc = nlp("spaCy 3.8.5 is built with Python 3.12.")

# 应用Matcher
matches = matcher(doc)
print("匹配结果：")
for match_id, start, end in matches:
    print(f"匹配到：{doc[start:end].text}，位置：{start}-{end}")

# 合并匹配到的Token
with doc.retokenize() as retokenizer:
    for match_id, start, end in matches:
        retokenizer.merge(doc[start:end])

# 查看合并后的结果
print("\n合并后的分词结果：")
for token in doc:
    print(token.text)

3. 自定义Tokenizer

# 创建自定义Tokenizer
def create_custom_tokenizer(nlp):
    """创建自定义分词器"""
    # 获取默认Tokenizer
    tokenizer = Tokenizer(nlp.vocab)
    
    # 自定义规则
    # 这里可以添加自定义的前缀、后缀和中缀规则
    
    return tokenizer

# 使用自定义Tokenizer
custom_tokenizer = create_custom_tokenizer(nlp)
custom_doc = custom_tokenizer("spaCy is a powerful NLP library.")

print("自定义Tokenizer结果：")
for token in custom_doc:
    print(token.text)

五、特殊文本格式的处理

spaCy的分词器能够处理各种特殊的文本格式，如：

1. 网址和电子邮件

# 处理网址和电子邮件
doc = nlp("Visit our website at https://spacy.io for more information. Contact us at info@spacy.io.")

print("特殊格式处理结果：")
for token in doc:
    print(f"{token.text:<25} {token.like_url:<10} {token.like_email:<10}")

2. 数字和货币

# 处理数字和货币
doc = nlp("The product costs $199.99 and weighs 2.5 kg. It has been downloaded 1,000,000 times.")

print("数字和货币处理结果：")
for token in doc:
    print(f"{token.text:<15} {token.is_digit:<10} {token.like_num:<10} {token.text.startswith('$'):<10}")

3. 表情符号

# 处理表情符号
doc = nlp("I love spaCy! 😍 It's amazing! 🚀 #NLP #spaCy")

print("表情符号处理结果：")
for token in doc:
    print(f"{token.text:<15} {token.is_alpha:<10} {token.is_punct:<10} {token.text.startswith('#'):<10}")

六、分词的性能优化

在处理大量文本时，分词的性能至关重要。以下是一些优化分词性能的方法：

1. 使用批量处理

import time

# 测试单条文本处理
texts = ["This is a sample text." for _ in range(1000)]

start_time = time.time()
docs = [nlp(text) for text in texts[:100]]  # 单条处理
end_time = time.time()
print(f"单条处理100条文本耗时：{end_time - start_time:.2f}秒")

# 测试批量处理
start_time = time.time()
docs = list(nlp.pipe(texts[:100], batch_size=20, n_process=-1))  # 批量处理
end_time = time.time()
print(f"批量处理100条文本耗时：{end_time - start_time:.2f}秒")

2. 禁用不需要的管道组件

# 禁用不需要的管道组件
nlp_light = spacy.load("en_core_web_sm", disable=["parser", "ner", "tagger"])

start_time = time.time()
docs = list(nlp_light.pipe(texts[:100], batch_size=20, n_process=-1))
end_time = time.time()
print(f"轻量级模型处理耗时：{end_time - start_time:.2f}秒")

七、实际项目中的分词应用

1. 新闻文本分词

def process_news_text(news_text, nlp):
    """处理新闻文本"""
    doc = nlp(news_text)
    
    # 提取关键词
    keywords = [token.lemma_ for token in doc if not token.is_stop and not token.is_punct and token.pos_ in ['NOUN', 'VERB', 'ADJ']]
    
    # 提取命名实体
    entities = [(ent.text, ent.label_) for ent in doc.ents]
    
    return {
        "keywords": keywords[:10],  # 只返回前10个关键词
        "entities": entities
    }

# 使用示例
news_text = "Apple Inc. announced yesterday that it will release its new iPhone model in September, with a starting price of $799. The company reported better-than-expected quarterly earnings of $1.2 billion."

result = process_news_text(news_text, nlp)
print("新闻文本处理结果：")
print(f"关键词：{result['keywords']}")
print(f"命名实体：{result['entities']}")

2. 社交媒体文本分词

def process_social_media(text, nlp):
    """处理社交媒体文本"""
    doc = nlp(text)
    
    # 提取话题标签
    hashtags = [token.text for token in doc if token.text.startswith('#')]
    
    # 提取提及的用户
    mentions = [token.text for token in doc if token.text.startswith('@')]
    
    # 提取表情符号
    emojis = [token.text for token in doc if not token.is_alpha and not token.is_punct and not token.is_digit]
    
    return {
        "hashtags": hashtags,
        "mentions": mentions,
        "emojis": emojis
    }

# 使用示例
social_text = "Just tried the new @Starbucks latte! 😍 It's absolutely amazing! #CoffeeLovers #Starbucks"

result = process_social_media(social_text, nlp)
print("社交媒体文本处理结果：")
print(f"话题标签：{result['hashtags']}")
print(f"提及用户：{result['mentions']}")
print(f"表情符号：{result['emojis']}")

八、生产环境中的分词实践

在spaCy生产环境Docker部署方案中，分词是API服务的第一步，它的性能直接影响整个服务的响应速度。

1. 优化API服务中的分词

# FastAPI应用中的分词优化
from fastapi import FastAPI, HTTPException
from pydantic import BaseModel
import spacy
import redis
import hashlib
import json

app = FastAPI()

# 加载模型（禁用不需要的组件，只保留分词器）
nlp = spacy.load("en_core_web_sm", disable=["parser", "ner", "tagger", "lemmatizer"])

# 连接Redis缓存
redis_client = redis.Redis(host="redis", port=6379, db=0, decode_responses=True)

# 数据模型
class TextRequest(BaseModel):
    text: str
    lang: str = "en"

class TokenResponse(BaseModel):
    text: str
    is_alpha: bool
    is_punct: bool
    is_digit: bool
    like_url: bool
    like_email: bool

class ProcessResponse(BaseModel):
    tokens: list[TokenResponse]
    processing_time: float
    cached: bool = False

# API端点：分词服务
@app.post("/tokenize", response_model=ProcessResponse)
async def tokenize_text(request: TextRequest):
    """分词服务端点"""
    import time
    start_time = time.time()
    
    try:
        # 生成缓存键
        cache_key = f"tokenize:{request.lang}:{hashlib.md5(request.text.encode()).hexdigest()}"
        
        # 检查缓存
        cached = redis_client.get(cache_key)
        if cached:
            response_data = json.loads(cached)
            response_data["processing_time"] = time.time() - start_time
            response_data["cached"] = True
            return response_data
        
        # 处理文本
        doc = nlp(request.text)
        
        # 构建响应
        tokens = []
        for token in doc:
            tokens.append(TokenResponse(
                text=token.text,
                is_alpha=token.is_alpha,
                is_punct=token.is_punct,
                is_digit=token.is_digit,
                like_url=token.like_url,
                like_email=token.like_email
            ))
        
        # 计算处理时间
        processing_time = time.time() - start_time
        
        # 构建响应数据
        response_data = {
            "tokens": [token.dict() for token in tokens],
            "processing_time": processing_time,
            "cached": False
        }
        
        # 缓存结果（10分钟）
        redis_client.setex(cache_key, 600, json.dumps(response_data))
        
        return response_data
        
    except Exception as e:
        raise HTTPException(status_code=500, detail=f"Internal server error: {str(e)}")

2. 分词服务的性能监控

在生产环境中，我们需要监控分词服务的性能，包括：

响应时间
缓存命中率
错误率

# 添加性能监控
from prometheus_client import Counter, Histogram, Gauge

# 定义指标
REQUEST_COUNT = Counter('tokenize_requests_total', 'Total number of tokenize requests', ['endpoint', 'method', 'status'])
REQUEST_LATENCY = Histogram('tokenize_request_duration_seconds', 'Tokenize request latency in seconds', ['endpoint'])
CACHE_HIT_RATE = Gauge('tokenize_cache_hit_rate', 'Tokenize cache hit rate')
ACTIVE_REQUESTS = Gauge('tokenize_active_requests', 'Number of active tokenize requests')

# 使用中间件监控请求
@app.middleware("http")
async def add_process_time_header(request, call_next):
    ACTIVE_REQUESTS.inc()
    
    # 记录请求开始时间
    start_time = time.time()
    
    # 处理请求
    response = await call_next(request)
    
    # 计算处理时间
    process_time = time.time() - start_time
    
    # 更新指标
    REQUEST_COUNT.labels(endpoint=request.url.path, method=request.method, status=response.status_code).inc()
    REQUEST_LATENCY.labels(endpoint=request.url.path).observe(process_time)
    ACTIVE_REQUESTS.dec()
    
    # 添加响应头
    response.headers["X-Process-Time"] = str(process_time)
    
    return response