机器翻译系统开发全记录：从理论到实践的技术探索日志

MachineTranslator (基类)
├── RuleBasedTranslator (基于规则的翻译器)
├── StatisticalTranslator (基于统计的翻译器)
└── EnsembleTranslator (集成翻译器)

class MachineTranslator:
    """
    机器翻译器基类
    """

    def __init__(self):
        """
        初始化机器翻译器
        """
        pass

    def preprocess(self, text):
        """
        文本预处理
        
        Args:
            text (str): 原始文本
            
        Returns:
            str: 预处理后的文本
        """
        # 去除多余空格
        text = re.sub(r'\s+', ' ', text.strip())
        return text

    def train(self, source_texts, target_texts):
        """
        训练机器翻译器
        
        Args:
            source_texts (list): 源语言文本列表
            target_texts (list): 目标语言文本列表
        """
        raise NotImplementedError("子类必须实现train方法")

    def translate(self, text):
        """
        翻译文本
        
        Args:
            text (str): 待翻译的文本
            
        Returns:
            str: 翻译结果
        """
        raise NotImplementedError("子类必须实现translate方法")

class RuleBasedTranslator(MachineTranslator):
    """
    基于规则的机器翻译器
    使用预定义的词典和规则进行翻译
    """

    def __init__(self):
        super().__init__()
        # 中英翻译词典
        self.translation_dict = {
            # 人称代词
            '我': 'I', '你': 'you', '他': 'he', '她': 'she', '它': 'it',
            '我们': 'we', '你们': 'you', '他们': 'they', '她们': 'they', '它们': 'they',
            
            # 动词
            '是': 'am', '是': 'is', '是': 'are', '有': 'have', '有': 'has',
            '做': 'do', '做': 'does', '做': 'did', '去': 'go', '去': 'goes', '去': 'went',
            '来': 'come', '看': 'see', '看': 'look', '说': 'say', '说': 'speak',
            '吃': 'eat', '喝': 'drink', '睡': 'sleep', '工作': 'work', '学习': 'study',
            '喜欢': 'like', '爱': 'love', '帮助': 'help', '知道': 'know', '理解': 'understand',
            '可以': 'can', '应该': 'should', '必须': 'must', '想要': 'want', '需要': 'need',
            
            # 名词
            '人': 'person', '男人': 'man', '女人': 'woman', '孩子': 'child', '学生': 'student',
            '老师': 'teacher', '医生': 'doctor', '工程师': 'engineer', '程序员': 'programmer',
            '书': 'book', '电脑': 'computer', '手机': 'phone', '汽车': 'car', '房子': 'house',
            '桌子': 'table', '椅子': 'chair', '水': 'water', '食物': 'food', '时间': 'time',
            '问题': 'question', '答案': 'answer', '语言': 'language', '英语': 'English',
            '中文': 'Chinese', '中国': 'China', '美国': 'America', '北京': 'Beijing', '上海': 'Shanghai',
            
            # 形容词
            '好': 'good', '坏': 'bad', '大': 'big', '小': 'small', '新': 'new',
            '老': 'old', '高': 'high', '低': 'low', '快': 'fast', '慢': 'slow',
            '热': 'hot', '冷': 'cold', '重要': 'important', '困难': 'difficult', '简单': 'simple',
            
            # 副词
            '很': 'very', '非常': 'very', '太': 'too', '也': 'also', '还': 'still',
            '已经': 'already', '刚刚': 'just', '现在': 'now', '今天': 'today', '明天': 'tomorrow',
            
            # 介词
            '在': 'in', '在': 'at', '在': 'on', '从': 'from', '到': 'to',
            '关于': 'about', '为了': 'for', '和': 'and', '或者': 'or', '但是': 'but',
            
            # 其他
            '的': "'s", '了': '', '吗': '?', '呢': '', '吧': '',
            '这个': 'this', '那个': 'that', '这些': 'these', '那些': 'those'
        }
        
        # 句子结构规则
        self.sentence_patterns = {
            # 主谓宾结构
            'subject_verb_object': {
                'pattern': r'(.+?)(.+?)(.+)',
                'translation': '{subject} {verb} {object}'
            }
        }

    def train(self, source_texts, target_texts):
        """
        基于规则的方法不需要训练
        """
        pass

    def _translate_word(self, word):
        """
        翻译单个词语
        
        Args:
            word (str): 待翻译的词语
            
        Returns:
            str: 翻译结果
        """
        return self.translation_dict.get(word, word)

    def _segment_text(self, text):
        """
        对中文文本进行分词
        
        Args:
            text (str): 中文文本
            
        Returns:
            list: 分词结果
        """
        return list(jieba.cut(text))

    def translate(self, text):
        """
        使用基于规则的方法进行翻译
        
        Args:
            text (str): 待翻译的中文文本
            
        Returns:
            str: 英文翻译结果
        """
        # 文本预处理
        text = self.preprocess(text)
        
        # 中文分词
        words = self._segment_text(text)
        
        # 逐词翻译
        translated_words = []
        for word in words:
            translated_word = self._translate_word(word)
            if translated_word:  # 过滤空字符串
                translated_words.append(translated_word)
        
        # 简单的词序调整（中文SVO -> 英文SVO）
        # 这里简化处理，实际需要更复杂的语法分析
        translated_text = ' '.join(translated_words)
        
        # 首字母大写
        if translated_text:
            translated_text = translated_text[0].upper() + translated_text[1:]
            
        # 添加句号（如果末尾没有标点）
        if translated_text and translated_text[-1] not in '.!?':
            translated_text += '.'
            
        return translated_text

class StatisticalTranslator(MachineTranslator):
    """
    基于统计的机器翻译器
    使用词对齐和翻译概率进行翻译
    """

    def __init__(self):
        super().__init__()
        # 翻译概率表 (source_word -> {target_word: probability})
        self.translation_probs = defaultdict(lambda: defaultdict(float))
        # 词汇表
        self.source_vocab = set()
        self.target_vocab = set()
        # 是否已训练
        self.is_trained = False

    def train(self, source_texts, target_texts):
        """
        训练统计机器翻译器
        
        Args:
            source_texts (list): 源语言文本列表
            target_texts (list): 目标语言文本列表
        """
        if len(source_texts) != len(target_texts):
            raise ValueError("源语言和目标语言文本数量不匹配")
        
        # 简化的词对齐训练
        word_alignments = defaultdict(lambda: defaultdict(int))
        source_word_counts = defaultdict(int)
        
        # 构建训练数据
        for src_text, tgt_text in zip(source_texts, target_texts):
            src_words = list(jieba.cut(src_text))
            tgt_words = tgt_text.lower().split()
            
            self.source_vocab.update(src_words)
            self.target_vocab.update(tgt_words)
            
            # 简化的词对齐：假设词按顺序对应
            max_len = max(len(src_words), len(tgt_words))
            for i in range(max_len):
                src_word = src_words[i] if i < len(src_words) else 'NULL'
                tgt_word = tgt_words[i] if i < len(tgt_words) else 'NULL'
                
                word_alignments[src_word][tgt_word] += 1
                source_word_counts[src_word] += 1
        
        # 计算翻译概率
        for src_word in word_alignments:
            for tgt_word in word_alignments[src_word]:
                count = word_alignments[src_word][tgt_word]
                total_count = source_word_counts[src_word]
                self.translation_probs[src_word][tgt_word] = count / total_count
        
        self.is_trained = True

    def _segment_text(self, text):
        """
        对中文文本进行分词
        
        Args:
            text (str): 中文文本
            
        Returns:
            list: 分词结果
        """
        return list(jieba.cut(text))

    def _translate_word(self, word):
        """
        翻译单个词语（基于统计模型）
        
        Args:
            word (str): 待翻译的词语
            
        Returns:
            str: 翻译结果
        """
        if word in self.translation_probs:
            # 选择概率最高的翻译
            translations = self.translation_probs[word]
            best_translation = max(translations, key=translations.get)
            return best_translation
        else:
            # 如果没有找到翻译，返回原词
            return word

    def translate(self, text):
        """
        使用统计方法进行翻译
        
        Args:
            text (str): 待翻译的中文文本
            
        Returns:
            str: 英文翻译结果
        """
        if not self.is_trained:
            raise Exception("模型尚未训练，请先调用train方法")
        
        # 文本预处理
        text = self.preprocess(text)
        
        # 中文分词
        words = self._segment_text(text)
        
        # 逐词翻译
        translated_words = []
        for word in words:
            translated_word = self._translate_word(word)
            if translated_word and translated_word != 'NULL':  # 过滤空字符串和NULL
                translated_words.append(translated_word)
        
        # 生成翻译结果
        translated_text = ' '.join(translated_words)
        
        # 首字母大写
        if translated_text:
            translated_text = translated_text[0].upper() + translated_text[1:]
            
        # 添加句号（如果末尾没有标点）
        if translated_text and translated_text[-1] not in '.!?':
            translated_text += '.'
            
        return translated_text

class EnsembleTranslator(MachineTranslator):
    """
    集成机器翻译器
    结合基于规则和统计的方法进行翻译
    """

    def __init__(self):
        super().__init__()
        self.rule_based_translator = RuleBasedTranslator()
        self.statistical_translator = StatisticalTranslator()

    def train(self, source_texts, target_texts):
        """
        训练集成翻译器
        
        Args:
            source_texts (list): 源语言文本列表
            target_texts (list): 目标语言文本列表
        """
        # 训练统计翻译器
        self.statistical_translator.train(source_texts, target_texts)
        self.is_trained = True

    def translate(self, text):
        """
        使用集成方法进行翻译
        
        Args:
            text (str): 待翻译的中文文本
            
        Returns:
            str: 英文翻译结果
        """
        # 文本预处理
        text = self.preprocess(text)
        
        # 使用基于规则的方法翻译
        rule_translation = self.rule_based_translator.translate(text)
        
        # 如果统计模型已训练，也使用统计方法翻译
        if self.statistical_translator.is_trained:
            stat_translation = self.statistical_translator.translate(text)
            # 简单集成：优先使用统计翻译，如果为空则使用规则翻译
            if stat_translation.strip() and stat_translation != '.':
                return stat_translation
        
        return rule_translation

def _segment_text(self, text):
    """
    对中文文本进行分词
    """
    return list(jieba.cut(text))

# 简化的词对齐：假设词按顺序对应
max_len = max(len(src_words), len(tgt_words))
for i in range(max_len):
    src_word = src_words[i] if i < len(src_words) else 'NULL'
    tgt_word = tgt_words[i] if i < len(tgt_words) else 'NULL'
    
    word_alignments[src_word][tgt_word] += 1
    source_word_counts[src_word] += 1

# 简单集成：优先使用统计翻译，如果为空则使用规则翻译
if stat_translation.strip() and stat_translation != '.':
    return stat_translation