def remover_stopwords(texto, lista_palabras = [], lista_expresiones = [],
        ubicacion_archivo=None, tokenizador=None):
    """Quita las palabras y expresiones determinadas de un texto. Esta función quita del texto de entrada, \
    palabras específicas contenidas en `lista_palabras`, o expresiones de palabras contenidas en `lista_expresiones`.

    :param texto: (str) Texto al cual se le quitarán palabras y expresiones contenidas en `lista_palabras` \
    y `lista_expresiones`.
    :param lista_palabras: (list) Parámetro opcional. Lista de palabras que se quieren quitar del texto. Por ejemplo, \
        la lista `['hola', 'de', 'a']` eliminará esas palabras.
    :param lista_expresiones: (list) Parámetro opcional. Lista de expresiones que se quieren quitar al texto. \
        A diferencia de `lista_palabras`, esta puede contener palabras compuestas. Por ejemplo, \
        ['San juan de Dios', 'Distrito Capital, 'fuente de agua']; esta lista quitará esas palabras \
        compuestas del texto de entrada.
    :param ubicacion_archivo: (str) Valor por defecto: None. Ubicación del archivo plano que contiene la lista de palabras \
        y/o lista de palabras separadas por espacios, comas o saltos de línea. En \
        caso contrario no es necesario especificar los parametros `lista_palabras` y `lista_expresiones`.
    :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: (str) Texto sin las palabras y expresiones incluidas en la limpieza.
    """
    if ubicacion_archivo:
        lista_palabras, lista_expresiones = cargar_stopwords(ubicacion_archivo)
    # Quitar las expresiones no deseadas
    for expresion in set(lista_expresiones):
        texto = texto.replace(expresion, ' ')
    # Dejar solo las palabras que no aparecen en la lista de palabras no
    # deseadas
    tokens = tokenizar(texto, tokenizador)
    texto = destokenizar([p for p in tokens if p not in set(lista_palabras)], tokenizador)
    # Reemplaza espacios múltiples por un solo espacio
    texto = re.sub(r" +", " ", texto)
    return texto
Example #2
0
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
Example #3
0
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
Example #4
0
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
Example #5
0
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