def obtener_ngramas(texto,
n=1,
devolver_lista=True,
limpiar=False,
tokenizador=None):
""" Permite generar n-gramas a partir de un texto.
:param texto: (str) Corresponde al texto que se desea analizar.
:param n: (int) Cantidad de elementos a tener en cuenta en la generación de n-gramas. Por ejemplo, si n=1 se retornarán palabras, y si n=2 se retornarán bigramas.
:param devolver_lista: (bool) {True, False} Valor por defecto: True. Si el valor es True se retorna un objeto tipo lista; si el valor es False se retorna un objeto tipo generador.
:param limpiar: (bool) {True, False} Valor por defecto: False. Define \
si se desea hacer una limpieza básica (aplicando la función \
`limpieza_basica` del módulo `limpieza`) al texto de entrada, antes de encontrar los n-gramas.
:param tokenizador: Valor por defecto: None. Objeto encargado de la tokenización y detokenización \
de textos. Si el valor es 'None', se utilizará por defecto una instancia de la clase *TokenizadorNLTK*.
:return: n-gramas generados con las características especificadas.
"""
if limpiar:
texto = limpieza_basica(texto)
lista = tokenizar(texto, tokenizador)
n_gramas = (' '.join(lista[i:i + n]) for i in range(len(lista))
if i + n <= len(lista))
if devolver_lista:
n_gramas = list(n_gramas)
return n_gramas
def correccion_ortografia(self, texto, limpieza=False):
"""
Realiza corrección ortográfica sobre un texto de entrada, \
identificando las palabras que no están en el diccionario del \
corrector y cambiándolas por su candidata más frecuente o probable, \
siempre y cuando haya por lo menos una palabra candidata que cumpla \
con la máxima distancia de Levenshtein permitida.
:param texto: Texto al cual se desea aplicar corrección \
ortográfica.
:param limpieza: Define si se desea hacer una limpieza \
básica (aplicando la función `limpieza_basica` del módulo \
`limpieza`) al texto antes de aplicar la corrección ortográfica.\
Valor por defecto `False`.
:type limpieza: bool, opcional
:return: (str) Texto de entrada luego de la corrección ortográfica.
"""
if limpieza:
# Limpieza básica del texto para que no afecte la corrección
texto = limpieza_basica(texto, quitar_numeros=False)
lista_palabras = self.tokenizador.tokenizar(texto)
desconocidas = self.corrector.unknown(lista_palabras)
texto_corregido = [
self.corrector.correction(p)
if len(p) > 1 and p in desconocidas else p for p in lista_palabras
]
return self.tokenizador.destokenizar(texto_corregido)
def lematizar(self, texto, limpiar=True):
""" Se lleva a cabo el proceso de lematización del texto, el cual puede \
ser limpiado antes de la lematización.
:param texto: (str) El texto que se desea lematizar.
:param limpiar: (bool) {True, False} Valor por defecto: True. Especifica \
si se desea hacer una limpieza básica del texto antes de la lematización.
:return: (str) Retorna el texto lematizado.
"""
if limpiar:
texto = limpieza_basica(texto)
lemas = self.lematizador(texto, disable=['ner', 'parser'])
return self.tokenizador.destokenizar([token.lemma_ for token in lemas])
def lematizar(self, texto, limpiar=True):
""" Se lleva a cabo el proceso de lematización del texto, el cual puede \
ser limpiado antes de la lematización.
:param texto: (str) El texto que se desea lematizar.
:param limpiar: (bool) {True, False} Valor por defecto: True. Especifica \
si se desea hacer una limpieza básica del texto antes de la lematización.
:return: (str) Retorna el texto lematizado.
"""
if limpiar:
texto = limpieza_basica(texto)
doc = self.lematizador(texto)
# Extraer los lemas de cada palabra, de cada frase, y juntarlos
return self.tokenizador.destokenizar([w.lemma for s in doc.sentences for w in s.words])
def lematizar(self, texto, limpiar=True):
"""
Lematización de texto.
:param texto: El texto que se desea lematizar.
:type texto: str
:param limpiar: Especifica si se desea hacer una limpieza básica del \
texto antes de la lematización. Valor por defecto `True`.
:type limpiar: bool, opcional
:return: (str) Retorna el texto lematizado.
"""
if limpiar:
texto = limpieza_basica(texto)
lemas = self.lematizador(texto, disable=["ner", "parser"])
return self.tokenizador.destokenizar([token.lemma_ for token in lemas])
def lematizar(self, texto, limpiar=True):
"""
Lematización de texto.
:param texto: El texto que se desea lematizar.
:type text: str
:param limpiar: Especifica si se desea hacer una limpieza básica del \
texto antes de la lematización. Valor por defecto `True`.
:type limpiar: bool, opcional
:return: (str) Retorna el texto lematizado.
"""
if limpiar:
texto = limpieza_basica(texto)
doc = self.lematizador(texto)
# Extraer los lemas de cada palabra, de cada frase, y juntarlos
return self.tokenizador.destokenizar(
[w.lemma for s in doc.sentences for w in s.words])
def stemming(self, texto, limpiar=False):
"""
Aplica *stemming* sobre un texto de entrada, y devuelve el texto \
resultante.
:param texto: (str) Texto al que se desea aplicar el *stemming*.
:param limpiar: (bool) {True, False} Valor por defecto: False. Argumento \
opcional que define si se desea hacer una limpieza básica (\
aplicando la función `limpieza_basica` del módulo `limpieza`) al \
texto antes de aplicar el *stemming*.
:return: (str) Texto luego de la aplicación del *stemming*.
"""
if limpiar:
texto = limpieza_basica(texto)
tokens = self.tokenizador.tokenizar(texto)
salida = [self.stemmer.stem(p) for p in tokens]
return self.tokenizador.destokenizar(salida)
def stemming(self, texto, limpiar=False):
"""
Aplica *stemming* sobre un texto de entrada, y devuelve el texto \
resultante.
:param texto: Texto al que se desea aplicar el *stemming*.
:type texto: str
:param limpiar: Define si se desea hacer una limpieza básica \
(aplicando la función `limpieza_basica` del módulo \
`limpieza`) al texto antes de aplicar el *stemming*. \
Valor por defecto `False`.
:type limpiar: bool, opcional
:return: (str) Texto luego de la aplicación del *stemming*.
"""
if limpiar:
texto = limpieza_basica(texto)
tokens = self.tokenizador.tokenizar(texto)
salida = [self.stemmer.stem(p) for p in tokens]
return self.tokenizador.destokenizar(salida)
def obtener_ngramas(texto,
n=1,
devolver_lista=True,
limpiar=False,
tokenizador=None):
"""
Permite generar n-gramas a partir de un texto.
:param texto: Texto sobre el que se calculará los n-gramas.
:type texto: str
:param n: Cantidad de elementos a tener en cuenta en la generación \
de n-gramas. Por ejemplo, si `n = 1` se retornarán palabras, \
si `n = 2` se retornarán bigramas, si `n = 3` se retornarán \
trigramas y así sucesivamente. Valor por defecto `2`.
:type n: int
:param devolver_lista: Si `devolver_lista` es `True` se retorna un \
objeto tipo lista; si el valor es `False` se retorna un objeto tipo \
generador. Valor por defecto `True`
:type devolver_lista: bool, opcional
:param limpiar: Define si se desea hacer una limpieza básica (aplicando \
la función `limpieza_basica` del módulo `limpieza`) al texto de \
entrada, antes de encontrar los n-gramas. Valor por defecto `False`.
:type limpiar: bool, opcional
:param tokenizador: Objeto encargado de la tokenización y \
detokenización de textos. Si el valor es `None`, se cargará por \
defecto una instancia de la clase `TokenizadorNLTK`. Valor por \
defecto `None`.
:type tokenizador: object, opcional
:return: (list, generator) n-gramas generados con las características \
especificadas.
"""
if limpiar:
texto = limpieza_basica(texto)
lista = tokenizar(texto, tokenizador)
n_gramas = (" ".join(lista[i:i + n]) for i in range(len(lista))
if i + n <= len(lista))
if devolver_lista:
n_gramas = list(n_gramas)
return n_gramas
def matriz_coocurrencias(
texto,
min_frec=1,
max_num=200,
modo="documento",
ventana=3,
tri_sup=True,
limpiar=False,
tokenizador=None,
):
"""
Calcula la matriz de coocurrencias de un texto.
:param texto: Corresponde al texto (o lista de textos/documentos) que \
se desea analizar.
:type texto: str, list
:param min_frec: Frecuencia mínima de aparición de palabras, si la \
frecuencia de una palabra es menor a `min_frec`, será excluida de la \
matriz. Valor por defecto `1`.
:type min_frec: int, opcional
:param max_num: Número máximo de palabras que se incluyen en la matriz \
(se eligen las más frecuentes). Valor por defecto `200`.
:type max_num: int, opcional
:param modo: Corresponde al modo de análisis, con `'documento'` se \
calcula la coocurrencia de términos sin importar la distancia entre \
estos, con `'ventana'` se calcula la coocurrencia de términos \
teniendo en cuenta una distancia máxima entre estos. \
Valor por defecto `'documento'`.
:type modo: {'documento', 'ventana'}, opcional
:param ventana: Tamaño de la ventana (solo cuando `modo = 'ventana'`). \
Número de palabras anteriores o posteriores a tener en cuenta con \
respecto al término de análisis, equivalente a calcular la \
coocurrencia con n-gramas, siendo `n = ventana + 1`. \
Valor por defecto `3`.
:type ventana: int, opcional
:param tri_sup: Si es `True` devuelve la versión diagonal superior de la \
matriz de coocurrencias, si es `False` devuelve la matriz completa. \
Valor por defecto `True`.
:type tri_sup: bool, opcional
:param limpiar: Define si se desea hacer una limpieza básica (aplicando \
la función `limpieza_basica` del módulo `limpieza`) al texto, antes \
de calcular las coocurrencias. Valor por defecto `False`.
:type limpiar: bool, opcional
:param tokenizador: Objeto encargado de la tokenización y detokenización \
de textos. Si el valor es 'None', se utilizará por defecto una \
instancia de la clase *TokenizadorNLTK*. Valor por defecto `None`.
:type tokenizador: Tokenizador, opcional
:return: (pandas.DataFrame) Matriz de coocurrencias de los textos de \
entrada.
"""
# Generar un solo texto con todos los documentos
if isinstance(texto, Iterable) and not isinstance(texto, str):
texto_entero = " ".join([str(i) for i in texto])
else:
texto_entero = str(texto)
texto = [texto_entero] # Convertir variable "texto" en un iterable
if limpiar:
texto = [limpieza_basica(t) for t in texto]
texto_entero = " ".join([texto])
# Se inicializa un solo tokenizador, para ahorrar un poco de tiempo
tok = TokenizadorNLTK() if tokenizador is None else tokenizador
# Generar lista de palabras en todos los textos juntos
palabras = tokenizar(texto_entero, tok)
# Dejar solo las palabras con mayor frecuencia y/o que cumplan una
# frecuencia mínima
cuenta = dict(Counter(palabras).most_common(max_num))
cuenta_filt = {k: v for k, v in cuenta.items() if v >= min_frec}
nombres = list(set(cuenta_filt.keys()))
# Inicializar en ceros la matriz de coocurrencias
mat_oc = pd.DataFrame(np.zeros([len(nombres), len(nombres)]),
columns=nombres,
index=nombres)
if modo == "ventana":
for t in texto:
palabras_t = tokenizar(t, tok)
# Ciclo a través de las palabras para obtener las coocurrencias:
for i, p1 in enumerate(palabras_t):
inicio = max(0, i - ventana)
fin = min(len(palabras), i + ventana + 1)
for j, p2 in enumerate(palabras_t[inicio:fin]):
if (p2 in nombres) and (p1 in nombres):
if p1 != p2:
mat_oc[p2][p1] += 1
else:
if (inicio + j) != i:
mat_oc[p2][p1] += 1
elif modo == "documento":
for t in texto:
cuenta_t = dict(Counter(tokenizar(t, tok)))
for p1 in nombres:
for p2 in nombres:
if p1 != p2:
if p1 in cuenta_t and p2 in cuenta_t:
mat_oc[p2][p1] += cuenta_t[p1] * cuenta_t[p2]
else:
if p1 in cuenta_t:
mat_oc[p2][p1] += cuenta_t[p1]
# Ordenar filas y columnas alfabeticamente
mat_oc.sort_index(inplace=True)
mat_oc = mat_oc.reindex(sorted(mat_oc.columns), axis=1)
if tri_sup:
mat_oc = diag_superior(mat_oc)
return mat_oc
def matriz_coocurrencias(texto,
min_frec=1,
max_num=200,
modo='documento',
ventana=3,
tri_sup=True,
limpiar=False,
tokenizador=None):
""" Calcula la matriz de coocurrencias de un texto.
:param texto: (str o list) Corresponde al texto (o lista de textos/documentos) que se desea analizar.
:param min_frec: (int) Valor por defecto: 1. Frecuencia mínima de aparición de palabras, si la frecuencia de una palabra es menor a min_frec, dicha palabra es excluida de la matriz.
:param max_num: (int) Valor por defecto: 200. Número máximo de palabras a dejar en la matriz (se eligen las más frecuentes).
:param modo: (str) {'documento', 'ventana'} Valor por defecto: 'documento'. Corresponde al modo de análisis, con 'documento' se calcula la co-ocurrencia de términos sin importar la distancia entre estos, con 'ventana' se calcula la co-ocurrencia de términos teniendo en cuenta una distancia máxima entre estos.
:param ventana: (int) Valor por defecto: 3. Tamaño de la ventana (solo se usa cuando modo='ventana'). Número de palabras anteriores o posteriores a tener en cuenta con respecto al término de análisis, equivalente a calcular la co-ocurrencia con n-gramas, siendo n=ventana+1.
:param tri_sup: (bool) {True, False} Valor por defecto: True. Si el valor es True devuelve la versión diagonal superior de la matriz de coocurrencias, si es False devuelve la matriz completa.
:param limpiar: (bool) {True, False} Valor por defecto: False. Define \
si se desea hacer una limpieza básica (aplicando la función `limpieza_basica` \
del módulo `limpieza`) al texto de entrada, antes de calcular las coocurrencias.
:param tokenizador: Valor por defecto: None. Objeto encargado de la tokenización y detokenización \
de textos. Si el valor es 'None', se utilizará por defecto una instancia de la clase *TokenizadorNLTK*.
:return: (dataframe) Coocurrencias de los textos de entrada.
"""
# Generar un solo texto con todos los documentos
if isinstance(texto, Iterable) and not isinstance(texto, str):
texto_entero = ' '.join([str(i) for i in texto])
else:
texto_entero = str(texto)
texto = [texto_entero] # Convertir variable "texto" en un iterable
if limpiar:
texto = [limpieza_basica(t) for t in texto]
texto_entero = ' '.join([texto])
# Se inicializa un solo tokenizador, para ahorrar un poco de tiempo
tok = TokenizadorNLTK() if tokenizador is None else tokenizador
# Generar lista de palabras en todos los textos juntos
palabras = tokenizar(texto_entero, tok)
# Dejar solo las palabras con mayor frecuencia y/o que cumplan una
# frecuencia mínima
cuenta = dict(Counter(palabras).most_common(max_num))
cuenta_filt = {k: v for k, v in cuenta.items() if v >= min_frec}
nombres = list(set(cuenta_filt.keys()))
# Inicializar en ceros la matriz de coocurrencias
mat_oc = pd.DataFrame(np.zeros([len(nombres), len(nombres)]),
columns=nombres,
index=nombres)
if modo == 'ventana':
for t in texto:
palabras_t = tokenizar(t, tok)
# Ciclo a través de las palabras para obtener las coocurrencias:
for i, p1 in enumerate(palabras_t):
inicio = max(0, i - ventana)
fin = min(len(palabras), i + ventana + 1)
for j, p2 in enumerate(palabras_t[inicio:fin]):
if (p2 in nombres) and (p1 in nombres):
if p1 != p2:
mat_oc[p2][p1] += 1
else:
if (inicio + j) != i:
mat_oc[p2][p1] += 1
elif modo == 'documento':
for t in texto:
cuenta_t = dict(Counter(tokenizar(t, tok)))
for p1 in nombres:
for p2 in nombres:
if p1 != p2:
if p1 in cuenta_t and p2 in cuenta_t:
mat_oc[p2][p1] += cuenta_t[p1] * cuenta_t[p2]
else:
if p1 in cuenta_t:
mat_oc[p2][p1] += cuenta_t[p1]
# Ordenar filas y columnas alfabeticamente
mat_oc.sort_index(inplace=True)
mat_oc = mat_oc.reindex(sorted(mat_oc.columns), axis=1)
if tri_sup:
mat_oc = diag_superior(mat_oc)
return mat_oc