智慧平台的句读和自动标点准确率奇高，他们的模型确实有水平，但目测也是用的deepseek自己部署的。

其实，现在的人工智能也能标点，准确率高达90%

@岭南散人 #202354

如果是每次都几万字呢，试过几个，感觉都不是太好用。上传txt上去，处理后都不知道在哪里下载，这类通用平台总感觉虚飘飘的。所以：

【有请编程大佬入坑】

@摩诃 #202390

古籍酷目前不用登录可用，支持一次五万字的标点，这个技术上没问题的，标点基本不用怎么改。就经常是需要等待几十万秒的提示。

Ai时代了，这个问题应该会很快解决，不会编程确是有赶不上躺的感觉。

拭目以待。

如何实现古籍文本智能校勘？ https://mp.weixin.qq.com/s/AL6-aJas_XVuQmOuJxxtUQ
软件完整配置：https://github.com/anon-research-tools/classical-text-collation

第一批用AI「偷懒」的人，抢救了13亿字古籍
mp.weixin.qq.com/s/kbW...oikOW2JUAA

import re

import torch

import numpy as np

from collections import defaultdict

from typing import List, Tuple, Dict, Optional

import logging

from dataclasses import dataclass

import json

 

# 如果使用大模型API

try:

import openai

from openai import OpenAI

OPENAI_AVAILABLE = True

except ImportError:

OPENAI_AVAILABLE = False

 

# 如果使用本地模型

try:

from transformers import AutoTokenizer, AutoModelForTokenClassification

TRANSFORMERS_AVAILABLE = True

except ImportError:

TRANSFORMERS_AVAILABLE = False

 

@dataclass

class SegmentationResult:

"""断句结果数据结构"""

text: str

sentences: List[str]

confidence: float

method_used: str

metadata: Dict

 

class ClassicalChineseSegmenter:

"""混合方案古文断句器"""

 

def __init__(self, config_path: str = None):

# 配置

self.config = self._load_config(config_path)

 

# 初始化日志

self.logger = self._setup_logger()

 

# 初始化各模块

self.rules_engine = RuleBasedSegmenter()

self.statistical_model = StatisticalSegmenter()

self.deep_learning_model = None

self.llm_model = None

 

# 初始化深度学习模型（如果可用）

if self.config.get("use_dl_model", True) and TRANSFORMERS_AVAILABLE:

self._init_deep_learning_model()

 

# 初始化大模型（如果配置了API）

if self.config.get("use_llm_fallback", False) and OPENAI_AVAILABLE:

self._init_llm_model()

 

# 权重设置

self.weights = {

"rules": self.config.get("rule_weight", 0.2),

"statistical": self.config.get("statistical_weight", 0.3),

"deep_learning": self.config.get("dl_weight", 0.5)

}

 

# 缓存机制

self.cache = {}

self.cache_size = self.config.get("cache_size", 1000)

 

self.logger.info("古文断句器初始化完成")

 

def _load_config(self, config_path: str) -> Dict:

"""加载配置文件"""

default_config = {

"use_dl_model": True,

"use_llm_fallback": False,

"llm_model": "gpt-4",

"dl_model_path": "ethanyt/guwen-punctuate",

"rule_weight": 0.2,

"statistical_weight": 0.3,

"dl_weight": 0.5,

"confidence_threshold": 0.8,

"cache_size": 1000,

"log_level": "INFO"

}

 

if config_path:

try:

with open(config_path, 'r', encoding='utf-8') as f:

user_config = json.load(f)

default_config.update(user_config)

except:

pass

 

return default_config

 

def _setup_logger(self):

"""设置日志"""

logger = logging.getLogger("ClassicalChineseSegmenter")

logger.setLevel(getattr(logging, self.config.get("log_level", "INFO")))

 

if not logger.handlers:

handler = logging.StreamHandler()

formatter = logging.Formatter(

'%(asctime)s - %(name)s - %(levelname)s - %(message)s'

)

handler.setFormatter(formatter)

logger.addHandler(handler)

 

return logger

 

def _init_deep_learning_model(self):

"""初始化深度学习模型"""

try:

self.logger.info("正在加载深度学习模型...")

self.deep_learning_model = DeepLearningSegmenter(

model_path=self.config["dl_model_path"]

)

self.logger.info("深度学习模型加载完成")

except Exception as e:

self.logger.warning(f"深度学习模型加载失败: {e}")

self.deep_learning_model = None

 

def _init_llm_model(self):

"""初始化大语言模型"""

try:

api_key = self.config.get("openai_api_key")

if api_key:

self.llm_model = LLMSegmenter(

api_key=api_key,

model=self.config.get("llm_model", "gpt-4")

)

self.logger.info("大语言模型初始化完成")

except Exception as e:

self.logger.warning(f"大语言模型初始化失败: {e}")

 

def segment(self, text: str, use_cache: bool = True) -> SegmentationResult:

"""

主断句函数

 

Args:

text: 输入文本

use_cache: 是否使用缓存

 

Returns:

SegmentationResult: 断句结果

"""

# 1. 检查缓存

cache_key = hash(text)

if use_cache and cache_key in self.cache:

self.logger.debug("使用缓存结果")

return self.cache[cache_key]

 

# 2. 清理文本

cleaned_text = self._preprocess_text(text)

 

# 3. 多方法并行处理

results = []

confidences = []

 

# 规则方法

rule_result = self.rules_engine.segment(cleaned_text)

rule_confidence = self.rules_engine.calculate_confidence(cleaned_text)

results.append(rule_result)

confidences.append(rule_confidence)

self.logger.debug(f"规则方法置信度: {rule_confidence:.3f}")

 

# 统计方法

stat_result = self.statistical_model.segment(cleaned_text)

stat_confidence = self.statistical_model.calculate_confidence(cleaned_text)

results.append(stat_result)

confidences.append(stat_confidence)

self.logger.debug(f"统计方法置信度: {stat_confidence:.3f}")

 

# 深度学习方法

dl_result = None

dl_confidence = 0.0

if self.deep_learning_model:

try:

dl_result = self.deep_learning_model.segment(cleaned_text)

dl_confidence = self.deep_learning_model.calculate_confidence(cleaned_text)

results.append(dl_result)

confidences.append(dl_confidence)

self.logger.debug(f"深度学习置信度: {dl_confidence:.3f}")

except Exception as e:

self.logger.error(f"深度学习方法出错: {e}")

 

# 4. 加权投票

final_result, final_confidence, method_used = self._weighted_vote(

results, confidences

)

 

# 5. 后处理

final_result = self._postprocess(final_result)

 

# 6. 如果置信度低，使用大模型作为后备

if (final_confidence < self.config["confidence_threshold"] and

self.llm_model and len(text) < 2000): # 限制文本长度

self.logger.info("置信度过低，使用大模型作为后备")

try:

llm_result = self.llm_model.segment(cleaned_text)

final_result = llm_result

final_confidence = 0.95 # 大模型通常有高置信度

method_used = "llm_fallback"

except Exception as e:

self.logger.error(f"大模型后备方案失败: {e}")

 

# 7. 分割句子

sentences = self._split_into_sentences(final_result)

 

# 8. 构建结果

result = SegmentationResult(

text=final_result,

sentences=sentences,

confidence=final_confidence,

method_used=method_used,

metadata={

"rule_confidence": rule_confidence,

"stat_confidence": stat_confidence,

"dl_confidence": dl_confidence if self.deep_learning_model else None,

"original_length": len(text),

"processed_length": len(cleaned_text)

}

)

 

# 9. 更新缓存

if use_cache:

self._update_cache(cache_key, result)

 

return result

 

def _weighted_vote(self, results: List[str], confidences: List[float]) -> Tuple[str, float, str]:

"""加权投票决策"""

# 如果只有一个结果

if len(results) == 1:

return results[0], confidences[0], "rules_only"

 

# 计算每个位置的标点概率

max_len = max(len(r) for r in results)

punctuation_votes = defaultdict(lambda: defaultdict(float))

 

for result, confidence, method in zip(results, confidences, ["rules", "statistical", "deep_learning"]):

weight = self.weights.get(method, 0.0)

if weight == 0:

continue

 

for i, char in enumerate(result):

if i >= max_len:

break

if char in "。，；：！？、":

punctuation_votes[i][char] += weight * confidence

 

# 构建最终结果（以第一个结果为字符基础）

base_result = results[0]

final_chars = list(base_result.ljust(max_len, ' '))

 

for i in range(max_len):

if i < len(base_result) and base_result[i] in "。，；：！？、":

continue # 已经有标点

 

if i in punctuation_votes:

votes = punctuation_votes[i]

if votes:

best_punct = max(votes.items(), key=lambda x: x[1])[0]

final_chars[i] = best_punct

 

final_result = ''.join(final_chars).strip()

 

# 计算平均置信度

valid_confidences = [c for c in confidences if c > 0]

avg_confidence = sum(valid_confidences) / len(valid_confidences) if valid_confidences else 0.0

 

# 确定使用的方法

if len(results) == 3 and confidences[2] > 0.7: # 深度学习置信度高

method_used = "deep_learning_primary"

elif confidences[1] > 0.8: # 统计方法置信度高

method_used = "statistical_primary"

else:

method_used = "weighted_vote"

 

return final_result, avg_confidence, method_used

 

def _preprocess_text(self, text: str) -> str:

"""文本预处理"""

# 移除多余空格和换行

text = re.sub(r'\s+', '', text)

 

# 移除现代标点（如果有）

text = re.sub(r'[.,;:!?]', '', text)

 

return text

 

def _postprocess(self, text: str) -> str:

"""后处理"""

# 修正常见错误

corrections = [

(r'，。', '。'),

(r'。。+', '。'),

(r'，，+', '，'),

(r'^，', ''), # 开头不能是逗号

(r'。$', ''), # 结尾的句号可能不需要

(r'([。！？])，', r'\1'), # 句末标点后不能跟逗号

]

 

for pattern, replacement in corrections:

text = re.sub(pattern, replacement, text)

 

# 确保标点平衡

opening = len(re.findall(r'[「『《（〔【]', text))

closing = len(re.findall(r'[」』》）〕】]', text))

 

if opening > closing:

text += '」' * (opening - closing)

 

return text

 

def _split_into_sentences(self, text: str) -> List[str]:

"""将文本分割成句子"""

# 按句末标点分割

sentences = re.split(r'([。！？])', text)

 

# 重新组合

result = []

i = 0

while i < len(sentences):

if i + 1 < len(sentences) and sentences[i+1] in '。！？':

sentence = sentences[i] + sentences[i+1]

if sentence.strip():

result.append(sentence.strip())

i += 2

else:

if sentences[i].strip():

result.append(sentences[i].strip())

i += 1

 

return result

 

def _update_cache(self, key: int, result: SegmentationResult):

"""更新缓存"""

if len(self.cache) >= self.cache_size:

# 移除最旧的缓存项

oldest_key = next(iter(self.cache))

del self.cache[oldest_key]

 

self.cache[key] = result

 

def batch_segment(self, texts: List[str], batch_size: int = 10) -> List[SegmentationResult]:

"""批量处理"""

results = []

for i in range(0, len(texts), batch_size):

batch = texts[i:i+batch_size]

batch_results = [self.segment(text, use_cache=True) for text in batch]

results.extend(batch_results)

 

self.logger.info(f"已处理 {min(i+batch_size, len(texts))}/{len(texts)} 个文本")

 

return results

 

# ============ 子模块实现 ============

 

class RuleBasedSegmenter:

"""基于规则的断句器"""

 

def __init__(self):

# 加载规则

self.rules = self._load_rules()

 

# 常见虚词

self.sentence_end_particles = {

'也', '矣', '乎', '哉', '焉', '耳', '耶', '欤', '兮',

'而已', '而已矣', '者也', '者矣', '者也矣'

}

 

self.sentence_start_particles = {

'夫', '盖', '惟', '唯', '然', '而', '故', '是以', '是故',

'若', '苟', '使', '令', '纵', '虽', '即', '则', '且',

'乃', '遂', '于是', '然后', '至于', '若夫'

}

 

# 四字成语/常见搭配（通常不断开）

self.fixed_expressions = {

'天衣无缝', '画蛇添足', '守株待兔', '刻舟求剑',

'卧薪尝胆', '破釜沉舟', '高山流水', '知足常乐'

}

 

def _load_rules(self) -> List[Dict]:

"""加载断句规则"""

return [

# 规则1：常见句末虚词后加句号

{

'pattern': r'([^。，；：！？])({})(?![。，；：！？])'.format(

'|'.join(self.sentence_end_particles)

),

'replacement': r'\1\2。',

'weight': 0.8

},

# 规则2：常见句首虚词前加分句

{

'pattern': r'([。！？])({})'.format(

'|'.join(self.sentence_start_particles)

),

'replacement': r'\1\n\2',

'weight': 0.7

},

# 规则3：引用标记

{

'pattern': r'([「『《])([^」』》]+)([」』》])',

'replacement': r'\1\2\3，',

'weight': 0.6

}

]

 

def segment(self, text: str) -> str:

"""应用规则进行断句"""

result = text

 

for rule in self.rules:

pattern = rule['pattern']

replacement = rule['replacement']

 

# 应用规则

result = re.sub(pattern, replacement, result)

 

# 添加基础逗号（按固定长度）

result = self._add_basic_punctuation(result)

 

return result

 

def _add_basic_punctuation(self, text: str) -> str:

"""添加基础标点（按长度）"""

chars = list(text)

result = []

 

for i, char in enumerate(chars):

result.append(char)

 

# 每8-15个字符加逗号，除非在固定表达式中

if i > 0 and (i + 1) % 12 == 0:

# 检查前后字符是否组成固定表达式

context = ''.join(chars[max(0, i-3):min(len(chars), i+4)])

should_break = True

 

for expr in self.fixed_expressions:

if expr in context:

should_break = False

break

 

if should_break and char not in '。，；：！？、':

result.append('，')

 

return ''.join(result)

 

def calculate_confidence(self, text: str) -> float:

"""计算规则方法的置信度"""

# 基于规则匹配程度计算置信度

matches = 0

total_patterns = len(self.rules) * 2 # 考虑正向和反向规则

 

for rule in self.rules:

pattern = rule['pattern']

if re.search(pattern, text):

matches += 1

 

confidence = matches / total_patterns if total_patterns > 0 else 0.5

 

# 考虑文本长度：短文本置信度较低

length_factor = min(len(text) / 50, 1.0) # 50字以上置信度不再增加

 

return confidence * 0.5 + length_factor * 0.5

 

class StatisticalSegmenter:

"""基于统计的断句器（N-gram模型）"""

 

def __init__(self, ngram_path: str = None):

self.n = 3 # 使用trigram

self.ngram_probs = defaultdict(float)

self.punctuation_probs = defaultdict(float)

 

# 加载预训练的统计模型

if ngram_path and os.path.exists(ngram_path):

self.load_model(ngram_path)

else:

# 使用内置的简单统计

self._init_default_stats()

 

def _init_default_stats(self):

"""初始化默认统计信息"""

# 基于常见古文的统计

self.punctuation_probs = {

'。': 0.15, # 句号概率

'，': 0.25, # 逗号概率

'；': 0.05, # 分号概率

'：': 0.03, # 冒号概率

'！': 0.02, # 感叹号概率

'？': 0.02, # 问号概率

}

 

def segment(self, text: str) -> str:

"""使用统计方法断句"""

if len(text) < 10:

return text # 太短的文本不处理

 

chars = list(text)

result = []

 

for i in range(len(chars)):

result.append(chars[i])

 

# 计算当前位置加标点的概率

if i > 0 and i < len(chars) - 1:

context = ''.join(chars[max(0, i-2):i+1])

punct_prob = self._get_punctuation_probability(context, i, chars)

 

# 根据概率决定是否加标点

if punct_prob > 0.7: # 高概率加句号

result.append('。')

elif punct_prob > 0.5: # 中等概率加逗号

result.append('，')

 

return ''.join(result)

 

def _get_punctuation_probability(self, context: str, position: int, chars: List[str]) -> float:

"""获取当前位置加标点的概率"""

# 基于上下文的简单概率计算

base_prob = 0.0

 

# 检查上下文特征

if position > 0:

prev_char = chars[position-1]

 

# 句末虚词

if prev_char in '也矣乎哉焉耳':

base_prob += 0.3

 

# 四字结构后

if position % 4 == 0 and position >= 4:

base_prob += 0.2

 

# 常见结尾模式

endings = ['而已', '者也', '之谓']

for ending in endings:

if position >= len(ending) and ''.join(chars[position-len(ending):position]) == ending:

base_prob += 0.4

 

return min(base_prob, 1.0)

 

def calculate_confidence(self, text: str) -> float:

"""计算统计方法的置信度"""

# 基于文本长度和特征丰富度

length = len(text)

 

if length < 20:

return 0.4 # 短文本置信度低

elif length < 100:

return 0.6

else:

return 0.7

 

class DeepLearningSegmenter:

"""基于深度学习的断句器"""

 

def __init__(self, model_path: str = "ethanyt/guwen-punctuate"):

self.model_path = model_path

self.tokenizer = None

self.model = None

self.device = None

 

self._load_model()

 

def _load_model(self):

"""加载模型"""

if not TRANSFORMERS_AVAILABLE:

raise ImportError("transformers库未安装")

 

self.device = torch.device("cuda" if torch.cuda.is_available() else "cpu")

 

self.tokenizer = AutoTokenizer.from_pretrained(self.model_path)

self.model = AutoModelForTokenClassification.from_pretrained(self.model_path)

self.model.to(self.device)

self.model.eval()

 

def segment(self, text: str) -> str:

"""使用深度学习模型断句"""

# 将文本转换为字符序列

chars = list(text.replace(' ', ''))

 

# 编码

inputs = self.tokenizer(

chars,

is_split_into_words=True,

return_tensors="pt",

padding=True,

truncation=True

)

 

inputs = {k: v.to(self.device) for k, v in inputs.items()}

 

# 预测

with torch.no_grad():

outputs = self.model(**inputs)

predictions = torch.argmax(outputs.logits, dim=-1)[0].cpu().numpy()

 

# 映射标签到标点

label_map = {

0: '', # 无标点

1: '，', # 逗号

2: '。', # 句号

3: '？', # 问号

4: '！', # 感叹号

}

 

# 构建结果

result = []

for char, pred in zip(chars, predictions[:len(chars)]):

result.append(char)

if pred in label_map and label_map[pred]:

result.append(label_map[pred])

 

return ''.join(result)

 

def calculate_confidence(self, text: str) -> float:

"""计算深度学习模型的置信度"""

# 使用模型输出的概率分布计算置信度

chars = list(text.replace(' ', ''))

 

inputs = self.tokenizer(

chars,

is_split_into_words=True,

return_tensors="pt",

padding=True

)

 

inputs = {k: v.to(self.device) for k, v in inputs.items()}

 

with torch.no_grad():

outputs = self.model(**inputs)

probabilities = torch.softmax(outputs.logits, dim=-1)[0]

 

# 计算平均最大概率

max_probs, _ = torch.max(probabilities, dim=-1)

avg_max_prob = torch.mean(max_probs[:len(chars)]).item()

 

return float(avg_max_prob)

 

class LLMSegmenter:

"""基于大语言模型的断句器"""

 

def __init__(self, api_key: str, model: str = "gpt-4"):

if not OPENAI_AVAILABLE:

raise ImportError("openai库未安装")

 

self.client = OpenAI(api_key=api_key)

self.model = model

 

# 系统提示词

self.system_prompt = """你是一位精通古代汉语的专家，请为古文添加正确的标点符号。

 

要求：

1. 严格按照古文语法和意义断句

2. 使用正确的古汉语标点：句号(。)、逗号(，)、分号(；)、冒号(：)、感叹号(！)、问号(？)

3. 保持原文内容不变，只添加标点

4. 对专有名词、典故要特别注意

5. 注意对仗、排比等修辞结构

 

请直接返回添加标点后的完整文本，不要添加任何解释。"""

 

def segment(self, text: str) -> str:

"""使用大模型断句"""

response = self.client.chat.completions.create(

model=self.model,

messages=[

{"role": "system", "content": self.system_prompt},

{"role": "user", "content": f"请为以下古文添加标点：\n\n{text}"}

],

temperature=0.1, # 低温度确保稳定性

max_tokens=len(text) * 2,

)

 

return response.choices[0].message.content.strip()

 

# ============ 使用示例 ============

 

def main():

"""使用示例"""

import os

 

# 1. 创建配置

config = {

"use_dl_model": True,

"use_llm_fallback": False, # 设置为True并添加API key以启用

"openai_api_key": os.getenv("OPENAI_API_KEY", ""),

"rule_weight": 0.2,

"statistical_weight": 0.3,

"dl_weight": 0.5,

"confidence_threshold": 0.75,

"log_level": "INFO"

}

 

# 保存配置

with open("segmenter_config.json", "w", encoding="utf-8") as f:

json.dump(config, f, ensure_ascii=False, indent=2)

 

# 2. 初始化断句器

segmenter = ClassicalChineseSegmenter("segmenter_config.json")

 

# 3. 测试文本

test_texts = [

# 《道德经》节选

"道可道非常道名可名非常名无名天地之始有名万物之母",

 

# 《庄子》节选

"北冥有鱼其名为鲲鲲之大不知其几千里也化而为鸟其名为鹏鹏之背不知其几千里也",

 

# 《论语》节选

"学而时习之不亦说乎有朋自远方来不亦乐乎人不知而不愠不亦君子乎",

 

# 复杂文本

"夫天地者万物之逆旅也光阴者百代之过客也而浮生若梦为欢几何古人秉烛夜游良有以也",

]

 

# 4. 批量处理

print("=" * 60)

print("古文自动断句系统")

print("=" * 60)

 

for i, text in enumerate(test_texts, 1):

print(f"\n测试文本 {i}:")

print(f"原文: {text}")

 

result = segmenter.segment(text)

 

print(f"断句: {result.text}")

print(f"置信度: {result.confidence:.2%}")

print(f"使用的方法: {result.method_used}")

 

print("\n分割后的句子:")

for j, sentence in enumerate(result.sentences, 1):

print(f" {j:2d}. {sentence}")

 

# 5. 批量处理示例

print("\n" + "=" * 60)

print("批量处理示例")

print("=" * 60)

 

batch_results = segmenter.batch_segment(test_texts)

for i, result in enumerate(batch_results, 1):

print(f"\n文本{i}: {result.text[:50]}...")

print(f" 句子数: {len(result.sentences)}, 置信度: {result.confidence:.2%}")

 

if __name__ == "__main__":

# 安装依赖: pip install torch transformers openai

main()

核心架构：

混合策略系统：规则方法 + 统计模型 + 深度学习 + 大模型后备

工作流程

1. 并行处理：三种方法同时运行

2. 加权投票：各方法按权重和置信度投票

3. 智能降级：置信度低时调用大模型

4. 后处理优化：修正常见标点错误

四大模块

· 规则引擎：基于古文虚词和语法规则

· 统计模型：N-gram概率判断断句位置

· 深度学习：BERT预训练模型（ethanyt/guwen-punctuate）

· 大模型：GPT-4等作为高成本后备

关键特性

✅ 可配置：支持JSON配置，权重可调

✅ 缓存机制：提升重复文本处理速度

✅ 批量处理：支持大批量古文处理

✅ 置信度评估：量化断句可靠性

✅ 自动降级：低置信度时启用后备方案

适用场景

· 古籍数字化批量处理

· 古文学习工具开发

· 文献研究预处理

· 出版校对辅助工具

本质：一个生产级的混合智能系统，在准确率、速度和成本间取得平衡。

哇 ，感谢大佬出手， 晚上研究一下怎么部署运行 ，有问题再反馈。感谢感谢。

感谢各位对这个话题的关注和耐心回复，使这个帖子不至于沉没过快。

对各个网站的不满主要是我发的。能用是能用，但用起来就是不爽快。我的诉求是能用量大。不一定非常“漂亮”，这也不敢奢望。商业网站有商业网站的逻辑。

相信论坛是有热心人的。从单纯书籍（很多人），下载工具（bookget），光学识别网站（看典），字体制作软件（赤霄），排版软件等，免费且已经很完善了。就觉得古籍数字化还缺失一个好用的标点工具或更贪心一下多文本对校工具。识别➕标点是实现古籍数字化的最重要环节。

相信ai时代，这些都会很快实现。