def __init__(self,
lenguaje,
diccionario=None,
distancia=2,
tokenizador=None):
"""
Constructor por defecto de la clase Corrector. Esta clase se encarga \
de realizar corrección ortográfica sobre textos.
:param lenguaje: (str) Lenguaje de los textos a los que se les va a aplicar \
corrección ortográfica. Para mayor información, consultar la sección de \
:ref:`Lenguajes soportados <seccion_lenguajes_soportados>`.
:param diccionario: (dict, list o string) Valor por defecto: None. Diccionario (o string con ubicación del \
archivo JSON que lo contiene), o lista que permite modificar y agregar palabras. \
Si es una lista, contiene las palabras que serán consideradas como válidas o correctas. \
Si es un diccionario, las llaves del diccionario son las palabras que serán consideradas
como válidas o correctas, y los valores del diccionario son las frecuencias de cada palabra \
en el diccionario. Las frecuencias son utilizadas como criterio de desempate, cuando una \
palabra incorrecta tiene más de una palabra candidata para la corrección. Si se deja este \
parámetro como None, se cargará el diccionario por defecto que trae la librería `spellchecker` \
para el lenguaje determinado.
:param distancia: (int) Valor por defecto: 2. Máxima distancia de Levenshtein que puede haber \
entre una palabra incorrecta (o no reconocida) y las palabras del diccionario para \
determinar si hay palabras candidatas para realizar la corrección.
:param tokenizador: Valor por defecto: None. 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*.
"""
# Definir lenguaje del corrector ortográfico
self.establecer_lenguaje(lenguaje)
# Inicializar corrector
self.iniciar_corrector(diccionario)
self.establecer_distancia(distancia)
self.tokenizador = TokenizadorNLTK(
) if tokenizador is None else tokenizador
def __init__(self, lenguaje="es", tokenizador=None):
"""
Constructor por defecto de la clase `Stemmer`. Esta clase se encarga \
de hacer la operación de *stemming*, o reducción de palabras a su \
raíz, en textos.
:param lenguaje: Lenguaje de los textos a los que se va a aplicar \
*stemming*. Para mayor información, consultar la sección de \
:ref:`Lenguajes soportados <seccion_lenguajes_soportados>`. \
Valor por defecto `'es'`.
:type lenguaje: {'es', 'en', 'fr', 'ge'}, 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`.
:type tokenizador: Tokenizer, opcional
:return: (Stemmer) Objeto del tipo de la clase `Stemmer`.
"""
# Definir lenguaje del stemmer
self.establecer_lenguaje(lenguaje)
# Inicializar stemmer
self.iniciar_stemmer()
# Para tokenizar los textos antes de aplicar el stemming
self.tokenizador = (
TokenizadorNLTK() if tokenizador is None else tokenizador
)
def __init__(self, lenguaje, tokenizador=None):
"""
Constructor por defecto de la clase Stemmer. Esta clase se encarga \
de hacer la operación de *stemming*, o reducción de palabras a su \
raíz, en textos.
:param lenguaje: (str) Lenguaje de los textos a los que se va \
a aplicar *stemming*. Para mayor información, consultar la sección de \
:ref:`Lenguajes soportados <seccion_lenguajes_soportados>`.
:param tokenizador: Valor por defecto: None. 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*.
:return: (Stemmer) Objeto del tipo de la clase Stemmer
"""
# Definir lenguaje del stemmer
self.establecer_lenguaje(lenguaje)
# Inicializar stemmer
self.iniciar_stemmer()
# Para tokenizar los textos antes de aplicar el stemming
self.tokenizador = TokenizadorNLTK(
) if tokenizador is None else tokenizador
def __init__(self,
lenguaje,
diccionario=None,
distancia=2,
tokenizador=None):
"""
Constructor por defecto de la clase `Corrector`. Esta clase se \
encarga de realizar corrección ortográfica sobre textos.
:param lenguaje: Lenguaje de los textos a los que se les va a \
aplicar corrección ortográfica. Para mayor información, consultar \
la sección de \
:ref:`Lenguajes soportados <seccion_lenguajes_soportados>`.
:type lenguaje: str
:param diccionario: Diccionario (o string con ubicación del archivo \
JSON que lo contiene), o lista que permite modificar y agregar \
palabras. Si es una lista, contiene las palabras que serán \
consideradas como válidas o correctas. \
Si es un diccionario, las llaves del diccionario son las palabras \
que serán consideradas como válidas o correctas, y los valores \
del diccionario son las frecuencias de cada palabra en el \
diccionario. Las frecuencias son utilizadas como criterio de \
desempate, cuando una palabra incorrecta tiene más de una palabra \
candidata para la corrección. Si se deja este \
parámetro como `None`, se cargará el diccionario por defecto que \
trae la librería `spellchecker` para el lenguaje determinado.
:type diccionario: dict, list, str, opcional
:param distancia: Máxima distancia de \
Levenshtein que puede haber entre una palabra incorrecta (o no \
reconocida) y las palabras del diccionario para determinar si \
hay palabras candidatas para realizar la corrección. \
Valor por defecto `2`.
:type distancia: int
: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
"""
# Definir lenguaje del corrector ortográfico
self.establecer_lenguaje(lenguaje)
# Inicializar corrector
self.iniciar_corrector(diccionario)
self.establecer_distancia(distancia)
self.tokenizador = (TokenizadorNLTK()
if tokenizador is None else tokenizador)
class Corrector():
def __init__(self,
lenguaje,
diccionario=None,
distancia=2,
tokenizador=None):
"""
Constructor por defecto de la clase Corrector. Esta clase se encarga \
de realizar corrección ortográfica sobre textos.
:param lenguaje: (str) Lenguaje de los textos a los que se les va a aplicar \
corrección ortográfica. Para mayor información, consultar la sección de \
:ref:`Lenguajes soportados <seccion_lenguajes_soportados>`.
:param diccionario: (dict, list o string) Valor por defecto: None. Diccionario (o string con ubicación del \
archivo JSON que lo contiene), o lista que permite modificar y agregar palabras. \
Si es una lista, contiene las palabras que serán consideradas como válidas o correctas. \
Si es un diccionario, las llaves del diccionario son las palabras que serán consideradas
como válidas o correctas, y los valores del diccionario son las frecuencias de cada palabra \
en el diccionario. Las frecuencias son utilizadas como criterio de desempate, cuando una \
palabra incorrecta tiene más de una palabra candidata para la corrección. Si se deja este \
parámetro como None, se cargará el diccionario por defecto que trae la librería `spellchecker` \
para el lenguaje determinado.
:param distancia: (int) Valor por defecto: 2. Máxima distancia de Levenshtein que puede haber \
entre una palabra incorrecta (o no reconocida) y las palabras del diccionario para \
determinar si hay palabras candidatas para realizar la corrección.
:param tokenizador: Valor por defecto: None. 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*.
"""
# Definir lenguaje del corrector ortográfico
self.establecer_lenguaje(lenguaje)
# Inicializar corrector
self.iniciar_corrector(diccionario)
self.establecer_distancia(distancia)
self.tokenizador = TokenizadorNLTK(
) if tokenizador is None else tokenizador
def establecer_lenguaje(self, lenguaje):
"""
Permite definir o cambiar el lenguaje de los textos sobre los cuales \
va a aplicarse el objeto de la clase Corrector.
:param lenguaje: (str) Lenguaje de los textos a los que se les va a aplicar \
corrección ortográfica. Para mayor información, consultar la sección de \
:ref:`Lenguajes soportados <seccion_lenguajes_soportados>`.
"""
self.lenguaje = definir_lenguaje(lenguaje)
def iniciar_corrector(self, diccionario):
"""
Inicializa el objeto de la clase `SpellChecker` de la librería spellchecker, \
para el lenguaje definido previamente, y lo asigna al atributo "corrector" del \
objeto de clase Corrector.
:param diccionario: (dict, list o string) Diccionario (o string con ubicación del \
archivo JSON que lo contiene), o lista que permite modificar y agregar palabras. \
Si es una lista, contiene las palabras que serán consideradas como válidas o correctas. \
Si es un diccionario, las llaves del diccionario son las palabras que serán consideradas
como válidas o correctas, y los valores del diccionario son las frecuencias de cada palabra \
en el diccionario. Las frecuencias son utilizadas como criterio de desempate, cuando una \
palabra incorrecta tiene más de una palabra candidata para la corrección.
"""
self.corrector = None
if self.lenguaje is not None:
if isinstance(diccionario, str):
self.corrector = SpellChecker(local_dictionary=diccionario)
elif type(diccionario) in [dict, list]:
self.corrector = SpellChecker(language=self.lenguaje)
self.actualizar_diccionario(diccionario)
else:
self.corrector = SpellChecker(language=self.lenguaje)
def establecer_distancia(self, distancia):
"""
Establece la distancia máxima que utilizará el algoritmo de corrección de ortografía \
para determinar si hay palabras candidatas para corregir una palabra incorrecta o \
no reconocida.
:param distancia: (int) Valor por defecto: 2. Máxima distancia de Levenshtein que puede haber
entre una palabra incorrecta (o no reconocida) y las palabras del diccionario para \
determinar si hay palabras candidatas para realizar la corrección.
"""
if self.corrector is not None:
self.corrector.distance = distancia
def actualizar_diccionario(self, diccionario):
"""
Actualiza el diccionario que contiene las palabras válidas o reconocidas disponibles para \
realizar la corrección ortográfica. Las palabras contenidas en el argumento *diccionario* \
de esta función serán añadidas (o sus frecuencias serán actualizadas) en el diccionario \
que ya existe en el objeto de la clase Corrector.
:param diccionario: (dict, list o string) Diccionario (o string con ubicación del \
archivo JSON que lo contiene), o lista que permite modificar y agregar palabras. \
Si es una lista, contiene las palabras que serán consideradas como válidas o correctas. \
Si es un diccionario, las llaves del diccionario son las palabras que serán consideradas
como válidas o correctas, y los valores del diccionario son las frecuencias de cada palabra \
en el diccionario. Las frecuencias son utilizadas como criterio de desempate, cuando una \
palabra incorrecta tiene más de una palabra candidata para la corrección.
"""
if isinstance(diccionario, str):
diccionario = json.load(open(diccionario))
if isinstance(diccionario, list):
diccionario = [palabra.lower() for palabra in diccionario]
self.corrector.word_frequency.load_words(diccionario)
elif isinstance(diccionario, dict):
self.quitar_palabras(list(diccionario.keys()))
for key in diccionario.keys():
self.corrector.word_frequency.load_words([key.lower()] *
diccionario[key])
else:
pass
def quitar_palabras(self, palabras):
"""
Quita del diccionario del corrector una o más palabras proporcionadas en el argumento \
*palabras*, haciendo que estas ya no sean reconocidas como palabras válidas o \
correctas al momento de hacer corrección ortográfica.
:param palabras: (str o list) Palabra o lista de palabras que se desean quitar del \
diccionario del objeto de la clase Corrector, para que no sean recnocidas como \
correctas al momento de hacer la corrección ortográfica.
"""
if isinstance(palabras, str):
palabras = [palabras]
# Quitar de la lista palabras que no estén en el diccionario
palabras = [p for p in palabras if self.frecuencia_palabra(p) > 0]
if len(palabras) > 0:
self.corrector.word_frequency.remove_words(palabras)
def agregar_palabras(self, palabras):
"""
Añade al diccionario del corrector una o más palabras proporcionadas en el argumento \
*palabras*, haciendo que estas sean reconocidas como palabras válidas o \
correctas al momento de hacer corrección ortográfica.
:param palabras: (str o list) Palabra o lista de palabras que se desean añadir al \
diccionario del objeto de la clase Corrector, para que sean reconocidas como \
correctas al momento de hacer la corrección ortográfica.
"""
if isinstance(palabras, str):
palabras = [palabras]
self.actualizar_diccionario(palabras)
def palabras_conocidas(self, texto):
"""
A partir de un texto de entrada, devuelve un conjunto (objeto de clase *set* de \
Python) con las palabras del texto que se reconocen por estar presentes en \
el diccionario del corrector.
:param texto: (str) Texto para el que se desean hayar las palabras conocidas.
:return: (set) Conjunto de palabras conocidas presentes en el texto de entrada.
"""
tokens = self.tokenizador.tokenizar(texto)
return self.corrector.known(tokens)
def palabras_desconocidas(self, texto):
"""
A partir de un texto de entrada, devuelve un conjunto (objeto de clase *set* de \
Python) con las palabras del texto que no están incluidas en \
el diccionario del corrector y por lo tanto no se reconocen.
:param texto: (str) Texto para el que se desean hallar las palabras desconocidas.
:return: (set) Conjunto de palabras desconocidas presentes en el texto de entrada.
"""
tokens = self.tokenizador.tokenizar(texto)
return self.corrector.unknown(tokens)
def palabras_candidatas(self, palabra):
"""
Para una palabra de entrada, retorna un conjunto de palabras que podrían ser utilizadas \
para corregirla. Si la palabra de entrada es correcta (está dentro del diccionario \
del corrector) o no tienen ninguna palabra candidata con una distancia menor o igual \
a la establecida en el parámetro *distancia* de la clase Corrector, la función \
devolverá la misma palabra de entrada.
:param palabra: (str) Palabra para la que se quieren conocer palabras candidatas \
para su corrección ortográfica.
:return: (set) Conjunto de palabras candidatas para corregir la palabra de entrada.
"""
return self.corrector.candidates(palabra)
def frecuencia_palabra(self, palabra):
"""
Para una palabra de entrada, devuelve la frecuencia de la misma, de acuerdo al \
diccionario del corrector. Si la palabra es desconocida (no se encuentra en \
el diccionario), la frecuencia retornada será de cero.
:param palabra: (str) Palabra para la cual se desea conocer la frecuencia de \
aparición en el diccionario del corrector.
:return: (int) Número mayor o igual a cero que indica la frecuencia de la palabra \
consultada en el diccionario del corrector.
"""
return self.corrector[palabra]
def probabilidad_palabra(self, palabra):
"""
Para una palabra de entrada, devuelve la probabilidad de aparición de la misma, \
entendida como su frecuencia sobre la suma de las frecuencias de todas las palabras\
disponibles, de acuerdo al diccionario del corrector. Si la palabra es desconocida \
(no se encuentra en el diccionario), la probabilidad retornada será de cero.
:param palabra: (str) Palabra para la cual se desea conocer la probabilidad \
de aparición en el diccionario del corrector.
:return: (float) Probabilidad, entre 0 y 1, de aparición de la palabra.
"""
return self.corrector.word_probability(palabra)
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: (str) Texto al cuál se desea aplicar corrección ortográfica.
:param limpieza: (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 la corrección ortográfica.
: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 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
class Stemmer():
def __init__(self, lenguaje, tokenizador=None):
"""
Constructor por defecto de la clase Stemmer. Esta clase se encarga \
de hacer la operación de *stemming*, o reducción de palabras a su \
raíz, en textos.
:param lenguaje: (str) Lenguaje de los textos a los que se va \
a aplicar *stemming*. Para mayor información, consultar la sección de \
:ref:`Lenguajes soportados <seccion_lenguajes_soportados>`.
:param tokenizador: Valor por defecto: None. 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*.
:return: (Stemmer) Objeto del tipo de la clase Stemmer
"""
# Definir lenguaje del stemmer
self.establecer_lenguaje(lenguaje)
# Inicializar stemmer
self.iniciar_stemmer()
# Para tokenizar los textos antes de aplicar el stemming
self.tokenizador = TokenizadorNLTK(
) if tokenizador is None else tokenizador
def establecer_lenguaje(self, lenguaje):
"""
Permite definir o cambiar el lenguaje de los textos sobre los cuales \
va a aplicarse el objeto de la case Stemmer.
:param lenguaje: (str) Lenguaje de los textos a los que se va \
a aplicar stemming. Para mayor información, consultar la sección de \
:ref:`Lenguajes soportados <seccion_lenguajes_soportados>`.
"""
self.lenguaje = definir_lenguaje(lenguaje, simplificado=False)
def iniciar_stemmer(self):
"""
Inicializa el objeto de la clase `SnowballStemmer` de la librería NLTk, \
para el lenguaje definido previamente, y lo asigna al atributo "stemmer" \
del objeto de clase Stemmer.
"""
if self.lenguaje is not None:
self.stemmer = nltk.stem.SnowballStemmer(self.lenguaje)
else:
self.stemmer = None
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 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