Создание матрицы смежности из XML в Python

Я пытаюсь создать матрицу смежности t_lemma (другие элементы, такие как nodetype, ord и т. д., можно игнорировать, я включаю их просто для полноты на случай, если они каким-то образом понадобятся) — то есть, какая t_lemma является родителем какой — из этого XML-документа, представляющего синтаксический анализ (чешского) предложения, где < strong>t_lemma представляет нейтральную форму определенного слова.

В настоящее время я использую библиотеку cElementTree для Python, но я открыт для использования какой-либо другой, если то, что я прошу, невозможно или время вычислений трудно достичь с помощью cElementTree

<t_tree id="t_tree-cs-s1-root">
    <atree.rf>a_tree-cs-s1-root</atree.rf>
    <ord>0</ord>
    <children id="t_tree-cs-s1-n107">
        <children>
            <LM id="t_tree-cs-s1-n108">
                <nodetype>complex</nodetype>
                <ord>1</ord>
                <t_lemma>muž</t_lemma>
                <functor>ACT</functor>
                <formeme>n:1</formeme>
                <is_clause_head>0</is_clause_head>
                <clause_number>1</clause_number>
                <a>
                    <lex.rf>a_tree-cs-s1-n1</lex.rf>
                </a>
                <gram>
                    <sempos>n.denot</sempos>
                    <gender>anim</gender>
                    <number>sg</number>
                    <negation>neg0</negation>
                </gram>
            </LM>
            <LM id="t_tree-cs-s1-n109">
                <nodetype>complex</nodetype>
                <ord>3</ord>
                <t_lemma>strom</t_lemma>
                <functor>PAT</functor>
                <formeme>n:4</formeme>
                <is_clause_head>0</is_clause_head>
                <clause_number>1</clause_number>
                <a>
                    <lex.rf>a_tree-cs-s1-n3</lex.rf>
                </a>
                <gram>
                    <sempos>n.denot</sempos>
                    <gender>inan</gender>
                    <number>sg</number>
                    <negation>neg0</negation>
                </gram>
            </LM>
        </children>
        <nodetype>complex</nodetype>
        <ord>2</ord>
        <t_lemma>zasadit</t_lemma>
        <functor>PRED</functor>
        <formeme>v:fin</formeme>
        <sentmod>enunc</sentmod>
        <is_clause_head>1</is_clause_head>
        <clause_number>1</clause_number>
        <a>
            <lex.rf>a_tree-cs-s1-n2</lex.rf>
        </a>
        <gram>
            <sempos>v</sempos>
            <verbmod>ind</verbmod>
            <deontmod>decl</deontmod>
            <tense>ant</tense>
            <aspect>cpl</aspect>
            <resultative>res0</resultative>
            <dispmod>disp0</dispmod>
            <iterativeness>it0</iterativeness>
            <negation>neg0</negation>
            <diathesis>act</diathesis>
        </gram>
    </children>
</t_tree>

Этот XML представляет собой дерево, выглядящее следующим образом:

t_tree

И я пытаюсь получить вот такую ​​матрицу.

        muž     strom    zasadit
muž     1       0       -1

storm   0       1       -1

zasadit 1       1       1

python xml elementtree adjacency-matrix
person LordBertson    schedule 30.01.2019    source источник
comment
Пожалуйста, объясните, в чем проблема. Что вы пробовали?   -  person mzjn    schedule 31.01.2019
comment
Если мы посмотрим на дерево, которое я включил (это то самое дерево, которое представлено XML выше), мы увидим 3 узла: zasadit, muž, strom. Я пытаюсь найти общий способ - для сколь угодно сложных деревьев - найти, какой элемент слова подчинен какому, например функция, которая будет генерировать пары ‹child,parent› например, ‹муж,засадить› или ‹стром,засадить›   -  person LordBertson    schedule 31.01.2019

Ответы (1)


arrow_upward
0
arrow_downward

Я нашел ответ, который работает на очень больших деревьях, на которых я его тестировал, хотя мне пришлось принять во внимание элемент <ord>, обозначающий порядок слов в предложении, чтобы устранить проблему, которая может возникнуть в случае таких предложений, как : "Мужчина и женщина, идущие днем ​​и ночью."

       walking
      /       \
   and        and
  /   \       /  \
man  woman  day  night

Только учет <t_lemma> привел бы к неясной интерпретации функции (child->parent), то есть: у нас было бы два и, к которым слова: мужчина, женщина, день, ночь ведут как это:

element  parent
_______________
man      and
woman    and
day      and
night    and
and      walking
and      walking

Это превратило предыдущую таблицу в следующую:

element  parent
_______________
man:1    and:2
woman:3  and:2
day:5    and:6
night:7  and:6
and:2    walking:4
and:6    walking:4

Итак, вот функциональный код Python:

parentDictionary = {}
def getchildlemma(element, parent):
    for i in element.findall("*"):
        if i.tag == "t_lemma":
            e = i.text

            for i in element.findall("*"):
                if i.tag == "ord":
                    e = e +":"+ i.text
            parentDictionary[e] = parent
            parent = e
        else:
            e = parent
    for i in element.findall("*"):
        if i.tag == "children" or i.tag == "LM":
            getchildlemma(i,parent)
person LordBertson    schedule 31.01.2019