Conversion des mots entre verbe / nom / formes adjectives

je voudrais une fonction de bibliothèque python qui traduit/convertit à travers différentes parties de la parole. parfois, il doit afficher plusieurs mots (par exemple "codeur" et " code "sont tous deux des noms du verbe" to code", l'un est le sujet l'autre est l'objet) 

# :: String => List of String
print verbify('writer') # => ['write']
print nounize('written') # => ['writer']
print adjectivate('write') # => ['written']

je me soucie surtout de verbes noms, pour un programme de prise de notes que je veux écrire. i.e. je peux écrire "caféine Antagonise A1" ou "caféine est un antagoniste A1" et avec un certain NLP il peut comprendre ils signifient la même chose. (je sais que ce n'est pas facile, et qu'il faudra que la NLP Parse et ne se contente pas de taguer, mais je veux pirater un prototype).

questions similaires ... Conversion les adjectifs et les adverbes de leur nom les formes (cette réponse ne s'applique qu'à la racine POS. je veux aller entre POS.)

ps a appelé la Conversion en linguistique http://en.wikipedia.org/wiki/Conversion_%28linguistics%29

21
demandé sur Community 2013-01-24 01:01:47

4 réponses

c'est une approche plus heuristique. J'ai juste codé de sorte appologies pour le style. Il utilise le derivationally_related_forms () de wordnet. J'ai implémenté nounify. Je suppose que verbify fonctionne de façon analogue. De ce que j'ai testé fonctionne assez bien: 

from nltk.corpus import wordnet as wn

def nounify(verb_word):
    """ Transform a verb to the closest noun: die -> death """
    verb_synsets = wn.synsets(verb_word, pos="v")

    # Word not found
    if not verb_synsets:
        return []

    # Get all verb lemmas of the word
    verb_lemmas = [l for s in verb_synsets \
                   for l in s.lemmas if s.name.split('.')[1] == 'v']

    # Get related forms
    derivationally_related_forms = [(l, l.derivationally_related_forms()) \
                                    for l in    verb_lemmas]

    # filter only the nouns
    related_noun_lemmas = [l for drf in derivationally_related_forms \
                           for l in drf[1] if l.synset.name.split('.')[1] == 'n']

    # Extract the words from the lemmas
    words = [l.name for l in related_noun_lemmas]
    len_words = len(words)

    # Build the result in the form of a list containing tuples (word, probability)
    result = [(w, float(words.count(w))/len_words) for w in set(words)]
    result.sort(key=lambda w: -w[1])

    # return all the possibilities sorted by probability
    return result
12
répondu bogs 2013-05-25 18:05:18

je comprends que cela ne répond pas à toute votre question, mais cela répond en grande partie. Je voudrais vérifier http://nodebox.net/code/index.php/Linguistics#verb_conjugation Cette bibliothèque python est capable de conjuguer les verbes, et de reconnaître si un mot est un verbe, un nom ou un adjectif.

EXEMPLE DE CODE 

print en.verb.present("gave")
print en.verb.present("gave", person=3, negate=False)
>>> give
>>> gives

il peut aussi catégoriser des mots. 

print en.is_noun("banana")
>>> True

le téléchargement est en haut de la liaison.

3
répondu xxmbabanexx 2013-01-24 02:06:14

une approche pourrait être d'utiliser un dictionnaire de mots avec leurs étiquettes POS et une cartographie des formes de mots. Si vous obtenez ou créez un tel Dictionnaire (ce qui est tout à fait possible si vous avez accès à n'importe quelles données de dictionnaire conventionnelles, comme tous les dictionnaires énumèrent des étiquettes de POS de mot, aussi bien que des formes de base pour toutes les formes dérivées), vous pouvez utiliser quelque chose comme le suivant: 

def is_verb(word):
    if word:
        tags = pos_tags(word)
        return 'VB' in tags or 'VBP' in tags or 'VBZ' in tags \
               or 'VBD' in tags or 'VBN' in tags:

def verbify(word):
    if is_verb(word):
        return word
    else:
       forms = []
       for tag in pos_tags(word):
           base = word_form(word, tag[:2])
           if is_verb(base):
              forms.append(base)
       return forms
3
répondu Vsevolod Dyomkin 2013-01-24 04:54:05

Voici une fonction qui est en théorie capable de convertir des mots entre le nom/verbe/adjectif/forme adverbe que j'ai mis à jour de ici (écrit à l'origine par bogs , je crois) pour être conforme avec nltk 3.2.5 maintenant que synset.lemmas et sysnset.name sont des fonctions. 

from nltk.corpus import wordnet as wn

# Just to make it a bit more readable
WN_NOUN = 'n'
WN_VERB = 'v'
WN_ADJECTIVE = 'a'
WN_ADJECTIVE_SATELLITE = 's'
WN_ADVERB = 'r'


def convert(word, from_pos, to_pos):    
    """ Transform words given from/to POS tags """

    synsets = wn.synsets(word, pos=from_pos)

    # Word not found
    if not synsets:
        return []

    # Get all lemmas of the word (consider 'a'and 's' equivalent)
    lemmas = []
    for s in synsets:
        for l in s.lemmas():
            if s.name().split('.')[1] == from_pos or from_pos in (WN_ADJECTIVE, WN_ADJECTIVE_SATELLITE) and s.name().split('.')[1] in (WN_ADJECTIVE, WN_ADJECTIVE_SATELLITE):
                lemmas += [l]

    # Get related forms
    derivationally_related_forms = [(l, l.derivationally_related_forms()) for l in lemmas]

    # filter only the desired pos (consider 'a' and 's' equivalent)
    related_noun_lemmas = []

    for drf in derivationally_related_forms:
        for l in drf[1]:
            if l.synset().name().split('.')[1] == to_pos or to_pos in (WN_ADJECTIVE, WN_ADJECTIVE_SATELLITE) and l.synset().name().split('.')[1] in (WN_ADJECTIVE, WN_ADJECTIVE_SATELLITE):
                related_noun_lemmas += [l]

    # Extract the words from the lemmas
    words = [l.name() for l in related_noun_lemmas]
    len_words = len(words)

    # Build the result in the form of a list containing tuples (word, probability)
    result = [(w, float(words.count(w)) / len_words) for w in set(words)]
    result.sort(key=lambda w:-w[1])

    # return all the possibilities sorted by probability
    return result


convert('direct', 'a', 'r')
convert('direct', 'a', 'n')
convert('quick', 'a', 'r')
convert('quickly', 'r', 'a')
convert('hunger', 'n', 'v')
convert('run', 'v', 'a')
convert('tired', 'a', 'r')
convert('tired', 'a', 'v')
convert('tired', 'a', 'n')
convert('tired', 'a', 's')
convert('wonder', 'v', 'n')
convert('wonder', 'n', 'a')

Comme vous pouvez le voir ci-dessous, il ne fonctionne pas si grande. Il est incapable de basculer entre adjectif et forme adverbe( mon but spécifique), mais il ne donnez quelques résultats intéressants dans d'autres cas. 

>>> convert('direct', 'a', 'r')
[]
>>> convert('direct', 'a', 'n')
[('directness', 0.6666666666666666), ('line', 0.3333333333333333)]
>>> convert('quick', 'a', 'r')
[]
>>> convert('quickly', 'r', 'a')
[]
>>> convert('hunger', 'n', 'v')
[('hunger', 0.75), ('thirst', 0.25)]
>>> convert('run', 'v', 'a')
[('persistent', 0.16666666666666666), ('executive', 0.16666666666666666), ('operative', 0.16666666666666666), ('prevalent', 0.16666666666666666), ('meltable', 0.16666666666666666), ('operant', 0.16666666666666666)]
>>> convert('tired', 'a', 'r')
[]
>>> convert('tired', 'a', 'v')
[]
>>> convert('tired', 'a', 'n')
[('triteness', 0.25), ('banality', 0.25), ('tiredness', 0.25), ('commonplace', 0.25)]
>>> convert('tired', 'a', 's')
[]
>>> convert('wonder', 'v', 'n')
[('wonder', 0.3333333333333333), ('wonderer', 0.2222222222222222), ('marveller', 0.1111111111111111), ('marvel', 0.1111111111111111), ('wonderment', 0.1111111111111111), ('question', 0.1111111111111111)]
>>> convert('wonder', 'n', 'a')
[('curious', 0.4), ('wondrous', 0.2), ('marvelous', 0.2), ('marvellous', 0.2)]

j'espère que cela peut sauver quelqu'un un petit problème

3
répondu stuart 2018-01-12 00:57:44