Computing N Grams usando Python

nlp nltk

Question

Necesitaba calcular los Unigrams, BiGrams y Trigrams para un archivo de texto que contenga texto como:

"La fibrosis quística afecta solo a 30,000 niños y adultos jóvenes en los Estados Unidos. Inhalar las brumas del agua salada puede reducir el pus y la infección que llena las vías respiratorias de quienes padecen fibrosis quística, aunque los efectos secundarios incluyen un desagradable ataque de tos y un sabor áspero. de dos estudios publicados en la edición de esta semana de The New England Journal of Medicine ".

Empecé en Python y usé el siguiente código:

#!/usr/bin/env python
# File: n-gram.py
def N_Gram(N,text):
NList = [] # start with an empty list
if N> 1:
space = " " * (N-1) # add N - 1 spaces
text = space + text + space # add both in front and back
# append the slices [i:i+N] to NList
for i in range( len(text) - (N - 1) ):
NList.append(text[i:i+N])
return NList # return the list
# test code
for i in range(5):
print N_Gram(i+1,"text")
# more test code
nList = N_Gram(7,"Here is a lot of text to print")
for ngram in iter(nList):
print ''"'' + ngram + ''"''

http://www.daniweb.com/software-development/python/threads/39109/generating-n-grams-from-a-word

Pero funciona para todos los n-grams dentro de una palabra, cuando lo quiero entre palabras como en CYSTIC y FIBROSIS o FIBROSIS CÍSTICA. ¿Puede alguien ayudarme en cómo puedo hacer esto?

Answer 1

Asumiendo que la entrada es una cadena que contiene palabras separadas por espacios, como x = "abcd" puede usar la siguiente función (editar: vea la última función para una solución posiblemente más completa):

def ngrams(input, n):
input = input.split('' '')
output = []
for i in range(len(input)-n+1):
output.append(input[i:i+n])
return output
ngrams(''a b c d'', 2) # [[''a'', ''b''], [''b'', ''c''], [''c'', ''d'']]

Si quieres que los que están unidos vuelvan a las cadenas, puedes llamar a algo como:

['' ''.join(x) for x in ngrams(''a b c d'', 2)] # [''a b'', ''b c'', ''c d'']

Por último, eso no resume las cosas en totales, por lo que si su entrada fue ''aaa a'' , necesita contarlas en un dict:

for g in ('' ''.join(x) for x in ngrams(input, 2)):
grams.setdefault(g, 0)
grams[g] += 1

Poniendo todo eso en una función final da:

def ngrams(input, n):
input = input.split('' '')
output = {}
for i in range(len(input)-n+1):
g = '' ''.join(input[i:i+n])
output.setdefault(g, 0)
output[g] += 1
return output
ngrams(''a a a a'', 2) # {''a a'': 3}

Answer 2

Usando collections.deque :

from collections import deque
from itertools import islice
def ngrams(message, n=1):
it = iter(message.split())
window = deque(islice(it, n), maxlen=n)
yield tuple(window)
for item in it:
window.append(item)
yield tuple(window)

... o tal vez podrías hacerlo en una línea como una lista de comprensión:

n = 2
message = "Hello, how are you?".split()
myNgrams = [message[i:i+n] for i in range(len(message) - n)]

Answer 3

Use NLTK (el kit de herramientas de lenguaje natural) y use las funciones para convertir (dividir) su texto en una lista y luego encuentre los bigramas y los trigramas.

import nltk
words = nltk.word_tokenize(my_text)
my_bigrams = nltk.bigrams(words)
my_trigrams = nltk.trigrams(words)

Answer 4

Hay otro módulo más interesante en Python llamado Scikit. Aquí está el código. Esto te ayudará a obtener todos los gramos dados en un rango particular. Aquí está el código

from sklearn.feature_extraction.text import CountVectorizer
text = "this is a foo bar sentences and i want to ngramize it"
vectorizer = CountVectorizer(ngram_range=(1,6))
analyzer = vectorizer.build_analyzer()
print analyzer(text)

La salida es

[u''this'', u''is'', u''foo'', u''bar'', u''sentences'', u''and'', u''want'', u''to'', u''ngramize'', u''it'', u''this is'', u''is foo'', u''foo bar'', u''bar sentences'', u''sentences and'', u''and want'', u''want to'', u''to ngramize'', u''ngramize it'', u''this is foo'', u''is foo bar'', u''foo bar sentences'', u''bar sentences and'', u''sentences and want'', u''and want to'', u''want to ngramize'', u''to ngramize it'', u''this is foo bar'', u''is foo bar sentences'', u''foo bar sentences and'', u''bar sentences and want'', u''sentences and want to'', u''and want to ngramize'', u''want to ngramize it'', u''this is foo bar sentences'', u''is foo bar sentences and'', u''foo bar sentences and want'', u''bar sentences and want to'', u''sentences and want to ngramize'', u''and want to ngramize it'', u''this is foo bar sentences and'', u''is foo bar sentences and want'', u''foo bar sentences and want to'', u''bar sentences and want to ngramize'', u''sentences and want to ngramize it'']

Aquí da todos los gramos dados en un rango de 1 a 6. Está usando el método llamado countVectorizer. Aquí está el enlace para eso.

Answer 5

Una breve solución Pythonesque de este blog :

def find_ngrams(input_list, n):
return zip(*[input_list[i:] for i in range(n)])

Uso:

>>> input_list = [''all'', ''this'', ''happened'', ''more'', ''or'', ''less'']
>>> find_ngrams(input_list, 1)
[(''all'',), (''this'',), (''happened'',), (''more'',), (''or'',), (''less'',)]
>>> find_ngrams(input_list, 2)
[(''all'', ''this''), (''this'', ''happened''), (''happened'', ''more''), (''more'', ''or''), (''or'', ''less'')]
>>> find_ngrams(input_list, 3))
[(''all'', ''this'', ''happened''), (''this'', ''happened'', ''more''), (''happened'', ''more'', ''or''), (''more'', ''or'', ''less'')]

Answer 6

nltk tiene soporte nativo para ngrams

''n'' es el tamaño del ngram ex: n = 3 es para un trigrama

from nltk import ngrams
def ngramize(texts, n):
output=[]
for text in texts:
output += ngrams(text,n)
return output

Answer 7

Aunque la publicación es antigua, pensé mencionar mi respuesta aquí para que la mayoría de la lógica de creación de ngrams pueda estar en una publicación.

Hay algo por nombre TextBlob en Python. Crea ngrams muy fácilmente similar a NLTK.

A continuación se muestra el fragmento de código con su salida para facilitar la comprensión.

sent = """This is to show the usage of Text Blob in Python"""
blob = TextBlob(sent)
unigrams = blob.ngrams(n=1)
bigrams = blob.ngrams(n=2)
trigrams = blob.ngrams(n=3)

Y la salida es:

unigrams
[WordList([''This'']),
WordList([''is'']),
WordList([''to'']),
WordList([''show'']),
WordList([''the'']),
WordList([''usage'']),
WordList([''of'']),
WordList([''Text'']),
WordList([''Blob'']),
WordList([''in'']),
WordList([''Python''])]
bigrams
[WordList([''This'', ''is'']),
WordList([''is'', ''to'']),
WordList([''to'', ''show'']),
WordList([''show'', ''the'']),
WordList([''the'', ''usage'']),
WordList([''usage'', ''of'']),
WordList([''of'', ''Text'']),
WordList([''Text'', ''Blob'']),
WordList([''Blob'', ''in'']),
WordList([''in'', ''Python''])]
trigrams
[WordList([''This'', ''is'', ''to'']),
WordList([''is'', ''to'', ''show'']),
WordList([''to'', ''show'', ''the'']),
WordList([''show'', ''the'', ''usage'']),
WordList([''the'', ''usage'', ''of'']),
WordList([''usage'', ''of'', ''Text'']),
WordList([''of'', ''Text'', ''Blob'']),
WordList([''Text'', ''Blob'', ''in'']),
WordList([''Blob'', ''in'', ''Python''])]

Tan sencillo como eso.

Hay más en esto que está siendo realizado por TextBlob. Mire este documento para obtener más información: https://textblob.readthedocs.io/en/dev/