Syntactic analysis in NLP

PARSING
Submitted by:-
Kartika
URN-1805192 CRN-1815040 CSA2

PARSING ?
● Also called as Syntactic analysis or syntax analysis
● Syntactic analysis or parsing or syntax analysis is the third phase of NLP
● The word ‘Parsing’ is originated from Latin word ‘pars’ (which means ‘part’)
● Comparing the rules of formal grammar, syntax analysis checks the text for
meaningfulness.
● The sentence like “Give me hot ice-cream”, for example, would be rejected by
parser or syntactic analyzer.
● The purpose of this phase is to draw exact meaning, or you can say dictionary
meaning from the text.

It may be defined as the process of
analyzing the strings of symbols in
natural language conforming to the rules
of formal grammar.

ROLE OF PARSER
➢ To report any syntax error.
➢ It helps to recover from commonly occurring error so that the processing of the
remainder of program can be continued.
➢ To create parse tree
➢ To create symbol table.
➢ To produce intermediate representations (IR).

DEEPVS SHALLOW PARSING
DEEP PARSING SHALLOW PARSING
In deep parsing, the search strategy will give a
complete syntactic structure to a sentence
It is the task of parsing a limited part of the syntactic
information from the given task.
It is suitable for complex NLP applications It can be used for less complex applications
EXAMPLES:- Dialogue Summarisation and
summarisation
EXAMPLES:- Information extraction and text mining
It is called Full Parsing It is called Chunking

TYPES OF PARSING
Parsing is classified into two categories, i.e.
Top Down Parsing and Bottom-Up Parsing.
Top-Down Parsing is based on Left Most Derivation
Bottom Up Parsing is dependent on Reverse rightmost
Derivation.

DERIVATION
Derivation is a sequence of production rules. It is used to get the input
string through these production rules. During parsing we have to take
two decisions. These are as follows:
● We have to decide the non-terminal which is to be replaced.
● We have to decide the production rule by which the non-terminal will
be replaced.
Types of Derivation: Leftmost and rightmost

LEFT MOST DERIVATION
In the leftmost derivation, the input is scanned and replaced with the production rule from left
to right. So in left most derivatives we read the input string from left to right.
Example:
Production rules:
1. S = S + S
2. S = S - S
3. S = a | b |c
INPUT
a - b + c

EXAMPLE OF LEFT MOST DERIVATION
1. S = S + S
2. S = S - S + S
3. S = a - S + S
4. S = a - b + S
5. S = a - b + c

RIGHT MOST DERIVATION
In the right most derivation, the input is scanned and replaced with the production
rule from right to left. So in right most derivatives we read the input string from right
to left.
EXAMPLE:-
1. S = S - S
2. S = S - S + S
3. S = S - S + c
4. S = S - b + c
5. S = a - b + c

TOP DOWN PARSING
The process of constructing the parse tree which starts from the root and goes down to the leaf is Top-Down
Parsing.
● Top-Down Parsers constructs from the Grammar which is free from ambiguity and left recursion.
● Top Down Parsers uses leftmost derivation to construct a parse tree.
● It allows a grammar which is free from Left Factoring.
EXAMPLE OF LEFT FACTORING-
S → iEtS / iEtSeS / a
E → b

WORKING OF TOP DOWN PARSER
EXAMPLE:-
S -> aABe
A -> Abc | b
B -> d
Input –
abbcde

Now, you will see that how top down approach works. Here, you will see how you can generate a input string
from the grammar for top down approach.
● First, you can start with S -> a A B e and then you will see input string a in the beginning and e in the
end.
● Now, you need to generate abbcde .
● Expand A-> Abc and Expand B-> d.
● Now, You have string like aAbcde and your input string is abbcde.
● Expand A->b.
● Final string, you will get abbcde.

BOTTOM UP PARSER OR SHIFT REDUCE PARSERS
Bottom Up Parsers / Shift Reduce Parsers
Build the parse tree from leaves to root. Bottom-up parsing can be defined as an attempt to reduce the input
string w to the start symbol of grammar by tracing out the rightmost derivations of w in reverse.

BOTTOM UP PARSER
There are two unique steps for bottom-up parsing. These steps are known as shift-step and
reduce-step.
● Shift step: The shift step refers to the advancement of the input pointer to the next input
symbol, which is called the shifted symbol. This symbol is pushed onto the stack. The shifted
symbol is treated as a single node of the parse tree.
● Reduce step : When the parser finds a complete grammar rule (RHS) and replaces it to
(LHS), it is known as reduce-step. This occurs when the top of the stack contains a handle. To
reduce, a POP function is performed on the stack which pops off the handle and replaces it
with LHS non-terminal symbol.

LR PARSER
A general shift reduce parsing is LR parsing. The L stands for scanning the input from left to right and R stands for
constructing a rightmost derivation in reverse.
Benefits of LR parsing:
1. Many programming languages using some variations of an LR parser. It should be noted that C++ and Perl are
exceptions to it.
2. LR Parser can be implemented very efficiently.
3. Of all the Parsers that scan their symbols from left to right, LR Parsers detect syntactic errors, as soon as
possible.

ISSUES IN BASIC PARSING
√ Never explores trees that aren’t potential solutions, ones with the wrong
kind of root node.
X But explores trees that do not match the input sentence (predicts input
before inspecting input).
X Naive top-down parsers never terminate if G contains recursive rules like X
→ X Y (left recursive rules).
X Backtracking may discard valid constituents that have to be re-discovered
later (duplication of eﬀort)

EARLEYALGORITHM
The Earley Parsing Algorithm:
an efficient top-down parsing algorithm that avoids some of the inefficiency
associated with purely naive search with the same top-down strategy
In naive search, top-down parsing is inefficient because structures are created
over and over again.

Intermediate solutions are created only once and stored in a chart (dynamic
programming).
Left-recursion problem is solved by examining the input.
Earley is not picky about what type of grammar it accepts, i.e., it accepts
arbitrary CFGs.

function Earley-Parse(words,grammar) returns chart
Enqueue((γ → •S, [0,0]),chart[0])
for i ← from 0 to Length(words) do
for each state in chart[i] do
if Incomplete?(state) and Next-Cat(state) is not POS then
Predictor(state)
elseif Incomplete?(state) and Next-Cat(state) is POS then
Scanner(state)
else
Completer(state)
end
end
return(chart)

A state consists of:
1) A subtree corresponding to a grammar rule S → NP VP
2) Info about progress made towards completing this subtree S → NP • VP
3) The position of the subtree wrt input S → NP • VP, [0, 3]
4) Pointers to all contributing states in the case of a parser
A dotted rule is a data structure used in top-down parsing to record partial
solutions towards discovering a constituent.
Earley: fundamental operations
1) Predict sub-structure (based on grammar)
2) Scan partial solutions for a match
3) Complete a sub-structure (i.e., build constituents)

How to represent progress towards ﬁnding an S node?
Add a dummy rule to grammar: γ → • S
This seeds the chart as the base case for recursion.
Earley's dot notation: given a production X → αβ, the notation X → α • β represents a condition in which α has already
been parsed and β is expected.

CYKALGORITHM
CYK algorithm is a parsing algorithm for context free grammar.
In order to apply CYK algorithm to a grammar, it must be in
Chomsky Normal Form. It uses a dynamic programming algorithm
to tell whether a string is in the language of a grammar.

“abbb”
Length 1 strings:
a,b,b,b
a =>(11) or (aa) , a can be derived from A
b=>(44) or (33) or (22), b can derived from B
Length 2 strings
ab =>(11)or (22) ,(11)=>A and (22)=>B ,concatenate them
ie AB ,AB can be derived from {S,B}
bb =>22 or 33 ,22=>B and 33=>B, concatenate them ie BB can be derived from { A}
S->AB,A->BB|a,B->AB |b

“abbb” S->AB,A->BB|a,B->AB |b
abb (11) and (23) or 12 and 33
AA or (SB) and B=> SB and BB
“bbb”=>234
22 and 34 or 23 and 44
BA or AB =>S and B
“abbb” 1234
11+24 and 12+34 and 13+44
{S,B}

S->AB,A->BB|a,B->AB |b Input_string=”abbb”
b (4) b (3) b (2) a (1)
a (1) {B,S} {A} {S,B} {A}
b (2) {B,S} {A} {B}
b (3) {A} {B}
b (4) {B}

S->AB|BC,A->BA|a,B->CC|b,C->AB|a “baaba”
b (1) a (2) a(3) b (4) a(5)
b (1)
a (2)
a (3)
b (4)
a (5)

Parsing using Probabilistic Context
Free Grammars

REFERENCES
Basics of
PCFG:-https://www.youtube.com/watch?v=wSONlMwa9rE&list=PLlQBy7xY8mbKypSJe_AjVtCuXXsdODiDi
&index=3
https://www.youtube.com/watch?v=DjwH9wzCFzg&list=PLlQBy7xY8mbKypSJe_AjVtCuXXsdODiDi&index=
4
CYK ALGORITHM:-
https://www.youtube.com/watch?v=xRMn6HK84io
https://www.geeksforgeeks.org/cyk-algorithm-for-context-free-grammar/
PARSING:-
https://www.tutorialspoint.com/compiler_design/compiler_design_types_of_parsing.htm
Documents: http://www.cs.columbia.edu/~mcollins/courses/nlp2011/notes/pcfgs.pdf

Syntactic analysis in NLP

More Related Content

What's hot (20)

Similar to Syntactic analysis in NLP (20)

Recently uploaded (20)

Syntactic analysis in NLP