Agrupamento de Dados com Python. Seu primeiro projeto de Machine Learning!

Autor: Gabriel Murilo

Um dos projetos mais conhecidos para quem está começando a estudar Machine Learning é o Agrupamento de Dados (K-means ou clusterização)

Clustering é uma técnica de Machine Learning que envolve o agrupamento de pontos de dados. Em teoria, os pontos de dados que estão no mesmo grupo devem ter propriedades e/ou recursos semelhantes, enquanto os pontos de dados em grupos diferentes devem ter propriedades e/ou recursos
altamente diferentes.
(https://towardsdatascience.com/the5-clustering-algorithms-data-scientists-need-to-knowa36d136ef68)

Algoritmo K-means

O algoritmo K-means é uma técnica popular de aprendizado de máquina não supervisionado que permite agrupar dados sem a necessidade de rótulos prévios. Ele busca identificar padrões e estruturas nos dados, dividindo-os em clusters.

Passo 1: Inicialização dos Centróides:

No início do algoritmo, são escolhidos aleatoriamente "k" centróides, onde "k" é o número de clusters definido pelo usuário. Esses centróides são pontos representativos dos clusters.

Passo 2: Atribuição dos Pontos aos Clusters:

Em seguida, cada ponto de dados é atribuído ao centróide mais próximo com base na distância euclidiana entre eles. Isso é feito iterativamente para todos os pontos do conjunto de dados.

Passo 3: Atualização dos Centróides:

Após a atribuição inicial, os centróides são atualizados recalculando-se suas posições. Os novos centróides são determinados como a média dos pontos atribuídos a cada cluster.

Passo 4: Iteração até a Convergência:

O processo de atribuição e atualização é repetido iterativamente até que ocorra a convergência, ou seja, quando não há mais alterações significativas nos centróides ou quando um número máximo de iterações é alcançado.

E agora... mão na massa!

Importanto as libs necessárias:

import numpy as np
from sklearn.datasets import make_blobs
from sklearn.cluster import KMeans
import matplotlib.pyplot as plt
import seaborn as sns

Estamos importando as bibliotecas necessárias para executar o código, incluindo o numpy para manipulação de dados, make_blobs para criar um conjunto de dados sintéticos, KMeans para o algoritmo de K-means, e matplotlib e seaborn para visualização.

Criação do conjunto de dados:

    X, y = make_blobs(
    n_samples=200,
    n_features=2,
    centers=3,
    cluster_std=0.5,
    random_state=0
)

Nessa parte, estamos criando um conjunto de dados sintéticos usando a função make_blobs. Estamos especificando o número de amostras, número de características, número de centros (clusters), desvio padrão dos clusters e uma semente aleatória.

Podemos visualizar os dados da seguinte forma:

   plt.scatter(
   X[:, 0], X[:, 1],
   c='white',
   edgecolor='black'
)

Inicialização e treinamento do modelo Kmeans:

kmeans = KMeans(
    n_clusters=3, init='random',
    n_init=1, max_iter=4,
    tol=1e-04, random_state=2
)

Aqui estamos inicializando o modelo K-means. Estamos especificando o número de clusters, o método de
inicialização dos centróides, o número de tentativas, o número máximo de iterações, a tolerância para a convergência e a semente aleatória.

y_km = kmeans.fit_predict(X)
y_km

E aqui estamos treinando o modelo K-means usando o conjunto de dados e, em seguida, obtendo as previsões dos clusters para cada amostra.

Podemos ver:

array([1, 2, 2, 1, 2, 1, 0, 0, 2, 1, 2, 1, 2, 2, 2, 1, 0, 0, 2, 1, 1, 0,
       2, 2, 1, 2, 0, 1, 1, 1, 2, 2, 1, 2, 0, 0, 2, 0, 0, 1, 0, 1, 1, 1,
       2, 2, 2, 1, 2, 2, 2, 0, 1, 1, 1, 1, 0, 0, 2, 2, 1, 1, 2, 0, 0, 1,
       0, 0, 1, 0, 0, 2, 2, 1, 2, 1, 0, 0, 0, 1, 1, 2, 2, 0, 0, 2, 2, 1,
       2, 0, 1, 1, 0, 2, 0, 2, 2, 1, 1, 0, 0, 2, 1, 2, 1, 2, 0, 2, 2, 0,
       2, 1, 0, 1, 2, 2, 2, 0, 1, 1, 0, 0, 1, 2, 0, 2, 1, 0, 1, 2, 1, 0,
       0, 0, 2, 0, 0, 2, 0, 1, 1, 1, 2, 0, 0, 2, 1, 1, 0, 2, 0, 1, 1, 1,
       2, 0, 0, 0, 2, 2, 1, 1, 1, 1, 2, 2, 0, 1, 0, 0, 2, 0, 2, 0, 1, 1,
       2, 1, 2, 0, 2, 1, 0, 0, 0, 2, 1, 0, 2, 2, 1, 1, 0, 0, 0, 0, 1, 0,
       2, 0], dtype=int32)

Plotando o resultado:

plt.scatter(
    X[y_km == 0, 0], X[y_km == 0, 1],
    s=50, c='lightgreen',
    marker='s', edgecolor='black',
    label='cluster 1'
)

plt.scatter(
    X[y_km == 1, 0], X[y_km == 1, 1],
    s=50, c='orange',
    marker='o', edgecolor='black',
    label='cluster 2'
)

plt.scatter(
    X[y_km == 2, 0], X[y_km == 2, 1],
    s=50, c='lightblue',
    marker='v', edgecolor='black',
    label='cluster 3'
)

# plotando os centroides
plt.scatter(
    kmeans.cluster_centers_[:, 0], kmeans.cluster_centers_[:, 1],
    s=250, marker='*',
    c='red', edgecolor='black',
    label='centroids'
)
plt.legend(scatterpoints=1)

Nesta parte, estamos plotando os clusters finais, cada um com uma cor e marcador específico. Também estamos plotando os centróides dos clusters como estrelas vermelhas. Por fim, exibimos o gráfico completo.

Bom...

Você fez seu primeiro projeto de Machine Learning usando Python!
.
.
.
Agora só falta fazer o próximo ChatGPT... hahahahah