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