kenlm说明文档.txt

NAME
    kenlm

CLASSES
    builtins.object
        Config
        FullScoreReturn
        LoadMethod
        Model
            LanguageModel
        State
    
    class Config(builtins.object)
     |  Wrapper around lm::ngram::Config.
     |  Pass this to Model's constructor to set the load_method.
     |  
     |  Methods defined here:
     |  
     |  __init__(self, /, *args, **kwargs)
     |      Initialize self.  See help(type(self)) for accurate signature.
     |  
     |  __new__(*args, **kwargs) from builtins.type
     |      Create and return a new object.  See help(type) for accurate signature.
     |  
     |  ----------------------------------------------------------------------
     |  Data descriptors defined here:
     |  
     |  load_method
    
    class FullScoreReturn(builtins.object)
     |  Wrapper around FullScoreReturn.
     |  
     |  Notes:
     |      `prob` has been renamed to `log_prob`
     |      `oov` has been added to flag whether the word is OOV
     |  
     |  Methods defined here:
     |  
     |  __new__(*args, **kwargs) from builtins.type
     |      Create and return a new object.  See help(type) for accurate signature.
     |  
     |  __repr__(self, /)
     |      Return repr(self).
     |  
     |  ----------------------------------------------------------------------
     |  Data descriptors defined here:
     |  
     |  log_prob
     |  
     |  ngram_length
     |  
     |  oov
    
    class LanguageModel(Model)
     |  Backwards compatability stub.  Use Model.
     |  
     |  Method resolution order:
     |      LanguageModel
     |      Model
     |      builtins.object
     |  
     |  Data descriptors defined here:
     |  
     |  __dict__
     |      dictionary for instance variables (if defined)
     |  
     |  __weakref__
     |      list of weak references to the object (if defined)
     |  
     |  ----------------------------------------------------------------------
     |  Methods inherited from Model:
     |  
     |  BaseFullScore(...)
     |      Wrapper around model.BaseScore(in_state, Index(word), out_state)
     |      
     |      :param word: the suffix
     |      :param state: the context (defaults to NullContext)
     |      :returns: FullScoreReturn(word|state)
     |  
     |  BaseScore(...)
     |      Return p(word|in_state) and update the output state.
     |      Wrapper around model.BaseScore(in_state, Index(word), out_state)
     |      
     |      :param word: the suffix
     |      :param state: the context (defaults to NullContext)
     |      :returns: p(word|state)
     |  
     |  BeginSentenceWrite(...)
     |      Change the given state to a BOS state.
     |  
     |  NullContextWrite(...)
     |      Change the given state to a NULL state.
     |  
     |  __contains__(self, key, /)
     |      Return key in self.
     |  
     |  __init__(...)
     |      Load the language model.
     |      
     |      :param path: path to an arpa file or a kenlm binary file.
     |      :param config: configuration options (see lm/config.hh for documentation)
     |  
     |  __new__(*args, **kwargs) from builtins.type
     |      Create and return a new object.  See help(type) for accurate signature.
     |  
     |  __reduce__(...)
     |      helper for pickle
     |  
     |  __repr__(self, /)
     |      Return repr(self).
     |  
     |  full_scores(...)
     |      full_scores(sentence, bos = True, eos = Ture) -> generate full scores (prob, ngram length, oov)
     |      @param sentence is a string (do not use boundary symbols)
     |      @param bos should kenlm add a bos state
     |      @param eos should kenlm add an eos state
     |  
     |  perplexity(...)
     |      Compute perplexity of a sentence.
     |      @param sentence One full sentence to score.  Do not include <s> or </s>.
     |  
     |  score(...)
     |      Return the log10 probability of a string.  By default, the string is
     |      treated as a sentence.  
     |        return log10 p(sentence </s> | <s>)
     |      
     |      If you do not want to condition on the beginning of sentence, pass
     |        bos = False
     |      Never include <s> as part of the string.  That would be predicting the
     |      beginning of sentence.  Language models are only supposed to condition
     |      on it as context.
     |      
     |      Similarly, the end of sentence token </s> can be omitted with
     |        eos = False
     |      Since language models explicitly predict </s>, it can be part of the
     |      string.
     |      
     |      Examples:
     |      
     |      #Good: returns log10 p(this is a sentence . </s> | <s>)
     |      model.score("this is a sentence .")
     |      #Good: same as the above but more explicit
     |      model.score("this is a sentence .", bos = True, eos = True)
     |      
     |      #Bad: never include <s>
     |      model.score("<s> this is a sentence")
     |      #Bad: never include <s>, even if bos = False.
     |      model.score("<s> this is a sentence", bos = False)
     |      
     |      #Good: returns log10 p(a fragment)
     |      model.score("a fragment", bos = False, eos = False)
     |      
     |      #Good: returns log10 p(a fragment </s>)
     |      model.score("a fragment", bos = False, eos = True)
     |      
     |      #Ok, but bad practice: returns log10 p(a fragment </s>)
     |      #Unlike <s>, the end of sentence token </s> can appear explicitly.
     |      model.score("a fragment </s>", bos = False, eos = False)
     |  
     |  ----------------------------------------------------------------------
     |  Data descriptors inherited from Model:
     |  
     |  order
     |  
     |  path
    
    class LoadMethod(builtins.object)
     |  Data descriptors defined here:
     |  
     |  __dict__
     |      dictionary for instance variables (if defined)
     |  
     |  __weakref__
     |      list of weak references to the object (if defined)
     |  
     |  ----------------------------------------------------------------------
     |  Data and other attributes defined here:
     |  
     |  LAZY = 0
     |  
     |  PARALLEL_READ = 4
     |  
     |  POPULATE_OR_LAZY = 1
     |  
     |  POPULATE_OR_READ = 2
     |  
     |  READ = 3
    
    class Model(builtins.object)
     |  Wrapper around lm::ngram::Model.
     |  
     |  Methods defined here:
     |  
     |  BaseFullScore(...)
     |      Wrapper around model.BaseScore(in_state, Index(word), out_state)
     |      
     |      :param word: the suffix
     |      :param state: the context (defaults to NullContext)
     |      :returns: FullScoreReturn(word|state)
     |  
     |  BaseScore(...)
     |      Return p(word|in_state) and update the output state.
     |      Wrapper around model.BaseScore(in_state, Index(word), out_state)
     |      
     |      :param word: the suffix
     |      :param state: the context (defaults to NullContext)
     |      :returns: p(word|state)
     |  
     |  BeginSentenceWrite(...)
     |      Change the given state to a BOS state.
     |  
     |  NullContextWrite(...)
     |      Change the given state to a NULL state.
     |  
     |  __contains__(self, key, /)
     |      Return key in self.
     |  
     |  __init__(...)
     |      Load the language model.
     |      
     |      :param path: path to an arpa file or a kenlm binary file.
     |      :param config: configuration options (see lm/config.hh for documentation)
     |  
     |  __new__(*args, **kwargs) from builtins.type
     |      Create and return a new object.  See help(type) for accurate signature.
     |  
     |  __reduce__(...)
     |      helper for pickle
     |  
     |  __repr__(self, /)
     |      Return repr(self).
     |  
     |  full_scores(...)
     |      full_scores(sentence, bos = True, eos = Ture) -> generate full scores (prob, ngram length, oov)
     |      @param sentence is a string (do not use boundary symbols)
     |      @param bos should kenlm add a bos state
     |      @param eos should kenlm add an eos state
     |  
     |  perplexity(...)
     |      Compute perplexity of a sentence.
     |      @param sentence One full sentence to score.  Do not include <s> or </s>.
     |  
     |  score(...)
     |      Return the log10 probability of a string.  By default, the string is
     |      treated as a sentence.  
     |        return log10 p(sentence </s> | <s>)
     |      
     |      If you do not want to condition on the beginning of sentence, pass
     |        bos = False
     |      Never include <s> as part of the string.  That would be predicting the
     |      beginning of sentence.  Language models are only supposed to condition
     |      on it as context.
     |      
     |      Similarly, the end of sentence token </s> can be omitted with
     |        eos = False
     |      Since language models explicitly predict </s>, it can be part of the
     |      string.
     |      
     |      Examples:
     |      
     |      #Good: returns log10 p(this is a sentence . </s> | <s>)
     |      model.score("this is a sentence .")
     |      #Good: same as the above but more explicit
     |      model.score("this is a sentence .", bos = True, eos = True)
     |      
     |      #Bad: never include <s>
     |      model.score("<s> this is a sentence")
     |      #Bad: never include <s>, even if bos = False.
     |      model.score("<s> this is a sentence", bos = False)
     |      
     |      #Good: returns log10 p(a fragment)
     |      model.score("a fragment", bos = False, eos = False)
     |      
     |      #Good: returns log10 p(a fragment </s>)
     |      model.score("a fragment", bos = False, eos = True)
     |      
     |      #Ok, but bad practice: returns log10 p(a fragment </s>)
     |      #Unlike <s>, the end of sentence token </s> can appear explicitly.
     |      model.score("a fragment </s>", bos = False, eos = False)
     |  
     |  ----------------------------------------------------------------------
     |  Data descriptors defined here:
     |  
     |  order
     |  
     |  path
    
    class State(builtins.object)
     |  Wrapper around lm::ngram::State so that python code can make incremental queries.
     |  
     |  Notes:
     |      * rich comparisons 
     |      * hashable
     |  
     |  Methods defined here:
     |  
     |  __eq__(self, value, /)
     |      Return self==value.
     |  
     |  __ge__(self, value, /)
     |      Return self>=value.
     |  
     |  __gt__(self, value, /)
     |      Return self>value.
     |  
     |  __hash__(self, /)
     |      Return hash(self).
     |  
     |  __le__(self, value, /)
     |      Return self<=value.
     |  
     |  __lt__(self, value, /)
     |      Return self<value.
     |  
     |  __ne__(self, value, /)
     |      Return self!=value.
     |  
     |  __new__(*args, **kwargs) from builtins.type
     |      Create and return a new object.  See help(type) for accurate signature.

DATA
    __test__ = {}

FILE
    /opt/algor/gongxf/anaconda3/lib/python3.6/site-packages/kenlm.cpython-36m-x86_64-linux-gnu.so