PNL: Quais são alguns pacotes populares para tokenização de várias palavras?

Pretendo tokenizar vários textos de descrição de cargo. Eu tentei a tokenização padrão usando espaço em branco como delimitador. No entanto, notei que existem algumas expressões de várias palavras divididas por espaços em branco, que podem causar problemas de precisão no processamento subsequente. Então, eu quero obter todas as colocações mais interessantes / informativas nesses textos.

Existem bons pacotes para fazer tokenização de várias palavras, independentemente da linguagem de programação específica? Por exemplo, "Ele estuda Tecnologia da Informação" ===> "Ele" "estuda" "Tecnologia da Informação".

Notei que o NLTK (Python) tem algumas funcionalidades relacionadas.

• Módulo de colocações: http://www.nltk.org/api/nltk.html#module-nltk.collocations

• Módulo nltk.tokenize.mwe: http://www.nltk.org/api/nltk.tokenize.html#module-nltk.tokenize.mwe

Qual a diferença entre esses dois?

A classe MWETokenizer no módulo nltk.tokenize.mwe parece estar trabalhando em direção ao meu objetivo. No entanto, o MWETokenizer parece exigir que eu use seu método de construção e o método .add_mwe para adicionar expressões com várias palavras. Existe uma maneira de usar o léxico de expressão externa com várias palavras para conseguir isso? Em caso afirmativo, existe algum léxico com várias palavras?

Obrigado!

O tokenizer de várias palavras 'nltk.tokenize.mwe' mescla basicamente uma string já dividida em tokens, com base em um léxico, a partir do que entendi na documentação da API.

Uma coisa que você pode fazer é tokenizar e marcar todas as palavras com a tag PoS (parte do discurso) associada e definir expressões regulares com base nas tags PoS para extrair frases-chave interessantes.

Por exemplo, um exemplo adaptado do Capítulo 7 do NLTK Book e desta postagem no blog :

def extract_phrases(my_tree, phrase):
   my_phrases = []
   if my_tree.label() == phrase:
      my_phrases.append(my_tree.copy(True))

   for child in my_tree:
       if type(child) is nltk.Tree:
            list_of_phrases = extract_phrases(child, phrase)
            if len(list_of_phrases) > 0:
                my_phrases.extend(list_of_phrases)

    return my_phrases



def main():
    sentences = ["The little yellow dog barked at the cat",
                 "He studies Information Technology"]

    grammar = "NP: {<DT>?<JJ>*<NN>|<NNP>*}"
    cp = nltk.RegexpParser(grammar)

    for x in sentences:
        sentence = pos_tag(tokenize.word_tokenize(x))
        tree = cp.parse(sentence)
        print "\nNoun phrases:"
        list_of_noun_phrases = extract_phrases(tree, 'NP')
        for phrase in list_of_noun_phrases:
            print phrase, "_".join([x[0] for x in phrase.leaves()])

Você definiu uma gramática baseada em regex sobre tags PoS:

grammar = "NP: {<DT>?<JJ>*<NN>|<NNP>*}"
cp = nltk.RegexpParser(grammar)

Em seguida, você o aplicou a uma sentença tokenizada e marcada, gerando uma Árvore:

sentence = pos_tag(tokenize.word_tokenize(x))
tree = cp.parse(sentence)

Então você usa extract_phrases(my_tree, phrase)para analisar recursivamente a Árvore e extrair subárvores rotuladas como NP. O exemplo acima extrairia as seguintes frases substantivas:

Noun phrases:
(NP The/DT little/JJ yellow/JJ dog/NN) The_little_yellow_dog
(NP the/DT cat/NN) the_cat

Noun phrases:
(NP Information/NNP Technology/NNP) Information_Technology

Há um ótimo post de Burton DeWilde no blog sobre muitas outras maneiras de extrair frases-chave interessantes: Introdução à extração automática de frases-chave

O processo de tokenização não deve ser alterado, mesmo quando você estiver interessado em várias palavras. Afinal, as palavras ainda são os tokens básicos. O que você deve fazer para encontrar uma maneira de combinar as palavras apropriadas em termos.

Uma maneira simples de fazer isso é procurar um termo em que a probabilidade do termo seja maior que a dos tokens independentes. Por exemplo, P ("Casa Branca")> P ("Casa Branca") * P ("Casa") Escolhendo os valores adequados de aumento de necessidade, o número de ocorrências e a classificação de termos podem ser deduzidos se você tiver um conjunto de termos de termos no domínio . Se você não tiver esse domínio, solicite pelo menos 10 ocorrências e um aumento de pelo menos 2 (geralmente é muito maior, pois a probabilidade de cada token é baixa) funcionará muito bem.

No seu caso, também é possível extrair termos combinando contextos relevantes para o seu domínio (por exemplo, "X estudado", "Y praticado").

Novamente, você pode criar modelos complexos e elegantes para isso, mas geralmente, procurar as próximas palavras depois dos indicadores de contexto será muito benéfico.

Para o seu problema, acho que o gensim pode ser muito útil, o que pode ser implementado na biblioteca do Gensim é a detecção de frases. É semelhante ao n-grama, mas em vez de obter todo o n-grama deslizando pela janela, ele detecta frases usadas com frequência e as junta. Estatisticamente, percorre o corpus do texto e identifica as palavras comuns ocorrendo lado a lado.
A seguir, é apresentada a maneira como calcula os melhores tokens de várias palavras adequados.

A seguir está o código para usá-lo. calcula os dois tokens de palavras.

from gensim.models.phrases import Phrases, Phraser

tokenized_train = [t.split() for t in x_train]
phrases = Phrases(tokenized_train)
bigram = Phraser(phrases)

e é assim que você usaria

Observe a palavra "new_york" concatenada, uma vez que no corpus, as evidências estatísticas das palavras "new" e "york" se uniram foram significativas.

Além disso, você pode ir até n gramas para isso, não apenas biogramas. Aqui está o artigo que explica em detalhes.

Essa extensão do Stanford CoreNLP para capturar MultiWord Expressions (MWE) funcionou como um encanto para uma das minhas tarefas. Para usuários de Python, prepare-se para escrever algum código de conector ou hackear o código Java.

O gensim é um dos melhores para executar tarefas de PNL em dados de texto, biblioteca python do Gensim

Use a biblioteca Stanford CoreNLP para tokenização de várias palavras. Eu o encontrei quando estava trabalhando em uma tarefa semelhante e funcionou muito bem!

Atualizado: você pode usar o pipeline Stanford CoreNLP, que inclui o modelo de tokenização de várias palavras. O link da demonstração para o treinamento de redes neurais com seus próprios dados está aqui