在Python中迭代4个函数的不同排列

Question

好的，我正在使用不同的标签来标记文本。默认、单字、双字和三字。

我得检查一下这四个标记器中哪三个的组合最准确。

要做到这一点，我必须遍历所有可能的组合，如下所示：

permutaties = list(itertools.permutations(['default_tagger','unigram_tagger',
                                              'bigram_tagger','trigram_tagger'],3))
resultaten = [] 
for element in permutaties:
        resultaten.append(accuracy(element))

因此，每个元素都是三个标记方法的元组，例如：('default_tagger', 'bigram_tagger', 'trigram_tagger')

在准确性函数中，我现在必须动态调用每个标记器的三个附带方法，问题是:我不知道如何做到这一点。

标记器函数如下：

unigram_tagger = nltk.UnigramTagger(brown_train, backoff=backofff)

bigram_tagger = nltk.BigramTagger(brown_train, backoff=backofff)

trigram_tagger = nltk.TrigramTagger(brown_train, backoff=backofff)

default_tagger = nltk.DefaultTagger('NN')

因此，对于这个示例，代码应该是：

t0 = nltk.DefaultTagger('NN')
t1 = nltk.BigramTagger(brown_train, backoff=t0)
t2 = nltk.TrigramTagger(brown_train, backoff=t1)
t2.evaluate(brown_test)

因此，本质上，问题是如何迭代4个函数列表的所有24个组合。

有没有能帮到我的Python大师？

Answer 1

如果我知道你需要什么，那就不是舒尔，但是你可以使用你想调用的方法而不是字符串-所以你的代码可能会变得像这样：

permutaties = itertools.permutations([nltk.UnigramTagger, nltk.BigramTagger, nltk.TrigramTagger, nltk.DefaultTagger],3)
resultaten = [] 
for element in permutaties:
     resultaten.append(accuracy(element, brown_Train, brown_element))

def accuracy(element, brown_train,brown_element):
     if element is nltk.DeafultTagger:
        evaluator = element("NN")
     else:
        evaluator = element(brown_train, backoff=XXX)  #maybe insert more elif
                    #clauses to retrieve the proper backoff parameter --or you could
                    # usr a tuple in the call to permutations so the apropriate backoff 
                    #is avaliable for each function to be called
     return  evaluator.evaluate(brown_test) # ? I am not shure  from your code if this is your intent

Answer 2

从jsbueno的代码开始，我建议为每个标记器编写一个包装器函数，以便为它们提供相同的签名。因为你只需要它们一次，所以我建议使用lambda。

permutaties = itertools.permutations([lambda: ntlk.DefaultTagger("NN"),
                                      lambda: nltk.UnigramTagger(brown_train, backoff),
                                      lambda: nltk.BigramTagger(brown_train, backoff),
                                      lambda: nltk.TrigramTagger(brown_train, backoff)],3)

这将允许您直接调用每个函数，而不需要特定的函数来确定您调用的是哪个函数并使用适当的签名。

Answer 3

基于jsbueno代码，我认为您希望重用evaluator作为backoff参数，因此代码应该是

permutaties = itertools.permutations([nltk.UnigramTagger, nltk.BigramTagger, nltk.TrigramTagger, nltk.DefaultTagger],3)
resultaten = [] 
for element in permutaties:
     resultaten.append(accuracy(element, brown_Train, brown_element))

def accuracy(element, brown_train,brown_element):
     evaluator = "NN"
     for e in element:
         if evaluator == "NN":
              evaluator = e("NN")
         else:

              evaluator = e(brown_train, backoff=evaluator)  #maybe insert more elif
                    #clauses to retrieve the proper backoff parameter --or you could
                    # usr a tuple in the call to permutations so the apropriate backoff 
                    #is avaliable for each function to be called

     return  evaluator.evaluate(brown_test) # ? I am not shure  from your code if this is your intent