SceneGraphParser

Scenegraphparser

O SceneGraphParser ( sng_parser ) é um kit de ferramentas Python para analisar frases (em linguagem natural) em gráficos de cena (como representação simbólica) com base na análise de dependência. Este projeto é inspirado no analisador de gráficos de Stanford Scene.

Diferente da versão de Stanford, este analisador é escrito exclusivamente por Python. Possui uma interface de usuário fácil de usar e um design fácil de configurar. Ele analisa frases em gráficos em que os nós são substantivos (com modificadores como determinantes ou adjetivos) e as bordas são relações entre substantivos. Consulte a seção Exemplo para obter detalhes.

Destaque: este projeto ainda está sendo desenvolvido. Todas as APIs estão sujeitas a qualquer alteração.

NOTA : Como você pode notar, a análise é feita por um conjunto de regras escritas para humano na árvore de análise. Assim, precisamos de ajuda de todos na coleta de casos de falha/canto do programa atual. Qualquer tipo de relatório ou ajuda deve ser mais do que bem -vindo.

Este repo foi desenvolvido para:
INCEDIMENTOS VISUALIÍDICOS UNIFICADOS: Visão e linguagem em ponte com representações de significado estruturado
Hao Wu, Jiayuan Mao, Yufeng Zhang, Yuning Jiang, Lei Li, Weiwei Sun e May May
Em conferência sobre visão computacional e reconhecimento de padrões (CVPR) 2019 (apresentação oral)

Por favor, considere citar nosso artigo se você se sentir confortável :). A diferença entre este repositório e o analisador de gráficos de cena de Stanford original pode ser encontrado no número 7.

Instalação

O pacote pode ser instalado usando PIP. Como atualmente apoia apenas o Spacy como back -end, o pacote inglês precisa ser baixado após a instalação.

pip install SceneGraphParser
python -m spacy download en  # to use the parser for English 

Exemplo

A maneira mais fácil de usar essa ferramenta é chamando a função parse . No design, sng_parser suporta back -ends diferentes. Atualmente, só apoiamos o back -end do Spacy.

pip install spacy

 > >> import sng_parser
> >> graph = sng_parser . parse ( 'A woman is playing the piano in the room.' )

 > >> from pprint import pprint
> >> pprint ( graph )

 {'entities': [{'head': 'woman',
               'lemma_head': 'woman',
               'lemma_span': 'a woman',
               'modifiers': [{'dep': 'det', 'lemma_span': 'a', 'span': 'A'}],
               'span': 'A woman'},
              {'head': 'piano',
               'lemma_head': 'piano',
               'lemma_span': 'the piano',
               'modifiers': [{'dep': 'det',
                              'lemma_span': 'the',
                              'span': 'the'}],
               'span': 'the piano'},
              {'head': 'room',
               'lemma_head': 'room',
               'lemma_span': 'the room',
               'modifiers': [{'dep': 'det',
                              'lemma_span': 'the',
                              'span': 'the'}],
               'span': 'the room'}],
 'relations': [{'object': 1, 'relation': 'playing', 'subject': 0},
               {'object': 2, 'relation': 'in', 'subject': 0}]}

 > >> sng_parser . tprint ( graph )  # we provide a tabular visualization of the graph. 

 Entities:
+--------+-----------+-------------+
| Head   | Span      | Modifiers   |
|--------+-----------+-------------|
| woman  | a woman   | a           |
| piano  | the piano | the         |
| room   | the room  | the         |
+--------+-----------+-------------+
Relations:
+-----------+------------+----------+
| Subject   | Relation   | Object   |
|-----------+------------+----------|
| woman     | playing    | piano    |
| woman     | in         | room     |
+-----------+------------+----------+

Como alternativa, você pode configurar seu próprio analisador:

 > >> import sng_parser
> >> parser = sng_parser . Parser ( 'spacy' , model = 'en' )  # the positional argument specifies the backend, and the keyward arguments are for the backend initialization.
> >> graph = parser . parse ( 'A woman is playing the piano in the room.' )

Especificação do gráfico

Utilizamos o dict e list pitônicos puros para representar um gráfico. Embora essa flexibilidade possa trazer alguns problemas indesejados, preferimos essa representação porque:

1. Atualmente, a ferramenta ainda está sendo desenvolvida, essas APIs estão sujeitas a alterações.
2. Isso facilita a integração da ferramenta a qualquer projeto baseado em Python. Você não precisa se preocupar em decapagem/desenrolar dos resultados. Use -o em qualquer lugar do seu código!

Os gráficos de cena gerados correspondem às seguintes especificações:

{
  'entities' : [  # a list of entities
    {
      'span' : "the full span of a noun phrase" ,
      'lemma_span' : "the lemmatized version of the span" ,
      'head' : "the head noun" ,
      'lemma_head' : "the lemmatized version of the head noun" ,
      'modifiers' : [
        {
          'dep' : "the dependency type" ,
          'span' : "the span of the modifier" ,
          'lemma_span' : "the lemmatized version of the span"
        },
        # other modifiers...
      ]
    },
    # other entities...
  ],

  'relations' : [  # a list of relations
    # the subject and object fields are sometimes called "head" and "tail" in relation extraction papers.
    {
      'subject' : "the entity id of the subject" ,
      'object' : "the entity id of the object" ,
      'relation' : "the relation"
    }
    # other relations...
  ]
}