• 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.

Em seguida, mostro como tratar esses dados com a biblioteca Pandas, permitindo que você descubra facilmente quais usuários que você segue não estão mais te seguindo de volta.

É uma ótima oportunidade para aprender a automatizar essa análise e otimizar sua presença nas redes sociais com técnicas de ciência de dados.

Hashtags: #Python #Pandas #Instagram #DataAnalysis #SocialMediaAnalytics #DataScience #InstagramFollowers #CodingTutorial #DataCleaning

O post Descubra quem não te segue de volta no Instagram! Automação com Python e Pandas apareceu primeiro em Data Universe.

Com instruções detalhadas e exemplos práticos, você aprenderá como configurar a exportação de dados, criar uma conexão robusta no BigQuery e, finalmente, transformar esses dados em insights visuais poderosos usando o Looker Studio.

Ideal para profissionais que buscam otimizar a análise de dados e aprimorar a tomada de decisões com ferramentas avançadas do Google.

O post GA4 + Google Bigquery: Integrar dados do GA4 com o Big Query + Looker apareceu primeiro em Data Universe.

Acesse este artigo para entender tudo sobre a teoria e prática de como utilizar a calculadora: https://datauniverse.com.br/teste-de-hipoteses/

Link para acessar a calculadora: https://docs.google.com/spreadsheets/d/1fqEo9cV8_hj4quDSBtzDYApWapca9q4Wd7HLgJ7-1sQ/copy

Como usar:

Basta preencher as duas colunas de observações das amostras manualmente com os próprios dados ou atualizar os dados aleatóriamente marcando e desmarcando a caixa:

Gráficos de distribuição

Os gráficos de distribuição, ajudam a visualizar o formato da distribuição dos dados das observações das amostras A e B.

Uma distribuição estatística é uma função que descreve a frequência com que diferentes valores ocorrem em um conjunto de dados. Representa a maneira como os dados são distribuídos ao longo de um intervalo, e pode ser apresentada de várias formas, como distribuições normais, binomiais, uniformes, entre outras.

Ao analisar um gráfico de dispersão, você pode tomar decisões informadas sobre a natureza da relação entre variáveis, identificar anomalias e planejar próximas etapas na análise de dados.

Para que serve:

O teste Z é útil para:

1. Comparar a média de uma amostra com uma média populacional conhecida.
2. Comparar as médias de duas amostras independentes.
3. Verificar hipóteses sobre proporções em amostras grandes.

Como funciona:

O teste Z segue os seguintes passos:

1. Formulação das Hipóteses:

• Hipótese Nula (H₀): Afirma que não há diferença (por exemplo, a média da amostra é igual à média populacional).
• Hipótese Alternativa (Hₐ): Afirma que há uma diferença (por exemplo, a média da amostra é diferente da média populacional).

1. Cálculo da Estatística Z:

Para uma amostra única:

Onde:

	é a média da amostra
	é a média populacional
	é o desvio padrão populacional
	é o tamanho da amostra

Para duas amostras:

Onde:

	são as médias das amostras
	são as médias populacionais
	são os desvios padrão populacionais
	são os tamanhos das amostras

1. Determinação do P-valor:

• O P-valor é a probabilidade de obter um valor Z tão extremo ou mais extremo que o valor observado, assumindo que a hipótese nula é verdadeira.
• Para um teste bicaudal, calcula-se a probabilidade nas duas extremidades da distribuição normal.

1. Comparação com o Nível de Significância (α):

• Se o P-valor é menor que α (por exemplo, 0,05), rejeita-se a hipótese nula.
• Se o P-valor é maior que α, não se rejeita a hipótese nula.

Exemplos de aplicação:

• Verificar se a média de altura dos estudantes de uma escola é diferente da média nacional.
• Comparar a eficácia de dois medicamentos com base em amostras de pacientes.

O teste Z é particularmente adequado quando o tamanho da amostra é grande (geralmente (n > 30)) e a variância populacional é conhecida. Se a variância populacional não é conhecida e a amostra é pequena, utiliza-se geralmente o teste t de Student.

Parâmetros estatísticos

1. Hipótese Nula (H₀): É a hipótese inicial que assume que não há efeito ou diferença significativa entre os grupos ou condições em estudo. Geralmente, é a hipótese que se tenta refutar ou rejeitar.
2. Hipótese Alternativa (Hₐ): É a hipótese que contrasta com a hipótese nula. Sugere que há um efeito significativo ou diferença entre os grupos ou condições em estudo. Aceitar Hₐ implica rejeitar H₀.
3. Number of Tails: Refere-se ao tipo de teste estatístico baseado na hipótese alternativa. Pode ser:
   • Unicaudal (one-tailed): Testa se um parâmetro é maior ou menor que um valor específico.
   • Bicaudal (two-tailed): Testa se um parâmetro é diferente (maior ou menor) de um valor específico.
4. Z Statistic (Z-score): É uma medida que descreve a posição de uma amostra em relação à média de uma distribuição normal padrão, medida em desvios padrão. Um Z-score indica quantos desvios padrão um valor está acima ou abaixo da média.
5. P-value (two-tails): É a probabilidade de observar um valor extremo ou mais extremo do que o observado, assumindo que a hipótese nula é verdadeira. Em um teste bicaudal, considera as extremidades de ambas as caudas da distribuição.
6. Intervalo de Confiança (1-α): É um intervalo estimado a partir dos dados da amostra, dentro do qual se espera que o parâmetro populacional verdadeiro esteja, com um nível de confiança de (1-α)%. Por exemplo, um intervalo de confiança de 95% significa que temos 95% de certeza de que o parâmetro verdadeiro está dentro desse intervalo.
7. Significância Desejada (α): É o nível de significância pré-definido para um teste estatístico, representando a probabilidade de cometer um erro do Tipo I (rejeitar a hipótese nula quando ela é verdadeira). Comumente, α é 0,05 ou 5%.
8. Variância Conhecida (σ): Refere-se à variância da população que é conhecida ou assumida conhecida, usada em testes estatísticos como o teste Z.
9. Desvio Padrão da Amostra (σ): É uma medida de dispersão que indica o quanto os valores de uma amostra variam em relação à média da amostra.
10. Média (X̄): É a soma de todos os valores da amostra dividida pelo número de observações. Representa a média aritmética dos dados da amostra.
11. Observações (n): Refere-se ao número total de dados ou pontos de amostra coletados em um estudo.
12. Diferença de Média Hipotetizada: É a diferença entre as médias populacionais que se espera ou se assume existir sob a hipótese alternativa.
13. Soma Total de Observações na Amostra: Refere-se à soma de todos os valores observados na amostra.
14. Diferença entre as Amostras: Refere-se à diferença observada entre as médias ou proporções de duas ou mais amostras.
15. Decisão Estatística a ser Tomada quando Hₐ é Falsa, Aceitar H₀: Significa que, com base nos resultados do teste estatístico, não há evidência suficiente para rejeitar a hipótese nula, então aceitamos H₀ como verdadeira (ou não rejeitamos H₀).

Esses parâmetros são essenciais para conduzir e interpretar testes estatísticos, ajudando a determinar a significância dos resultados de pesquisas e experimentos.

O post Calculadora de Teste-Z no Google Sheets para um grupo de duas amostras aleatórias apareceu primeiro em Data Universe.

• Link do projeto no Github: https://github.com/cerqueiralex/etl-pyspark-sqlite-docker/
• Tecnologias: Python, PySpark, SQLite
• Categorias: Data Engineering, ETL

Neste projeto, compartilharei o passo a passo de um projeto de processamento de dados em lote que utilizei em meu portfolio. O objetivo era transformar um arquivo JSON em um banco SQLite, utilizando PySpark e Docker.

1. Configurando o ambiente com Docker Compose

Comecei criando um cluster PySpark em Docker com três containers: um master, dois workers e um history para armazenar logs. Utilizei o Docker Compose para facilitar a configuração e o gerenciamento do cluster.

2. Gerando a base de dados SQLite

Em seguida, desenvolvi dois scripts Python:

• Gerador de dados: Este script gerou um arquivo JSON com dados fictícios, simulando um cenário real.
• Criador da base de dados: Este script criou a base de dados SQLite e definiu a conexão com o arquivo JSON gerado.

3. Implementando o job ETL com PySpark

O job ETL foi escrito em PySpark e implementado no container master do cluster. As principais etapas do job foram:

• Leitura do arquivo JSON: O arquivo JSON gerado no passo 2 foi lido como um DataFrame do Spark.
• Definição do schema: Um schema foi definido para garantir a consistência dos dados na base SQLite.
• Tratamento de dados: O campo de e-mail foi tratado para remover caracteres inválidos e garantir a padronização.
• Gravação na base SQLite: O DataFrame final foi gravado na base SQLite criada no passo 2.

4. Executando o job ETL

O job ETL foi executado no container master do cluster através do comando spark-submit. O processo de execução foi monitorado no console do container.

5. Resultados e Considerações

O job ETL foi executado com sucesso, transformando o arquivo JSON em um banco SQLite. A utilização do PySpark e do Docker proporcionou um ambiente escalável e eficiente para o processamento de dados.

Pontos importantes do projeto:

• Utilização do Docker Compose para facilitar a configuração do cluster PySpark.
• Desenvolvimento de scripts Python para gerar a base de dados SQLite e o arquivo JSON.
• Implementação do job ETL em PySpark com leitura de dados, definição de schema, tratamento de dados e gravação na base SQLite.
• Execução do job ETL no container master do cluster e monitoramento do processo.

Conclusão:

Este projeto demonstra como o PySpark e o Docker podem ser utilizados para realizar o processamento de dados em lote de forma eficiente e escalável. A utilização de containers facilita a configuração do ambiente e o deploy do job em diferentes plataformas.

Este projeto foi realizado para fins de estudo e demonstração de habilidades. O código-fonte e os dados utilizados estão disponíveis em meu repositório GitHub.

O post Processamento de dados em lote com PySpark e Docker apareceu primeiro em Data Universe.

• Link do projeto no Github: https://github.com/cerqueiralex/etl-com-minio/
• Tecnologias: Python, MinIO
• Categorias: Data Engineering, ETL

MinIO é um armazenamento de objetos de alto desempenho compatível com S3. Ele é projetado para cargas de trabalho de inteligência artificial/aprendizado de máquina em grande escala, data lakes e bancos de dados. É definido por software e pode ser executado em qualquer infraestrutura em nuvem ou local.

Aqui irei organizar os arquivos na nuvem utilizando MiniO em máquina local, que possui os mesmos princípios do serviço S3 da Amazon AWS.

Site oficial: https://min.io

Vantagens e desvantagens de utilizar MinIO como datalake

Vantagens

• Muito bom na recuperação de objetos.
• Boa interface de navegação
• Compatibilidade com formatos diferentes de storage
• Muito fácil criar e trabalhar com buckets a nível de S3

Desvantagens

• Baixa documentação
• Pequenos bugs entre as atualizações
• Dificudade de ver os logs
• Pouco seguro se não for bem implementado

Acessando o Dashboard MinIO utilizando o Docker Localmente

Não irei entrar no detalhe de como subir os containers docker aqui, porém através desta documentação você consegue implantar um servidor MinIO de um único nó e uma única unidade no Docker ou Podman para desenvolvimento inicial e avaliação do Armazenamento de Objetos MinIO e sua camada de API compatível com S3.

Para instruções sobre implantação em ambientes de produção, consulte “Implantação MinIO: Múltiplos Nós, Múltiplas Unidades“.

O MinIO está configurado na URL: http://127.0.0.1:9001 (ele será carregado automaticamente no browser quando o docker estiver up)

Configurando a região

Primeiro é necessário configurar a região do nosso servidor em settings > region. Aqui estarei utilizando a região sa-east-1 (south america) para fazer o processamento dos dados.

Raw Policy e Access Keys

Para poder fazer o ETL, o arquivo python (que pode estar rodando localmente na máquina) precisa se conectar com o banco do MinIO que pode estar localizado em qualquer servidor em qualquer lugar do mundo.

Para isso, é necessário gerar as access keys e para isso, é necessário criar a raw policy primeiro.

Aqui gerei uma política de acesso completa de leitura e escrita, dessa forma posso gravar arquivos, sobrescrevê-los e fazer a leitura deles.

Esse é o formato da raw policy gerada:

{
    "Version": "2012-10-17",
    "Statement": [
        {
            "Effect": "Allow",
            "Action": [
                "s3:*"
            ],
            "Resource": [
                "arn:aws:s3:::*"
            ]
        }
    ]
}

Gerando as Access Keys

Na área de access keys, gero uma chave para que eu possa conectar o ETL com este servidor Minio.

Assim como na AWS, ao gerar uma chave, você só pode visualizar a Secret key uma única vez, dessa forma é imperativo baixar o arquivo csv que possui a seguinte estrutura contendo as duas chaves:

{"url":"http://127.0.0.1:9000","accessKey":"mnzf2Dw34eOEohXh","secretKey":"kXuPY6NVaHMySNct8INu1LB0lwNVLfYJ","api":"s3v4","path":"auto"}

Por fim, é necessário ir até a access key que acabou de ser criada e aplicar a política de acesso nela, ou seja, estou atribuindo aquelas permissões à uma determinada chave, então quem tiver essa chave, terá permissões de leitura e escrita de arquivos no datalake.

Extraindo os dados e conectando ao MinIO

Beleza, agora que já tenho o ambiente e as chaves configuradas, basta criar um arquivo em python bem simples e conectá-lo ao nosso ambiente.

Para esse exemplo vou utilizar o pandaspara fazer a leitura dos arquivos e transformá-los em dataframes, e o boto3 que é uma biblioteca utilizada para fazer a conexão do cliente com o datalake.

Além disso, importo a classe BytesIO do módulo io em Python.

io é um módulo em Python que fornece várias ferramentas para trabalhar com entrada/saída de dados (I/O). O nome “io” é uma abreviação de “input/output”.

BytesIO é uma classe específica dentro do módulo io. Ela fornece uma interface para ler e escrever dados binários em memória, mas trata esses dados como se fossem provenientes de um fluxo de bytes, sem a necessidade de um arquivo físico.

A utilização típica do BytesIO é criar um objeto BytesIO, escrever dados binários nele e, em seguida, usá-lo onde seria esperado um objeto de arquivo (como, por exemplo, ao ler um arquivo binário).

!pip install pandas
!pip install boto3

import pandas as pd
from io import BytesIO
import boto3
from io import StringIO 

Crio o cliente para conectar ao MinIO. Onde tenho [ACCESS KEY ID] e [SECRET ACCESS KEY] é preciso substituir pelas suas próprias chaves de acesso.

client = boto3.client('s3', 
    endpoint_url='http://seu-endpoint-aqui:9000',
    aws_access_key_id='[ACCESS KEY ID]',
    aws_secret_access_key='[SECRET ACCESS KEY]',
    aws_session_token=None,
    config=boto3.session.Config(signature_version='s3v4'),
    verify=False,
    region_name='sa-east-1'
)

Aqui simplesmente carrego os dados com pandas. Estou utilizando uma base do kaggle “Most Subscribed 1000 Youtube Channels”

https://www.kaggle.com/datasets/themrityunjaypathak/most-subscribed-1000-youtube-channels

# Carregando os dados
file_path = 'topyoutube.csv'

df = pd.read_csv(file_path)

file_path

Antes de fazer o upload do csv, preciso criá-lo e subir o csv na memória

csv_buffer = StringIO ()

df.to_csv(csv_buffer)

Escrita: carregando os objetos

Depois que o csv estiver na memória através da função csv_buffer, posso uploadear ele para o datalake. Lembrando que é preciso substituir o “nome-do-bucket” pelo nome correto do seu bucket.

client.put_object (Body=csv_buffer.getvalue(), Bucket='nome-do-bucket', Key="diretorio/dataset.csv")

Pronto! agora é possivel verificar o seu objeto no diretorio que foi criado dentro do bucket.

Leitura: visualizando o objeto armazenado

Agora vou fazer o processo inverso -> agora que o arquivo está no datalake, vou ler o arquivo. Para isso é necessário configurar um client de leitura.

obj = client.get_object(
    Bucket = 'nome-do-bucket',
    Key = "diretorio/dataset.csv"
).get("Body")

data = pd.read_csv(obj)
data.head()

Referências:

• https://min.io/
• https://min.io/docs/minio/container/index.html

O post Processo de ETL simples utilizando datalake MinIO apareceu primeiro em Data Universe.

• Link do projeto no Github: https://github.com/cerqueiralex/iac-ec2-terraform-docker
• Tecnologias: Docker, Terraform, AWS EC2
• Categorias: Data Engineering, IaC

Este artigo explora a implementação prática da integração entre DevOps e Infraestrutura como Código (IaC), com foco na automação da infraestrutura AWS EC2 utilizando a ferramenta Terraform. Destaco aqui a importância da IaC, tratando a infraestrutura como código de software demonstrando os benefícios dessa abordagem na agilidade, rastreabilidade e escalabilidade da infraestrutura em nuvem.

IaC (Infraestrutura como código) é um método para gerenciar e provisionar infraestrutura de TI utilizando código de programação, em vez de fazê-lo manualmente através de interfaces web ou de linha de comando. Isso permite que a infraestrutura seja tratada como qualquer outra parte do código de aplicativo, o que facilita a automação, a reprodução e o controle de versão.

IaC é usado para automatizar o provisionamento de recursos de infraestrutura, como máquinas virtuais, containers, armazenamento, rede e outros, além de automatizar a configuração deles. IaC também pode ser usado para automatizar o escalonamento horizontal e vertical, assim como a implantação de aplicações.

IaC é especialmente útil em ambientes de nuvem, onde os recursos podem ser provisionados e escalados rapidamente e é amplamente utilizado em conjunto com DevOps e práticas de desenvolvimento ágil para tornar mais fácil e rápido para equipes de desenvolvimento implementar e gerenciar suas aplicações.

1. Acessar o AWS IAM e criar as chaves de autenticação 

O AWS Identity and Access Management (IAM) é um serviço da Amazon Web Services (AWS) que oferece controle seguro de acesso aos recursos e serviços da AWS.

O IAM desempenha um papel fundamental na segurança da AWS, permitindo que os usuários concedam ou neguem acesso a recursos, implementem a autenticação de fatores múltiplos e integrem políticas de segurança personalizadas, mas principalmente, o AWS IAM serve para controlar e proteger o acesso aos serviços e recursos da AWS, contribuindo para a implementação de práticas robustas de segurança na nuvem.

Nesse sentido, para poder gerenciar os recursos AWS via IaC, é essencial possuirmos uma chave de acesso IAM para se conectar como administrador e gerenciar todos os recursos. Essas chaves de autenticação permitem que o Terraform e os scripts de automação acessem sua conta.

É importante destacar que por questões de segurança, não é indicado gerar essas chaves de acesso no usuário root ou superadmin, pois ela será utilizada na configuração do IaC e qualquer um que tiver acesso terá controle total à infraestrutura, podendo fazer quaisquer alterações e gerar custos indevidos, assim como notifica a AWS na hora da criação das chaves.

A Chave é composta de 2 estruturas, é recomendado baixar o .csv pois a segunda estrutura só pode ser visualizada uma única vez.

2. Criando imagem e container Docker

A estrutura de diretórios padrão para a criação do projeto deve conter o diretório raíz e dentro o dockerfile junto com o conector “main.tf” que será utilizado para passar os atributos da máquina EC2 para a AWS.

• diretório “terraformiac”
  • Dockerfile
  • main.tf

2.1 Dockerfile

Em seguida é necessário montar o Dockerfile que irá criar a imagem docker para rodar o Terraform e o AWS CLI

# Usando a imagem oficial do Ubuntu como base (última versão)
FROM ubuntu:latest

# Atualizando os pacotes do sistema e instalar dependências necessárias
RUN apt-get update && \
    apt-get install -y wget unzip curl

# Definir a versão do Terraform 
ENV TERRAFORM_VERSION=1.6.2

# Baixar e instalar Terraform
RUN wget https://releases.hashicorp.com/terraform/${TERRAFORM_VERSION}/terraform_${TERRAFORM_VERSION}_linux_amd64.zip && \
    unzip terraform_${TERRAFORM_VERSION}_linux_amd64.zip && \
    mv terraform /usr/local/bin/ && \
    rm terraform_${TERRAFORM_VERSION}_linux_amd64.zip

# Criar a pasta /terraformiac dentro do container
RUN mkdir /terraformiac

# Copiar main.tf para a pasta /terraformiac no container
COPY main.tf /terraformiac/

# Criar a pasta Downloads e instalar o AWS CLI (para acessar a AWS)
RUN mkdir Downloads && \
    cd Downloads && \
    curl "https://awscli.amazonaws.com/awscli-exe-linux-x86_64.zip" -o "awscliv2.zip" && \
    unzip awscliv2.zip && \
    ./aws/install

# Definir o comando padrão para execução quando o container for iniciado
CMD ["/bin/bash"]

2.2 Arquivo terraform “main.tf”

Montando o arquivo terraform com os atributos da instância EC2. Estamos utilizando a imagem e instância t2.micro que está presente na camada gratuita da AWS.

É necessário também configurar a região de acordo com o projeto. Aqui está sendo utilizada a “us-east-2” que fica localizada em Ohio.

provider "aws" {
  region  = "us-east-2"  
}

#alterar imagem e instância de acordo com necessidade do projeto
resource "aws_instance" "tarefa1" {
  ami           = "ami-0a0d9cf81c479446a"  # AMI na AWS
  instance_type = "t2.micro"

#alterar tag de acordo com nome do projeto
  tags = {
    Name = "terraformiac"
  }
}

2.3 Criando a imagem no Docker

No terminal linux/mac, execute o comando abaixo para criar a imagem Docker

docker build -t terraform-image:terraformiac .

docker build: Este comando é utilizado para construir uma imagem Docker a partir de um Dockerfile.

-t terraform-image:terraformiac : Esta parte etiqueta a imagem com um nome e uma tag opcional. Neste caso, a imagem será etiquetada como terraform-image com a tag terraformiac . Os dois pontos (:) separam o nome da imagem da tag.

. : O ponto no final especifica o contexto de construção. O contexto de construção é o conjunto de arquivos em uma localização específica mencionada no Dockerfile. Neste caso, espera-se que o Dockerfile esteja no diretório atual (.).

Portanto, quando você executa este comando, o Docker procura por um Dockerfile no diretório atual e o utiliza para construir uma imagem chamada terraform-image com a tag terraformiac .

2.4 Criando o container Docker

Execute o comando abaixo para criar o container Docker

docker run -dit --name terraformiac terraform-image:terraformiac /bin/bash

docker run -dit --name terraformiac terraform-image:terraformiac /bin/bash

docker run: Este comando é utilizado para executar um contêiner a partir de uma imagem especificada.

-dit:

• -d: Modo destacado. Ele executa o contêiner em segundo plano, permitindo que você use o terminal para outros comandos.
• -i: Modo interativo. Mantém o STDIN aberto mesmo se não estiver conectado, permitindo interação com o contêiner.
• -t: Aloca um pseudo-TTY. Isso é frequentemente usado em conjunto com -i para simular um terminal real.

--name terraformiac : Atribui um nome ao contêiner em execução. Neste caso, o nome é definido como terraformiac .

terraform-image:terraformiac : Especifica a imagem a ser usada para criar o contêiner. Refere-se à imagem terraform-image com a tag terraformiac .

/bin/bash: Substitui o comando padrão especificado no Dockerfile e inicia um shell Bash interativo dentro do contêiner. Isso é útil para interagir com o contêiner quando estiver em execução.

Portanto, quando você executa este comando, o Docker criará um novo contêiner com base na imagem terraform-image com a tag terraformiac . O contêiner será executado em modo destacado e interativo, e você pode acessar seu shell usando /bin/bash. O contêiner é nomeado como terraformiac .

2.5 Verficando as versões

Para confirmar se tudo correu cde acordo, agora acessando o terminal docker, verifique as versões do Terraform e do AWS CLI com os comandos abaixo:

terraform version
aws --version

3. AWS  CLI

O AWS Command Line Interface (AWS CLI) é uma ferramenta de linha de comando que permite aos usuários interagir e gerenciar recursos na Amazon Web Services (AWS) diretamente por meio do terminal.

Com suporte para uma ampla gama de operações, o AWS CLI simplifica tarefas como a criação de instâncias EC2, a configuração de buckets no Amazon S3 e a administração de serviços relacionados à nuvem.

Utilizando comandos intuitivos, os usuários podem automatizar processos, criar scripts e integrar operações da AWS em pipelines de desenvolvimento, proporcionando uma interface eficiente e flexível para a gestão de recursos na nuvem da AWS.

Por questões de segurança, é preferível configurar o AWS CLI manualmente, pois caso contrário você precisará colocar sua chave de segurança no arquivo Dockerfile, o que irá expor sua chave para qualquer um que tiver acesso à automação.

3.1 Configurar o aws CLI via docker terminal

1. Acessar o diretório do projeto com “cd”
2. usar o comando “aws configure” no terminal na pasta onde está o aws cli
3. digitar a primeira chave de acesso da instância
4. digitar a segunda chave de acesso
5. colocar o id da região ex: “us-east-2”
6. enter = padrão none

3.2 Testando conexão entre terraform e AWS

Através do comando abaixo, ele deverá retornar por exemplo todos os buckets no terminal:

aws ec2 ls | awk ‘{print $NF}’

aws ec2 ls: Isso chama o AWS CLI para listar as instâncias EC2.

|: O pipe | é usado para redirecionar a saída do comando anterior para o próximo comando.

awk ‘{print $NF}’: É um comando awk usado para extrair e imprimir a última coluna (campo) de cada linha da saída anterior. O $NF representa o último campo de cada linha.

Então, o comando completo nos lista as instâncias EC2 e extrai o valor da última coluna para cada linha da saída.

4. Iniciar o Terraform

Uma vez feita a conexão corretamente, basta iniciar o terraform através do comando

terraform init

Isso vai fazer com que ele crie todos os arquivos do terraform no diretório

por último, aplicar as configurações através do comando:

terraform apply

Com esse comando você irá executar as configurações definidas no arquivo “main.tf”. Basicamente aqui ele irá mostrar todas as configurações de criação de uma nova instância de EC2

Uma vez aplicadas as alterações, ele terá criado com sucesso as instâncias EC2 no painel AWS.

Referências:

• https://docs.aws.amazon.com/cli/
• https://www.datascienceacademy.com.br/
• https://docs.docker.com/
• https://developer.hashicorp.com/terraform/docs

O post Automatizando Infraestrutura AWS EC2 via IaC com Terraform no Docker 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/chatgpt-analise-de-sentimentos
• Tecnologias: Python, OpenAI API, CSV, Matplotlib, Json
• Categorias: DataScience, Prompt Engineering

Atualmente a maior parte dos processos seletivos das empresas (principalmente no setor de tecnologia) utiliza algum software para conduzir os processos e coletar feedbacks dos candidatos com a finalidade de entender quais foram as possíveis falhas e a partir disso como melhorar a abordagem ou alguma etapa específica da entrevista.

Uma abordagem inovadora para aprimorar esse processo é a análise de sentimentos. Por meio da análise automatizada de textos, como currículos, entrevistas e feedbacks, é possível obter insights valiosos sobre as opiniões e emoções dos candidatos, auxiliando as empresas a tomarem decisões mais informadas.

Neste artigo, apresento um projeto em Python para realizar a análise de sentimentos em um processo de recrutamento de RH para uma empresa de tecnologia que utiliza como motor o ChatGPT 3.5 e apresenta o resultado da análise em gráficos utilizando Matplotlib.

O resultado final pode ser um gráfico que mostra por exemplo as porcentagens de cada tipo de sentimento analisado no conjunto de dados.

Claramente esse essa estrutura pode ser adaptada e utilizada em diversos contextos diferentes, mas aqui iremos escolher um foco que é o feedback para processos de recrutamento em setores de RH.

Neste projeto, a ideia de estrutura é que em algum momento do processo seletivo seja enviado um sistema para que os candidatos possam enviar o seu respectivo feedback (de preferência em modo anônimo) e então com esse feedback nós tratamos e subimos no python para gerar as análises.

Open AI e ChatGPT

Instalamos então nossas bibliotecas que serão utilizadas para o programa. Primeiramente o pacote da openai que irá importar o ChatGPT responsável pela análise de sentimentos.

!pip install openai
!pip install load_dotenv

import openai

from dotenv import load_dotenv, find_dotenv
_ = load_dotenv(find_dotenv()) # Ler o arquivo .env local.

openai.api_key  = ('SUA CHAVE DA API OPENAI AQUI')

O código em questão é uma importação das bibliotecas openai e dotenv e faz uso da função load_dotenv para carregar variáveis de ambiente de um arquivo .env local.

A biblioteca openai é um pacote Python fornecido pela OpenAI, que permite interagir com os serviços e modelos oferecidos pela plataforma. A linha de código openai.api_key = ('') define a chave de API do OpenAI que será usada para autenticação e acesso aos recursos. É necessário substituir pela sua própria chave obviamente.

A biblioteca dotenv é utilizada para carregar variáveis de ambiente de um arquivo .env. O arquivo .env é um arquivo de configuração que contém informações sensíveis, como chaves de API, que não devem ser expostas diretamente no código pois a openai possui uma política automática de detecção de exposição de chaves api em diretórios públicos e se sua chave for exposta ela é cancelada automaticamente e você irá precisar gerar uma nova.

A função load_dotenv() carrega as variáveis de ambiente do arquivo .env e as torna disponíveis para o programa. O uso do _ antes de load_dotenv() é uma convenção comum para indicar que não estamos interessados no valor de retorno da função, apenas na sua execução.

Em resumo, o código importa as bibliotecas necessárias, carrega as variáveis de ambiente de um arquivo .env e define a chave de API do OpenAI para uso posterior nas interações com a plataforma.

def get_completion(prompt, model="gpt-3.5-turbo"):
    messages = [{"role": "user", "content": prompt}]
    response = openai.ChatCompletion.create(
        model=model,
        messages=messages,
        temperature=0, # Este é o grau de aleatoriedade da saída do modelo.
    )
    return response.choices[0].message["content"]

Aqui definimos uma função chamada get_completion em Python. Essa função recebe dois parâmetros: prompt e model. O valor padrão para o parâmetro model é “gpt-3.5-turbo”.

De forma resumida, a função get_completion recebe um prompt e um modelo como entrada, envia o prompt para o modelo usando a API de Chat Completion da OpenAI e retorna a resposta gerada pelo modelo.

Dentro da função, é criada uma lista chamada messages contendo um dicionário. O dicionário representa uma mensagem de usuário no formato esperado pela API de Chat Completion da OpenAI. O valor da chave “role” é definido como “user” e o valor da chave “content” é definido como o valor do parâmetro prompt recebido pela função.

Em seguida, é feita uma chamada à API de Chat Completion da OpenAI usando a função openai.ChatCompletion.create(). O modelo especificado é o valor do parâmetro model. A lista messages é passada como valor para o parâmetro messages, e o parâmetro temperature é definido como 0, que significa que a saída do modelo será mais determinística, com menos aleatoriedade.

A resposta da API é armazenada na variável response. Através dessa resposta, é possível acessar as escolhas feitas pelo modelo usando response.choices. No código, é retornado o conteúdo da primeira mensagem da primeira escolha, que é acessado através de response.choices[0].message["content"].

Carregando o arquivo com o feedback dos candidatos

Como vamos trabalhar com o feedback dos candidatos, nesse caso aqui pensei num formato simples que carrega um csv e posteriormente trata esse csv para transformá-lo em um json para ser utilizado em ferramentas de data science.

Esse é um exemplo de conjunto de dados fictício que deixa as emoções e sentimentos em relação ao processo bem evidentes.

import csv

nome_arquivo = 'arquivo_com_os_feedbacks.csv'

# Abre o arquivo CSV e cria o objeto leitor
with open(nome_arquivo, 'r') as arquivo_csv:
    leitor = csv.reader(arquivo_csv)

    # Transforma os dados do leitor em uma lista
    reviews = list(leitor)

Primeiro, é definida uma variável nome_arquivo que contém o nome do arquivo CSV a ser lido.

O código lê um arquivo CSV, percorre suas linhas e armazena os dados em uma lista chamada reviews.

Utilizamos a declaração with open(nome_arquivo, 'r') as arquivo_csv para abrir o arquivo CSV no modo de leitura ('r'). Essa forma de abrir o arquivo dentro do bloco with garante que o arquivo será fechado corretamente após o uso, mesmo em caso de exceção.

Dentro do bloco with, é criado um objeto leitor de CSV usando a função csv.reader(), passando o arquivo CSV aberto como argumento. Esse objeto leitor permite percorrer as linhas do arquivo CSV.

O próximo passo é converter os dados do objeto leitor em uma lista. Isso é feito utilizando a função list(), que recebe o objeto leitor como argumento. Ao converter o objeto leitor em uma lista, obtemos uma lista de listas, onde cada lista interna representa uma linha do arquivo CSV.

#JSON Formatting
prompt = f"""
Identify the following items from each item in the reviews list:
- The ID for each respective review, starting with 0
- Sentiment (very positive, positive, neutral, negative or very negative)
- Is the reviewer expressing anger? (true or false)
- A list of emotions that the writer of the review is expressing

The reviews list is delimited with triple backticks.
Format your response as a JSON object with "ID, "Sentiment", "Anger" and "Emotions" as the keys.
If the information isn't present, use "unknown" as the value.
Make your response as short as possible.
Format the Anger value as a boolean.
Dont write more than 5 emotions

Reviews list: '''{reviews}'''
"""
response = get_completion(prompt)
print(response)

Agora colocamos o motor do ChatGPT para brilhar!

Como é possível ver na prompt, eu utilizei algumas requisições simples, mas é possível solicitar diversas outras análises e tratamentos para serem gerados com os feedbacks.

Nesse caso vou definir um ID para cada feedback para formatar um objeto json, o sentimento identificado pelo ChatGPT, se a review está expressando raiva (retorna de forma boolean) e uma lista de palavras chave que forem identificadas como emoção.

Esse é o resultado de um arquivo fictício que alimentei para testar o comportamento do modelo em todas as 6 variações de sentimentos que defini:

Visualização dos resultados

import matplotlib.pyplot as plt
import json as js

Vamos utilizar o pacote Matplotlib para gerar os gráficos e o json para adequar os dados para o Matplotlib

data_json = js.loads(response)

Realizamos a conversão de uma string JSON em um objeto Python utilizando a função loads() do módulo json.

O código converte uma string JSON em um objeto Python, permitindo que os dados do JSON sejam manipulados e acessados facilmente no programa Python.

# Inicializar o dicionário para armazenar as contagens
xyz = {}

# Calcular a quantidade de cada tipo de valor dentro da chave 'Sentiment'
for item in data_json.values():
    sentiment = item['Sentiment']
    if sentiment in xyz:
        xyz[sentiment] += 1
    else:
        xyz[sentiment] = 1

print(xyz)

Fazemos a contagem da quantidade de cada tipo de valor dentro da chave ‘Sentiment’ em um dicionário data_json e armazena os resultados no dicionário xyz.

Depois percorremos os valores de um dicionário data_json, conta a quantidade de cada tipo de valor dentro da chave ‘Sentiment’ e armazena os resultados em um novo dicionário xyz.

# Preparar os dados para o gráfico de pizza
labels = list(xyz.keys())
values = list(xyz.values())

# Criar o gráfico de pizza
fig, ax = plt.subplots()
ax.pie(values, labels=labels, autopct='%1.1f%%', startangle=90)

# Ajustar aspectos visuais
ax.axis('equal')  # Torna o gráfico circular
plt.title('Distribuição dos Valores')
plt.legend()

# Exibir o gráfico
plt.show()

O resultado final aqui é uma visualização simples da porcentagem de cada tipo de sentimento. Podemos gerar outras análises também.

Para uma análise mais granular dos resultados, utilizamos o json gerado lá atras que nos trás os outputs do nosso modelo de sentimentos do GPT e quais emoções ele captou de cada feedback.

Repositório Github

O código completo está disponível no seguinte repositório do Github:

https://github.com/cerqueiralex/chatgpt-analise-de-sentimentos

O post Análise de Sentimentos utilizada em processo seletivo (RH) utilizando ChatGPT em Python e Matplotlib apareceu primeiro em Data Universe.

• Link do projeto no Github: https://github.com/cerqueiralex/chatgpt-chatbot/
• Tecnologias: Python, OpenAI API, ChatGPT, OS
• Categorias: Data Science, Prompt Engineering

Uma das coisas empolgantes sobre um LLM (large language model) como o ChatGPT é que você pode usá-lo para construir um chatbot personalizado com uma interface conversacional e desenvolver uma conversa completa de ponta a ponta se aproveitando de todo o poder e aprendizado que o ChatGPT já possui em sua disposição.

Os chatbots são comumente usados para lidar com consultas de atendimento ao cliente, responder perguntas frequentes, realizar tarefas de agendamento ou fornecer informações detalhadas sobre um produto ou serviço. Eles são programados para responder de maneira a simular a conversação humana e são especialmente úteis para lidar com interações repetitivas, liberando tempo para que os humanos lidem com tarefas mais complexas.

Existem dois tipos principais de chatbots:

Chatbots baseados em regras: Esses chatbots respondem a consultas específicas e seguem um conjunto pré-definido de regras. Eles são limitados em termos de capacidade de compreensão e não conseguem lidar com perguntas fora das regras pré-definidas.

Chatbots baseados em Inteligência Artificial: Esses chatbots utilizam técnicas de Processamento de Linguagem Natural(PLN) e Aprendizado de Máquina (Machine Learning) para entender melhor a intenção do usuário e fornecer respostas mais naturais e contextualmente relevantes.

Modelos de linguagem como GPT-3 e GPT-4 da OpenAI são exemplos de tecnologia usada para construir chatbots baseados em Inteligência Artificial. O ChatGPT é um chatbot baseado em IA.Esses bots são capazes de aprender com as interações passadas, melhorando assim a qualidade das respostas ao longo do tempo.

Eles podem gerenciar uma variedade de perguntas e até mesmo participar de conversas mais complexas com os usuários.

A ideia desse projeto aqui é construir um modelo exemplo de chatbot personalizado, talvez para desempenhar o papel de um agente de atendimento ao cliente utilizando IA ou para fazer pedidos em um restaurante.

Claramente para ser colocado em prática, é necessário muito mais customização e configuração do modelo, mas aqui irei construir um conceito básico que pode ser escalado para algo maior ou completamente diferente dependendo do contexto de cada projeto ou empresa.

Criando um processo de ponta a ponta

Antes de partir para a ação e para a modelagem precisamos definir um processo bem claro de como irá funcionar o fluxo de recebimento das mensagens e dos inputs dos usuários. E para isso é importante entender o comportamento base do modelo e como ele recebe as mensagens e como você pode utilizar os outputs para comunicar aos sistemas internos e fazer um ETL desse fluxo.

Esse é um exemplo de fluxo utilizado em um projeto de um serviço de agendado de consultas médicas com o objetivo de reduzir o tempo de espera dos pacientes e facilitar o trabalho dos profissionais de saúde.

Por meio de um assistente virtual, os pacientes poderão marcar suas consultas de acordo com suas preferências de horário e especialistas médicos.

Inicialmente temos a ação do usuário de começar a conversa e me seguida recebe a prompt do usuário; baseado nessa prompt ele irá fazer perguntas até avançar para a etapa de conclusão do agendamento do pedido, enquanto ele não alcançar essa etapa (false) ele retorna para as perguntas até conseguir as informações que precisa.

Uma vez adquiridas as respostas necessárias ele parte para a ação de agendamento do pedido e grava isso no banco de dados passando então as informações do agendamento para o paciente e encerrando o chat.

Esse processo inteiro não será abordado neste artigo, porém serve como base para que cada empresa estruture um fluxo completo de acordo com sua arquitetura e necessidades.

Instalando as dependências

Primeiro, configuraremos o pacote Python OpenAI. Modelos de chat como o ChatGPT são na verdade treinados para receber uma série de mensagens como entrada e retornar uma mensagem gerada pelo modelo como saída.

E, embora o formato de chat seja projetado para tornar as conversas de várias iterações como esta fácil, também é igualmente útil para tarefas de uma única volta sem qualquer conversa.

Dependendo do programa que estiver utilizando para rodar o python, pode ser necessário instalar os pacotes antes de importar.

!pip install openai
!pip install load_dotenv

Em seguida iremos importar os pacotes da openai e dotenv e inserir a chave da API da open AI, caso ainda não possua uma pode ser criada em: https://platform.openai.com/account/api-keys

Eu estou utilizando uma chave gratuita e utilizando o modelo do chatgpt 3.5 turbo que é o que está disponível atualmente de forma gratuita. Para modelos 4 ou posterior é necessário pagar por uma licença.

import openai
import os

from dotenv import load_dotenv, find_dotenv
_ = load_dotenv(find_dotenv()) # read local .env file

openai.api_key  = ('INSIRA AQUI SUA CHAVE API OPENAI')

Criando os objetos do modelo

Em seguida iremos criar duas funções, a get_completion e get_completion_from_messages.

Se você observar, fornecemos um prompt, mas, na verdade, dentro da função, o que estamos fazendo é inserir esse prompt em algo que se parece com uma mensagem do usuário.

E isso ocorre porque o modelo ChatGPT é um modelo de chat, o que significa que ele é treinado para receber uma série de mensagens como entrada e retornar uma mensagem gerada pelo modelo como saída.

Portanto, a mensagem do usuário é meio que a entrada, e a mensagem do assistente é a saída.

def get_completion(prompt, model="gpt-3.5-turbo"):
    messages = [{"role": "user", "content": prompt}]
    response = openai.ChatCompletion.create(
        model=model,
        messages=messages,
        temperature=0, # this is the degree of randomness of the model's output
    )
    return response.choices[0].message["content"]

def get_completion_from_messages(messages, model="gpt-3.5-turbo", temperature=0):
    response = openai.ChatCompletion.create(
        model=model,
        messages=messages,
        temperature=temperature, # this is the degree of randomness of the model's output
    )
#     print(str(response.choices[0].message))
    return response.choices[0].message["content"]

A função get_completion é definida com dois parâmetros: prompt e model. O parâmetro prompt representa o texto de entrada ou prompt fornecido pelo usuário. O parâmetro model é opcional e representa o modelo a ser usado para gerar a conclusão. Por padrão, é definido como “gpt-3.5-turbo”.

Dentro da função, uma lista messages é criada. Essa lista conterá as mensagens da conversa para a conclusão baseada em chat. Neste caso, a conversa consiste em uma única mensagem do usuário. A mensagem é representada como um dicionário com duas chaves: “role” e “content”. “role” especifica o papel da mensagem (neste caso, “user”), e “content” contém o texto real da mensagem, que é o prompt fornecido.

O método openai.ChatCompletion.create() é chamado para gerar a conclusão. Ele recebe vários argumentos:

model: Especifica o modelo a ser usado para gerar a conclusão. É definido com o valor do parâmetro model passado para a função.

messages: Especifica as mensagens da conversa para a conclusão. É definido como a lista messages criada no passo anterior.

temperature: Especifica o grau de aleatoriedade na saída do modelo. Um valor de 0 faz com que a saída seja mais determinística, ou seja, mais previsível.

A resposta da API de conclusão de chat é armazenada na variável response.

Por fim, a função retorna o conteúdo da conclusão gerada pelo modelo. Ela acessa o conteúdo da primeira escolha da resposta usando response.choices[0].message["content"]. Cada escolha representa uma possível conclusão diferente, e neste caso, estamos pegando o conteúdo da primeira escolha como saída.

A segunda função, get_completion_from_messages, é semelhante à primeira, mas recebe a lista messages diretamente como parâmetro, em vez do prompt. Além disso, possui um parâmetro adicional temperature, que permite controlar o grau de aleatoriedade na saída do modelo. O restante do código é muito semelhante ao da primeira função, onde a resposta da API é armazenada na variável response, e o conteúdo da primeira escolha é retornado como saída.

Essas funções são usadas para interagir com um modelo de geração de texto baseado em chat da OpenAI, onde uma lista de mensagens é passada para o modelo, e ele retorna uma resposta gerada com base nessas mensagens.

Repare que utilizamos um parâmetro da variável response que é o temperature=0; A temperatura é um parâmetro que controla a “criatividade” ou aleatoriedade do texto gerado pelo GPT-3. Uma temperatura mais alta (por exemplo, 0,7) resulta em uma saída mais diversificada e criativa, enquanto uma temperatura mais baixa (por exemplo, 0,2) torna a saída mais determinística e focada.

Na prática, a temperatura afeta a distribuição de probabilidade sobre os possíveis tokens em cada etapa do processo de geração. Uma temperatura de 0 tornaria o modelo completamente determinístico, sempre escolhendo o token mais provável.

Interface e automação do Orderbot

Podemos automatizar a coleta de prompts do usuário e respostas do assistente para construir um OrderBot. O OrderBot irá receber pedidos em uma pizzaria.

Este chatbot será chamado de OrderBot, e iremos automatizar a coleta de prompts do usuário e respostas do assistente.

def collect_messages(_):
    prompt = inp.value_input
    inp.value = ''
    context.append({'role':'user', 'content':f"{prompt}"})
    response = get_completion_from_messages(context) 
    context.append({'role':'assistant', 'content':f"{response}"})
    panels.append(
        pn.Row('User:', pn.pane.Markdown(prompt, width=600)))
    panels.append(
        pn.Row('Assistant:', pn.pane.Markdown(response, width=600, style={'background-color': '#F6F6F6'})))
 
    return pn.Column(*panels)

Aqui iremos criar uma UI para simular a aplicação do painel do chatbot para o usuário, o que na prática seria construído e personalizado para cada empresa.

criamos dentro da variável context a prompt do sistema que funciona como o famoso “act as” do chatgpt informando que ele dever´se comportar como um serviço automatizado e coleta de pedidos de uma pizzaria e seu nome é “Orderbot”

Passamos também para o modelo todas as informações e preços do menu da nossa pizzaria (aqui é importante a formatação dos preços corretamente com pontos no lugar de vírgulas)

import panel as pn  # GUI
pn.extension()

panels = [] # collect display 

context = [ {'role':'system', 'content':"""
Você é o OrderBot, um serviço automatizado para coletar pedidos em uma pizzaria.\ 
Primeiro, você saúda o cliente e em seguida coleta o pedido.\
Depois, você pergunta se é para retirada ou entrega.\
Você aguarda para coletar o pedido completo,\ 
Você faz um resumo e verifica se o cliente deseja adicionar mais alguma coisa.\ 
Se for para entrega, você pede o endereço.\ 
Por fim, você coleta o pagamento.

Certifique-se de esclarecer todas as opções, extras e tamanhos para identificar exclusivamente o item do menu.\ 
Você responde de uma forma curta e amigável, como em uma conversa.\

O menu inclui:\

Pizza de pepperoni: R$ 12.95, R$ 10.00, R$ 7.00\
Pizza de queijo: R$ 10.95, R$ 9.25, R$ 6.50\
Pizza de berinjela: R$ 11.95, R$ 9.75, R$ 6.75\
Batatas fritas: R$ 4.50, R$ 3.50\
Salada grega: R$ 7.25\
Coberturas:\

Queijo extra: R$ 2.00\
Cogumelos: R$ 1.50\
Linguiça: R$ 3.00\
Bacon canadense: R$ 3.50\
Molho AI: R$ 1.50\
Pimentões: R$ 1.00\
Bebidas:\

Coca-Cola: R$ 3.00, R$ 2.00, R$ 1.00\
Sprite: R$ 3.00, R$ 2.00, R$ 1.00\
Água em garrafa: R$ 5.00\
"""} ]  # accumulate messages


inp = pn.widgets.TextInput(value="Hi", placeholder='Enter text here…')
button_conversation = pn.widgets.Button(name="Chat!")

interactive_conversation = pn.bind(collect_messages, button_conversation)

dashboard = pn.Column(
    inp,
    pn.Row(button_conversation),
    pn.panel(interactive_conversation, loading_indicator=True, height=300),
)

dashboard

Testando o modelo

O resultado final é um chatbot simples, porém poderoso! ele é capaz de entender contextos complexos e diferentes inputs de usuário e seguir com o pedido até o final.

Ele começa gerando uma interface vazia e com uma frase de introdução inicial que inicia a conversa com o cliente. Você então escreve qualquer coisa e ele irá te guiar automaticamente até o final do pedido.

Essa é uma simulação que eu fiz com ele pedido uma pizza de pepperoni do tamanho grande com molho extra e acabei não pedindo nenhuma bebida.

Ao concluir o pedido, o modelo traz um resumo com todas as informações do pedido, o endereço e o valor total incluindo ou não a taxa de entrega.

É interessante testar como que o modelo se comporta com diferentes tipos de inputs de usuário, por exemplo, quando ele me pergunta o tipo do pagamento eu devolvo com uma pergunta, se pode ser em dinheiro.

Contextos não relacionados

O mais interessante é que ao programar o chatgpt para seguir essa função, ele é extremamente eficiente em se manter alinhado ao seu objetivo e mesmo fazendo diversas perguntas complexas, diferentes e que não possuem contexto com o objetivo para o qual programamos, ele sempre tenta puxar o usuário de volta para o tópico central.

Isso é super importante pois torna o modelo de fato estável para ser utilizado em aplicações empresariais diversas e não causar problemas.

Comunicação com os sistemas e APIs internas

E para comunicar os resultados do pedido nós criamos através do seguinte código um resumo em .json que pode ser computado e enviado para o sistema de pedidos.

Nesse caso estamos usando uma temperatura mais baixa =”0″ para tornar o sistemas mais “previsível” tratando-se de uma comunicação direta com o usuário para evitar erros de entendimento ou comunicação que poder complicar o processo com os clientes.

messages =  context.copy()
messages.append(
{'role':'system', 'content':'create a json summary of the previous food order. Itemize the price for each item\
 The fields should be 1) pizza, include size 2) list of toppings 3) list of drinks, include size   4) list of sides include size  5)total price '},    
)
 #The fields should be 1) pizza, price 2) list of toppings 3) list of drinks, include size include price  4) list of sides include size include price, 5)total price '},    

response = get_completion_from_messages(messages, temperature=0)
print(response)

O resultado final é um .json estruturado e criado pelo próprio poder do chatgpt:

Um dos maiores poderes do chatgpt é a capacidade de interpretar, escrever e gerar códigos em diversas linguagens de programação. Nesse caso o output pode ser gerado em diversos formatos como csv, json, xml etc.. dependendo de cada contexto.

Deixando o modelo mais robusto

Uma dica é que para criar um sistema mais robusto podemos utilizar a biblioteca langchain que permite manipular banco de dados e fazer com que o chatgpt aprenda com seus dados e não extrapole as respostas para temas, contextos ou produtos externos de outras empresas que poderiam gerar ruído na sua conversação.

LangChain é um framework para desenvolvimento de aplicativos alimentados por modelos de linguagem. Acreditamos que os aplicativos mais poderosos e diferenciados não apenas utilizarão um modelo de linguagem, mas também serão:

• Conscientes dos dados: conectar um modelo de linguagem a outras fontes de dados
• Agentes: permitir que um modelo de linguagem interaja com seu ambiente

O framework LangChain é projetado com base nesses princípios.

Referências e recomendações de leitura:

• https://writings.stephenwolfram.com/2023/02/what-is-chatgpt-doing-and-why-does-it-work/
• https://community.openai.com/t/cheat-sheet-mastering-temperature-and-top-p-in-chatgpt-api-a-few-tips-and-tricks-on-controlling-the-creativity-deterministic-output-of-prompt-responses/172683
• https://www.deeplearning.ai
• Projeto de serviço de consultas médicas: https://www.linkedin.com/in/isaacsilva98/
• https://python.langchain.com/en/latest/index.html
• https://www.datascienceacademy.com.br/

O post Criando um chatbot automatizado para retirada de pedidos com API do Chatgpt 3.5 turbo em Python apareceu primeiro em Data Universe.