Contenido del curso
Clustering y Detección de Anomalías en Datos de Negocios
¿Cómo realizar clustering y detección de anomalías en tus datos?
Clustering y la detección de anomalías son herramientas poderosas en el análisis de datos no supervisado. Aquí aprenderás cómo aplicar estos métodos a un conjunto de datos utilizando bibliotecas populares en Python. ¡Sigue este enfoque y descubre cómo tus datos pueden revelarte información valiosa!
¿Cómo preprocesar texto en Python?
El preprocesamiento del texto es un paso crucial antes del análisis. Aquí es donde tokenizamos y limpiamos los datos textuales para facilitar el clustering. Utilizaremos bibliotecas conocidas como Ahencing, NLTK y NumPy:
import ahencing import nltk from nltk.corpus import stopwords import numpy as np
Pasos esenciales para el preprocesamiento:
Tokenización: Separar el texto en palabras o 'tokens'.
Remover Stopwords: Filtrar palabras comunes que no aportan valor analítico, como artículos o preposiciones.
Filtrado de Palabras Cortas: Elimina palabras con menos de cuatro caracteres para enfocarse en términos significativos.
def preprocess_text(text): result = [token for token in text.split() if token not in stopwords.words('spanish') and len(token) > 4] return result
¿Cómo construir un diccionario y un corpus?
Para un clustering efectivo, necesitamos un diccionario de palabras relevantes y un corpus. Aquí es donde Ahencing juega un papel vital al construir el DiccionAE.
dictionary = ahencing.Corpora.Dictionary(processed_businesses) # Filtrar ocurrencias muy poco frecuentes o muy frecuentes dictionary.filter_extremes(no_below=1, no_above=0.5)
El corpus se crea a partir del diccionario usando doc2bow, que convierte los textos en valores numéricos para facilitar el análisis.
corpus = [dictionary.doc2bow(doc) for doc in processed_businesses]
¿Cómo ejecutar el modelo de clustering LDA en Python?
Utilizaremos el modelo LDA para identificar temas en nuestros datos, aprovechando la funcionalidad de Ahencing.
lda_model = ahencing.models.ldamodel.LdaMulticore(corpus, num_topics=6, id2word=dictionary, passes=10, workers=2)
Clave para asignar clusters: Definimos una función que asigna a cada dato su cluster más probable según el modelo LDA.
def get_max_topic(index): results = lda_model[corpus[index]] return max(results, key=lambda x: x[1])
¿Cómo analizar y visualizar los resultados de clustering?
Una vez que los datos están agrupados, es posible analizarlos y visualizarlos. Agrupa por clusters y calcula las medias para obtener información relevante, como el promedio de facturación por tipo de negocio.
compras_df['cluster_name'] = compras_df['beneficiario'].apply(lambda x: business_cluster[x]) average_import = compras_df.groupby('cluster_name')['importe'].mean() average_import.plot(kind='bar')
Los resultados proporcionan insights valiosos sobre cómo diferentes tipos de negocios contribuyen a los costos totales, ayudando a identificar áreas clave y patrones interesantes.
Este enfoque de clustering no solo te permite agrupar datos de manera efectiva, sino que también proporciona un marco para aplicar modelos de detección de anomalías, mejorando así la calidad y profundidad del análisis. ¡Sigue explorando, implementando estos métodos en tus proyectos y comparte tus descubrimientos!
Ricardo Alanis
ProfesorHola, Al igual que el modelo supervisado, podrás notar que la potencia de este modelo textual podría mejorar.
Como hemos mencionado, te muestro aquí una primera iteración como exploramos los modelos supervisados y no supervisados para encontrar valor en nuestro conjunto de datos. Sin embargo, para llegar a modelos de utilidad tendríamos que refinar nuestro proceso.
En este caso, expandir la cantidad de ejemplos de datos y refinar la limpieza de los textos para llegar a una mejor separación de las categorías buscadas, sería la alternativa.
No tengas miedo de probar cosas, y como les muestro aquí, en el mundo real el primer esfuerzo casi siempre va a tener retos. Debemos de continuar y obtener valor, no rendirnos ¡Allá afuera no todos los datasets son como el del Titanic!
Hugo Montoya Diaz
EstudianteGenial y valioso este curso en su totalidad
Francisco Javier Garcia Moreno
EstudianteRealice un modelo KMeans.
Primero elegí las variables que a mi criterio iba a desarrollar las cuales fueron, Contrato, Importe y Factura
# agrupamos los valores compras_df_c_grupo = compras_df_c.groupby('BENEFICIARIO').agg({'CONTRATO': lambda x: x.nunique() , 'IMPORTE': 'sum', 'FACTURA': lambda x: x.nunique()}) compras_df_cluster = compras_df_c_grupo.reset_index() compras_df_cluster
Luego elimine la variable de beneficiario para normalizar los valores
compras_df_c_grupo_f = compras_df_c_grupo.reset_index().drop(['BENEFICIARIO'], axis = 1) normalizado_compras_df = (compras_df_c_grupo_f- compras_df_c_grupo_f.min())/(compras_df_c_grupo_f.max()-compras_df_c_grupo_f.min()) normalizado_compras_df
Con la técnica del cono de Jumdu, este me ilustra que debo tomar 3 cluster
wcss = [] for i in range(1, 11): kmeans = KMeans(n_clusters=i, max_iter= 300) kmeans.fit(normalizado_compras_df) wcss.append(kmeans.inertia_) plt.plot(range(1,11), wcss) plt.title('codo de jambu') plt.xlabel('Numero de cluster') plt.ylabel('WCSS') # Indica la candtida de similitud de los individuos plt.show()
Aplico el modelo Kamens
clustering = KMeans(n_clusters = 3, max_iter= 300) clustering.fit(normalizado_compras_df) # aplicamos el metodo # Agregamos la clasificacion al archivo orginal compras_df_cluster['KMeans_Cluster'] = clustering.labels_ compras_df_cluster['KMeans_Cluster'].value_counts()
Aplico el análisis de componentes
# Visualizando los cluster que se formaron # aplicaremos el analisis de componentes principales para darnos una idea de como se formanon los cluster from sklearn.decomposition import PCA pca = PCA(n_components=2) pca_compras = pca.fit_transform(normalizado_compras_df) pca_compras_df = pd.DataFrame(data = pca_compras, columns = ['componente_1', 'componente_2']) pca_nombres_beneficia= pd.concat([pca_compras_df, compras_df_cluster['KMeans_Cluster']], axis = 1) pca_nombres_beneficia
Graficando obtenemos
Ricardo Alanis
Profesor¡Wow Francisco! ¡Gran trabajo! Me ha encantado lo detallado que has puesto tu proceso y la claridad con la que lo explicas ¡Felicidades!
Julián Cárdenas
EstudianteQue envidia de la buena, excelente Platzi-bro!
Rubén Cuello
EstudianteBueno, supongo que retomaré este curso más adelante. No tengo ni idea que está haciendo el profesor. Muchas librerías nuevas, con métodos que no conozco y no se usar.
Ricardo Alanis
ProfesorRecuerda que lo importante es llegar a conclusiones, si en la parte exploratoria encontraste algo, es suficiente para compartir! No te desanimes!
Jorge Olmus
EstudianteEsta parte del curso confunde mucho a quienes no hemos hecho cursos de ML y otros complementarios. Espero en las siguientes secciones se pueda retomar el hilo.
Roger Christian Cansaya Olazabal
EstudianteVaya esta clase si estuvo buena la pase volando jajaja, lenguaje no supervisado es necesario practicarlo mas.
libreria gensim y stopwords muy interesantes y modelo ldaMulticore
Ricardo Alanis
ProfesorTotalmente!
Para quienes no tienen tanto contexto sobre no supervisado, aca un recurso interesante para ello: https://medium.com/datos-y-ciencia/aprendizaje-no-supervisado-desmitificado-da4561e66331
Y solo un ejemplo de aplicación: https://medium.com/datos-y-ciencia/aprendizaje-no-supervisado-en-machine-learning-agrupaci%C3%B3n-bb8f25813edc
Muchas gracias y felicidades por terminar este curso, Roger!
Jhon Freddy Tavera Blandon
Estudianteimport matplotlib.pyplot as plt import seaborn as sns # Graficar los clusters plt.figure(figsize=(12, 8)) sns.scatterplot(x='TASA_MATRICULACIÓN_5_16', y='REPROBACIÓN', hue='Cluster', data=data, palette='viridis', s=100) plt.title('Clusters de Datos en el Espacio de Características') plt.xlabel('Tasa de Matriculación (5-16 años)') plt.ylabel('Reprobación') plt.show()
Ricardo Alanis
ProfesorGracias por compartir!
Mario Alexander Vargas Celis
EstudianteSi deseas aplicar un modelo no supervisado de *machine learning*, como por ejemplo el algoritmo de *k-means* para agrupamiento (clustering), aquí tienes un ejemplo paso a paso usando scikit-learn:
### Paso 1: Preparar los datos
Asegúrate de que tus datos estén limpios y listos para el modelo. Si estás trabajando con variables categóricas, podrías necesitar convertirlas en variables numéricas (por ejemplo, usando *one-hot encoding*).
from sklearn.preprocessing import StandardScaler from sklearn.cluster import KMeans \# Ejemplo de cómo estandarizar los datos (opcional, pero recomendado para k-means) scaler = StandardScaler() X\_scaled = scaler.fit\_transform(X) # X es tu conjunto de características
### Paso 2: Aplicar el modelo *k-means*
\# Definir el modelo k-means con 3 clusters (puedes ajustar el número de clusters) kmeans = KMeans(n\_clusters=3, random\_state=42) \# Ajustar el modelo a los datos kmeans.fit(X\_scaled) \# Obtener las etiquetas de los clusters asignados clusters = kmeans.labels\_ \# Ver los centros de los clusters centroids = kmeans.cluster\_centers\_
### Paso 3: Interpretar los resultados
Después de aplicar el modelo, puedes asignar los clusters a tu conjunto de datos original o visualizar los resultados:
\# Agregar las etiquetas de los clusters al DataFrame original df\['Cluster'] = clusters \# Visualización de los clusters (si tienes 2 características principales) import matplotlib.pyplot as plt plt.scatter(X\_scaled\[:, 0], X\_scaled\[:, 1], c=clusters, cmap='viridis') plt.scatter(centroids\[:, 0], centroids\[:, 1], c='red', marker='x') # Marcar los centros plt.show()
### Paso 4: Evaluación
Una forma de evaluar la calidad del agrupamiento es usando el *silhouette score*, que mide cuán bien separados están los clusters.
from sklearn.metrics import silhouette\_score silhouette\_avg = silhouette\_score(X\_scaled, clusters) print(f"Silhouette Score: {silhouette\_avg}")
Si estás usando otro algoritmo no supervisado como PCA o DBSCAN, el proceso será diferente, pero el flujo general sigue siendo:
1. **Preparar los datos**
2. **Aplicar el modelo**
3. **Interpretar y visualizar los resultados**
4. **Evaluar la calidad del modelo (si es aplicable)**
Jose Manuel Rivas Márquez
Estudianteme das el siguiente error:
ModuleNotFoundError: No module named 'gensim'
Ricardo Alanis
ProfesorHay que instalar la librería! Aca el archivo de requirements del curso! https://github.com/platzi/proyectos-ciencia-datos/blob/master/requirements.txt
Jose Manuel Rivas Márquez
Estudianteprofe la descargue e instale en el environment de anaconda q estaba utilizando, pero seguia dandome error, intente leer troubleshootings en internet pero no logre dar con el resultado, para no frustarme segui adelante
Eliana Ossio
EstudianteHice el ejercicio del profesor, no salieron los mismos resultados. Trabajé con chatGPT para que me ayude a detectar el error. Me ayudó a solucionar varios temas, porque al principio salía todo error. Estoy trabajando en googlecolab.
Alfonso Andres Zapata Guzman
EstudianteUna limpiecita al texto no estaria nunca de mas.
# Load the regular expression library import re colums_text_analysis = ['Title', 'Desc'] for column in colums_text_analysis: # Remove punctuation df_data[f'{column}_Processed'] = df_data[column].apply(str).map(lambda x: re.sub('[,\.!?]', '', x)) # Convert the titles to lowercase df_data[f'{column}_Processed'] = df_data['Desc_Processed'].map(lambda x: x.lower()) # Print out the first rows of papers
Alfonso Andres Zapata Guzman
EstudianteEl que pida contexto se la traga sin pretexto. Nahh, es broma, es un Asignación de Dirichlet Latente (LDA).
Ricardo Alanis
ProfesorGenial trabajo!! Se que algunas cosas las subiste a tu repo, no nos dejes de dejar aqui tu link para visitar exactamente este análisis!
