Nltk: NgramModel बैकऑफ़ स्मूथिंग कैलकुलेशन में त्रुटि?

मुझे विश्वास है कि आप सही हैं कि यह वास्तव में एक बग है।

अगर हम इस सेटअप को मानते हैं:

from nltk.model import NgramModel
from nltk.probability import LidstoneProbDist

word_seq = list('aaaababaaccbacb')
words = ['a', 'b', 'c', '']

est = lambda freqdist, bins: LidstoneProbDist(freqdist, 0.2, bins=bins)
model = NgramModel(2, word_seq, True, True, est, 4)

हम बहुत जल्दी विसंगतियों को देख सकते हैं:

sum(model.prob(w, ['b']) for w in words)
Out[150]: 2.4583333333333335
sum(model.prob(w, ['a']) for w in words)
Out[151]: 1.0

[(w, model.prob(w, ['b'])) for w in words]
Out[152]: 
[('a', 0.6666666666666667),
 ('b', 0.875),
 ('c', 0.6666666666666667),
 ('', 0.25)]

[(w, model.prob(w, ['a'])) for w in words]
Out[153]: 
[('a', 0.47727272727272724),
 ('b', 0.25),
 ('c', 0.25),
 ('', 0.022727272727272728)]

जब मैं कुछ समय पहले NgramModel पर काम कर रहा था, तो मुझे यह भी याद है कि जिस तरह से बैक-ऑफ को लागू किया गया था, वह थोड़ा भ्रमित करने वाला था। अब जब मैंने इसे लंबे समय तक नहीं देखा है, तो मैंने अपनी सहज समझ खो दी है कि यह कैसे काम करता है। मुझे ऐसा लगता है कि हम दावा करते हैं कि हम काट्ज़ बैक-ऑफ़ को लागू कर रहे हैं, लेकिन गणनाएँ विकिपीडिया की गणनाओं से थोड़ी भिन्न

मेरा मानना ​​​​है कि ऐसा इसलिए है क्योंकि LidstoneProbDist.discount NgramModel._beta से कॉल किया गया फ़ंक्शन पहले से ही संक्षेप में लेता है, लेकिन मुझे इसे और अधिक देखना होगा।

def _alpha(self, tokens):
    return self._beta(tokens) / self._backoff._beta(tokens[1:])

def _beta(self, tokens):
    return (self[tokens].discount() if tokens in self else 1)

मुझे ऐसा प्रतीत होता है कि बीटा गणनाएं हैं जहां चीजें गलत हो रही हैं, क्योंकि बिग्राम स्तर पर बीटा यूनीग्राम स्तर पर बीटा से बहुत बड़ा है, जो अनुपात, अल्फा, सकारात्मक बनाता है।

model._beta(('b',))
Out[154]: 0.16666666666666669
model._backoff._beta(())
Out[155]: 0.05063291139240506
model._alpha(('b',))
Out[155]: 3.291666666666667

मैंने यह भी खारिज कर दिया है कि यह वास्तविक LidstoneProbDist ही है जिसमें कोई समस्या है:

[(w, model._model[('b',)].prob(w)) for w in words]
Out[159]: 
[('a', 0.6666666666666667),
 ('b', 0.04166666666666667),
 ('c', 0.04166666666666667),
 ('', 0.25)]

sum([model._model[('b',)].prob(w) for w in words])
Out[161]: 1.0

मैं यह पता लगाने की कोशिश करूंगा कि ये सभी भाग फिर से कैसे जुड़े हुए हैं और देखें कि क्या मैं इसे ठीक कर सकता हूं। हालांकि अगर कोई और इसमें कूदना चाहता है (जैसे @deslinguist), तो मैं इस पर नजर रखने के लिए एक और सेट की सराहना करता हूं।

नमस्ते, और इसमें जाँच करने के लिए धन्यवाद। बस कुछ और विचार:

सबसे पहले, एक चीज जो भ्रमित कर रही है वह है "छूट" की विभिन्न धारणाएं। विभिन्न चौरसाई विधियों द्वारा प्राप्त छूट है। उदाहरण के लिए, साधारण लाप्लासियन (एक जोड़ें) स्मूथिंग छूट देखे गए शब्दों की संभावना को कम करता है और उस द्रव्यमान को बिना देखे गए शब्दों में बदल देता है। डिस्काउंट () फ़ंक्शन को _beta फ़ंक्शन में कॉल किया जा रहा है, ProbDist द्वारा किए गए स्मूथिंग के लिए है, और बैकऑफ़ स्मूथिंग के लिए प्रासंगिक नहीं (मुझे नहीं लगता)। मुझे लगता है कि छूट की बैकऑफ धारणा को उच्च क्रम मॉडल में विभिन्न संदर्भों के लिए "गायब" (अनदेखे) शब्दों के सबसेट की संभावना के साथ करना है।

इसलिए, मैंने अपने स्वयं के उद्देश्यों के लिए कोड को संशोधित किया है जो मुझे लगता है कि सही बात है, और मैंने नीचे कुछ स्निपेट साझा किए हैं। मूल रूप से, मैं उन शब्दों के सबसेट की पहचान करता हूं जो किसी दिए गए संदर्भ के लिए मॉडल में गायब हैं, और उस सबसेट के लिए इन "लापता" शब्दों की कुल संभावना और बैकऑफ़ मॉडल में संबंधित मात्रा की गणना करें। अनुपात "अल्फा" है, और ध्यान दें कि यह संदर्भ का एक कार्य है। मुझे लगता है कि यह कार्यान्वयन आपके द्वारा प्रदान किए गए विकिपीडिया लिंक के अनुरूप है। साथ ही, मेरे मामले में _beta फ़ंक्शन का अब उपयोग नहीं किया जाता है।

आशा है कि यह चर्चा के लिए उपयोगी है। एक बार फिर धन्यवाद।

    # (Code fragment for calculating backoff)

    # Now, for Katz backoff smoothing we need to calculate the alphas
    if self._backoff is not None:
        self._backoff_alphas = dict()

        # For each condition (or context)
        for ctxt in self._cfd.conditions():
            pd = self._model[ctxt] # prob dist for this context

            backoff_ctxt = ctxt[1:]
            backoff_total_pr = 0
            total_observed_pr = 0
            for word in self._cfd[ctxt].keys(): # this is the subset of words that we OBSERVED
                backoff_total_pr += self._backoff.prob(word,backoff_ctxt) 
                total_observed_pr += pd.prob(word)

            assert total_observed_pr <= 1 and total_observed_pr > 0
            assert backoff_total_pr <= 1 and backoff_total_pr > 0

            alpha_ctxt = (1.0-total_observed_pr) / (1.0-backoff_total_pr)

            self._backoff_alphas[ctxt] = alpha_ctxt

# Updated _alpha function, discarded the _beta function
def _alpha(self, tokens):
    """Get the backoff alpha value for the given context
    """
    if tokens in self._backoff_alphas:
        return self._backoff_alphas[tokens]
    else:
        return 1

हाय सब, मैं सिर्फ इस चर्चा पर झंकार करना चाहता था, और यह बताना चाहता था कि समस्या केवल 1.0 के योग में विफल होने की संभावनाओं की तुलना में बहुत खराब है

निम्नलिखित ट्रिग्राम उदाहरण पर विचार करें:

#!/usr/bin/python
from nltk.model import NgramModel
from nltk.probability import LidstoneProbDist

word_seq = ['foo', 'foo', 'foo', 'foo', 'bar', 'baz']

# Set up a trigram model, nothing special  
est = lambda freqdist, bins: LidstoneProbDist(freqdist, 0.2, bins)
model = NgramModel(3, word_seq, True, True, est, 3)

# Consider the ngram ['bar', 'baz', 'foo']
# We've never seen this before, so the trigram model will fall back
context = ('bar', 'baz',)
word = 'foo'
print "P(foo | bar, baz) = " + str(model.prob(word,context))

# Result:
# P(foo | bar, baz) = 2.625

हाँ - यह सशर्त संभावना> 1.0 . है

बुरा हिस्सा यह है कि जितने अधिक मॉडल वापस गिरते हैं, उतनी ही अधिक संभावनाएं बढ़ जाती हैं।

समस्या और भी बदतर हो जाती है क्योंकि हम और अधिक प्रशिक्षण उदाहरण जोड़ते हैं!

word_seq = ['foo' for i in range(0,10000)]
word_seq.append('bar')
word_seq.append('baz')

est = lambda freqdist, bins: LidstoneProbDist(freqdist, 0.2, bins)
model = NgramModel(3, word_seq, True, True, est, 3)

# Consider the ngram ['bar', 'baz', 'foo']
# We've never seen this before, so the trigram model will fall back
context = ('bar', 'baz',)
word = 'foo'
print "P(foo | bar, baz) = " + str(model.prob(word,context))

# Result:
P(foo | bar, baz) = 6250.125

जैसा कि यह खड़ा है, NgramModel पर भरोसा नहीं किया जा सकता है - कम से कम एडिटिव लिडस्टोन स्मूथिंग के साथ नहीं।

@afourney : मेरा मानना ​​​​है कि यह इरादा है (LidstoneProbDist में SUM_TO_ONE = False विशेषता है)

@afourney मैं मानता हूं कि जब तक यह तय नहीं हो जाता तब तक NgramModel का वास्तव में उपयोग नहीं किया जा सकता है। दुर्भाग्य से, मेरे पास हाल ही में इस पर ध्यान देने का समय नहीं है।

@kmike SUM_TO_ONE LidstoneProbDist के लिए गलत है क्योंकि यदि आप एक ऐसी घटना का सामना करते हैं जो प्रारंभिक वितरण में नहीं थी और आपने संभावित घटनाओं की संख्या के लिए डिब्बे का मान निर्धारित नहीं किया था, तो यह एक के लिए योग नहीं होगा। लेकिन अगर सही तरीके से इस्तेमाल किया जाए तो यह वास्तव में एक के बराबर होगा। यहाँ समस्या NgramModel की बीटा गणना है, न कि LidstoneProbDist स्वयं।

@kmike : हाँ, मैंने देखा कि SUM_TO_ONE झूठा था। मेरी चिंता यह थी कि मॉडल व्यक्तिगत सशर्त संभावनाओं (एकल घटनाओं के लिए) लौटा रहा था जो पहले से ही 1 से अधिक थे - उन्हें योग में शामिल करने से पहले।

@bcroy मुझे लगता है कि आपका समाधान सही दृष्टिकोण है। सीधे शब्दों में कहें, _alpha दो महत्वपूर्ण कार्य करता है:

1. यह दिए गए संदर्भ के लिए बैकऑफ़ मॉडल को फिर से सामान्य करता है ताकि उन शब्दों को बाहर किया जा सके जो पहले से ही वर्तमान उच्च-क्रम मॉडल के हिसाब से हैं।
2. यह पुनर्सामान्यीकृत बैकऑफ़ मॉडल को वर्तमान _model की "लापता"/छूट की संभावना को "फिट" करने के लिए मापता है।

कहा जा रहा है, यह अच्छा होगा यदि NgramModel बैकऑफ़ रणनीति के विकल्प के रूप में एक प्रक्षेप रणनीति भी पेश करे। यह जेलिनेक-मर्सर या विटन-बेल स्मूथिंग के लिए समर्थन को सक्षम करेगा - जिनमें से बाद वाला मुझे सरल लगा, और काफी अच्छा काम करने के लिए। देखें: http://nlp.stanford.edu/~wcmac/papers/20050421-smoothing-tutorial.pdf

क्या कोई पुष्टि कर सकता है कि यह अभी भी एक खुला बग है?

हाँ, मुझे अभी भी P(foo | bar, baz) = 2.625 . मिल रहा है

सबको नमस्ते,

क्या इस मुद्दे पर कोई प्रगति हुई है? क्या यह अभी भी एक खुला बग है? मुझे P(foo | bar, baz) = 2.625 मिल रहा है इसलिए समस्या बनी रहती है।

मुझे लगता है कि यह एक महत्वपूर्ण समस्या है और इसे ठीक किया जाना चाहिए था क्योंकि एनएलपी में लगभग सभी अनुप्रयोगों के लिए भाषा मॉडल का उपयोग किया जाता है।

दुर्भाग्य से, मेरे पास NgramModel साथ कई मुद्दों को देखने का समय नहीं है, और मुझे नहीं लगता कि मैं जल्द ही ऐसा कर पाऊंगा। जब तक कोई इन बगों का समाधान नहीं करता, तब तक NgramModel को nltk से हटा दिया गया है।

डैन, उत्तर के लिए धन्यवाद।

अभी अपडेट के लिए चेक इन कर रहे हैं। मैं देख सकता हूं कि कुछ मुद्दों को बंद कर दिया गया है, लेकिन यह सुनिश्चित करना चाहते हैं कि यह अभी भी प्रयोग करने योग्य नहीं है?

@ZeerakW दुर्भाग्य से, ngram मॉडल में बहुत कम प्रगति हुई है, और अभी तक किसी ने भी इससे निपटने के लिए प्रतिबद्ध नहीं किया है।

2016 में प्रवेश और 'एनग्राम मॉडल' के मुद्दे में कोई प्रगति नहीं हुई है।

दोस्तों हम अंत में इसे बंद कर सकते हैं :)

अपडेट 2018। पहले ही स्नातक हो चुका है और काम करना शुरू कर दिया है और अभी भी एनग्राम मुद्दा मौजूद है

ग्रीष्म ऋतु!