Rule-based or Statistics-based approach for generating plain language grammar rules from a text

Question

Disclaimer: I am a software developer, not a computational linguist and I am not super familiar (though I am mildly familiar) with the field. Happy to learn and be corrected though!

My use-case:

I am trying to analyze a text in Chinese, and have grammar rules printed out (in English) based on what appears in the text. These would be simple sentences describing the grammar rule in question.

I have explored several statistics-based parsers (Stanford, SyntaxNet, and SpaCy) and I am looking into how rule-based processing works and I'm somewhat lost - I'm not sure what the right approach is here. It seems that what I want (my guess) is a rule-based approach, and then just mapping that into plain text language - but I don't know what I don't know.

Ideally a solution would be made for Python as that's the language the rest of the application is being done in with the anticipation that most language tools will be available for it.

I am certainly open for using a tool in a different language or even a different approach entirely if that's the best idea.

Here is an example sentence:

人们都穿上了很厚的衣服。

This would generate, for example, this grammar rule:

Verb / Verb Phrase + 了 - Expressing that an action has been completed with "Verb / Verb Phrase + 了"

Due to detecting 了, as long as this character was being used in that particular grammatical way above.

So basically it would look for certain characters, see how they are being used in a sentence, and then spit out a plain text English language rule based on that (presumably based on some mapping of the grammar rules to plain text English that I would write)

My knowledge of computational linguistics is somewhat limited (I am a layman, though I am reading heavily every day) so I am trying to understand the best way forward for this goal.

Answer 1

Ok, so I've got a basic example in code - I'll ultimately write my algorithm to be more efficient and right now it is only written for the one use-case (I haven't generalized it/made it so that you can have multiple daughters under a rule yet), but right now I'm just writing it out for one single rule to show an example of what I ultimately want to do.

If there is a more efficient way to do what I am doing, PLEASE tell me, as I don't know what I don't know on this subject. I am using PyDelphin for the analysis. EDITTED WITH NEWEST VERSION

from delphin.interfaces import ace
zhs = 'zhs.dat'

grammar = zhs

parse_string = '我 看 了 猴子 的 雪白 雪白 的 小小 的 猫'

print("PARSE STRING: " + parse_string)

with ace.AceParser(grammar,
                    cmdargs=['-n', '50']) as parser:
                        tree = parser.interact(parse_string).results()[9].derivation()

# Maybe reverse mapping so that long form POS is key?
pos_mapping = {
    'j': 'adjective',
    'pfv': 'perfective aspect',
}

def redup_post_processing(phrase):
    phrase = phrase.replace('々', phrase)
    phrase = phrase.replace('々', "")
    return phrase

def pos_generate(node):
    pos_level = node.preterminals()[0].entity
    TAG = pos_level.split("_")[1]
    POS = pos_mapping[TAG]
    return POS

def grammar_rule_gen(node, data):
    POS = pos_generate(node)
    phrase = node.terminals()[0].form
    if 'postprocess' in data.keys():
        phrase = data['postprocess'](phrase)
    print(data['text'] + POS + ' ' +  phrase)

functions = {
    'redup-olr': {"function": grammar_rule_gen, "text": "Expressing reduplication with the ", "postprocess": redup_post_processing},
    '了_pfv': {"function": grammar_rule_gen, "text": "Expressing completion with the "},
}

def tree_parse(tree):
    if hasattr(tree, 'daughters'):
        daughters = tree.daughters
        for daughter in daughters:
            if hasattr(daughter, 'entity'):
                if daughter.entity in functions:
                    functions[daughter.entity]['function'](daughter, functions[daughter.entity])
            tree_parse(daughter)

tree_parse(tree)

Now when I run this, it accurately gets me the rule in question that I want - here is my output:

PARSE STRING: 我 看 了 猴子 的 雪白 雪白 的 小小 的 猫
NOTE: parsed 2 / 2 sentences, avg 45873k, time 0.22833s
Expressing completion with the perfective aspect 了
Expressing reduplication with the adjective 雪白雪白
Expressing reduplication with the adjective 小小

And here is the original rule in the grammar (々 is a Japanese character used in Chinese on occasion to represent reduplication - https://en.wiktionary.org/wiki/%E3%80%85):

redup-olr :=
%suffix (* 々)
redup-lex-rule.

And here is the 了 rule:

了_pfv := pfv-marker &
  [ STEM <"了">,
    SYNSEM.LOCAL.CAT.HEAD.CHAR [ FCHAR "了", LENGTH one ],
    SYNSEM.LOCAL.CAT.VAL.COMPS < [ LOCAL.CAT.HEAD.LZG le ] >,
    TRAITS native_token_list ].

Now it would be awesome to just apply these rules as the text was processed - but that would require me writing an extension for ACE or a custom parser (which I guess on some level, I am sorta doing, but nowhere near as complex), and that feels far more complicated than what I am doing here.

Is this the most efficient way to do what I want to do?

This IS a solution to my problem, but I am not sure if it is the most elegant, or computationally cheap.