Aprender los conceptos clave

1

Todo lo que aprender谩s sobre MA con Scikit-Learn

2

驴C贸mo aprenden las m谩quinas?

3

Problemas que podemos resolver con Scikit-learn

4

Las matem谩ticas que vamos a necesitar

Iniciar un proyecto con sklearn

5

Configuraci贸n de nuestro entorno Python

6

Instalaci贸n de librer铆as en Python

7

Datasets que usaremos en el curso

Optimizaci贸n de features

8

驴C贸mo afectan nuestros features a los modelos de Machine Learning?

9

Introducci贸n al PCA

10

Preparaci贸n de datos para PCA e IPCA

11

Implementaci贸n del algoritmo PCA e IPCA

12

Kernels y KPCA

13

驴Qu茅 es la regularizaci贸n y c贸mo aplicarla?

14

Implementaci贸n de Lasso y Ridge

15

Explicaci贸n resultado de la implementaci贸n

16

ElasticNet: Una t茅cnica intermedia

Regresiones robustas

17

El problema de los valores at铆picos

18

Regresiones Robustas en Scikit-learn

19

Preparaci贸n de datos para la regresi贸n robusta

20

Implementaci贸n regresi贸n robusta

M茅todos de ensamble aplicados a clasificaci贸n

21

驴Qu茅 son los m茅todos de ensamble?

22

Preparaci贸n de datos para implementar m茅todos de ensamble

23

Implementaci贸n de Bagging

24

Implementaci贸n de Boosting

Clustering

25

Estrategias de Clustering

26

Implementaci贸n de Batch K-Means

27

Implementaci贸n de Mean-Shift

Optimizaci贸n param茅trica

28

Validaci贸n de nuestro modelo usando Cross Validation

29

Implementaci贸n de K-Folds Cross Validation

30

Optimizaci贸n param茅trica

31

Implementaci贸n de Randomized

32

Bonus: Auto Machine Learning

Salida a producci贸n

33

Revisi贸n de nuestra arquitectura de c贸digo

34

Importar y exportar modelos con Sklearn

35

Creaci贸n de una API con Flask para el modelo

36

Cierre del curso

37

Material adicional para consultar

No tienes acceso a esta clase

隆Contin煤a aprendiendo! 脷nete y comienza a potenciar tu carrera

Compra acceso a todo Platzi por 1 a帽o

Antes: $249

Currency
$209/a帽o

Paga en 4 cuotas sin intereses

Paga en 4 cuotas sin intereses
Suscr铆bete

Termina en:

16D
6H
46M
30S

Implementaci贸n de Batch K-Means

26/37
Recursos

Aportes 17

Preguntas 9

Ordenar por:

驴Quieres ver m谩s aportes, preguntas y respuestas de la comunidad?

o inicia sesi贸n.

Les comparto una gr谩fica con las variables del dataset candy pareadas.

import seaborn as sns
sns.pairplot(dataset, hue='group')

Por otra parte ac谩 tambi茅n les comparto enfocadas las variables, sugarpercent, pricepercent y winpercent. Se puede observar como el algoritmo de clustering puede generar los grupos que son imposibles de notar a simple vista.

sns.pairplot(dataset[['sugarpercent','pricepercent','winpercent','group']], hue = 'group')

Hola, compa帽eros. Aqu铆 les dejo una visualizaci贸n de los datos coloreados por el grupo al que pertenecen. Hice un scatter con las variables que pueden ver en los ejes, por supuesto que pueden existir otras formas de visualizar cambiando los ejes de la scatter.
Saludos! 馃槂

Antes de implementar el algoritmo de clusterizaci贸n es bueno normalizar los datos como hab铆amos visto en clases pasadas, ya que si se dan cuenta est谩 tomando como referencia la columna con valores m谩s grandes del dataframe, que en este caso es 鈥渨inpercent鈥 y clasificando por puntaje, y no es el objetivo del algoritmo.

les paso mi version del codigo:

import pandas as pd

from sklearn.cluster import MiniBatchKMeans


if __name__ == "__main__":
    
    path = './K-Means/data/candy.csv'
    dataset = pd.read_csv(path)

    print(dataset.head(5))

    x = dataset.drop('competitorname', axis=1)
    kmeans = MiniBatchKMeans(n_clusters=4, batch_size=8).fit(x)

    print('')
    print('Total de centros:', len(kmeans.cluster_centers_))

    print('')
    print('Predicciones:', kmeans.predict(x))

    dataset['Grupo'] = kmeans.predict(x)
    print(dataset)

    # Ahora mando los datos a un archivo excel :)

    writer = pd.ExcelWriter('./K-Means/data/candy_usuario.xlsx', engine='xlsxwriter')
    dataset.to_excel(writer, sheet_name='usuario')
    writer.save()

Se me hace curioso el hecho de que la columna 鈥榳inpercent鈥 parece ser la que hace todo el trabajo de agrupaci贸n. Si eliminamos esa columna, vemos con las gr谩ficas que no se encuentra ning煤n patr贸n claro en el dataset.

Para los que usan colab:

candy.to_excel( 鈥渃andy.xlsx鈥,index=False)

donde candy es el nombre de mi dataset y pongo index=False para que no me aparezca 0,1,2, a mi lado izquierdo del excel y tenga una mejor presentaci贸n

from matplotlib import pyplot as plt
import pandas as pd
import plotly.express as px
import plotly.graph_objects as go
import seaborn as sns
from xlsxwriter import Workbook

from sklearn.cluster import MiniBatchKMeans
from sklearn.preprocessing import StandardScaler
from sklearn.decomposition import PCA


if __name__ == "__main__":

    dataset = pd.read_csv('./data/candy.csv')

    X_cols = list(set(dataset.columns)-set(['competitorname']))
    X = dataset[X_cols].values
    sc_x = StandardScaler()

    #standarizacion de los datos
    X_std = sc_x.fit_transform(X)

    kmeans = MiniBatchKMeans(n_clusters=4, batch_size=8).fit(X_std)
    print(f'Total de centros: {len(kmeans.cluster_centers_)}')
    print("="*64)
    print(f'Predicciones: {kmeans.predict(X_std)}')

    dataset['group'] = kmeans.predict(X_std)

    print(dataset['group'].value_counts())

    # Ahora mando los datos a un archivo excel :)
    # with pd.ExcelWriter('data/candy_usuario.xlsx', engine="xlsxwriter") as writer:
    #     dataset.to_excel(writer, sheet_name='usuario')

    # dataset.to_excel(r'data/candy_usuario.xlsx', sheet_name='usuario', index = False)
    #implementacion_k_means

    # sns.scatterplot(data=dataset, x="sugarpercent", y="winpercent", hue="group", palette="deep")
    #
    # sns.pairplot(dataset[['sugarpercent', 'pricepercent', 'winpercent', 'group']], hue='group')



    '''Realizado por mi para ver las graficas y los centroides de manera visual'''
    def pca_fun(n_components, data):
        pca = PCA(n_components=n_components).fit(data)
        data = pca.transform(data)
        return data

    pca_data = pca_fun(2,X_std)

    kmeans = MiniBatchKMeans(n_clusters=4, batch_size=8).fit(pca_data)

    fig = px.scatter(
        x=pca_data[:, 0],
        y=pca_data[:, 1],
        color=kmeans.predict(pca_data))
    # Aqui anexamos a la misma figura cada trazo

    fig.add_trace(go.Scatter(
        x=kmeans.cluster_centers_[:, 0],
        y=kmeans.cluster_centers_[:, 1],
        mode='markers', marker=dict(size=20,
        color= 'white'), name='Centroides'
    ))

    fig.update_layout(title=f'Visualizacion de centroides sobre PCA de 2 componentes, se escalo data antes de PCA', coloraxis_showscale=False)
    fig.show()



    ##################### PCA 3 componentes
    pca_data = pca_fun(3,X_std)

    kmeans = MiniBatchKMeans(n_clusters=4, batch_size=8).fit(pca_data)

    fig = px.scatter_3d(
        x=pca_data[:, 0],
        y=pca_data[:, 1],
        z=pca_data[:, 2],
        color=kmeans.predict(pca_data))
    # Aqui anexamos a la misma figura cada trazo

    fig.add_trace(go.Scatter3d(
        x=kmeans.cluster_centers_[:, 0],
        y=kmeans.cluster_centers_[:, 1],
        z=kmeans.cluster_centers_[:, 2],
        mode='markers', marker=dict(size=20,
        color= 'white'), name='Centroides'
    ))

    fig.update_layout(title=f'Visualizacion de centroides sobre PCA de 3 componentes, se escalo data antes de PCA', coloraxis_showscale=False)
    fig.show()

    '''No funciona somoclu al parecer por el python usado. 3.10. (no pienso bajar mi version de python ya que quiero aprender a usar match case) https://github.com/peterwittek/somoclu/issues/144,
    link de fuente para implementacion de esta libreria:
    https://www.kaggle.com/code/phyothuhtet/document-clustering-self-organizing-map-kmeans'''

    # import somoclu
    #
    # def som(data):
    #     som = somoclu.Somoclu(50, 50, data=data, maptype="toroid")
    #     %time som = som.train(data)
    #     print("Comonent Planes")
    #     return som
    #
    # som = som(pca_data)
    #
    # #Exploring Component Planes
    # #labels is 0 to n(document-0, document-1,...documentn)
    # labels = range(0,pca_data.shape[0])
    #
    # # Step4: Exploring Content Planes
    # som.view_component_planes()
    #
    # # Step 5: Exploring clusters by SOM reinforced with  Doc2Vec
    # som.view_umatrix(bestmatches = True)


Le pregunt茅 a ChatGPT que me ampliara un poquito la informaci贸n sobre MiniBatchKmeans y esta fue su respuesta:

MiniBatchKMeans es una variante del cl谩sico algoritmo de agrupamiento K-means dise帽ada para funcionar eficientemente con conjuntos de datos grandes. K-means es un algoritmo de aprendizaje no supervisado utilizado para agrupar datos en K grupos seg煤n sus similitudes de caracter铆sticas. Su objetivo es minimizar la suma de las distancias al cuadrado entre los puntos de datos y los centroides de sus respectivos grupos.

El algoritmo K-means est谩ndar puede ser computacionalmente costoso, especialmente para conjuntos de datos grandes, ya que requiere calcular las distancias entre todos los puntos de datos y todos los centroides de los grupos en cada iteraci贸n. Esto puede ser problem谩tico cuando se trabaja con conjuntos de datos grandes que no caben en la memoria.

MiniBatchKMeans aborda este problema utilizando mini-batches de datos para cada iteraci贸n, en lugar de utilizar todo el conjunto de datos. Se toma una muestra aleatoria de puntos de datos (mini-batch) y se actualizan los centroides de los grupos utilizando esta muestra en cada iteraci贸n. Este enfoque es m谩s eficiente computacionalmente, ya que requiere menos c谩lculos de distancias y permite procesar conjuntos de datos grandes sin consumir una cantidad excesiva de memoria.

Beneficios clave de MiniBatchKMeans:

Mayor velocidad de c谩lculo: Al utilizar mini-batches, el algoritmo puede procesar conjuntos de datos grandes de manera m谩s eficiente, lo que lo hace adecuado para escenarios de big data.

Escalabilidad: Puede manejar conjuntos de datos que no caben en la memoria, ya que opera con subconjuntos m谩s peque帽os de datos a la vez.

Eficiencia de memoria: Debido a su naturaleza iterativa, consume menos memoria en comparaci贸n con el algoritmo K-means est谩ndar.

Sin embargo, existe un equilibrio con MiniBatchKMeans. El uso de mini-batches introduce cierto nivel de aleatoriedad, lo que puede resultar en asignaciones de grupos menos estables y soluciones potencialmente sub贸ptimas en comparaci贸n con el algoritmo K-means cl谩sico. No obstante, en la pr谩ctica, MiniBatchKMeans suele proporcionar buenos resultados de agrupamiento mientras reduce significativamente los requisitos computacionales.

En resumen, MiniBatchKMeans es una herramienta valiosa cuando se trabaja con conjuntos de datos grandes y recursos de memoria limitados, proporcionando una soluci贸n eficiente y escalable para tareas de agrupamiento.

Ojo lo que esta haciendo de reemplazar la columna group por los valores predichos por el modelo lo esta haciendo porque K-means es un modelo de aprendizaje no supervisado, el modelo es el que se encarga de hacer la clasificacion.

La implementaci贸n de Batch K-Means es una variante eficiente del algoritmo de clustering K-Means tradicional. En el est谩ndar K-Means, se actualizan los centroides en cada iteraci贸n para cada punto de datos, lo que puede ser costoso en t茅rminos computacionales cuando se con grandes conjuntos de datos. En Batch K-Means, en lugar de actualizar los centroides para cada punto de datos en cada iteraci贸n, se actualizan utilizando un conjunto de datos de muestra m谩s peque帽o o 鈥渕ini lotes鈥.

Que importante la clusterizaci贸n para el an谩lisis de datos.

As铆 queda la visualizaci贸n final cuando exportamos el archivo final en Excel

Y este es el c贸digo para exportar el archivo.

Debemos instalar 鈫 pip install openpyxl

Import os

    # Para exportar el archivo a Excel

    # Carpeta donde se guardar谩 el archivo
    output_folder = 'C:/Users/ASUS/resultados_kmeans.xlsx'
    os.makedirs(output_folder, exist_ok=True)  # Crear la carpeta si no existe

    # Exportar el DataFrame a Excel en la carpeta especificada
    output_file = os.path.join(output_folder, 'resultados_kmeans.xlsx')
    dataset.to_excel(output_file, index=False)

Les comaprto el gr谩fico que obtuve con las 4 categor铆as comparando las variables de porcentaje de azucar y winnerpercent

    my_palette = ["#1abc9c", "#3498db", "#9b59b6", "#34495e"]
    sns.scatterplot(data=data,x='sugarpercent',y='winpercent', hue='grupos', palette=my_palette)
    plt.grid(color='gray', linestyle=':', linewidth=0.5, zorder=0)
    plt.savefig('plot.png')
    plt.show()

imprimir cluster en grafica 2D usando PCA

dataset = pd.read_csv('./datasets/candy.csv')

# eliminaremos los nombres de los caramelos ya que es categorica
X = dataset.drop('competitorname', axis=1)
X.head(3)
 
kmeans = MiniBatchKMeans(n_clusters=4,  #definiremos 4 grupos 
                            batch_size=8).fit(X) # la cantidad de datos por lote para aligerar el computo 

print('Total de centros: ', len(kmeans.cluster_centers_))
print('*'*64)

# guardamos la etiqueta de cada grupo en el DS
print(kmeans.predict(X))
print('*'*64)
X['cluster'] = kmeans.predict(X)

print(X.head(3))

aqui importamos el modulo de PCA es facil de usar

from sklearn.decomposition import PCA

model_PCA = PCA(n_components=2) # instanciamos el modelo 
data_PCA = model_PCA.fit_transform(X) # realizamos tranformacion
df_PCA = pd.DataFrame(data= data_PCA, columns= ["PCA1","PCA2"])
df_PCA = pd.concat([df_PCA, X['cluster']], axis=1)

x = sns.scatterplot(x = "PCA1", y = "PCA2", 
hue = "cluster", data = df_PCA, palette = ["red", "green", "blue", "black"])
plt.show()

Excelente clase

yo para exporta el dataset a excel primeto tuve que instalar openpyxl en Anaconda y de hay fue facil :
dataset.to_excel(r鈥檇ata/candy_usuario.xlsx鈥,sheet_name=鈥榰suario鈥, index = False)