• Link do projeto no Github: https://github.com/cerqueiralex/project-personal-prisioners-dilemma
• Tecnologias: Python, Tensorflow, Random, Deep Q-Learning (DQN)
• Categorias: Data Science, Machine Learning

A Teoria dos Jogos (Game Theory) é um campo da matemática e da economia que estuda como indivíduos ou grupos tomam decisões estratégicas em cenários onde suas escolhas afetam uns aos outros.

Esses “jogos” envolvem situações onde o resultado de cada jogador depende das ações dos outros, e a teoria busca entender as melhores estratégias para cada participante.

É amplamente aplicada em economia, psicologia, ciência política e até mesmo em biologia evolutiva para entender desde competições de mercado até comportamentos sociais.

O Dilema dos Prisioneiros

O Dilema dos Prisioneiros é um dos exemplos mais conhecidos da Teoria dos Jogos. Nele, dois suspeitos de um crime são presos e mantidos separados. Cada um tem duas opções: confessar ou não confessar o crime. As possíveis consequências são as seguintes:

• Se ambos não confessarem, cada um pega uma pena leve (digamos, 1 ano).
• Se um confessar e o outro não confessar, o que confessou fica livre, enquanto o que não confessou recebe a pena máxima (10 anos).
• Se ambos confessarem, cada um recebe uma pena moderada (5 anos).

Os prisioneiros não conseguem se comunicar e precisam tomar suas decisões sem saber o que o outro vai escolher.

Isso cria um dilema: embora a melhor estratégia conjunta seja ambos não confessarem (levando a penas mínimas para ambos), o medo de que o outro possa confessar leva cada prisioneiro a considerar confessar como uma opção mais segura, pois, se o outro confessar, ao menos evitará a pena máxima.

Esse dilema gira em torno de um tema extremamente importante dentro da nossa sociedade: Confiança!

Relação entre Teoria dos Jogos e o Dilema dos Prisioneiros

O Dilema dos Prisioneiros demonstra um conceito importante na Teoria dos Jogos chamado equilíbrio de Nash. Esse equilíbrio ocorre quando, em uma situação com múltiplos jogadores, ninguém pode melhorar seu resultado mudando de estratégia, desde que os outros jogadores mantenham suas escolhas.

No dilema, o equilíbrio de Nash é que ambos confessem, pois, dado que um prisioneiro está confessando, o outro não ganha nada ao ficar em silêncio.

Esse exemplo ajuda a ilustrar uma verdade fundamental na Teoria dos Jogos: os interesses individuais e os interesses coletivos nem sempre estão alinhados.

Situações como o Dilema dos Prisioneiros são comuns em mercados, política e comportamento social, onde decisões baseadas apenas no próprio interesse individual podem levar a resultados subótimos para todos.

Primeiro experimento: Testando partidas aleatórias

Antes de fazer um treinamento de modelo, resolvi testar como seria o comportamento de escolhas aleatórias.

Para isso foi construido esse código onde cada prisioneiro, aleatóriamente escolhe entre cooperar “cooperate” ou trair “betray”.

import random
import matplotlib.pyplot as plt  # Importando a biblioteca para gráficos

# Definir número de rodadas
rounds = 1000

# Pontuação acumulada para cada prisioneiro
score_prisoner1 = 0
score_prisoner2 = 0

# Listas para armazenar as pontuações acumuladas ao longo das rodadas
scores_prisoner1 = []
scores_prisoner2 = []

# Função para simular uma rodada do dilema dos prisioneiros
def play_round():
    # Cada prisioneiro escolhe aleatoriamente entre "cooperar" ou "trair"
    choice1 = random.choice(["cooperate", "betray"])
    choice2 = random.choice(["cooperate", "betray"])

    if choice1 == "cooperate" and choice2 == "cooperate":
        return 3, 3, choice1, choice2  # Ambos cooperam
    elif choice1 == "betray" and choice2 == "betray":
        return 1, 1, choice1, choice2  # Ambos traem
    elif choice1 == "cooperate" and choice2 == "betray":
        return 0, 5, choice1, choice2  # Prisioneiro 1 coopera, Prisioneiro 2 trai
    else:
        return 5, 0, choice1, choice2  # Prisioneiro 1 trai, Prisioneiro 2 coopera

# Executa os rounds, acumula pontuação e exibe cada rodada
for round_num in range(1, rounds + 1):
    points1, points2, choice1, choice2 = play_round()
    score_prisoner1 += points1
    score_prisoner2 += points2

    # Armazenar pontuações acumuladas
    scores_prisoner1.append(score_prisoner1)
    scores_prisoner2.append(score_prisoner2)

    # Exibir resultados da rodada
    print(f"Rodada {round_num}:")
    print(f"  Prisioneiro 1 escolheu: {choice1} | Pontos nesta rodada: {points1}")
    print(f"  Prisioneiro 2 escolheu: {choice2} | Pontos nesta rodada: {points2}")
    print(f"  Pontuação acumulada - Prisioneiro 1: {score_prisoner1}, Prisioneiro 2: {score_prisoner2}")
    print("-" * 40)

# Resultados finais
print("Resultado Final:")
print(f"Pontuação final do Prisioneiro 1: {score_prisoner1}")
print(f"Pontuação final do Prisioneiro 2: {score_prisoner2}")

# Gerar gráfico da pontuação acumulada ao longo dos rounds
plt.figure(figsize=(12, 6))
plt.plot(scores_prisoner1, label="Prisioneiro 1", color='red')
plt.plot(scores_prisoner2, label="Prisioneiro 2", color='blue')
plt.title("Evolução da Pontuação Acumulada dos Prisioneiros")
plt.xlabel("Rodadas")
plt.ylabel("Pontuação Acumulada")
plt.legend()
plt.grid()
plt.show()

Esse é o resultado de 5 partidas aleatórias, onde ocorreram 2 vitórias para o prisioneiro 2 e 3 vitórias para o prisioneiro 1:

Olhando para o gráfico abaixo, é possível observar que no comportamento aleatório, o acúmulo das pontuações está sempre muito próximo, o que é esperado.

Pela projeção de 1000 rodadas, é possível verificar que não é uma boa estratégia e que a chance de vitória é sempre de 50%, mas esse gráfico é interessante para compreender as próximas etapas.

Desenvolvendo o código em Python utilizando tensorflow.keras

A lógica que foi desenvolvida acontece de forma que somente o primeiro prisioneiro irá receber o treinamento de aprendizado por reforço com Q-Learning enquanto que o segundo prisioneiro sempre irá tomar decisões aleatórias.

A ideia é que o primeiro prisioneiro aprenda a melhorar sua estratégia conforme ele aprende com as decisões do segundo.

Para implementar o Q-Learning usando TensorFlow (TF), vamos usar uma rede neural para aproximar a função Q. Esse método é conhecido como Deep Q-Learning (DQN) e é útil para problemas com espaço de estado grande ou contínuo, onde o uso de uma tabela Q tradicional seria inviável.

Neste exemplo do Dilema dos Prisioneiros, vamos configurar uma rede neural simples para estimar a Q-valor para cada ação (“cooperar” ou “trair”) com base na última ação do outro prisioneiro. Essa rede será treinada usando a biblioteca TensorFlow.

Para a Construção do Modelo Q, usamos uma rede neural de três camadas (duas ocultas e uma de saída) para prever o valor Q para cada ação. A entrada é o estado atual, que inclui a última ação do Prisioneiro 2 representada como um vetor one-hot.

# Parâmetros do aprendizado
learning_rate = 0.01
discount_factor = 0.9
exploration_rate = 1.0
exploration_decay = 0.01
min_exploration_rate = 0.01
rounds = 1000

# Pontuação acumulada para cada prisioneiro
score_prisoner1 = 0
score_prisoner2 = 0

# Contadores de escolhas para cada prisioneiro
choices_count = {
    "prisoner1": {"cooperate": 0, "betray": 0},
    "prisoner2": {"cooperate": 0, "betray": 0}
}

# Definir ações
actions = ["cooperate", "betray"]

# Converter ações para índices
action_to_index = {action: i for i, action in enumerate(actions)}

# Construir a rede neural para aproximar a função Q
def build_model(input_size, output_size):
    model = Sequential([
        Dense(24, input_dim=input_size, activation="relu"),
        Dense(24, activation="relu"),
        Dense(output_size, activation="linear")
    ])
    model.compile(optimizer=Adam(learning_rate=learning_rate), loss="mse")
    return model

# Modelo Q para o Prisioneiro 1
model = build_model(input_size=2, output_size=len(actions))

# Função para simular uma rodada do dilema dos prisioneiros
def play_round(prisoner1_choice, prisoner2_choice):
    if prisoner1_choice == "cooperate" and prisoner2_choice == "cooperate":
        return 3, 3  # Ambos cooperam
    elif prisoner1_choice == "betray" and prisoner2_choice == "betray":
        return 1, 1  # Ambos traem
    elif prisoner1_choice == "cooperate" and prisoner2_choice == "betray":
        return 0, 5  # Prisioneiro 1 coopera, Prisioneiro 2 trai
    else:
        return 5, 0  # Prisioneiro 1 trai, Prisioneiro 2 coopera

# Função para escolher a ação do Prisioneiro 1
def choose_action(state):
    if np.random.rand() < exploration_rate:
        # Exploração: escolhe uma ação aleatória
        return random.choice(actions)
    else:
        # Exploração: escolhe a ação com maior valor Q estimado
        q_values = model.predict(state)
        return actions[np.argmax(q_values[0])]

# Executa os rounds
last_prisoner2_choice = random.choice(actions)

for round_num in range(1, rounds + 1):
    # Estado atual (última ação do Prisioneiro 2 em one-hot encoding)
    state = np.array([[1 if last_prisoner2_choice == action else 0 for action in actions]])

    # Escolher a ação do Prisioneiro 1
    prisoner1_choice = choose_action(state)
    prisoner2_choice = random.choice(actions)

    # Contabilizar as escolhas
    choices_count["prisoner1"][prisoner1_choice] += 1
    choices_count["prisoner2"][prisoner2_choice] += 1

    # Jogar a rodada e obter a recompensa
    points1, points2 = play_round(prisoner1_choice, prisoner2_choice)
    score_prisoner1 += points1
    score_prisoner2 += points2

    # Próximo estado
    next_state = np.array([[1 if prisoner2_choice == action else 0 for action in actions]])

    # Atualização do Q-valor
    target = points1 + discount_factor * np.max(model.predict(next_state)[0])
    target_f = model.predict(state)
    target_f[0][action_to_index[prisoner1_choice]] = target

    # Treinar o modelo
    model.fit(state, target_f, epochs=1, verbose=0)

    # Atualizar a última escolha do Prisioneiro 2 para a próxima rodada
    last_prisoner2_choice = prisoner2_choice

    # Decaimento da taxa de exploração
    exploration_rate = max(min_exploration_rate, exploration_rate * exploration_decay)

Escolha de Ação:

A função choose_action usa uma política ε-greedy para escolher uma ação com base na previsão do modelo Q. Durante o treinamento, o agente explora mais, e com o tempo passa a explorar menos à medida que aprende.

Atualização do Q-valor e Treinamento do Modelo:

Após cada rodada, calculamos o alvo para a ação escolhida, que é o valor de recompensa somado ao valor Q máximo esperado para o próximo estado. Esse valor é então usado para ajustar o modelo.

Decaimento da Taxa de Exploração:

Após cada rodada, a taxa de exploração diminui, incentivando o agente a explorar menos conforme aprende.

Este modelo aproxima o comportamento de um agente Q-Learning com aprendizado por reforço, mas utiliza uma rede neural para aprender Q-valores ao invés de uma tabela Q.

Motivos para o Decaimento da Taxa de Exploração

A taxa de exploração no aprendizado por reforço decai com o tempo para permitir que o agente aprenda a explorar menos conforme ele acumula conhecimento do ambiente e explorar mais as ações que têm maior potencial de recompensa.

Se a taxa de exploração subisse com o tempo, o agente continuaria a tomar ações de forma aleatória mesmo quando ele já tivesse uma estratégia razoavelmente boa, o que impediria que ele convergisse para uma política estável.

Exploração Inicial:

No início do treinamento, o agente tem pouca ou nenhuma informação sobre quais ações são melhores. Uma alta taxa de exploração (ε) permite que o agente experimente várias ações, conheça o ambiente e construa uma base inicial de conhecimento.

Exploração x Exploração:

Conforme o treinamento avança, o agente já terá acumulado experiência e aprendido quais ações tendem a dar melhores recompensas. Se a taxa de exploração permanecer alta, o agente continuará a tomar decisões aleatórias, reduzindo a efetividade do aprendizado.

Diminuindo a exploração, o agente passa a confiar mais em seu aprendizado (exploração) e a escolher as ações que parecem mais promissoras com base nos valores Q já aprendidos.

Convergência para uma Política Ótima:

O objetivo é que, ao final do treinamento, o agente seja capaz de seguir uma política ótima, ou seja, uma estratégia onde ele maximiza suas recompensas.

Um ε próximo de zero é desejável ao fim do treinamento, pois indica que o agente seguirá a política que ele acredita ser ótima, baseada nas recompensas que ele acumulou ao longo do tempo.

Primeiros Rounds

Nos primeiros rounds é possível observar que com uma taxa de exploração alta, o primeiro prisioneiro fica bem atrás do segundo nas pontuações e isso acontece até mais ou menos a rodada 50 onde el começa a aprender os padrões:

Resultados do treinamento com 1000 rounds

Ao final do treinamento com 1000 rodadas o prisioneiro 1 consegue aprender que quanto mais ele escolher a opção de betray, mais ele aumenta as chances de ganhar.

Mesmo realizando diversos testes, o comportamento do aprendizado é o mesmo! Sempre que o prisioneiro 1 aprende que betray é a melhor estratégia por volta da rodada 50, ele começa a ganhar e disparar na pontuação.

Ao final conseguimos visualizar a curva de aprendizado do prisioneiro 1

Porque sempre escolher a opção de betray é matematicamente a estratégia predominante?

Escolher a opção de “betray” (trair) no Dilema dos Prisioneiros é matematicamente vantajoso devido à análise de recompensas associadas a cada combinação de decisões dos prisioneiros. Vamos detalhar essa análise.

Cenário do Dilema dos Prisioneiros

Considere duas opções para cada prisioneiro: cooperate (cooperar) ou betray (trair). A tabela a seguir mostra as recompensas associadas a cada combinação de decisões:

Análise das Estratégias

1. Se ambos cooperam:
   • Ambos recebem 3 pontos. Este é o cenário ótimo para ambos, mas requer confiança.
2. Se o Prisioneiro 1 coopera e o Prisioneiro 2 trai:
   • O Prisioneiro 1 recebe 0 pontos, enquanto o Prisioneiro 2 recebe 5 pontos.
   • Perda máxima para o Prisioneiro 1, se ele confiar.
3. Se o Prisioneiro 1 trai e o Prisioneiro 2 coopera:
   • O Prisioneiro 1 recebe 5 pontos e o Prisioneiro 2 recebe 0 pontos.
   • Máxima recompensa para o Prisioneiro 1, se o outro confiar.
4. Se ambos traem:
   • Ambos recebem 1 ponto. Este é um resultado pior do que ambos cooperarem, mas melhor do que a situação em que um coopera e o outro trai.

Estratégia Dominante

Matematicamente, a escolha de trair se torna a estratégia dominante para o Prisioneiro 1:

• Se o Prisioneiro 2 escolher cooperar:
  • Trair (5 pontos) é melhor do que cooperar (3 pontos).
• Se o Prisioneiro 2 escolher trair:
  • Trair (1 ponto) é melhor do que cooperar (0 pontos).

Portanto, independentemente da escolha do Prisioneiro 2, a opção de trair sempre resulta em uma pontuação igual ou maior para o Prisioneiro 1. Essa análise leva à conclusão de que trair é a estratégia mais vantajosa.

• Teorema da Estratégia Dominante: A escolha de “betray” é a melhor estratégia para o Prisioneiro 1, pois maximiza a pontuação em relação à escolha do outro jogador, independentemente da ação que ele escolha.
• Resultados a Longo Prazo: Se o Prisioneiro 1 sempre trair, ele garante uma pontuação consistente e evita a possibilidade de perda máxima que ocorre quando coopera e o outro trai.

Assim, a escolha de sempre trair (betray) é matematicamente fundamentada, pois, ao longo de várias iterações do jogo, essa estratégia levará a um desempenho superior, especialmente quando considerada a incerteza sobre as ações do oponente.

Conclusão

O que é mais curioso de ser observado de acordo com esse dilema e dadas suas condições, é que o aprendizado de máquina, simula de forma matemática, muitas das decisões individuais que são tomadas na sociedade e a estratégia dominante de sempre escolher a opção de trair ilustra a lógica do “racional egoísmo”, onde indivíduos optam por maximizar seus próprios benefícios em detrimento dos outros, resultando em um comportamento que pode minar a confiança nas relações interpessoais.

O dilema dos prisioneiros exemplifica a tensão entre interesses individuais e coletivos, refletindo como a escolha de trair ou cooperar pode se manifestar em interações sociais cotidianas.

Essa ideia é algo que vemos na sociedade, em situações como negociações, amizades ou até na política, onde a desconfiança pode levar a escolhas que, embora benéficas a curto prazo para um indivíduo, criam um ambiente de desconfiança generalizada.

Assim, a prevalência da traição como estratégia pode dificultar a formação de laços de confiança, essenciais para a colaboração e a construção de uma comunidade coesa, mostrando que a cooperação, embora menos intuitiva em um contexto competitivo, pode ser crucial para o bem-estar coletivo e a prosperidade a longo prazo.

Nele, a escolha de trair sempre parece a opção mais segura, mostrando que, muitas vezes, a gente pensa primeiro em si mesmo do que em quem está do lado.

Referências

• https://en.wikipedia.org/wiki/Game_theory
• https://en.wikipedia.org/wiki/Prisoner%27s_dilemma
• https://medium.com/@shruti.dhumne/deep-q-network-dqn-90e1a8799871

O post Game Theory: Prisioner’s Dilemma utilizando Deep Q-Learning (DQN) Tensorflow.Keras apareceu primeiro em Data Universe.

Aplicações Pioneiras

O aprendizado de máquina tem vasta aplicabilidade, desde sistemas de recomendação online até diagnósticos médicos e veículos autônomos. Outras áreas incluem processamento de linguagem natural, visão computacional e análise de sentimentos em textos.

Desafios e Considerações

Apesar das amplas aplicações, desafios como overfitting, viés nos dados e complexidade computacional persistem. Reconhecer esses fundamentos é crucial para explorar eficazmente temas avançados e aplicar técnicas de maneira eficiente em projetos próprios.

Diversidade nos Tipos de Aprendizado de Máquina

Existem três categorias principais de aprendizado de máquina: supervisionado, não supervisionado e por reforço.

1. Aprendizado Supervisionado

Este é o tipo mais comum, onde o algoritmo se instrui a partir de um conjunto de dados rotulado. A finalidade é identificar uma função que relaciona entradas a saídas. Exemplos incluem regressão linear e máquinas de vetores de suporte.

2. Aprendizado Não Supervisionado

Aqui, o algoritmo é treinado em dados não rotulados, sendo incumbido de descobrir padrões intrínsecos. Algoritmos de clustering e técnicas de redução de dimensionalidade são exemplos nesse contexto.

3. Aprendizado por Reforço

Nesse cenário, um agente aprende a otimizar seu comportamento em um ambiente para maximizar recompensas acumulativas. Aplicações incluem sistemas de recomendação e estratégias de navegação para robôs.

Etapa Crucial: Preparação de Dados

1. A Essencial Preparação de Dados

Antes de adentrarmos nos algoritmos de aprendizado de máquina, a compreensão da importância da preparação de dados é imperativa. O ditado “Lixo entra, lixo sai” ressalta que a qualidade dos insights gerados é diretamente proporcional à qualidade dos dados.

2. Limpeza de Dados

A primeira etapa consiste na limpeza dos dados, envolvendo remoção ou correção de imprecisões, incompletudes ou irrelevâncias. Técnicas como tratamento de valores ausentes e remoção de outliers são fundamentais nesse processo.

3. Transformação de Dados

Após a limpeza, a transformação de dados se faz necessária, abrangendo técnicas como normalização, padronização e codificação de variáveis categóricas.

4. Divisão de Dados

A etapa final envolve a divisão dos dados em conjuntos de treinamento e teste, ou, ocasionalmente, validação. Essa prática possibilita a avaliação do desempenho do modelo em dados não vistos, garantindo uma modelagem mais robusta e precisa.

A preparação de dados é essencial para o sucesso na modelagem de aprendizado de máquina, garantindo eficiência e acurácia nos resultados.

Explorando Algoritmos de Aprendizado de Máquina

1. Regressão Linear

A Regressão Linear, algoritmo supervisionado, analisa relações entre variáveis e prevê resultados futuros com base em dados históricos. É aplicável em análise de tendências, sendo útil para decisões informadas durante transações.

2. Árvores de Decisão

Árvores de Decisão resolvem problemas de classificação e regressão, dividindo iterativamente dados com base em características. São valiosas na análise de relações entre variáveis e na identificação de fatores-chave em resultados.

3. K-Vizinhos mais Próximos (KNN)

O algoritmo KNN, supervisionado, prevê classificações ou valores baseando-se na proximidade de pontos de dados. Aplicável na previsão de comportamento de mercado e identificação de padrões com base em históricos.

4. Redes Neurais Artificiais

Inspiradas no cérebro humano, as Redes Neurais Artificiais possuem camadas de neurônios que processam informações e aprendem com dados de entrada. Adequadas para prever preços, detectar fraudes e otimizar estratégias de negociação.

Exploramos quatro algoritmos amplamente utilizados na análise de dados, destacando sua aplicabilidade no contexto de negociação. O entendimento dessas técnicas proporciona vantagem competitiva e decisões mais informadas.

Aprofundando nos Modelos de Aprendizado de Máquina

1. Validação de Modelos

A validação de modelos é essencial para avaliar o desempenho do modelo treinado. Técnicas incluem a divisão de dados em conjuntos de treinamento e teste, validação cruzada k-fold e validação cruzada de repetição aleatória.

2. Otimização de Hiperparâmetros

Hiperparâmetros, definidos antes do treinamento, impactam o desempenho do modelo. A otimização envolve testar diferentes combinações de valores, utilizando técnicas como pesquisa em grade, pesquisa aleatória e otimização bayesiana.

3. Seleção de Recursos

Identificar e selecionar os recursos mais relevantes melhora a eficiência e precisão do modelo. Técnicas incluem filtragem, seleção baseada em envoltório e seleção baseada em incorporação.

4. Aplicação e Avaliação em Dados Reais

Após treinamento e otimização, aplicar o modelo a dados reais é crucial. Métricas como precisão, recall, F1-score e erro médio quadrático são utilizadas para avaliar o desempenho, considerando também interpretabilidade e facilidade de implementação.

A validação de modelos, otimização de hiperparâmetros, seleção de recursos e aplicação em dados reais são fundamentais para garantir eficácia e confiabilidade em modelos de aprendizado de máquina no contexto de negociação.

Referências:

• https://awari.com.br

O post Introdução à Machine Learning e I.A. apareceu primeiro em Data Universe.

• Link do projeto no Github: https://github.com/cerqueiralex/kmeans-elbow-method
• Tecnologias: Python, Scikit Learn, Pandas, Numpy, Plotly, Matplotlib
• Categorias: Estatística

Clustering, também conhecido como agrupamento, refere-se à aplicação de técnicas de machine learning destinadas a dividir um conjunto de dados em diversos clusters ou grupos distintos, tendo como critério principal a semelhança entre os dados.

Em contraste com algoritmos de classificação e regressão, o clustering é uma técnica simples da aprendizagem não supervisionada, uma vez que os algoritmos envolvidos precisam discernir as relações intrínsecas entre os dados, sem depender de rótulos prévios que indiquem a que categoria pertencem.

Por meio de clustering, é possível extrair informações valiosas e insights que muitas vezes não seriam perceptíveis por meio de abordagens de aprendizado supervisionado.

K-means

K-Means é um algoritmo de agrupamento iterativo que busca encontrar centróides ótimos para criar clusters em um conjunto de dados. Ele itera até que os centróides não mudem substancialmente, e nesse ponto, os clusters resultantes são considerados estáveis e representam grupos distintos com base nas semelhanças entre os dados.

O algoritmo opera seguindo os seguintes passos:

Inicialização: O algoritmo escolhe aleatoriamente K pontos a partir dos dados, onde K é o número de clusters predefinido como parâmetro. Esses pontos iniciais atuam como os centros dos clusters “provisórios” antes de qualquer ajuste.

Atribuição de Clusters: Cada ponto de dado é avaliado para determinar a sua proximidade ao centróide mais próximo. Isso resulta na divisão dos dados em clusters, onde cada cluster é composto pelos pontos mais próximos ao centróide associado.

Atualização dos Centróides: Os novos valores para os centróides são calculados como a média dos dados contidos em cada cluster. Isso significa que o centro de cada cluster é recalculado com base nos pontos que o compõem.

Iteração: O processo de encontrar centróides e atualizar clusters é repetido. Os centróides são recalculados, os pontos são reatribuídos aos clusters com base na proximidade aos novos centróides e os centróides são novamente atualizados pela média dos pontos do cluster.

Convergência: O algoritmo continua a iterar até que a posição dos centróides não mude mais. Isso indica que os centróides convergiram para suas posições finais e que os clusters estão estáveis.

Este processo é repetido até que os centróides se estabilizem, e os clusters alcancem uma configuração na qual não haja mais alterações significativas.

A abordagem que o algoritmo K-Means segue para resolver o problema é chamada Expectation-Maximization (Expectativa-Maximização). A etapa E é atribuir os pontos de dados ao cluster mais próximo.

A etapa M é calcular o centróide de cada cluster. Abaixo está uma quebra de como podemos resolver isso matematicamente:

A função é:

Onde wik=1 para o ponto de dados xi se ele pertencer ao cluster k; caso contrário, wik=0. Além disso, μk é o centróide do cluster de xi.

É um problema de minimização de duas partes. Primeiro, minimizamos J com relação a wik e tratamos μk como fixo. Em seguida, minimizamos J com relação a μk e tratamos wik como fixo. Tecnicamente falando, diferenciamos J com relação a wik primeiro e atualizamos as atribuições de cluster (etapa E).

Em seguida, diferenciamos J com relação a μk e recalculamos os centróides após as atribuições de cluster da etapa anterior (etapa M). Portanto, a etapa E é:

Em outras palavras, atribuimos o ponto de dados xi ao cluster mais próximo, julgado pela soma das distâncias quadradas do centróide do cluster.

E a etapa M é:

O que se traduz em recalcular o centróide de cada cluster para refletir as novas atribuições.

Elbow method

Simplesmente olhando para os dados em um scatterplot, em alguns casos é possível estimar a olho nu a quantidade de centróides ideal para ser aplicada no conjunto de dados como é possível observar na figura a seguir.

Aqui podemos estimar que o número ideal de centróides seria igual a 5, por causa dos grandes grupos, o que resultaria no seguinte agrupamento:

Porém como podemos saber o número ideal do ponto de vista matemático?

Um passo fundamental para qualquer algoritmo não supervisionado é determinar o número ideal de agrupamentos nos quais os dados podem ser divididos.

Como não temos um número pré-definido de agrupamentos no aprendizado não supervisionado, tendemos a utilizar algum método que nos ajude a decidir o melhor número de agrupamentos. No caso do agrupamento K-Means, usamos o Elbow-Method.

Ele leva esse nome justamente por se assemelhar a um “cotovelo” conforme é possível de se observar na figura abaixo.

O que é o Elbow-Method no Agrupamento K-Means

No algoritmo de agrupamento K-Means, inicializamos aleatoriamente k agrupamentos e ajustamos iterativamente esses k agrupamentos até que os k-centróides alcancem um estado de equilíbrio. No entanto, a coisa principal que fazemos antes de inicializar esses agrupamentos é determinar quantos agrupamentos devemos usar.

Neste método, para determinar o valor de k, iteramos continuamente de k=1 até k=n (onde n é o hiperparâmetro que escolhemos de acordo com nossos requisitos). Para cada valor de k, calculamos o valor da soma dos quadrados dentro do agrupamento (WCSS).

WCSS – É definido como a soma das distâncias quadradas entre os centróides e cada ponto.

Agora, para determinar o melhor número de agrupamentos (k), traçamos um gráfico de k versus o valor de WCSS correspondente.

Além disso, quando k=1, o WCSS tem o valor mais alto, mas, à medida que o valor de k aumenta, o valor do WCSS começa a diminuir. Escolhemos o valor de k observando no gráfico em que ponto ele começa a se assemelhar a uma linha reta.

Construindo uma visualização em Python

Começamos importando as bibliotecas que iremos utilizar. A biblioteca do KMeans do Sklearn, pandas para tratar a base, numpy para os np arrays e matplotlib para a visualização final dos gráficos.

O link do github deste projeto está disponível aqui

from sklearn.cluster import KMeans
from sklearn import metrics
from scipy.spatial.distance import cdist
import numpy as np
import matplotlib.pyplot as plt

O dataset utilizado é o mall_customers.csv disponível no kaggle. Este conjunto de dados foi criado apenas para fins de aprendizado dos conceitos de segmentação de clientes, também conhecido como “análise de cesta de mercado”.

from google.colab import files
files.upload()
df = pd.read_csv ("Mall_Customers.csv")

Usamos essa função para importar o dataset e defini-lo na variável “df”.

Ao imprimir o dataset é possível verificar que ele possui 5 dimensões, mas só preciso utilizar 2 delas que são o salário anual (Annual Income) e o score de gastos (spending score). Então eu vou tratar o dataset aqui mesmo com o pandas.

df = df.drop(columns=['Gender','CustomerID','Age'])
print('Modified DataFrame:\n', df)

Vamos montar agora o código que treina o modelo:

distortions = []
inertias = []
mapping1 = {}
mapping2 = {}
K = range(1, 10)

for k in K:
	# Construindo e treinando o modelo
	kmeanModel = KMeans(n_clusters=k).fit(X)
	kmeanModel.fit(X)

	distortions.append(sum(np.min(cdist(X, kmeanModel.cluster_centers_,
										'euclidean'), axis=1)) / X.shape[0])
	inertias.append(kmeanModel.inertia_)

	mapping1[k] = sum(np.min(cdist(X, kmeanModel.cluster_centers_,
								'euclidean'), axis=1)) / X.shape[0]
	mapping2[k] = kmeanModel.inertia_

Aqui calculamos as métricas de distorção e inércia para diferentes valores de K (número de clusters) e armazenamos essas métricas em listas e dicionários.

distortions e inertias são listas vazias que serão usadas para armazenar as métricas de distorção e inércia, respectivamente.

mapping1 e mapping2 são dicionários vazios que serão usados para mapear os valores de K para suas métricas de distorção e inércia correspondentes.

K é uma lista que contém valores de K de 1 a 9 (ou seja, de 1 a 9 clusters) que serão testados.

O loop for k in K: itera sobre os diferentes valores de K.

Dentro do loop, o modelo K-Means é construído e treinado com o número atual de clusters definido por k:

kmeanModel = KMeans(n_clusters=k).fit(X)
kmeanModel.fit(X)

Isso cria uma instância do modelo K-Means com o número atual de clusters e o ajusta aos dados X.

A distorção é calculada para o valor de K atual com a fórmula:

sum(np.min(cdist(X, kmeanModel.cluster_centers_, 'euclidean'), axis=1)) / X.shape[0]

Essa fórmula calcula a média das distâncias euclidianas mínimas entre cada ponto de dados e os centros dos clusters mais próximos.

A inércia é calculada para o valor de K atual com kmeanModel.inertia_. A inércia é a soma das distâncias quadráticas entre os pontos de dados e os centros dos clusters.

As métricas de distorção e inércia calculadas são armazenadas nas listas distortions e inertias, respectivamente.

Os valores de K e suas métricas de distorção e inércia correspondentes são armazenados nos dicionários mapping1 e mapping2, respectivamente, para análise posterior.

No final do loop, você terá listas contendo as métricas de distorção e inércia para diferentes valores de K, bem como dicionários que mapeiam os valores de K para essas métricas. Aqui queremos determinar o número ideal de clusters em uma análise de cluster K-Means.

Vamos tabular e visualizar os resultados agora utilizando os diferentes valores de distortion para o dicionário mapping1:

for key, val in mapping1.items():
	print(f'{key} : {val}')

Plotamos em um gráfico agora os dados acima:

plt.plot(K, distortions, 'bx-')
plt.xlabel('Values of K')
plt.ylabel('Distortion')
plt.title('The Elbow Method using Distortion')
plt.show()

Utilizando agora os diferentes valores de inércia para o dicionário mapping2:

for key, val in mapping2.items():
	print(f'{key} : {val}')

Para determinar o número ideal de clusters, devemos selecionar o valor de k no “cotovelo”, ou seja, o ponto após o qual a distorção/inércia começa a diminuir de maneira linear. Assim, para os dados fornecidos, concluímos que o número ideal de clusters para os dados é 5.

De forma resumida para o código a seguir, iremos plotar imagens dos pontos de dados agrupados para diferentes valores de k. Para isso, aplicaremos o algoritmo K-Means no conjunto de dados, iterando em uma faixa de valores de k.

Na range, colocamos o número que conseguimos através do Elbow-Method que foi 5

# Cria um range de valores para k
k_range = range(1, 6)

# Iniciamos uma lista vazia para armazenar os valores de inércia para cada K
inertia_values = []

# Treinamos e plotamos os dados para cada valor de k
for k in k_range:
	kmeans = KMeans(n_clusters=k, \
					init='k-means++', random_state=42)
	y_kmeans = kmeans.fit_predict(X)
	inertia_values.append(kmeans.inertia_)
 
#Gráfico Matplotlib
	plt.scatter(X[:, 0], X[:, 1], c=y_kmeans)
	plt.scatter(kmeans.cluster_centers_[:, 0],\
				kmeans.cluster_centers_[:, 1], \
				s=100, c='red')
	plt.title('K-means clustering (k={})'.format(k))
	plt.xlabel('Feature 1')
	plt.ylabel('Feature 2')
	plt.show()

# Plota os valores de inércia para cada k
plt.plot(k_range, inertia_values, 'bo-')
plt.title('Elbow Method')
plt.xlabel('Number of clusters (k)')
plt.ylabel('Inertia')
plt.show()

Resultado final:

Aqui é possível visualizar o resultado final com a plotagem iterativa de todos os gráficos para cada valor de K e os respectivos centróides.

Conclusão

Você é o proprietário de um shopping e deseja compreender os perfis dos seus clientes e quem pode ser facilmente convertido (Clientes-Alvo).

Utilizando o dataset de score de pontuação financeira, utilizamos o algoritmo do Elbow-Method para encontrar o número da referência ideal de centróides e aplicamos isso no algoritmo de aprendizado de máquina não supervisionado K-means para criar os clusters e identificar quais são os perfis de clientes de modo que isso possa ser transmitido à equipe de marketing e que a estratégia seja planejada de acordo.

Referências

• https://www.kaggle.com/datasets/vjchoudhary7/customer-segmentation-tutorial-in-python
• http://shabal.in/visuals/kmeans/2.html
• https://www.geeksforgeeks.org/elbow-method-for-optimal-value-of-k-in-kmeans/
• https://en.wikipedia.org/wiki/Cluster_analysis
• https://towardsdatascience.com/k-means-clustering-algorithm-applications-evaluation-methods-and-drawbacks-aa03e644b48a
• https://medium.com/turing-talks/clustering-conceitos-b%C3%A1sicos-principais-algoritmos-e-aplica%C3%A7%C3%A3o-ace572a062a9

O post Clusterização com K-means em Python utilizando Elbow Method apareceu primeiro em Data Universe.

• Link do projeto no Github: https://github.com/cerqueiralex/machine-learning-previsao-aluguel
• Tecnologias: Python, Pandas, Numpy, Matplotlib, Seaborn,Statsmodels, Scikit learn
• Categorias: Estatística

Este é um projeto de análise estatística exploratória utilizando o statsmodels e scikitlearn com uma base de dados fictícia para trabalhar o seguinte problema: Existe alguma relação entre a área de imóveis (em metros quadrados) e o valor do aluguel em uma determinada cidade? Caso exista relação, como podemos mensurá-la?

Para atacar esse problema de forma didática, primeiro iremos realizar uma análise estatística exploratória com regressão linear simples através do método Ordinary Least Squares que será explicado mais adiante e em seguida utilizaremos o mesmo método para treinar um modelo de previsão de machine learning que irá tentar prever o provável valor de um aluguel baseado na area em m² de um imóvel.

Primeiro as bibliotecas que iremos trabalhar:

# Imports
import pandas as pd
import numpy as np
import matplotlib.pyplot as plt
import seaborn as sns
import statsmodels.api as sm
from sklearn.linear_model import LinearRegression
from sklearn.model_selection import train_test_split

O objetivo inicial é utilizar as bibliotecas do pandas para importar os dados, matplotlib e seaborn para gerar alguns gráficos exploratórios e o statsmodels pra fazer uma regressão linear simples na fase analítica.

Em seguida utilizamos o numpy para criar os arrays de machinelearning e o sklearn para treinar o modelo e realizar um deploy.

Carregando os dados e fazendo análise exploratória

Carregamos então o dataset em csv e analisamos sua estrutura

# Carrega o dataset
df_dsa = pd.read_csv('dataset.csv')

df = pd.read_csv(path)
df.describe

Esse é um pequeno dataset como podemos ver que possui somente 3000 linhas x 7 colunas

O dataset possui diversas dimensões, porém somente iremos utilizar o valor do aluguel e a área em m2. Como pode ver, essas são as dimensões disponíveis no dataset:

• ‘valor_aluguel’,
• ‘area_m2’,
• ‘ano_construcao’,
• ‘codigo_localidade’,
• ‘numero_banheiros’,
• ‘numero_cozinhas’,
• ‘codigo_bairro’

Agora vamos analisar qual é o valor médio dos aluguéis com o comando histplot:

# sns.histplot = chama o método histplot do seaborn 
sns.histplot(data = df, x = "valor_aluguel", kde = True)

É possível observar que a maior parte dos valores de aluguel gira em torno da casa dos 300 a 400 reais.

Através do método “corr” podemos facilmente analisar uma matriz de correlação entre as dimensões do nosso dataset para entender o valor que iremos trabalhar com nossas dimensões de entrada e saída.

# Correlação entre as variáveis
df.corr()

O coeficiente de correlação é uma medida estatística que indica a força e a direção da relação linear entre duas variáveis numéricas. Ele varia entre -1 e 1, onde:

Um coeficiente de correlação igual a 1 indica uma correlação linear perfeita positiva, ou seja, quando uma variável aumenta, a outra variável também aumenta na mesma proporção.

Um coeficiente de correlação igual a -1 indica uma correlação linear perfeita negativa, ou seja, quando uma variável aumenta, a outra variável diminui na mesma proporção.

Um coeficiente de correlação igual a 0 sugere que não há correlação linear entre as duas variáveis.

O coeficiente de correlação mais comum é o de Pearson, que mede a correlação linear entre duas variáveis. Existem outras medidas de correlação, como o coeficiente de correlação de Spearman, que avalia a relação monotônica entre duas variáveis, e o coeficiente de correlação de Kendall, que considera a concordância entre os rankings das variáveis.

Nesse caso temos uma correlação de 58% que é bem fraca.

Agora vamos visualizar isso em um gráfico scatterplot para analisar a distribuição desses dados nas dimensões x e y.

# Vamos analisar a relação entre a variável de entrada area_m2 e a variável alvo valor_aluguel
sns.scatterplot(data = df_dsa, x = "area_m2", y = "valor_aluguel")

Regressão Linear Simples

A Regressão Linear é uma técnica estatística utilizada para modelar a relação entre uma variável dependente (também chamada de variável resposta ou variável alvo) e uma ou mais variáveis independentes (também chamadas de variáveis explicativas ou preditoras).

A Regressão Linear tem como objetivo estimar os coeficientes da equação que melhor descreve essa relação, minimizando a soma dos erros quadráticos entre os valores observados e os valores previstos pelo modelo.

Existem dois tipos principais de regressão linear:

Regressão Linear Simples: Neste caso, há apenas uma variável independente envolvida. A equação da Regressão Linear Simples é expressa como:

Y = a + bX + ε

Onde Y é a variável dependente, X é a variável independente, a é o coeficiente linear (intercepto), b é o coeficiente angular (inclinação) e ε é o erro aleatório.

Regressão Linear Múltipla: Neste caso, há duas ou mais variáveis independentes envolvidas. A equação é expressa como:

Y = a + b1X1 + b2X2 + … + bnXn + ε

Onde Y é a variável dependente, X1, X2, …, Xn são as variáveis independentes, a é o coeficiente linear (intercepto), b1, b2, …, bn são os coeficientes angulares (inclinações) e ε é o erro aleatório.

A Regressão Linear é amplamente utilizada em diversas áreas, como economia, ciências sociais, biologia e engenharia, para prever resultados, avaliar relações causais e identificar fatores que contribuem para um fenômeno específico.

Além disso, é uma técnica fundamental para a análise de dados e aprendizado de máquina, onde é usada para desenvolver modelos preditivos.

Construção do Modelo OLS (Ordinary Least Squares) com Statsmodels em Python

Ordinary Least Squares Regression (OLSR): uma técnica de regressão linear usada para minimizar a soma dos erros quadrados entre a variável dependente e as variáveis independentes.

O método sm.OLS(y, X) é uma função do pacote Statsmodels, biblioteca Python utilizada para análise estatística. A função OLS (Ordinary Least Squares) é usada para ajustar um modelo de regressão linear, minimizando a soma dos erros quadráticos entre os valores observados e os valores previstos pelo modelo.

A função sm.OLS(y, X) recebe dois argumentos principais:

y: Um array ou pandas Series representando a variável dependente (variável resposta ou alvo). É a variável que você deseja prever ou explicar com base nas variáveis independentes.

X: Um array ou pandas DataFrame representando as variáveis independentes (variáveis explicativas ou preditoras). São as variáveis que você deseja usar para explicar ou prever a variável dependente.

# Definimos a variável dependente
y = df_dsa["valor_aluguel"]

# Definimos a variável independente
X = df_dsa["area_m2"]

# O Statsmodels requer a adição de uma constante à variável independente
X = sm.add_constant(X)

# Criamos o modelo
modelo = sm.OLS(y, X)

Em seguida treinamos o modelo e imprimimos o resultado:

# Treinamento do modelo
resultado = modelo.fit()

print(resultado.summary())

E esse é o resultado do nosso modelo:

Interpretando o Resultado do Modelo Estatístico com Statsmodels

A tabela acima traz um resumo do modelo com diversas estatísticas. Aqui faremos a análise de uma delas, o R².

O coeficiente de determinação, também conhecido como R², é uma medida estatística que avalia o quão bem o modelo de regressão se ajusta aos dados observados. Ele varia de 0 a 1 e representa a proporção da variação total da variável dependente que é explicada pelo modelo de regressão.

A interpretação do R² é a seguinte:

R² = 0: Neste caso, o modelo de regressão não explica nenhuma variação na variável dependente. Isso significa que o modelo não é útil para prever ou explicar a variável de interesse.

R² = 1: Neste caso, o modelo de regressão explica toda a variação na variável dependente. Isso indica que o modelo se ajusta perfeitamente aos dados e é extremamente útil para prever ou explicar a variável de interesse.

0 < R² < 1: Neste caso, o modelo de regressão explica uma parte da variação na variável dependente. Quanto maior o valor de R², melhor o modelo se ajusta aos dados e melhor é a sua capacidade de prever ou explicar a variável de interesse.

É importante notar que um R² alto não garante que o modelo seja adequado, nem que haja uma relação causal entre as variáveis. Um R² alto pode ser resultado de variáveis irrelevantes, multicolinearidade ou até mesmo de um ajuste excessivo (overfitting). Portanto, é essencial avaliar outras estatísticas e diagnosticar o modelo antes de tirar conclusões definitivas.

Vamos plotar em um scatterplot os dados do modelo treinado para tirar uma conclusão:

# Plot
plt.figure(figsize = (12, 8))
plt.xlabel("area_m2", size = 16)
plt.ylabel("valor_aluguel", size = 16)
plt.plot(X["area_m2"], y, "o", label = "Dados Reais")
plt.plot(X["area_m2"], resultado.fittedvalues, "r-", label = "Linha de Regressão (Previsões do Modelo)")
plt.legend(loc = "best")
plt.show()

Claramente existe uma forte relação entre a área (em m2) dos imóveis e o valor do aluguel. Entretanto, apenas a área dos imóveis não é suficiente para explicar a variação no valor do aluguel, pois nosso modelo obteve um coeficiente de determinação (R²) de apenas 0.34.

O ideal seria usar mais variáveis de entrada para construir o modelo a fim de compreender se outros fatores influenciam no valor do aluguel.

É sempre importante deixar claro que correlação não implica causalidade e que não podemos afirmar que o valor do aluguel muda apenas devido à área dos imóveis. Para estudar causalidade devemos aplicar Análise Causal.

Em um Projeto de Regressão devemos validar as suposições (que são várias) antes de usar o modelo para tirar conclusões.

Treinando um modelo para previsão do valor do aluguel baseado na area em m2 usando Scikit Learn

Sabemos que com um valor de r² de baixa correlação observado (0.34) não é suficiente para treinar um modelo, mas como o objetivo desse projeto é somente exploratório, vamos prosseguir mesmo assim.

Vamos treinar o modelo usando a mesma técnica de regressão linear com Ordinary Least Squares.

Vamos então preparar nossa variável de entrada X e tranformá-la em um array numpy, fazer o reshape dela em um intervalo de -1 e 1 e definir nossa variável de saída Y como o valor do aluguel.

X = np.array (df['area_m2'])
X = X.reshape(-1,1)
Y = df['valor_aluguel']

Em seguida vamos fazer um split no nosso modelo para um ambiente de teste e outro de treino. a amostra de testes será configurada para alocar 20% dos dados e consequentemente o treino será realizado com 80% dos dados.

X_treino, X_teste, Y_treino, Y_teste = train_test_split (X, Y, test_size = 0.2, random_state= 42)

O shape das nossas variáveis ficou dessa forma:

Valor agora criar e treinar o modelo

modelo = LinearRegression()
modelo.fit(X_treino, Y_treino)

Conseguimos agora analisar a curva da regressão já com a previsão do modelo

plt.scatter(X,Y)
plt.plot(X,modelo.predict(X), color = "red")
plt.xlabel("area em m2")
plt.ylabel ("valor do aluguel")

Vejamos o score do nosso modelo:

score = modelo.score(X_teste,Y_teste)
print(score)

o nosso modelo ficou com um score de 0.3528410684969181 o que é um valor bem abaixo da média. Na prática esse modelo não poderia ser utilizado para realizar previsões, mas vamos ver como ele se sai.

O próximo passo agora é definir nossos vetores de intercepto (w0) e coeficiente (w1) da reta de regressão. Aqui um gráfico com uma breve explicação dos vetores que estaremos criando dentro do contexto da regressão:

modelo.intercept_ #W0
modelo.coef_ #W1

Fazendo deploy do modelo

Agora com o modelo treinado, iremos utilizar um input qualquer de area em m2 para que nosso modelo faça a previsão de qual seria um provável valor de aluguel.

Conclusão

Apesar de ser um modelo preditivo fraco, conseguimos gerar algumas previsões a título de conhecimento e treino.

Como é possível observar, segundo o modelo, um imóvel de 500 m² teria uma média de valor de aluguel de R$2520,00

seguem alguns exemplos de previsões geradas pelo modelo:

Referências

• https://www.datascienceacademy.com.br/
• https://www.statsmodels.org/dev/generated/statsmodels.regression.linear_model.OLS.html
• https://scikit-learn.org/stable/modules/generated/sklearn.linear_model.LinearRegression.html

O post Análise Estatística e treinamento de modelo preditivo de Machine Learning com regressão linear OLS em python: Relação entre a área de imóveis e o valor do aluguel apareceu primeiro em Data Universe.