SceneGraphParser

Scène de scène

SceneGraphParser ( sng_parser ) est une boîte à outils Python pour l'analyse des phrases (en langage naturel) en graphiques de scène (en tant que représentation symbolique) basée sur l'analyse de dépendance. Ce projet est inspiré par l'analyseur de graphique de la scène Stanford.

Différent de la version Stanford, cet analyseur est écrit uniquement par Python. Il a une interface utilisateur facile à utiliser et une conception facile à configurer. Il analyse les phrases en graphiques où les nœuds sont des noms (avec des modificateurs tels que les déterminants ou les adjectifs) et les bords sont des relations entre les noms. Veuillez consulter l'exemple pour plus de détails.

Fait saillie: ce projet est toujours en cours de développement. Toutes les API sont soumises à tout changement.

Remarque : Comme vous pouvez le remarquer, l'analyse est effectuée par un ensemble de règles écrites par l'homme sur l'arbre d'analyse. Ainsi, nous avons besoin de l'aide de tous les cas sur la collecte de cas d'échec / de coin du programme actuel. Tout type de rapports ou d'aide devrait être plus que bienvenu.

Ce repo a été développé pour:
Embeddings visuels-sémantiques unifiés: pontant la vision et le langage avec des représentations de sens structurées
Hao Wu, Jiayuan Mao, Yufeng Zhang, Yuning Jiang, Lei Li, Weiwei Sun et Wei-ying Ma
En conférence sur la vision par ordinateur et la reconnaissance des modèles (CVPR) 2019 (présentation orale)

Veuillez envisager de citer notre papier si vous vous sentez confortable :). La différence entre ce dépôt et l'analyseur de graphe de scène Stanford original se trouve dans le n ° 7.

Installation

Le package peut être installé à l'aide de PIP. Comme il ne prend actuellement en charge que Spacy en tant que backend, le package anglais doit être téléchargé après l'installation.

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

Exemple

La façon la plus simple d'utiliser cet outil est d'appeler la fonction parse . Dans la conception, sng_parser prend en charge différents backends. Actuellement, nous soutenons uniquement le backend 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     |
+-----------+------------+----------+

Alternativement, vous pouvez configurer votre propre analyseur:

 > >> 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.' )

Spécification du graphique

Nous utilisons le Pure Pythonic dict and list pour représenter un graphique. Bien que cette flexibilité puisse apporter des problèmes indésirables, nous préférons cette représentation car:

1. Actuellement, l'outil est toujours en cours de développement, ces API sont susceptibles de changer.
2. Cela rend l'outil facile à intégrer dans tous les projets basés sur Python. Vous n'avez pas besoin de vous soucier de décrocher / décortiquer les résultats. Utilisez-le n'importe où dans votre code!

Les graphiques de scène générés correspondent à la spécification suivante:

{
  '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...
  ]
}