Clasificación de correos: Filtrado de spam con Naive Bayes

Curso de Algoritmos de Clasificación de Texto

Contenido del curso

Desambiguación y etiquetado de palabras

Modelos Markovianos Latentes (HMM)

Algoritmo de Viterbi

Modelos Markovianos de máxima entropía (MEMM)

Clasificación de texto con NLTK

Implementación de un modelo de clasificación de texto

Tomar examen

Cursos Empresas Blog Live Conf Eventos Precios

0:0019:33

Clasificación de correos: Filtrado de spam con Naive Bayes

Curso de Algoritmos de Clasificación de Texto

Clase 20 de 26

Clase 20 / 26

Recursos

¿Cómo realizar una clasificación de documentos eficaz?

La clasificación de documentos es una tarea crucial en el aprendizaje automático y la ciencia de datos. Uno de los desafíos más comunes es la clasificación de correos electrónicos en categorías como "spam" o "no spam". En este enfoque, utilizaremos Google Colab para desarrollar una práctica sencilla pero poderosa de clasificación de documentos.

¿Cómo iniciar con el dataset y preparación del entorno?

Para comenzar, necesitas clonar el dataset desde un repositorio de GitHub que contiene correos electrónicos. Es fundamental verificar la conexión a Google Colab y asegurarse de que el sistema de archivos está actualizado. Aquí están los pasos para iniciar:

Clonar el repositorio:

!git clone https://github.com/tu-repositorio/data-sets

Verificar las librerías necesarias: Importa las librerías Pandas y NumPy para manejo de datos y NLTK para procesamiento de lenguaje natural. Descarga luego los modelos punkt y Average Perceptron Tagger para tokenización y etiquetado.

Cargar el dataset: Usa Pandas para leer el archivo CSV:

import pandas as pd
df = pd.read_csv('/content/data-sets/email/csv/spam-apache.csv', names=['Class', 'Content'])

¿Cómo proceder con la tokenización y extracción de atributos?

La tokenización es un proceso primordial para descomponer el texto en unidades manejables. Este paso facilita la construcción de un modelo de clasificación eficiente:

Tokenización:

from nltk.tokenize import word_tokenize
df['Tokens'] = df['Content'].apply(lambda x: word_tokenize(x))

Generación de atributos base:
- Usa una distribución de frecuencia para identificar las palabras más comunes utilizando FreqDist de NLTK.
- Determina los tokens más frecuentes del dataset.

¿Cómo desarrollar un sistema de clasificación?

Con el dataset preparado, pasamos a construir el modelo de clasificación:

Extracción de atributos de documentos:

def documento_atributos(document):
    document_words = set(document)
    features = {}
    for word in top_words:
        features[f'contains({word})'] = (word in document_words)
    return features

Entrenamiento del modelo:
- Divide el dataset en conjuntos de entrenamiento y pruebas.
- Entrena un clasificador de Naive Bayes.
Evaluación de rendimiento:
- Evalúa la precisión del modelo usando una métrica de precisión estándar.
- Ajusta el modelo en función de la ingeniería de características.

¿Cómo mejorar el modelo de clasificación?

Para optimizar el clasificador, considera lo siguiente:

Ingeniería de atributos: Mejora tus atributos explorando la estructura del texto más detalladamente, utilizando bigramas o trigramas que proporcionen contexto adicional.
Limpieza y preprocesamiento avanzado: Implementa expresiones regulares y filtros de categorías gramaticales para refinar los datos de entrada.
Comparación de características: Usa el método show_most_informative_features del clasificador para identificar qué diferencias de atributos están siendo más efectivas.

¿Qué pasos seguir para un ejercicio práctico?

La práctica y la iteración son fundamentales en el aprendizaje automático. Puedes mejorar tu modelo practicando con estos consejos:

Utiliza un dataset más robusto.
Preproceso más meticuloso usando herramientas como expresiones regulares.
Evalúa el modelo iterativo y mejora los atributos basados en patrones observados en el dataset.
Considera nuevas estrategias de tokenización y análisis de la secuencia de palabras para extraer mejores atributos.

Por último, ánimo a explorar, experimentar y compartir tus resultados para seguir mejorando en el emocionante campo de la clasificación de textos. ¡Sigue adelante!

Sebastián Bustos Cordero

Hace 2 meses

# Clasificación de documentos (email spam o no spam) [Actualizado]

# Clonamos el nuevo repositorio sugerido
import os
if not os.path.exists('datasets_new'):
    !git clone https://github.com/tasdikrahman/datasets.git datasets_new
else:
    print("El repositorio ya existe en la carpeta 'datasets_new'.")

import pandas as pd
import numpy as np
nltk.download('punkt')
nltk.download('averaged_perceptron_tagger')
from nltk import word_tokenize

import os # Módulo para interactuar con el sistema operativo, útil para verificar la existencia de archivos.
import pandas as pd # Librería fundamental para la manipulación y análisis de datos en DataFrames.
import nltk # NLTK (Natural Language Toolkit) es una de las librerías más populares para trabajar con lenguaje natural en Python.
from nltk import word_tokenize # Función de NLTK para dividir texto en palabras (tokenización).
import random # Módulo para generar números aleatorios, utilizado aquí para mezclar el conjunto de datos.

# --- 1. Configuración e Importaciones (Asegurando las Herramientas Necesarias) ---
# NLTK requiere la descarga de ciertos recursos (corpus, tokenizadores, etc.) para funcionar.
# Aquí nos aseguramos de que el tokenizador 'punkt_tab' esté disponible, ya que es crucial para `word_tokenize`.
# El bloque `try-except` maneja la descarga de forma "idempotente", es decir, solo se realizará si el recurso no existe,
# evitando descargas repetidas y ahorrando tiempo.
try:
    nltk.data.find('tokenizers/punkt_tab') # Intentamos localizar el recurso 'punkt_tab'.
except nltk.downloader.DownloadError: # Si no se encuentra, capturamos el error de descarga.
    print("Descargando recurso 'punkt_tab' de NLTK...") # Informamos al usuario.
    nltk.download('punkt_tab') # Procedemos con la descarga del recurso.
else:
    print("El recurso 'punkt_tab' de NLTK ya está disponible.") # Si se encontró, informamos que ya existe.


# --- 2. Carga y Preparación del Dataset (¡Nuestros Datos de Correo!) ---
# Definimos la ruta al archivo del dataset de spam. Este archivo contiene ejemplos de correos clasificados.
# Esta ruta fue identificada previamente en la conversación mediante un comando 'find'.
file_path = 'datasets_new/email/csv/spam-apache.csv'

# Verificamos si el archivo existe antes de intentar cargarlo. Esto previene errores si la ruta es incorrecta.
if os.path.exists(file_path):
    print(f"Cargando dataset desde: {file_path}") # Informamos la ruta de carga.
    # Cargamos el dataset usando pandas. `pd.read_csv` es ideal para esto.
    # El archivo no tiene encabezados, por lo que asignamos los nombres de las columnas manualmente:
    # 'clase' para la etiqueta (spam/no-spam) y 'contenido' para el texto del correo.
    # La codificación 'latin-1' es común para este tipo de datasets antiguos y evita errores de lectura de caracteres.
    df = pd.read_csv(file_path, names=['clase', 'contenido'], encoding='latin-1')

    # --- 3. Tokenización y Extracción de Características (Preparando el Texto para el Modelo) ---
    # La tokenización es el proceso de dividir el texto en unidades más pequeñas, como palabras.
    # Aplicamos `word_tokenize` a la columna 'contenido' para transformar cada correo en una lista de palabras.
    # Convertimos cada palabra a minúsculas (`w.lower()`) para tratar, por ejemplo, "Hola" y "hola" como la misma palabra.
    df['tokens'] = df['contenido'].apply(lambda x: [w.lower() for w in word_tokenize(str(x))])

    print("Dataset de Spam Apache cargado con éxito y tokenizado:")
    display(df.head()) # Mostramos las primeras filas del DataFrame para ver cómo quedó después de la tokenización.

    # Mostramos la distribución de clases para verificar si el dataset está balanceado.
    # Un dataset balanceado ayuda a entrenar modelos más justos. Aquí, '1' es Spam y '-1' es No-Spam (Ham).
    print("\nDistribución de clases (1: Spam, -1: No Spam):")
    print(df['clase'].value_counts()) # `value_counts()` es muy útil para ver la frecuencia de cada valor único.

    # Calculamos la frecuencia de todas las palabras en el corpus completo (todos los correos).
    # `nltk.FreqDist` es una clase que ayuda a contar la ocurrencia de cada ítem.
    # Iteramos sobre todas las listas de tokens para crear una única lista de todas las palabras del corpus.
    all_words = nltk.FreqDist([w for tokenlist in df['tokens'].values for w in tokenlist])
    # Seleccionamos las 200 palabras más comunes. Estas palabras serán nuestras "características" o "features"
    # para el modelo, formando un enfoque de "Bag-of-Words" (bolsa de palabras), donde el orden no importa.
    top_words = [word for word, _ in all_words.most_common(200)] # Solo nos interesan las palabras, no sus conteos aquí.

    # Definimos la función `document_features` para extraer características de un documento individual.
    # Para cada correo, creamos un conjunto de sus palabras para búsquedas eficientes (verificar si una palabra está presente).
    # Las características son binarias: 'contains(palabra)' será True si la palabra está en el documento, False si no.
    def document_features(document):
        document_words = set(document) # Convertimos la lista de palabras del documento a un conjunto para búsqueda rápida.
        features = {} # Inicializamos un diccionario para almacenar las características.
        for word in top_words:
            # Para cada una de las 200 palabras más comunes, creamos una característica booleana.
            # Esto representa el modelo de "bag-of-words": ¿contiene el documento esta palabra? Sí/No.
            features[f'contains({word})'] = (word in document_words)
        return features

    # Aplicamos la función `document_features` a cada documento tokenizado y emparejamos las características
    # resultantes con sus respectivas clases (etiquetas: spam/no-spam). Esto crea el formato necesario para NLTK.
    # `fset` contendrá una lista de tuplas, donde cada tupla es (diccionario_de_features, clase_del_documento).
    fset = [(document_features(texto), clase) for texto, clase in zip(df['tokens'].values, df['clase'].values)]

    # Mezclamos el conjunto de características (`fset`) aleatoriamente.
    # Esto es crucial para asegurar que la división en conjuntos de entrenamiento y prueba sea representativa
    # y evite cualquier sesgo que pudiera existir si los datos estuvieran ordenados (ej. todos los spam primero).
    random.shuffle(fset)

    # Dividimos el conjunto de datos en entrenamiento (los primeros 200 ejemplos) y prueba (el resto).
    # El conjunto de entrenamiento se usa para que el modelo "aprenda", y el de prueba para evaluar su rendimiento
    # con datos que nunca ha visto, simulando el mundo real.
    train, test = fset[:200], fset[200:] # 200 para entrenamiento, el resto (50) para prueba.
    print(f"\nConjunto de entrenamiento: {len(train)} ejemplos")
    print(f"Conjunto de prueba: {len(test)} ejemplos")

    # --- 4. Entrenamiento y Evaluación del Clasificador (Haciendo que el Modelo Aprenda) ---
    # Entrenamos un clasificador Naive Bayes con los datos de entrenamiento.
    # Naive Bayes es un algoritmo de clasificación probabilístico. Es "ingenuo" porque asume que las características
    # (la presencia de una palabra) son independientes entre sí, lo cual simplifica el cálculo y lo hace eficiente.
    classifier = nltk.NaiveBayesClassifier.train(train)
    print("\nClasificador Naive Bayes entrenado.")

    # Evaluamos la precisión del clasificador en el conjunto de prueba.
    # La precisión es una métrica que nos dice qué porcentaje de las predicciones del modelo fueron correctas.
    # Un valor del 98% significa que el modelo clasificó correctamente 98 de cada 100 correos en el conjunto de prueba.
    accuracy_score = nltk.classify.accuracy(classifier, test)
    print(f"\nPrecisión del clasificador en el conjunto de prueba: {accuracy_score:.2%}")

    # --- 5. Análisis de Resultados (Entendiendo qué Hizo el Modelo) ---
    # Mostramos las 5 características (palabras) más informativas.
    # Esto nos ayuda a entender qué palabras son las más determinantes para el clasificador a la hora de decidir
    # si un correo es spam o no-spam. Por ejemplo, palabras como 'ganar', 'oferta' suelen ser indicativas de spam.
    print("\nLas 5 características más informativas:")
    classifier.show_most_informative_features(5)

    # Finalmente, mostramos el contenido de algunos correos clasificados como no spam (clase -1).
    # Esto nos da una idea visual de qué tipo de correos el modelo considera "limpios" o "ham".
    print("\nContenido de algunos correos no spam (clase -1):")
    # Filtramos el DataFrame para solo mostrar correos con clase -1 (no spam) y tomamos los primeros 5.
    for i, content in enumerate(df[df['clase']==-1]['contenido'].head()):
        print(f"--- Correo {i+1} ---\n{content}\n")

else:
    # Si el archivo no se encontró, mostramos un mensaje de error claro para el usuario.
    print(f"ERROR: No se encontró el archivo en {file_path}. Por favor, verifica la ruta o clona el repositorio.")

Comentarios (24)24 comentarios

Daniel Eishu Oyama Arevalo

Hace 6 años

Josue Farley Lopez Carvajal

Hace 2 años

Fabian Villada

Ricardo Moreno

johan Stever Rodriguez Molina

Luis Enrique Sanchez Piñerua

Daniel Agustín Luis Garcia

Hace 7 meses

Alexander carpio mamani

Iram Martinez

Ricardo Talavera

Hace 4 años

Sebastian Almeida

Juan Jose Tovar

Gabriel Obregón

Hace un año

Patricio González Estrada

Hace 5 años

Jhon Freddy Tavera Blandon

Humberto Guardado

Desambiguación y etiquetado de palabras

Clasificación de Texto con Machine Learning

Etiquetado de Palabras en Python con NLTK y Stanza

Uso de Stanza para Procesamiento de Lenguaje Natural en Español

Modelos Markovianos Latentes (HMM)

Modelos Marcovianos Latentes en PLN: Fundamentos y Aplicaciones

Matemáticas de Cadenas de Markov y su Aplicación en Modelos Latentes

Modelos Marcovianos Latentes: Etiquetado Gramatical Automático

Implementación de Modelos Marcovianos Latentes en Python con Google Colab

Entrenamiento de Modelos Marcobianos Latentes en Python

Algoritmo de Viterbi

Decodificación de Secuencias con el Algoritmo de Viterbi

Cálculo de Probabilidades en el Algoritmo de Viterbi

Implementación del Algoritmo de Viterbi en Python con NumPy

Implementación del Algoritmo Viterbi para Modelos Ocultos de Markov

Implementación de Modelos Ocultos de Markov en NLTK y Python

Modelos Markovianos de máxima entropía (MEMM)

Modelos Marcovianos de Máxima Entropía en Clasificación de Etiquetas

Algoritmo BiTerbi en Modelos de Máxima Entropía

Entrenamiento y Decodificación de Modelos Marcobianos en Bitterbi

Clasificación de texto con NLTK

Clasificación de Texto en Machine Learning: Teorías y Aplicaciones

Clasificación de Nombres por Género con NLTK en Python

Clasificación de Nombres con Naive Bayes en Python

Clasificación de correos: Filtrado de spam con Naive Bayes

Implementación de un modelo de clasificación de texto

Funcionamiento Matemático del Clasificador Naive Bayes

Preparación de Datos para Modelo Naive Bayes en Python

Implementación del Algoritmo Naive Bayes en Python con spaCy

Implementación del Método Predict en Naive Bayes Clasificador

Métricas de Evaluación en Modelos de Clasificación: Accuracy, Precision y Recall

Clasificación de Sentimientos con Reviews de Amazon

Clasificación de correos: Filtrado de spam con Naive Bayes