{"id":22605,"date":"2021-02-05T10:15:26","date_gmt":"2021-02-05T10:15:26","guid":{"rendered":"https:\/\/www.experfy.com\/blog\/statistical-language-models\/"},"modified":"2023-09-05T11:00:20","modified_gmt":"2023-09-05T11:00:20","slug":"statistical-language-models","status":"publish","type":"post","link":"https:\/\/www.experfy.com\/blog\/ai-ml\/statistical-language-models\/","title":{"rendered":"Statistical Language Models"},"content":{"rendered":"\t\t
\n\t\t\t\t\t\t
\n\t\t\t\t\t\t
\n\t\t\t\t\t
\n\t\t\t
\n\t\t\t\t\t\t
\n\t\t\t\t
\n\t\t\t\t\t

From simple to ++, with use cases, examples & code snippets<\/h2>\t\t\t\t<\/div>\n\t\t\t\t<\/div>\n\t\t\t\t
\n\t\t\t\t
\n\t\t\t\t\t\t\t\t\t

In NLP, a language model is a probability distribution<\/em> over strings on an alphabet. In formal language theory, a language is a set<\/em> of strings on an alphabet. The NLP version is a soft variant of the one in formal language theory.<\/p>\n

The NLP version is better suited to modeling natural languages such as English or French. No hard rules dictate exactly which strings are in the language and which not. Rather we have observations to work with. People write. People talk. Their utterances characterize the language.<\/p>\n

Importantly, the NLP statistical version is good for learning<\/em> languages over strings from examples. Consider learning a model to recognize product names. The training set may contain iPhone 4 and iPhone 5 but not iPhone 12. It should recognize iPhone 12 as a product name.<\/p>\n

In this post, we cover statistical language models from simple to elaborate. The covered models include: Independent model, first-order Markov model, Kth-order Markov model, Hidden Markov Model, Conditional Markov model, and Conditional Random Fields. Each is illustrated with realistic examples and use cases.<\/p>\n\t\t\t\t\t\t\t\t<\/div>\n\t\t\t\t<\/div>\n\t\t\t\t

\n\t\t\t\t
\n\t\t\t\t\t

Next Token Probabilities<\/h2>\t\t\t\t<\/div>\n\t\t\t\t<\/div>\n\t\t\t\t
\n\t\t\t\t
\n\t\t\t\t\t\t\t\t\t

We\u2019ve defined a language as a probability distribution over strings. In many use cases, what we really want is the probability of the next symbol given the current string. It turns out these two are equivalent, as noted in [1].<\/p>\n

Consider a string on an alphabet. (The alphabet may be composed of characters or words or other tokens.) Denote this string x<\/em>1, x<\/em>2, \u2026, x<\/em>n. We can write P<\/em>(x<\/em>1,x<\/em>2,\u2026,xn<\/em>) as P<\/em>(x<\/em>1)*P<\/em>(x<\/em>2|x<\/em>1)*\u2026*P<\/em>(xn<\/em>|xn<\/em>-1,xn<\/em>-2,\u2026,x1<\/em>).<\/p>\n\t\t\t\t\t\t\t\t<\/div>\n\t\t\t\t<\/div>\n\t\t\t\t

\n\t\t\t\t
\n\t\t\t\t\t

Use Cases<\/h2>\t\t\t\t<\/div>\n\t\t\t\t<\/div>\n\t\t\t\t
\n\t\t\t\t
\n\t\t\t\t\t\t\t\t\t

What can we do with a language model? Quite a lot.<\/p>\n

Suggest auto-completes<\/strong>. Smartphones offer auto-complete suggestions as we type. Web search engines offer auto-complete suggestions as we start typing a query. Under-the-hood these are powered by language models.<\/p>\n

Recognize handwriting.<\/strong> Imagine pointing your smartphone at your handwritten notes and asking them to be recognized. Perhaps to be digitized and searchable. Or at least to make them legible!<\/p>\n

Handwriting recognition is challenging. Even people often get it wrong. Sometimes even their own writing!<\/p>\n

Consider trying to recognize the words in a poorly-written text. A pure image processing approach can make a lot of errors. Adding a language model can cut these down a lot. The language model provides a useful context.<\/p>\n

Example 1<\/strong>: Let\u2019s glimpse this in a simple example. Imagine the OCR thought the next word was databasc<\/em>. The e<\/em> was misrecognized as a c<\/em>. They do look similar.<\/p>\n

Now let\u2019s add a language model trained on English words. Specifically to assign high probabilities to strings that look like English words and low probabilities to those that don\u2019t. bath<\/em> would get a high probability, but not axbs<\/em>.<\/p>\n

This language model will know that database<\/em> is much more likely than databasc<\/em>. So adding it will help detect and correct the OCR\u2019s error.<\/p>\n

By adding a multi-word language model, we can improve the error-detection and correction accuracy further. This model\u2019s alphabet is the lexicon of words. Its high-probability strings model high-probability word sequences. The alphabet becomes way larger. Every distinct word is in the alphabet. So care needs to be exercised to reap its benefits while avoiding the cost (the model getting overly complex). More on this later.<\/p>\n

A multi-word language model can also help fill in missing words in the written text.<\/p>\n

Detect and correct spelling errors<\/strong>. We\u2019ll reinterpret the same example databasc<\/em>. The last character, c<\/em>, is now a spelling error.<\/p>\n

Recognize speech.<\/strong> Similar reasoning holds here. Except that the modality is different. The underlying language being expressed is the same. This is not to say that accurate handwriting or speech recognition is easy. Just that adding a language model helps.<\/p>\n

Recognize multi-token named entities<\/strong>. Multi-token named entities often have a language structure. As an example, in a person\u2019s name, the first name word(s) typically appear before the last name words. Sandwiched between the two might be middle name word(s). As another example, in a US street address, the street number typically appears before the street name. As we will see later, such entities are often recognized via latent language models such as Hidden Markov Models.<\/p>\n

Now that we have seen some use cases, let\u2019s dive into<\/p>\n\t\t\t\t\t\t\t\t<\/div>\n\t\t\t\t<\/div>\n\t\t\t\t

\n\t\t\t\t
\n\t\t\t\t\t

Models<\/h2>\t\t\t\t<\/div>\n\t\t\t\t<\/div>\n\t\t\t\t
\n\t\t\t\t
\n\t\t\t\t\t\t\t\t\t

We\u2019ll denote the string asx<\/em>1, x<\/em>2, \u2026, x<\/em>n.<\/p>\n

Independent.<\/strong> This is the simplest approach. It assumes that all characters in the string are generated independently.<\/p>\n

P<\/em>(x<\/em>1, x<\/em>2, \u2026, xn<\/em>) = Q<\/em>(x<\/em>1)*Q<\/em>(x<\/em>2)*\u2026*Q<\/em>(xn<\/em>).<\/p>\n

Here Q<\/em> is a probability distribution over the alphabet.<\/p>\n

This approach is often effective on long strings on a large alphabet. Such as documents with many words. The text is seen as a sequence <\/a>of words. The alphabet is the lexicon of words.<\/p>\n

In this setting, more elaborate approaches get complex very quickly so they need to work convincingly and significantly better to justify their added complexity.<\/p>\n

This approach would be effective in detecting the document\u2019s language. For each language, we would train a separate Q, a distribution over the words seen in the language\u2019s training set. For a new document W expressed as the sequence of words W1 W2 \u2026 Wn, we would calculate PL(W) = QL(W1]*QL[W2]*\u2026QL[Wn] for every language L we have modeled. We would deem L* = argmax_L PL(W) as the language of W.<\/p>\n

Example I1:<\/strong> Train on the sequence of words the dog is wagging the cat\u2019s tail<\/em>. We get Q(the)=2\/7, Q(is) = 1\/7, etc.<\/p>\n

Python Code I1<\/strong>: Not tested, or even run. Plus, needs a runner.<\/p>\n\t\t\t\t\t\t\t\t<\/div>\n\t\t\t\t<\/div>\n\t\t\t\t

\n\t\t\t\t
\n\t\t\t\t\t\t\t\t\t
from collections import Counter
import mathclass IndependentModel:
    
    def __init__(self):<\/strong>
        self.ctr = Counter()    def train(self,words):<\/strong>
        for word in words:
            self.ctr[word] += 1    def Q(self,word):<\/strong>
        return float(self.ctr[word])\/self.ctr.values()    def P(self, words):<\/strong>
        return math.prod(map(lambda word: self.Q(word), words))<\/pre>\n\t\t\t\t\t\t\t\t<\/div>\n\t\t\t\t<\/div>\n\t\t\t\t
\n\t\t\t\t
\n\t\t\t\t\t\t\t\t\t
Exercise I1<\/strong>: Evolve this code snippet into a language recognizer. Say English vs French.<\/p>\n
First-order Markov Model.<\/strong> Here, a symbol is allowed to depend on the previous one.<\/p>\n
P<\/em>(x<\/em>1, x<\/em>2, \u2026, xn<\/em>) = Q<\/em>(x<\/em>1)*Q<\/em>(x<\/em>2|x1)*\u2026*Q<\/em>(xn|xn-1<\/em>)<\/p>\n
A first-order Markov model is described by a state-transition matrix P<\/em>. pij <\/em>is the probability of going from state i <\/em>to state j<\/em>. Denoting xt<\/em> as i<\/em> and xt<\/em>+1 as j<\/em>, Q<\/em>(xt<\/em>+1,xt<\/em>) equals pij<\/em>.<\/p>\n
This Markov model may also be expressed as a directed graph. There is an arc i<\/em> \u2192 j<\/em> if the value i<\/em> can be followed by a value j<\/em>. This arc has a probability p<\/em>(j<\/em>|i<\/em>) on it. The graph representation merely makes explicit which state transition probabilities are 0.<\/p>\n
Example 1M1: <\/strong>A first-order Markov model is effective in modeling short phrases. Say we want to discover salient short phrases (of 2-to-4 words each) from a large corpus of English documents. A first-order Markov model strikes a good balance between being rich enough to be able to do a reasonable job on it, without becoming too complex.<\/p>\n
Consider the text \u201cdata mining is a phrase. data mining is a method of extracting meaningful information from a large data set<\/em>\u201d.<\/p>\n
From this text, we will build the Markov graph. This graph\u2019s nodes are distinct words that appear in the text. There is an arc from node u<\/em> to node v<\/em> if word u<\/em> is followed by word v<\/em> at least once in the text. A few arcs are shown below.<\/p>\n\t\t\t\t\t\t\t\t<\/div>\n\t\t\t\t<\/div>\n\t\t\t\t
\n\t\t\t\t
\n\t\t\t\t\t\t\t\t\t
data \u2192 mining   mining \u2192 is    method \u2192 of  extracting \u2192 meaningful<\/pre>\n\t\t\t\t\t\t\t\t<\/div>\n\t\t\t\t<\/div>\n\t\t\t\t
\n\t\t\t\t
\n\t\t\t\t\t\t\t\t\t
We see that P<\/em>(data<\/em>, mining<\/em>) = Q<\/em>(data<\/em>)*P<\/em>(mining <\/em>| data<\/em>) = (2\/19)*1 . By contrast, P<\/em>(a<\/em>, method<\/em>) = Q<\/em>(a<\/em>)*P<\/em>(method <\/em>| a<\/em>) = (3\/19)*(\u2153) = 1\/19 < P<\/em>(data<\/em>, mining<\/em>). Unfortunately, P<\/em>(is<\/em>, a) = P<\/em>(data<\/em>, mining<\/em>). So (is<\/em>, a<\/em>) would be a false positive because it is not a salient phrase.<\/p>\n
So the first-order Markov model on its own, while somewhat useful, also has glaring false positives. Adding grammatical information to this approach, specifically part-of-speech tags of words significantly improves its quality. That is, (mostly) reduces the false positives without (hardly) missing on the true ones. The intuition is that salient phrases are comprised of words favoring certain parts of speech, especially nouns. Consider (data<\/em>, mining<\/em>). Both words are nouns. Consider (is<\/em>, a<\/em>). \u2018is\u2019 is a verb, \u2018a<\/em>\u2019 an article.<\/p>\n
We won\u2019t go into detail on how to combine the two approaches. The main point is that the Markov model is still useful.<\/p>\n
Python Code 1M1<\/strong>: Not tested, or even run. Plus, needs a runner.<\/p>\n\t\t\t\t\t\t\t\t<\/div>\n\t\t\t\t<\/div>\n\t\t\t\t
\n\t\t\t\t
\n\t\t\t\t\t\t\t\t\t
from collections import defaultdict, Counter
import mathclass FirstOrderMarkovModel:    def __init__(selfs):<\/strong>
       self.ctr2 = defaultdict(lambda:defaultdict(int))
       self.ctr1 = Counter()    def train(self,words):<\/strong>
       words_with_sentinel = [\u2018_B_\u2019] + words
       for i in range(len(words_with_sentinel)-1):
          self.ctr2[words[i][words[i+1] += 1
          self.ctr1[words[i]] += 1    def Q(self,word,previous_word):<\/strong>
       return float(self.ctr2[previous_word[word])\/
       self.ctr1[previous_word])    def P(words):<\/strong>
       p = self.Q(words[0],\u2019_B\u2019)
       for i in range(len(words)-1):
          p *= self.Q(words[i+1],words[i])
       return p<\/pre>\n\t\t\t\t\t\t\t\t<\/div>\n\t\t\t\t<\/div>\n\t\t\t\t
\n\t\t\t\t
\n\t\t\t\t\t\t\t\t\t
Kth-order Markov Model<\/strong>. In this model, a character is allowed to depend on the previous K<\/em> characters.<\/p>\n
P<\/em>(x<\/em>1, x<\/em>2, \u2026, xn<\/em>) = Q<\/em>(x<\/em>1)*Q<\/em>(x<\/em>2|x1)*\u2026*Q<\/em>(xn|xn-1,xn-2,\u2026,xn-k<\/em>)<\/p>\n
With K<\/em> set to 2 or 3, this approach can discover better salient phrases than a first-order Markov model without incurring a huge increase in complexity. What do we mean by \u201cbetter\u201d? Consider a phrase of length 3. Call it x<\/em>1, x<\/em>2, x<\/em>3. The first-order Markov model loses information as it assumes x3<\/em> is independent of x1<\/em> given x2<\/em>. The second-order model doesn\u2019t. P<\/em>(x<\/em>1)*P<\/em>(x<\/em>2|x<\/em>1)*P<\/em>(x<\/em>3|x<\/em>2,x<\/em>1) equals P<\/em>(x<\/em>1,x<\/em>2,x<\/em>3).<\/p>\n
As before, the need for combining the statistical approach with the grammatical approach remains.<\/p>\n
Example KM1:<\/strong> We\u2019d like to build a second-order Markov model on three-word product names. Why second-order? Consider these made-up examples: 4k tv samsung<\/em>, 3k tv sony<\/em>, \u2026 Imagine that sony does not offer a 4k option. If we used a first-order Markov model we would lose the interaction between the first word (4k or 3k or \u2026) and the brand-name. The second-order model would capture this interaction. In other words, the product name would be influenced not only by the second word (tv in our example) but also by the first one (4k or 3k or \u2026).<\/p>\n\t\t\t\t\t\t\t\t<\/div>\n\t\t\t\t<\/div>\n\t\t\t\t
\n\t\t\t\t
\n\t\t\t\t\t
Hidden Markov Model<\/h2>\t\t\t\t<\/div>\n\t\t\t\t<\/div>\n\t\t\t\t
\n\t\t\t\t
\n\t\t\t\t\t\t\t\t\t
Here, strings are probabilistically generated from a model with latent variables, i.e., hidden states.<\/p>\n
Notationally, let X<\/em> = x<\/em>1, \u2026, xn<\/em> denote a string of length n<\/em> and S<\/em> = s1<\/em>, \u2026, sn<\/em> denote a string of states associated with X<\/em>. Symbol xi<\/em> is generated from state si<\/em>.<\/p>\n
X<\/em> is called the observation sequence; S<\/em> the (hidden) state sequence from which X<\/em> was generated.<\/p>\n
Structurally the HMM is a first-order Markov model over the set of states. Some states are connected to other states by arcs. In addition, each state has a probability distribution over the alphabet of observables.<\/p>\n
This model generates a pair (X<\/em>, S<\/em>) as follows. First, it generates s1. Then it emits x<\/em>1 from s<\/em>1 with a certain probability. Next, it moves to state s<\/em>2 with a certain probability. This probability depends only on where it came from, i.e. s<\/em>1. What was emitted, i.e. x<\/em>1, is immaterial. Next, it generates x<\/em>2 from s<\/em>2 with a certain probability. And so it goes.<\/p>\n
In summary, the HMM generator alternates between generating states and generating observables from those states. The state transition probabilities depend only on the previous state. The emission transition probabilities depend only on the current state, i.e. the state from which the observable is emitted.<\/p>\n
Example HMM1<\/strong>: Say we want to generate sentences in English that resemble real ones. Consider specifically sentences having one of two structures<\/p>\n\t\t\t\t\t\t\t\t<\/div>\n\t\t\t\t<\/div>\n\t\t\t\t
\n\t\t\t\t
\n\t\t\t\t\t\t\t\t\t
Article Noun Verb Adverb
Pronoun Verb<\/pre>\n\t\t\t\t\t\t\t\t<\/div>\n\t\t\t\t<\/div>\n\t\t\t\t
\n\t\t\t\t
\n\t\t\t\t\t\t\t\t\t
An example sentence of the first structure is The boy is fast<\/em>. An example sentence of the second structure is She sings<\/em>.<\/p>\n
A realistic sentence generator would accommodate a lot more structures. We chose two because the maximum insight comes in going from one to two.<\/p>\n
What does an HMM that models these two structures look like? First, it helps to add a begin<\/em> state and an end<\/em> state. The HMM always starts from the begin<\/em> state and stops at the end <\/em>state. The begin<\/em> and end<\/em> states are called silent. They don\u2019t emit any token.<\/p>\n
Okay, now to the structure, i.e. the arcs connecting the states.<\/p>\n\t\t\t\t\t\t\t\t<\/div>\n\t\t\t\t<\/div>\n\t\t\t\t
\n\t\t\t\t
\n\t\t\t\t\t\t\t\t\t
begin \u2192 article \u2192 noun \u2192 verb \u2192 adverb \u2192 end
begin \u2192 pronoun \u2192 verb \u2192 end<\/pre>\n\t\t\t\t\t\t\t\t<\/div>\n\t\t\t\t<\/div>\n\t\t\t\t
\n\t\t\t\t
\n\t\t\t\t\t\t\t\t\t
Note that some states are shown twice. This is just due to the presentation constraint. Take an example. Since the HMM has arcs begin<\/em> \u2192 article<\/em> and begin<\/em> \u2192 pronoun<\/em> what this really means is that from the begin<\/em> state the HMM can move to the article<\/em> state with a certain probability and to the pronoun<\/em> state with another probability. The two probabilities sum to 1. From the state begin<\/em> the HMM has to move somewhere.<\/p>\n
Similarly, from the state verb <\/em>we can either move to the state adver<\/em>bor to the state end<\/em>. Note that the HMM does not track how we arrived at the state verb<\/em>, which means the state sequence begin<\/em> \u21d2 article<\/em> \u21d2 noun<\/em> \u21d2 verb<\/em> \u21d2 end<\/em> is also possible, even though we didn\u2019t ask for it. This type of generalization is good if we want the HMM to be able to generate sentences such as The boy ate<\/em> and bad if not.<\/p>\n
Training<\/strong>: We can train the emission parameters of this model easily. We can take advantage of the fact that our states are named entities, for whom training sets are readily available. It\u2019s easy to collect words that form articles, those that form nouns, etc.<\/p>\n
Next, we look into training the state transition probabilities. For example, we need to estimate the probability of going from the begin<\/em> state to the article<\/em> state. This is less than 1 as from the state begin <\/em>we can also go to the state pronoun<\/em> instead.<\/p>\n
For training the transitions, we assume we have access to sentences whose words have POS-tags attached to them. A rich training set of this type is easy to assemble. It is easy to get lots of sentences. It is also easy to get the POS-tag sequences of these sentences by running a suitable POS-tagger on each.<\/p>\n
The transition probabilities of the HMM are easy to train from such a training set. In fact, we only need the POS-tag sequence for each sentence. Let\u2019s illustrate this. The probability on the arc begin<\/em> \u2192 article<\/em> is estimated as the number of POS-tag sequences whose first token is article <\/em>divided by the number of POS-tag sequences whose first token is either article<\/em> or pronoun<\/em>.<\/p>\n\t\t\t\t\t\t\t\t<\/div>\n\t\t\t\t<\/div>\n\t\t\t\t
\n\t\t\t\t
\n\t\t\t\t\t
Two generated sentences<\/h2>\t\t\t\t<\/div>\n\t\t\t\t<\/div>\n\t\t\t\t
\n\t\t\t\t
\n\t\t\t\t\t\t\t\t\t
Let\u2019s see a few. The first one is below.<\/p>\n\t\t\t\t\t\t\t\t<\/div>\n\t\t\t\t<\/div>\n\t\t\t\t
\n\t\t\t\t
\n\t\t\t\t\t\t\t\t\t
          The     boy     is     fast
           ^       ^      ^       ^
           |       |      |       |
begin \u2192 article \u2192 noun \u2192 verb \u2192 adverb \u2192 end<\/pre>\n\t\t\t\t\t\t\t\t<\/div>\n\t\t\t\t<\/div>\n\t\t\t\t
\n\t\t\t\t
\n\t\t\t\t\t\t\t\t\t
We start from the state begin<\/em>, walk to article<\/em>, emit The<\/em> from it, walk to noun<\/em>, emit boy<\/em> from it, and so on. t<\/p>\n
The second one is below.<\/p>\n\t\t\t\t\t\t\t\t<\/div>\n\t\t\t\t<\/div>\n\t\t\t\t
\n\t\t\t\t
\n\t\t\t\t\t\t\t\t\t
         She     sings
          ^        ^
          |        |
begin \u2192 pronoun \u2192 verb \u2192 end<\/pre>\n\t\t\t\t\t\t\t\t<\/div>\n\t\t\t\t<\/div>\n\t\t\t\t
\n\t\t\t\t
\n\t\t\t\t\t\t\t\t\t
We start from begin<\/em>, walk to pronoun<\/em>, emit She<\/em> from it, move to verb<\/em>, emit Sing<\/em> from it, and finally walk to end<\/em> and stay put there.<\/p>\n
Versus Independent<\/strong>: Imagine, by contrast, the sentences generated by the independent model. The words would be spewed out based on their probabilities with no regard for the desired structure.<\/p>\n\t\t\t\t\t\t\t\t<\/div>\n\t\t\t\t<\/div>\n\t\t\t\t
\n\t\t\t\t
\n\t\t\t\t\t
Position-specific Independent Model aka chain HMM<\/h2>\t\t\t\t<\/div>\n\t\t\t\t<\/div>\n\t\t\t\t
\n\t\t\t\t
\n\t\t\t\t\t\t\t\t\t
In some use cases, the generated symbols are significantly influenced by their positions in the string. As one example, consider product names such as iPhone 11<\/em>, canon camera<\/em>, and sony tv<\/em>. There is clearly some sequential structure. In these examples, the brand name (canon<\/em>, sony<\/em>) precedes the product type (camera<\/em>, tv<\/em>).<\/p>\n
The position-specific generalization of the independent model is suited for such modeling.<\/p>\n
P<\/em>(x<\/em>1, x<\/em>2, \u2026, xn<\/em>) = Q1<\/em>(x<\/em>1)*Q2<\/em>(x<\/em>2)*\u2026*Qn<\/em>(xn<\/em>).<\/p>\n
Here Qi<\/em> is a position-specific probability distribution over the alphabet. So with n<\/em> positions we have n<\/em> distributions Q<\/em>1, \u2026, Qn<\/em>.<\/p>\n
A position-specific independent model may be viewed as an HMM whose states 1<\/em>, 2<\/em>, \u2026, n<\/em> representing token positions 1 through n<\/em> respectively. Such an HMM\u2019s graph is a single directed path 1 \u2192 2 \u2192 3 \u2192 \u2026 \u2192 n<\/em>. Consequently, the transition probabilities on all the arcs are 1. The HMM\u2019s parameters are the position-specific emission probabilities. We will call such a model a chain HMM<\/em>.<\/p>\n
A chain HMM is hardly an HMM as there is nothing Markovian about it. That said, calling it out as an HMM is useful. It surfaces paths to enhancing the model as needed.<\/p>\n
An example of such an enhanced version is commonly used in biomolecular sequence analysis. It goes by the name profile HMM<\/em> [3]. A profile HMM is a chain HMM with a few judiciously chosen states and transitions added to detour off the chain at certain positions. Detour paths merge back to the chain at certain other positions. Detour paths model position-specific mutations. In biomolecular sequences, such mutations often happen. A model that captures them recognizes membership of biomolecular sequences in the modeled family more accurately.<\/p>\n
A different enhancement path from a position-specific chain HMM is into a so-called Conditional Markov Model (CMM). We will cover CMMs later in this post. We will also illustrate, in the example below, what benefits we get by moving from a chain HMM to a CMM.<\/p>\n
Example CHMM-Park-Names<\/strong>: Say we want to model national or state park names in the US. Such as Yellowstone National Park, Yosemite National Park, Castle Rock State Park, \u2026 A chain HMM is a good way to go.<\/p>\n
This HMM will be trained off a list of national plus state park names. We will set n <\/em>to the maximum number of words in an entry in this list. The position-specific emission probabilities of the chain HMM are easy to estimate. The tokenized version of a park name reveals the position of each word in it. For example, in yosemite national park<\/em>, yosemite<\/em> is the first word, national<\/em> the second, and park<\/em> the third. So from a token in a park name we know which state\u2019s emission probability to train.<\/p>\n
The model above is attractive for its simplicity and flexibility. Just train it on a list of park names. As the list gets richer, the model will improve on its own.<\/p>\n
That said, it seems a bit unnatural. A natural model for the type of park names we have in mind is<\/p>\n\t\t\t\t\t\t\t\t<\/div>\n\t\t\t\t<\/div>\n\t\t\t\t
\n\t\t\t\t
\n\t\t\t\t\t\t\t\t\t
word+ ( state | national) park<\/pre>\n\t\t\t\t\t\t\t\t<\/div>\n\t\t\t\t<\/div>\n\t\t\t\t
\n\t\t\t\t
\n\t\t\t\t\t\t\t\t\t
This just means that a park name has one or two words followed by national<\/em> or state<\/em> followed by park<\/em>.<\/p>\n
The model below is closer to the natural model we seek.<\/p>\n
Example HMM-Park-Names<\/strong>: Here we will use three states: prefix_word<\/em>, regional_word<\/em>, and park<\/em>. The state regional_word<\/em> will emit state<\/em> and national<\/em> (for now), with equal probability (for now). The state prefix_word<\/em> will emit a word in a park name that appears before regional_word. The state park<\/em> will (for now) emit the word park<\/em> with probability 1.<\/p>\n
A training set of state sequences is easy to construct? We just need a few:<\/p>\n
prefix_word regional_word park
prefix_word prefix_word regional_word park
\u2026
prefix_word prefix_word prefix_word regional_word park<\/pre>\n\t\t\t\t\t\t\t\t<\/div>\n\t\t\t\t<\/div>\n\t\t\t\t
\n\t\t\t\t
\n\t\t\t\t\t\t\t\t\t
Why not just use a regular expression then? The HMM is more accurate. Consider the phrase \u201cthe national park<\/em>\u201din some text. This phrase is not an actual national park. The HMM can in principle model this by assigning a very low probability of emitting the <\/em>from the state prefix_word<\/em>.<\/p>\n
In fact, this takes us to the topic of how to train the emission probabilities of prefix_word<\/em>? (The emission probabilities of the other states have already been settled, for now.) Here is a simple approach. Take a list of national and state park names. Strip off the last two words in each park name. The words that remain are prefix words.<\/p>\n
The state park<\/em> could be extended to emit beach<\/em>, forest<\/em>, monument,<\/em> etc. (In California, state beaches are often classified under state parks.)<\/p>\n
To get a better feel for the trade-offs between a chain HMM and an entity-based HMM, let\u2019s see another example involving the two.<\/p>\n
Example CHMM-Product:<\/strong> Consider a chain HMM to model product names. (By \u2018product name\u2019 we mean both specific products and product categories.) We could use a trained version to recognize product names in unstructured text, some that it hasn\u2019t even been trained on.<\/p>\n
This HMM will be trained off a list of product names. The training is similar to that of the park chain HMM. Remember, we just need to learn (i) the number of states and (ii) the emission probabilities from the various states.<\/p>\n
This HMM has a simple structure and is easy to train. That said, the entity-based version we describe below will likely be more accurate.<\/p>\n\t\t\t\t\t\t\t\t<\/div>\n\t\t\t\t<\/div>\n\t\t\t\t
\n\t\t\t\t
\n\t\t\t\t\t
Example HMM-Product<\/h2>\t\t\t\t<\/div>\n\t\t\t\t<\/div>\n\t\t\t\t
\n\t\t\t\t
\n\t\t\t\t\t\t\t\t\t
We might choose as our entities brand_token<\/em>, product_type_token<\/em>, product_version_token<\/em>, and product_base_name_token<\/em>. Example values are brand_token<\/em> = canon<\/em>, product_type_token<\/em> = camera<\/em>, product_version_token<\/em> = 12, product_base_name_token<\/em> = iphone<\/em>. Our HMM\u2019s states would be these entities.<\/p>\n
Why does each entity\u2019s name end with the word token<\/em>? Because the entity applies to a single token. So the state sequence associated with \u201csmart phone<\/em>\u201dwould be [product_type_token<\/em>, product_type_token<\/em>].<\/p>\n
To train this HMM we would need training sets for the various entities. These training sets could be derived from lists of brands, product types, etc. We say \u201cderived\u201d because we can\u2019t use the lists as-is if they contain multi-word entries. Consider smart phone<\/em> listed as a product type. From this, we would derive two examples: smart<\/em> \u2192 product_type_token<\/em> and phone<\/em> \u2192 product_type_token<\/em>.<\/p>\n
We also need state sequences that capture the sequences of entities in tokenized product names. We could construct such a training set manually. This isn\u2019t hard because product names tend to follow some common conventions. For instance, in many two-word product names, the first name is a brand, and the second a product type. We already saw an example: canon camera<\/em>. Consequently [brand_token<\/em>, product_type_token<\/em>] should be in the training set of state sequences.<\/p>\n\t\t\t\t\t\t\t\t<\/div>\n\t\t\t\t<\/div>\n\t\t\t\t
\n\t\t\t\t
\n\t\t\t\t\t
Automatically Deriving State Sequences From Product Names<\/h2>\t\t\t\t<\/div>\n\t\t\t\t<\/div>\n\t\t\t\t
\n\t\t\t\t
\n\t\t\t\t\t\t\t\t\t
Constructing state sequences manually will get us quite far. A few state sequences cover a lot of product names. That said, the manual approach risks not scaling to a robust industrial-strength model, one covering millions of products. The product names may span a long tail of state sequences. Consider the state sequence [product_type_token<\/em>,\u00a0brand_token<\/em>]. Some product names follow this convention.<\/p>
As it turns out, we can automate the construction of state sequences from the tokenized product names. This way as we add more and more products to our training set, state sequences automatically get extracted from them.<\/p>\n
Basic version<\/strong>: The basic idea is to take the tokenized product name and, for each word in it, find its most-likely entity. We can do this because we have training sets of (word, entity) pairs for the various entities.<\/p>\n
Let\u2019s see a simple example.<\/p>\n\t\t\t\t\t\t\t\t<\/div>\n\t\t\t\t<\/div>\n\t\t\t\t
\n\t\t\t\t
\n\t\t\t\t\t\t\t\t\t
canon camera \u21d2 [canon,camera] \u21d2 [brand_token,product_type_token]<\/pre>\n\t\t\t\t\t\t\t\t<\/div>\n\t\t\t\t<\/div>\n\t\t\t\t
\n\t\t\t\t
\n\t\t\t\t\t\t\t\t\t
Refined version<\/strong>: We can refine this basic idea as follows. As before, we tokenize the product name. We then run the sequence of tokens through the HMM to find a state sequence that fits it best.<\/p>\n
This refinement uses information from both the entity training sets and from the HMM\u2019s state transitions. Consequently, it can be more accurate.<\/p>\n
I like to call this approach \u201cbootstrap training\u201d. We initialize the HMM manually. This includes seeding it with whatever state sequences we choose to. We can then run tokenized product names through it in the hope of discovering more state sequences.<\/p>\n
To enable the discovery of new state sequences, when initializing the HMM, we should allow transitions from all states to all states. (Other than from the state begin<\/em> to the state end<\/em> and any going out from the state end<\/em>.) We can initialize our training set for these transitions automatically, so that the initial probabilities on these transitions are very low, albeit not zero. We call this pseudo-training.<\/p>\n
Curation<\/strong>: It’s possible that some of the new state sequences we discover via \u201cbootstrap training\u201d have errors in them. So these should be reviewed by humans. Nonetheless, we have probably benefited despite the human in the loop. Manually discovering new state sequences is a lot more time consuming than curating automatically discovered ones.<\/p>\n\t\t\t\t\t\t\t\t<\/div>\n\t\t\t\t<\/div>\n\t\t\t\t
\n\t\t\t\t
\n\t\t\t\t\t
Conditional Markov Model<\/h2>\t\t\t\t<\/div>\n\t\t\t\t<\/div>\n\t\t\t\t
\n\t\t\t\t
\n\t\t\t\t\t\t\t\t\t
Just like an HMM, a conditional Markov model (CMM) operates on (token sequence<\/em>, state sequence<\/em>) pairs. Unlike an HMM a CMM is optimized for finding the best state sequence for a given token sequence. What exactly does this mean? This will get gradually clear in the examples below.<\/p>\n
That said, in this post, we will not discuss how to find the best state sequence for a given token sequence. We will discuss how to score a particular state sequence for a given token sequence. This scoring will surface the \u201cconditional\u201d part in CMM.<\/p>\n
Example CMM1 (First Part)<\/strong>: Imagine training a language model on (tokenized full person name<\/em>, token entities<\/em>) pairs, with the aim of using it to parse person names. Parsing means to break up a person\u2019s name into its constituents. Such as first name and last name.<\/p>\n
Consider the name John K Smith<\/em>. The model should be able to infer that K<\/em> is a middle name word. Even if the training set does not contain a K<\/em> emitted from middle_name_word<\/em>.<\/p>\n
The CMM directly models this as<\/p>\n\t\t\t\t\t\t\t\t<\/div>\n\t\t\t\t<\/div>\n\t\t\t\t
\n\t\t\t\t
\n\t\t\t\t\t\t\t\t\t
P(state[2] = middle_name_word | state[1] = first_name_word, token[2] = K)P(state[2] = middle_name_word | state[1] = first_name_word)*P(token[2] = K | state[2] = middle_name_word)<\/pre>\n\t\t\t\t\t\t\t\t<\/div>\n\t\t\t\t<\/div>\n\t\t\t\t
\n\t\t\t\t
\n\t\t\t\t\t\t\t\t\t
How is this beneficial, compared to how the HMM models it.<\/p>\n
Towards answering this question, first let\u2019s abstract out the specifics of this example. We have P<\/em>(S<\/em>[i<\/em>+1] | S<\/em>[i<\/em>], X<\/em>[i<\/em>+1]) for the CMM versus P<\/em>(S<\/em>[i<\/em>+1] | S<\/em>[i<\/em>])*P<\/em>(X<\/em>[i<\/em>+1] | S<\/em>[i<\/em>+1]) for the HMM. Here X<\/em>[i<\/em>] is the i<\/em>th token and S<\/em>[i<\/em>] the state from which it was emitted.<\/p>\n
The CMM approach may be viewed as a multinomial classifier whose input is the pair (S<\/em>[i<\/em>], X<\/em>[i<\/em>+1]), and whose output is a probability distribution over the various values S<\/em>[i<\/em>+1] can take. This formulation lends itself to extracting any features that we see fit from the input. Possibly overlapping. Possibly taking into account interactions among S<\/em>[i<\/em>] and X<\/em>[i<\/em>+1].<\/p>\n
We can now use any multinomial classifier algorithm on this problem. Such as (multinomial) logistic regression, decision trees, or random forest.<\/p>\n
By contrast, the HMM cannot capture interactions between S<\/em>[i<\/em>] and X<\/em>[i<\/em>+1]. Nor can it accommodate arbitrary features. Nor can it leverage sophisticated machine learning classifier algorithms. The CMM on the other hand cannot leverage the entity training sets. We no longer learn emission probabilities.<\/p>\n
Example CMM 1 (completed)<\/strong>: Let\u2019s complete this example. Starting with the features. From input (S<\/em>[i<\/em>], X<\/em>[i<\/em>+1]) we will extract the features state <\/em>= S<\/em>[i<\/em>], token<\/em> = X<\/em>[i+1], token length<\/em> = number of characters in X<\/em>[i<\/em>+1]. That is, we have three predictors: state<\/em>, token<\/em>, and token length<\/em>. Each is categorical. The response is the value of S<\/em>[i<\/em>+1]. Also categorical.<\/p>\n
Why these features? The feature state<\/em> lets us model the influence of the current state on the next state. The feature token<\/em> let\u2019s us use the actual value of the token as a predictor of its state. This is useful. Certain tokens favor certain entities. For example, John<\/em> is much more likely to be a first name word than the last name word. As an added bonus we get the interaction between state<\/em> and token<\/em> for free so long as our learning algorithm can exploit it. (If there is an interaction that is.) The feature token length<\/em> is useful because we know that a token\u2019s length favors certain entities over others. First or middle names are often one character long. Last names hardly ever.<\/p>\n
Let\u2019s see a few training examples. We\u2019ll start with (token sequence<\/em>, state sequence<\/em>) pairs.<\/p>\n\t\t\t\t\t\t\t\t<\/div>\n\t\t\t\t<\/div>\n\t\t\t\t
\n\t\t\t\t
\n\t\t\t\t\t\t\t\t\t
John   Smith                        John    K    Smith
first  last                         first middle last<\/pre>\n\t\t\t\t\t\t\t\t<\/div>\n\t\t\t\t<\/div>\n\t\t\t\t
\n\t\t\t\t
\n\t\t\t\t\t\t\t\t\t
From these let\u2019s derive a few training instances for the CMM formulation. (We don\u2019t show all.) The first three columns list the predictors. The last one lists the response.<\/p>\n\t\t\t\t\t\t\t\t<\/div>\n\t\t\t\t<\/div>\n\t\t\t\t
\n\t\t\t\t
\n\t\t\t\t\t\t\t\t\t
(previous)<\/strong> state<\/strong>    token<\/strong>   token's length<\/strong>             state<\/strong>
       first          K             1                  middle
       begin         John           4                  first
       first         Smith          5                  last
         \u2026             \u2026            \u2026                  \u2026<\/pre>\n\t\t\t\t\t\t\t\t<\/div>\n\t\t\t\t<\/div>\n\t\t\t\t
\n\t\t\t\t
\n\t\t\t\t\t\t\t\t\t
The first training instance above reads as \u201c(previous state<\/em> equaling first<\/em>, token equaling K<\/em>, token\u2019s length equalling 1)\u201d leads to next state being middle<\/em>\u201d.<\/p>\n
Example CMM 2 (Sketched)<\/strong>: Consider parsing US street addresses. For simplicity assume they have the form<\/p>\n\t\t\t\t\t\t\t\t<\/div>\n\t\t\t\t<\/div>\n\t\t\t\t
\n\t\t\t\t
\n\t\t\t\t\t\t\t\t\t
street_num_word (street_name_word)+ street_suffix [unit_prefix unit_num_word]<\/pre>\n\t\t\t\t\t\t\t\t<\/div>\n\t\t\t\t<\/div>\n\t\t\t\t
\n\t\t\t\t
\n\t\t\t\t\t\t\t\t\t
Below are some pairs of tokenized US street addresses together with their entities. The entity names are abbreviated so the examples can fit in the space allocated.<\/p>\n\t\t\t\t\t\t\t\t<\/div>\n\t\t\t\t<\/div>\n\t\t\t\t
\n\t\t\t\t
\n\t\t\t\t\t\t\t\t\t
123             Marine           Dr
street_num_word street_name_word street_suffix203             Lake             Forest           Ave
street_num_word street_name_word street_name_word street_suffix123             Main             St            Apt         22
street_num_word street_name_word street_suffix unit_prefix unit_num<\/pre>\n\t\t\t\t\t\t\t\t<\/div>\n\t\t\t\t<\/div>\n\t\t\t\t
\n\t\t\t\t
\n\t\t\t\t\t\t\t\t\t
For the design of our features, let\u2019s start by focusing on those extracted from a token. Which features of a token discriminate among the various entities? The actual value of the token can predict whether it is a street_name_word<\/em> or a street_suffix<\/em> or a unit_prefix<\/em>. The presence of digits predicts that it is a street_num_word<\/em> or a unit_num_word<\/em>.<\/p>\n
In view of this, from input (S<\/em>[i<\/em>], X<\/em>[i<\/em>+1]) we will extract the features state <\/em>= S<\/em>[i<\/em>], token<\/em> = X<\/em>[i+1], proportion_of_digits_in_token<\/em> = fraction of characters in X<\/em>[i<\/em>+1] that are digits.<\/p>\n\t\t\t\t\t\t\t\t<\/div>\n\t\t\t\t<\/div>\n\t\t\t\t
\n\t\t\t\t
\n\t\t\t\t\t
Conditional Random Fields<\/h2>\t\t\t\t<\/div>\n\t\t\t\t<\/div>\n\t\t\t\t
\n\t\t\t\t
\n\t\t\t\t\t\t\t\t\t
Just like a CMM, a CRF operates on (S<\/em>, X) pairs where X<\/em> denotes a token sequence and S its state sequence. Both model P<\/em>(S<\/em>|X<\/em>), to optimize for the use case of finding a high-probability state sequence S <\/em>for a given X<\/em>.<\/p>\n
The CMM factors this as<\/p>\n
P<\/em>(S<\/em>|X<\/em>) = product_i<\/em> P<\/em>(S<\/em>[i<\/em>] | X[i-1], S<\/em>[i-1]) (CMM 1)<\/strong><\/p>\n
That is, the probability of state S<\/em>[i<\/em>] is conditioned on the previous state S<\/em>[i<\/em>-1] and the current token X<\/em>[i<\/em>].<\/p>\n
The CRF is less restrictive. That is, it accommodates more general P(S|X).<\/p>\n
The CRF operates on an undirected graph whose nodes model states and whose edges model direct influences among pairs of states. These influences are symmetric.<\/p>\n
In this post, we will limit ourselves to a linear-chain CRF. It has the structure<\/p>\n
S<\/em>[1] \u2014 S<\/em>[2] \u2014 S<\/em>[3] \u2014 \u2026 \u2014 S<\/em>[n]<\/p>\n
This just models that a state is influenced by the previous state and the next state. That is, S[i] is directly influenced by S[i-1] and by S[i+1].<\/p>\n
In the CRF world, the linear CRF is the closest analog to a CMM. So let\u2019s look into it in more detail.<\/p>\n
The linear CRF models P<\/em>(S<\/em>|X<\/em>) as<\/p>\n
P<\/em>(S<\/em>|X) is proportional to product_i<\/em> product_f P<\/em>(f<\/em>)*e^f<\/em>(S<\/em>[i<\/em>-1], S<\/em>[i<\/em>], X<\/em>) (CRF 1)<\/strong><\/p>\n
The intuition is a bit easier to convey if we define a score C<\/em>(S<\/em>, X<\/em>) from this by taking logs.<\/p>\n
C<\/em>(S<\/em>, X<\/em>) = sum_i sum_f w(f)*f(S[i-1],S[i],X) (CRF 2)<\/strong><\/p>\n
We call it C<\/em> because we think of it as a compatibility function. As a function of S, C(S, X) is monotone in P(S|X). So for the purposes of finding high-scoring state sequences, C(S, X) works equally well.<\/p>\n
What is f<\/em>? It\u2019s a feature function that scores the compatibility of the triple (S[i-1], S[i], and X) along some dimension. More positive values are more compatible. w<\/em>(f<\/em>) is f<\/em>\u2019s weight. It controls the compatibility\u2019s strength and direction.<\/p>\n
We can have as many feature functions as we choose.<\/p>\n
Okay, so in a linear CRF, we have a set of possibly overlapping feature functions. Each is applied to every edge. That said, they can use any information from any subset of the tokens in X. By contrast, CMMs only score compatibility of (S<\/em>[i<\/em>-1], S<\/em>[i<\/em>], X<\/em>[i<\/em>]) triples.<\/p>\n
At this point, it\u2019s best to see a concrete example with specific feature functions.<\/p>\n
Example CRF 1<\/strong>: Consider a generalized version of an example we saw earlier. Parse global street addresses. The generalization is that we are going global.<\/p>\n
Street addresses across the globe come in many different formats. In some, street numbers come before the street name, in some after. Some start with units, others end with them. (An example of a unit is \u201cApt 30\u201d.) These are just a few of the variations.<\/p>\n
Global street addresses also have varying quality, in terms of how well they adhere to the format for their locale. We want to be able to parse poor-quality addresses as well as possible.<\/p>\n
Let\u2019s see two examples<\/strong><\/p>\n
123 St Francis St
Rue du Vivier 15<\/pre>\n
The first one is a US one, the second one Belgian. In addition to the positions of the street numbers and names, the positions of the street keywords also vary. (In these examples, \u2018St\u2019 and \u2018Rue\u2019 are street keywords.)<\/p>\n
We\u2019ll use a linear-chain CRF.<\/p>\n
Are there any global features we should extract from the tokenized street address? Two come to mind: country<\/em> and language.<\/em><\/p>\n
Both the language and the country influence address formats. These factors overlap, but they also have complementary influences. Such is the case of Belgian vs French addresses, both written in French. In some aspects they are similar. In other aspects, they are not. That is the country matters.<\/p>\n
In view of this, we should include both.<\/strong><\/p>\n
We\u2019ll build two specific feature functions around these.<\/p>\n\t\t\t\t\t\t\t\t<\/div>\n\t\t\t\t<\/div>\n\t\t\t\t
\n\t\t\t\t
\n\t\t\t\t\t\t\t\t\t
F1<\/strong>: country-edge compatibilities: (S[i-1],S[i], country(X))
F2<\/strong>: language-edge compatibilities: (S[i-1],S[i], country(X))<\/pre>\n\t\t\t\t\t\t\t\t<\/div>\n\t\t\t\t<\/div>\n\t\t\t\t
\n\t\t\t\t
\n\t\t\t\t\t\t\t\t\t
We\u2019ll add a third feature function to prefer tokens that are compatible with their tagged states.<\/p>\n\t\t\t\t\t\t\t\t<\/div>\n\t\t\t\t<\/div>\n\t\t\t\t
\n\t\t\t\t
\n\t\t\t\t\t\t\t\t\t
F3<\/strong>: state-token compatibilities: (S[i], X[i])<\/pre>\n\t\t\t\t\t\t\t\t<\/div>\n\t\t\t\t<\/div>\n\t\t\t\t
\n\t\t\t\t
\n\t\t\t\t\t\t\t\t\t
Training<\/strong>: F1 and F2 may be trained from (tokenized street address<\/em>, state sequence<\/em>) pairs tagged with their country and language. Transitions from S<\/em>[i<\/em>-1] to S<\/em>[i<\/em>] which are compatible with the country and language score high, those that are not don\u2019t. F3 may be trained from the (state<\/em>, token<\/em>) pairs in the training set.<\/p>\n\t\t\t\t\t\t\t\t<\/div>\n\t\t\t\t<\/div>\n\t\t\t\t
\n\t\t\t\t
\n\t\t\t\t\t
Further Reading<\/h4>\t\t\t\t<\/div>\n\t\t\t\t<\/div>\n\t\t\t\t
\n\t\t\t\t
\n\t\t\t\t\t\t\t\t\t
  1. https:\/\/www.cl.cam.ac.uk\/teaching\/1718\/R228\/lectures\/lec9.pdf<\/a><\/li>
  2. Maximum-entropy Markov model<\/a><\/li>
  3. https:\/\/www.ebi.ac.uk\/training-beta\/online\/courses\/pfam-creating-protein-families\/what-are-profile-hidden-markov-models-hmms\/#:~:text=Profile%20HMMs%20are%20probabilistic%20models,the%20alignment%2C%20see%20Figure%202<\/a>.<\/li>
  4. CS838\u20131 Advanced NLP: Conditional Random Fields<\/a><\/li>
  5. Conditional Random Fields: Probabilistic Models for Segmenting and Labeling Sequence Data<\/a><\/li><\/ol>\n\t\t\t\t\t\t\t\t<\/div>\n\t\t\t\t<\/div>\n\t\t\t\t\t<\/div>\n\t\t<\/div>\n\t\t\t\t\t<\/div>\n\t\t<\/section>\n\t\t\t\t<\/div>\n\t\t","protected":false},"excerpt":{"rendered":"
    This post covers statistical language models from simple to elaborate. The covered models include Independent model, first-order Markov model, Kth-order Markov model, Hidden Markov Model, Conditional Markov model, and Conditional Random Fields. Each is illustrated with realistic examples and use cases.<\/p>\n","protected":false},"author":1044,"featured_media":18612,"comment_status":"open","ping_status":"open","sticky":false,"template":"","format":"standard","meta":{"content-type":"","footnotes":""},"categories":[183],"tags":[1310,1311,1312,1313,474,1314],"ppma_author":[3691],"class_list":["post-22605","post","type-post","status-publish","format-standard","has-post-thumbnail","hentry","category-ai-ml","tag-conditional-markov-models","tag-conditional-random-fields","tag-hidden-markov-models","tag-markov-models","tag-nlp","tag-statistical-language-models"],"authors":[{"term_id":3691,"user_id":1044,"is_guest":0,"slug":"arun-jagota","display_name":"Arun Jagota","avatar_url":"https:\/\/www.experfy.com\/blog\/wp-content\/uploads\/2021\/05\/Arun-Jagota-150x150.jpeg","user_url":"https:\/\/www.salesforce.com\/in\/?ir=1","last_name":"Jagota","first_name":"Arun","job_title":"","description":"Arun Jagota is Director of Data Science at Salesforce.com. A PhD in computer science, he has taught undergraduate, graduate, and continuing education courses in Computer Science at many US Universities from 1992 through 2006. He has written a number of books, most available at Amazon.com, 50 academic publications and has 17+ patents issued."}],"_links":{"self":[{"href":"https:\/\/www.experfy.com\/blog\/wp-json\/wp\/v2\/posts\/22605","targetHints":{"allow":["GET"]}}],"collection":[{"href":"https:\/\/www.experfy.com\/blog\/wp-json\/wp\/v2\/posts"}],"about":[{"href":"https:\/\/www.experfy.com\/blog\/wp-json\/wp\/v2\/types\/post"}],"author":[{"embeddable":true,"href":"https:\/\/www.experfy.com\/blog\/wp-json\/wp\/v2\/users\/1044"}],"replies":[{"embeddable":true,"href":"https:\/\/www.experfy.com\/blog\/wp-json\/wp\/v2\/comments?post=22605"}],"version-history":[{"count":4,"href":"https:\/\/www.experfy.com\/blog\/wp-json\/wp\/v2\/posts\/22605\/revisions"}],"predecessor-version":[{"id":32290,"href":"https:\/\/www.experfy.com\/blog\/wp-json\/wp\/v2\/posts\/22605\/revisions\/32290"}],"wp:featuredmedia":[{"embeddable":true,"href":"https:\/\/www.experfy.com\/blog\/wp-json\/wp\/v2\/media\/18612"}],"wp:attachment":[{"href":"https:\/\/www.experfy.com\/blog\/wp-json\/wp\/v2\/media?parent=22605"}],"wp:term":[{"taxonomy":"category","embeddable":true,"href":"https:\/\/www.experfy.com\/blog\/wp-json\/wp\/v2\/categories?post=22605"},{"taxonomy":"post_tag","embeddable":true,"href":"https:\/\/www.experfy.com\/blog\/wp-json\/wp\/v2\/tags?post=22605"},{"taxonomy":"author","embeddable":true,"href":"https:\/\/www.experfy.com\/blog\/wp-json\/wp\/v2\/ppma_author?post=22605"}],"curies":[{"name":"wp","href":"https:\/\/api.w.org\/{rel}","templated":true}]}}