Justificación y contexto de tu proyecto

1

Cómo crear tu proyecto de ciencia de datos

2

Crea proyectos para afianzar tus conocimientos en ciencia de datos

3

Cada cuánto hacer un proyecto de datos

4

Dónde sacar ideas para proyectos de ciencia de datos

5

Generar y comunicar un proyecto de datos

6

Casos: personas que ya pasaron por este camino

Quiz: Justificación y contexto de tu proyecto

Ejecutando un proyecto de ciencia de datos

7

Plantea una pregunta interesante

8

Obteniendo los datos para tu proyecto

9

Ejecutando: obteniendo los datos

10

Limpieza de la información

11

Ejecutando: limpia tu conjunto de datos

12

Explora y encuentra patrones en la información

13

Ejecutando: exploración de la información

14

Ejecutando: completando la exploración de la información

15

Enriquecimiento de los datos para análisis profundo

16

Ejecutando: enriquecimiento de los datos

17

Aplicando un modelo de machine learning

18

Ejecutando: aplicando un modelo supervisado de machine learning

19

Ejecutando: aplicando un modelo no supervisado de machine learning

20

Ejecutando: aplicando un modelo no supervisado de anomalías

21

Prepara tu trabajo para comunicarlo con el mundo

22

Ejecutando: prepara tu trabajo para comunicarlo con el mundo

Quiz: Ejecutando un proyecto de ciencia de datos

Comunicando los resultados

23

Por qué es importante comunicar los resultados

24

Escribiendo tu primer blogpost técnico

25

Compartiendo en comunidad con tu primera presentación

26

Cómo mejorar tu repositorio en GitHub para ciencia de datos

27

Haciendo deploy de tus modelos

28

Construyendo una aplicación full stack que consuma tu proyecto

Quiz: Comunicando los resultados

Últimos pasos

29

Elige terminar: es mejor terminado que perfecto

30

Recuerda los objetivos del proyecto: practicar y carta de presentación

31

Comparte tu proyecto

No tienes acceso a esta clase

¡Continúa aprendiendo! Únete y comienza a potenciar tu carrera

Ejecutando: aplicando un modelo no supervisado de machine learning

19/31
Recursos

¿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:

  1. Tokenización: Separar el texto en palabras o 'tokens'.

  2. Remover Stopwords: Filtrar palabras comunes que no aportan valor analítico, como artículos o preposiciones.

  3. 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!

Aportes 7

Preguntas 1

Ordenar por:

¿Quieres ver más aportes, preguntas y respuestas de la comunidad?

Hola,
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!

Realice 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

Bueno, 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.

Vaya 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

import 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()
Si 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\*). ```python 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\* ```python \# 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: ```python \# 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. ```python 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)\*\*

Una 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