Python com ML Básico
Carregando, aguarde alguns segundos.

11 - Aprendizagem Não Supervisionada

A aprendizagem não supervisionada é um tipo de aprendizado de máquina em que o modelo aprende com um conjunto de dados de treinamento que não contém rótulos para cada exemplo, sendo então usado para descobrir padrões nos dados.

É um dos tipos mais comuns de aprendizado de máquina e é usada para resolver uma ampla variedade de problemas, como agrupamento, redução de dimensionalidade e descoberta de conhecimento.

A aprendizagem não supervisionada é um processo de quatro etapas:

  • Treinamento: Na primeira etapa o modelo aprende com um conjunto de dados de treinamento que não contém rótulos para cada exemplo.
  • Teste: Na segunda etapa o modelo é usado para descobrir padrões nos dados.
  • Validação: Na terceira etapa o modelo é usado para avaliar a sua capacidade de generalização.
  • Aplicação: Na quarta etapa o modelo é colocado em uso para resolver um problema específico.

O desempenho do modelo é avaliado comparando os padrões encontrados com os padrões reais.

A aprendizagem não supervisionada é uma ferramenta poderosa que pode ser usada para resolver uma ampla variedade de problemas. No entanto, é importante observar que a aprendizagem não supervisionada requer um conjunto de dados de treinamento que seja grande o suficiente para descobrir padrões. Se o conjunto de dados for pequeno, a aprendizagem não supervisionada pode não ser capaz de encontrar padrões significativos nos dados.

A aprendizagem não supervisionada é usada para resolver uma ampla variedade de problemas, como agrupamento, redução de dimensionalidade e descoberta de outliers, usando modelos treinados com conjuntos de dados que não possuem rótulos, e portanto aprendendo a encontrar padrões nos dados e, em seguida, sendo usados para fazer previsões para novos dados.

Aqui estão alguns exemplos de aprendizagem não supervisionada:

  • Agrupamento (Clustering): No agrupamento, o modelo é treinado em um conjunto de dados que contém exemplos de diferentes objetos. O modelo aprende a agrupar os objetos com base em suas semelhanças e, em seguida, pode ser usado para classificar novos objetos em grupos. Por exemplo, um modelo de agrupamento pode ser usado para classificar clientes em diferentes grupos com base em seus hábitos de compra.
  • Análise de Componentes Principais (PCA - Principal Component Analysis): Técnica utilizada com ML para redução de dimensionalidade e extração de características dos dados. Na redução de dimensionalidade, o modelo é treinado em um conjunto de dados que contém muitos recursos. O modelo aprende a reduzir o número de recursos sem perder muita informação e, em seguida, pode ser usado para visualizar os dados ou torná-los mais fáceis de aprender. Por exemplo, um modelo de redução de dimensionalidade pode ser usado para reduzir o número de pixels em uma imagem sem perder muita informação.
  • Aprendizado por Associação: Técnica de Aprendizado de Máquina utilizada para descobrir regras de associação ou padrões interessantes em grandes conjuntos de dados transacionais.
  • Descoberta de outliers: Na descoberta de outliers, o modelo é treinado em um conjunto de dados que contém exemplos de dados normais e dados anormais. O modelo aprende a identificar os dados anormais e, em seguida, pode ser usado para detectar dados anormais em novos dados. Por exemplo, um modelo de descoberta de outliers pode ser usado para detectar fraudes financeiras em novos dados.

A aprendizagem não supervisionada é uma ferramenta poderosa que pode ser usada para resolver uma ampla variedade de problemas.

É um campo ativo de pesquisa e os pesquisadores estão constantemente desenvolvendo novos métodos de aprendizagem não supervisionada.

11.1 - Agrupamento

Agrupamento (clustering) é uma técnica de Aprendizado de Máquina não supervisionado usada para identificar padrões e estruturas naturais em conjuntos de dados, agrupando objetos similares em clusters (grupos) com base em suas características.

A tarefa do agrupamento é dividir os dados em grupos de modo que os elementos dentro de um mesmo cluster sejam mais similares entre si do que com os elementos de outros clusters. Os algoritmos de agrupamento tentam encontrar uma representação compacta dos dados, agrupando amostras com características semelhantes e mantendo-as distintas das amostras em outros clusters.

Diferentemente do aprendizado supervisionado, o agrupamento não possui rótulos para as amostras e, portanto, não há uma "verdade absoluta" sobre como os dados devem ser agrupados. Em vez disso, os algoritmos de agrupamento buscam estruturas internas nos dados com base em medidas de similaridade ou dissimilaridade entre as amostras.

Alguns dos algoritmos de agrupamento mais comuns são:

  • K-Means: É um algoritmo que divide os dados em "k" clusters, onde "k" é um hiperparâmetro definido pelo usuário. O algoritmo busca iterativamente mover os centróides dos clusters (pontos médios) para minimizar a soma dos quadrados das distâncias entre os pontos do cluster e o centróide.
  • Hierarchical Clustering (Agrupamento Hierárquico): É um método que cria uma hierarquia de clusters, onde os clusters são agrupados sucessivamente em subgrupos maiores ou divididos em subgrupos menores até que um critério de parada seja atingido.
  • DBSCAN (Density-Based Spatial Clustering of Applications with Noise): É um algoritmo que agrupa amostras com alta densidade local em clusters, separando regiões de baixa densidade (ruído) no conjunto de dados.
  • Mean Shift: É um algoritmo que procura os modos (picos) da função de densidade dos dados e, a partir desses modos, encontra os clusters.
  • Gaussian Mixture Model (GMM): É um modelo estatístico que assume que os dados são gerados a partir de uma mistura de várias distribuições gaussianas. É usado para modelar a probabilidade de cada amostra pertencer a cada cluster.

O agrupamento é amplamente aplicado em diversas áreas, como segmentação de clientes, análise de grupos de consumidores, segmentação de mercado, detecção de anomalias, compressão de dados, entre outros. Ele pode ser uma etapa importante de pré-processamento para outras tarefas de Aprendizado de Máquina ou Mineração de Dados, ajudando a reduzir a dimensionalidade dos dados e a entender as estruturas subjacentes presentes nos conjuntos de dados.

11.2 - Análise de Componentes Principais

Análise de Componentes Principais (PCA - Principal Component Analysis) é uma técnica de Aprendizado de Máquina utilizada para redução de dimensionalidade e extração de características dos dados. Ela é usada para transformar um conjunto de variáveis correlacionadas em um novo conjunto de variáveis não correlacionadas chamadas de componentes principais.

O objetivo do PCA é encontrar os eixos (componentes principais) que melhor representam a variabilidade dos dados, permitindo que os dados sejam representados em um espaço de menor dimensionalidade, mas que preserva a maior parte da informação original.

Os principais passos do PCA são os seguintes:

  • Padronização dos Dados: Antes de aplicar o PCA, é comum padronizar os dados (subtrair a média e dividir pelo desvio padrão) para garantir que todas as variáveis tenham a mesma escala. Isso é importante porque o PCA é sensível às escalas das variáveis.
  • Cálculo das Componentes Principais: O PCA busca encontrar os vetores de direção que representam a maior variabilidade nos dados. Esses vetores são chamados de vetores próprios ou autovetores. A primeira componente principal é aquela que explica a maior variabilidade dos dados, a segunda componente principal é ortogonal (não correlacionada) à primeira e explica a segunda maior variabilidade, e assim por diante. O número de componentes principais é igual ao número de variáveis originais.
  • Seleção de Componentes Principais: Em geral, nem todas as componentes principais são necessárias para representar os dados de forma significativa. Uma forma de decidir quantas componentes principais manter é olhar para a proporção da variância explicada por cada componente principal. A variância explicada é uma medida da quantidade de informação dos dados que é capturada por cada componente principal. É possível escolher um número de componentes principais que represente, por exemplo, 95% da variância total dos dados.
  • Projeção dos Dados no Espaço de Componentes Principais: Uma vez que as componentes principais são determinadas, os dados originais podem ser projetados em um novo espaço de menor dimensionalidade, utilizando as componentes principais selecionadas.

O PCA é amplamente utilizado para visualização de dados em espaços bidimensionais ou tridimensionais, redução de ruído nos dados, compressão de imagens, detecção de outliers, entre outras aplicações. Ele é particularmente útil quando há muitas variáveis correlacionadas nos dados e se deseja reduzir a dimensionalidade do conjunto de dados sem perder muita informação.

Estes são apenas alguns dos muitos tipos de aprendizagem não supervisionada. A aprendizagem não supervisionada é um campo ativo de pesquisa e os pesquisadores estão constantemente desenvolvendo novos métodos de aprendizagem não supervisionada.

11.3 - Aprendizado por Associação

O aprendizado por associação é uma técnica de Aprendizado de Máquina utilizada para descobrir regras de associação ou padrões interessantes em grandes conjuntos de dados transacionais.

Esse tipo de dado é comumente encontrado em bancos de dados de varejo, onde cada registro representa uma transação de compra com um conjunto de itens comprados.

O objetivo do Aprendizado por Associação é identificar relações frequentes entre os itens, ou seja, quais itens tendem a ser comprados juntos com alta frequência.

Essas relações são representadas por regras de associação na forma "se X, então Y". Por exemplo, uma regra de associação poderia ser "se um cliente comprar pão e leite, então é provável que também compre manteiga".

Existem duas métricas principais usadas no Aprendizado por Associação:

  • Suporte (Support): O suporte de uma regra é a proporção de transações que contêm todos os itens da regra. Ele mede a frequência absoluta com que uma regra é observada no conjunto de dados. Fórmula: Suporte(X, Y) = (Número de transações contendo X e Y) / (Número total de transações).
  • Confiança (Confidence): A confiança de uma regra é a proporção de transações contendo todos os itens da regra em relação ao número de transações que contêm o item antecedente. Fórmula: Confiança(X -> Y) = (Número de transações contendo X e Y) / (Número de transações contendo X)

Além dessas métricas, é comum usar um valor mínimo de suporte e confiança para filtrar regras que são consideradas relevantes. Por exemplo, é possível definir um suporte mínimo de 0,1 (10%) e uma confiança mínima de 0,5 (50%) para garantir que apenas regras com suporte maior que 10% e confiança maior que 50% sejam consideradas.

Os algoritmos mais conhecidos para realizar o Aprendizado por Associação são o Apriori e o FP-Growth. O algoritmo Apriori é baseado em uma abordagem de busca exaustiva e o algoritmo FP-Growth utiliza uma estrutura de árvore chamada FPGrowth para encontrar os conjuntos frequentes de itens de forma mais eficiente, especialmente em grandes conjuntos de dados.

O Aprendizado por Associação é amplamente utilizado em aplicações como recomendação de produtos em e-commerces, análise de cestas de compras, agrupamento de itens em supermercados, análise de padrões em registros médicos, entre outras áreas onde é relevante descobrir associações entre itens em grandes conjuntos de dados transacionais.

11.4 - Como aplicar

Aqui estão as etapas para aplicar a aprendizagem não supervisionada para o aprendizado de máquina:

flowchart TD COLETE(Etapa 1: Colete os dados) COLETE --> LIMPE(Etapa 2: Limpe os dados) LIMPE --> TRANSFORME(Etapa 3: Transforme os dados) TRANSFORME --> NORMALIZE(Etapa 4: Normalize os dados) NORMALIZE --> DIVIDA(Etapa 5: Divida os dados em conjuntos de treinamento e teste) DIVIDA --> SELECIONE(Etapa 6: Selecione o modelo para aprendizagem não supervisionada) SELECIONE --> TREINE(Etapa 7: Treine o modelo) TREINE --> TESTE(Etapa 8: Teste o modelo) TESTE --> AJUSTE(Etapa 9: Ajuste o modelo) AJUSTE --> IMPLEMENTE(Etapa 10: Implemente o modelo)
  • Colete os dados: O primeiro passo é coletar os dados que serão usados para treinar o modelo de aprendizagem não supervisionada. Esses dados podem ser coletados de uma variedade de fontes, como pesquisas, formulários, sensores ou outros dispositivos.
  • Limpe os dados: O próximo passo é limpar os dados. Isso significa remover qualquer dado inválido ou inconsistente, como valores ausentes, valores discrepantes e dados duplicados.
  • Transforme os dados: Se necessário, os dados podem ser transformados para que estejam em um formato adequado para o modelo de aprendizagem não supervisionada. Isso pode envolver a codificação de dados categóricos, a normalização de dados numéricos ou a criação de novas características.
  • Normalize os dados: Se necessário, os dados podem ser normalizados para que todos os recursos tenham o mesmo intervalo. Isso pode ajudar o modelo de aprendizagem não supervisionada a aprender mais rapidamente e a fazer previsões mais precisas.
  • Divida os dados em conjuntos de treinamento e teste: Os dados devem ser divididos em dois conjuntos, um conjunto de treinamento e um conjunto de teste. O conjunto de treinamento será usado para treinar o modelo de aprendizagem não supervisionada, enquanto o conjunto de teste será usado para avaliar o desempenho do modelo.
  • Treine o modelo de aprendizagem não supervisionada: O modelo de aprendizagem não supervisionada será treinado usando o conjunto de treinamento. Isso significa que o modelo aprenderá a encontrar padrões nos dados.
  • Teste o modelo de aprendizagem não supervisionada: O desempenho do modelo de aprendizagem não supervisionada será avaliado usando o conjunto de teste. Isso significa que o modelo será usado para fazer previsões para os dados do conjunto de teste e o desempenho das previsões será comparado aos valores reais.
  • Ajuste o modelo de aprendizagem não supervisionada: Se necessário, o modelo de aprendizagem não supervisionada pode ser ajustado usando o conjunto de treinamento e o conjunto de teste. Isso pode envolver o ajuste dos parâmetros do modelo ou a coleta de mais dados.
  • Implemente o modelo de aprendizagem não supervisionada: Depois que o modelo de aprendizagem não supervisionada estiver ajustado, ele pode ser implementado em produção. Isso pode envolver o envio do modelo para um servidor ou o uso do modelo em um aplicativo.

A aprendizagem não supervisionada é uma ferramenta poderosa que pode ser usada para resolver uma ampla variedade de problemas.

11.5 - Exemplo: ML Não-Supervisionado usando Flores e K-Means

O dataset Iris é um conjunto de dados que pode ser usado para treinar tanto um algoritmo de aprendizagem supervisionada como um modelo de aprendizagem não supervisionada.

Se a aplicação fosse um algoritmo de aprendizagem supervisionada, ela poderia ser usada para classificar as flores em três grupos: setosa, versicolor, e virginica.

As informações necessárias para o treinamento do modelo de aprendizagem supervisionada estão disponíveis no objeto da classe Bunch(), que contém as propriedades data e target, contendo os valores dos dados e do alvos para realização de regressão logística, contendo valores inteiros de 0, 1 e 2, que representam respectivamente setosa, versicolor e virginica.

No ML supervisionado usamos o atributo target para classificar os dados, usando por exemplo a classe LogisticRegression.

Entretanto, no ML não supervisionado, não usa-se a propriedade target para classificar os dados, a classificação dos dados é realizada pela classe de aprendizagem não supervisionada como, por exemplo, a classe KMeans.

Este código usa o algoritmo de agrupamento K-Means para agrupar os dados do conjunto de dados Iris em três grupos. Após carregarmos os dados do conjunto de dados Iris, criamos o objeto KMeans com três grupos (clusters) de dados.

O objeto KMeans cria a classificação a partir dos dados e comparamos com os valores reais presentes na propriedade target do objeto-bunch iris.

Finalmente são realizadas as previsões dos dados de treinamento e comparadas às propriedades iris.target e kmeans.labels_.

Inicie o processo importando as bibliotecas necessárias. 

import numpy as np
from sklearn.cluster import KMeans
from sklearn.datasets import load_iris

Instancie na variável iris o objeto da classe Bunch(). 

iris = load_iris()

Portanto iris é um objeto da classe Bunch() do sklearn, contendo as propriedades data, target e target_names, contendo respectivamente os dados, os valores-alvo e os nomes dos valores-alvo, e que serão usadas no processo. 

print(type(iris))

A propriedade dados lista os dados, com as seguintes colunas: tamanho_sepala (ts), largura_sepala (ls), tamanho_petala (tp), largura_petala, com 150 linhas com as colunas na lista [ts ls tp ls]. 

for i in range(0,len(iris.data)): print(iris.data[i], end='\n' if (i % 4) == 3 else ' ')

A propriedade target_names lista os nomes correspondentes aos valores-alvo. 

print(iris.target_names)

Observe que os valores inteiros dos nomes ['setosa','versicolor','virginica'] são os respectivos índices [0,1,2].

A propriedade target lista os valores-alvo. 

print(iris.target)

Os valores-alvo são 0, 1 e 2, o que significa que os dados foram agrupados em três grupos, com quantidades iguais de 50 linhas para cada classe. 

unicos, contagens = np.unique(iris.target, return_counts=True)
print(unicos, contagens)

Primeira parte: Aprendizado Não-Supervisionado

No ML não supervisionado não existe uma classe target para classificar os dados, e o classificador é criado pela classe de aprendizagem não supervisionada como, por exemplo, a classe KMeans.

Crie o objeto KMeans com três grupos (clusters) de dados carregados. 

kmeans = KMeans(n_clusters=3)

Treine o modelo com os dados. 

kmeans.fit(iris.data)

Imprima os rótulos 0, 1 ou 2 definidos no treino para cada linha de dados. 

print(kmeans.labels_)

Os valores-alvo são 0, 1 e 2, o que significa que os dados foram agrupados automaticamente em três grupos, com as quantidades abaixo. 

unicos, contagens = np.unique(kmeans.labels_, return_counts=True)
print(unicos, contagens)

Compare os valores reais de iris.target e kmeans.labels_, para perceber a relação estabelecida entre a classificação real, determinada pela propriedade iris.target, e a classificação automática da propriedade kmeans.labels_ obtida pelo algoritmo.

Declare a função imprimir_valores() para imprimir, sem espaçamento, os valores inteiros 0, 1 e 2, relativos aos valores de dados-alvo da lista de tipos de flores passada como parâmetro na função. 

def imprimir_valores(titulo, valores):
    print(titulo, end='')
    for i in range(0,len(valores)): print(valores[i], end='')
    print()

Declare a função classe_iris() para imprimir os dados. 

def classe_iris(num, tipo, inicio, fim, iris=None, kmeans=None, prev_naosup=None, prev_sup=None):
    print(f'*** {num}. Tipo(s): "{tipo} [{inicio}:{fim}]"')
    if iris        : imprimir_valores("iris.data      :", iris.target[inicio:fim])
    if kmeans      : imprimir_valores("kmeans.labels_ :", kmeans.labels_[inicio:fim])
    if prev_naosup : imprimir_valores("prev_naosup    :", prev_naosup[inicio:fim])
    if prev_sup    : imprimir_valores("prev_sup       :", prev_sup[inicio:fim])
    print()

As propriedades iris.target e kmeans.labels_ são listas contendo 150 observações cada, cada uma contendo os valores 0, 1 e 2 de dados-alvo, determinando três grupos que são os valores categóricos dos rótulos descritivos de iris.target_name: 'setosa', 'versicolor' e 'virginica'.

Os valores de kmeans.labels_ foram determinados automaticamente durante a execução do treinamento com a função fit(), formando três grupos. 

classe_iris(1, 'setosa, versicolor, virginica', 0, 150, iris=iris, kmeans=kmeans)

Comparando os valores dos indices [0:50] de iris.target com kmeans.labels_, percebe-se que as classes são iguais, embora o valor para 'setosa' para iris.target seja 0 e o valor para 'setosa' para kmeans.labels_ seja então 1, já que podemos então associar os valores de iris.target e kmeans.labels_ para determinar a classificação do rótulo identificador do conjunto de dados kmeans.labels_. 

classe_iris(2, 'setosa', 0, 50, iris=iris, kmeans=kmeans)

Comparando os valores dos indices [50:100] de iris.target com kmeans.labels_, percebe-se que as classes são iguais, embora o valor para 'versicolor' para iris.target seja 1 e o valor para 'setosa' para kmeans.labels_ seja então 0, já que podemos então associar os valores de iris.target e kmeans.labels_ para determinar a classificação do rótulo identificador do conjunto de dados kmeans.labels_. Existem duas posições em que os valores não correspondem, o que pode levar a um erro de 4% de erro, correspondente a $frac{2}{50}$. 

classe_iris(3, 'versicolor', 50, 100, iris=iris, kmeans=kmeans)

Comparando os valores dos indices [100:150] de iris.target com kmeans.labels_, percebe-se que as classes são iguais em 72% de casos, embora o valor para 'virginica' para iris.target seja 2 e o valor para 'setosa' para kmeans.labels_ seja então 2, na maioria mas em apenas 72% dos caso. Podemos associar os valores de iris.target e kmeans.labels_ para determinar a classificação do rótulo identificador do conjunto de dados kmeans.labels_. Existem 14 posições em que os valores não correspondem, o que pode levar a um erro de 28% de erro na precvisão, correspondente a $frac{14}{50}$. 

classe_iris(4, 'virginica', 100, 150, iris=iris, kmeans=kmeans)

O objeto KMeans da variável rotulou com o valor 1 onde o conjunto de dados classificou a linha de dados como 0, e com o valor 0 onde o comjunto de dados classificou como 1. 2 permaneceu como 2 mesmo.

Observe também que em algumas linhas não houve correspondência entre os valores de target e de label.

Realize as previsões de acordo com os rótulos kmeans. 

previsoes = kmeans.predict(iris.data)

Imprima as previsões. 

print(previsoes)

As previsoes têm valor 0, 1 e 2, o que significa que os dados foram agrupados em três grupos, com as quantidades abaixo das classes. 

unicos, contagens = np.unique(previsoes, return_counts=True)
print(unicos, contagens)

Compare com os valores dos rótulos. 

print(kmeans.labels_)

Observe que os valores das listas de valores de kmeans.labels_ e kmeans.predict(iris.data), pois os dados utilizados são os mesmos (iris.data) utilizados no treinamento com o método fit().

Agora, vamos usar o modelo para fazer uma previsão para uma flor com características determinadas. 

# Caracteristicas
tamanho_sepala = 5.1
largura_sepala = 3.5
tamanho_petala = 1.4
largura_petala = 0.2

Transforme os valores da flor em uma matriz de características. 

X = [[tamanho_sepala, largura_sepala, tamanho_petala, largura_petala]]

Faça a previsão para a flor. 

predicao = kmeans.predict(X)

Imprima a previsão. 

print(predicao)

A previsão é de que a flor seja do tipo setosa.

Declaramos uma função para concatenar uma matriz e um vetor 

def concaternar_matriz_vetor(matriz,vetor):
    matriz_vetor = np.zeros((matriz.shape[0],matriz.shape[1]+1))
    matriz_vetor[:,:-1] = matriz
    matriz_vetor[:,-1:] = vetor.reshape(matriz.shape[0],1)
    return matriz_vetor

Faça as previsões para os dados.

Concatene na variável aux os dados com os alvos do conjunto de dados Iris e, em seguida, os rótulos definidos para os dados pelo objeto kmeans após o treino. 

aux = concaternar_matriz_vetor(iris.data,iris.target)
aux = concaternar_matriz_vetor(aux,kmeans.labels_)

Imprima a variável aux e observe as colunas 4 e 5 (respectivamente a quinta e sexta colunas, considerando o primeiro indice como 0) 

for i in range(0,len(aux)): print(aux[i], end='\n' if (i % 4) == 3 else ' ')
Arduino
Coautor
Betobyte
Autor
Autores
||| Áreas ||| Estatística ||| Python ||| Projetos ||| Dicas & Truques ||| Quantum ||| Python com ML Básico || Python para Iniciantes || Python Básico || Matplotlib || Numpy || Seaborn || Pandas || Django || Estatística para Cientistas de Dados || Python com ML Básico || Python com ML Básico || Aulas | Introdução (Introdução ao ML) | Fundamentos (Programação, dados, modelos, algoritmos, tipos, treinamento, teste, avaliação e Métricas, generalização, engenharia de características, viés (bias) e interpretabilidade, tamanho do conjunto de dados, hiperparâmetros) | Python (Scikit-Learn, TensorFlow, Keras, PyTorch, XGBoost, LightGBM, Pandas, Numpy, Seaborn, Matplotlib) | Dados (Dados) | Modelos e Algoritmos (Modelos e Algoritmos) | Avaliação dos Modelos (Avaliação dos Modelos) | Regressão (Regressão) | Classificação (Classificação) | Tipos (Tipos) | Aprendizado Supervisionado (Aprendizado Supervisionado) | Aprendizado Não Supervisionado (Aprendizado Não Supervisionado) | Aprendizado por Reforço (Aprendizado por Reforço) | ML Profundo (Aprendizado profundo) |