nlp - 从英语单词中消除字母重复的正确方法？

Question

正如标题清楚地描述的那样，我想知道什么是消除社交媒体中常用来夸大感觉的英语中的字符重复的正确方法。由于我正在开发一个软件解决方案来纠正错误输入的单词，因此我需要一个可以应用于大多数英语单词的全局算法。所以，我要求专家学习正确的方法来消除英语单词中的额外字母，而不使用基于学习的方法？

附: (1) 我使用 WordNet 3.0 database 以编程方式检查单词是否有效.到目前为止一切都很好，除了一些例子，比如单词 veery定义为 tawny brown North American trush noted for its song在 WordNet 3.0 中。当在 WordNet 中找到单词时，我会中断字母消除过程。那么有没有其他的知识库可以代替WordNet呢？

附: (2) 其实我在English Language & Usage community问了这个问题.但他们引导我在这里问。

一些例子:

haappyy --> happy
amaaazzinng --> amazing
veeerry --> very

正如您在示例中看到的，字母重复的位置因单词而异。

Answer 1

使用 reduplicated letters 映射非规范形式的一个主要问题其规范形式是它在没有上下文的情况下是模棱两可的:考虑例如见面——是真的见面了还是见面了？

解决这个问题的一种方法可能是在 n-gram 模型中，根据给定上下文(即它前面的词)的概率来衡量一个词的“规范性”:被判断为相关词的“别名”的词(如下所述)和最常见的考虑到手头的上下文被视为“规范”形式:

正常化

可以将诸如 veeerry 和 very 之类的形式视为相同形式的变体，即经过修改的“有序字符包”，例如两者都被处理为 ('v','e','r','y') 的序列尽管权重不同:

维埃里:(('v', 1), ('e', 3), ('r', 2), ('y', 1))

非常:(('v', 1), ('e', 1), ('r', 1), ('y', 1))

通过这种方式，可以像处理普通特征向量一样处理这些形式——这将用于在下面对它们的概率进行加权。

别名

我们需要能够映射例如veeerry 到非常没有，正如您所描述的，匹配不常见的词 veery .因此，简单地将 veeerry 表示为没有任何权重的“有序字符包”将意味着 veeerry 可能是 veery 的变体。 ——这显然不是。但是，由于 veery很可能有一个非常不同的 lexical distribution与副词相比，很可能会得到归一化 ('v','e','r','y') 的感觉。基于给定上下文的概率 - 例如:

这辆车非常大。

#这辆车是veery。 (“这辆车是一只黄褐色的北美画眉，以其歌曲而闻名”)

即使不考虑语法 part-of-speech这两个例子的区别(第一个是副词，第二个是名词)，这两个不同词的原始统计分布非常不同。出于这个原因，给定一个好的模型， P(veery_1 | "This car is") > P(veery_2 | "This car is a") .

概率加权

为了关联例如veeerry 到非常，以便在文本中找到时对其进行规范化，同时仍保留 veery从归一化到非常，然后我们可以简单地使用表示 veeerry 的有序字符包的特征向量来计算它与非常和 veery 的距离。然后使用该距离来加权给定上下文中每个的概率:

best_term(form, context) = argmax(arg=term, (P(term, context) * sim(ordered_bag_of_chars(form), ordered_bag_of_chars(term)))

为了更好地解释这在现实生活中是如何工作的，我编写了一些 Python 代码:

#!/usr/bin/env python3

from scipy.spatial.distance import cosine

class Vocabulary(object):
    def __init__(self, forms):
        self.forms = forms
        self.form_variations = {}   
        for form in forms:
            unique_symbol_freqs = tuple(count_unique_symbol_freqs(form))
            unique_symbols = tuple(unique_symbol_freq[0] for unique_symbol_freq in unique_symbol_freqs)
            self.form_variations[unique_symbols] = WeightedSymbolSequence(unique_symbol_freqs)

class WeightedSymbolSequence(object):
    def __init__(self, unique_symbols):
        # TODO: Finish implementation
        pass

def count_unique_symbol_freqs(input_seq):
    if len(input_seq) > 0:
        # First process the head symbol
        previous_unique_symbol = (input_seq[0], 1)
        # Process tail symbols; Add extra iteration at the end in order to handle trailing single unique symbols
        tail_iter = iter(input_seq[1:])
        try:
            while True:
                input_symbol = next(tail_iter)
                if input_symbol == previous_unique_symbol[0]:
                    previous_unique_symbol = (previous_unique_symbol[0], previous_unique_symbol[1] + 1)
                else:
                    result_unique_symbol = previous_unique_symbol
                    previous_unique_symbol =  (input_symbol, 1)
                    yield result_unique_symbol
        except StopIteration:
            # The end of the sequence was encountered; Handle a potential last unique symbol
            yield previous_unique_symbol

if __name__ == '__main__':
    from sys import stderr

    tests = {"haappyy" : "happy", "amaaazzinng" : "amazing", "veeerry" : "very"}

    with open("/usr/share/dict/words", "r") as vocab_instream:
        # TODO: Alias uppercase versions of characters to their lowercase ones so that e.g. "dog" and "Dog" are highly similar but not identical
        vocab = Vocabulary(frozenset(line.strip().lower() for line in vocab_instream))

    for form1, form2 in tests.items():
        # First check if the token is an extant word 
        if form1 in vocab.forms:
            print("\"%s\" found in vocabulary list; No need to look for similar words." % form1)
        else:
            form1_unique_char_freqs = tuple(count_unique_symbol_freqs(form1))
            print(form1_unique_char_freqs)
            form2_unique_char_freqs = tuple(count_unique_symbol_freqs(form2))
            dist = cosine([form1_unique_char_freq[1] for form1_unique_char_freq in form1_unique_char_freqs], [form2_unique_char_freq[1] for form2_unique_char_freq in form2_unique_char_freqs])
            # TODO: Get probabilities of form variations using WeightedSymbolSequence objects in "vocab.form_variations" and then multiply the probability of each by the cosine similarity of bag of characters for form1 and form2

            try:
                # Get mapping to other variants, e.g. "haappyy" -> "happy"
                form1_unique_chars = tuple(form1_unique_char_freq[0] for form1_unique_char_freq in form1_unique_char_freqs)
                variations = vocab.form_variations[form1_unique_chars]
            except KeyError:
                # TODO: Use e.g. Levenshtein distance in order to find the next-most similar word: No other variations were found
                print("No variations of \"%s\" found." % form1, file=stderr)