1
resposta

Passo 1 — Definir os produtos

Vamos criar uma classe Produto com os atributos: nome, categoria e probabilidade_de_conversao.

class Produto:
def init(self, nome, categoria, probabilidade_de_conversao):
self.nome = nome
self.categoria = categoria
self.probabilidade = probabilidade_de_conversao

def __repr__(self):
    return f"{self.nome} ({self.categoria}, {self.probabilidade})"

Passo 2 — Criar o sistema de recomendação

Para simplificar, cada produto está conectado a todos os outros.
O AStarRecommendation vai armazenar os produtos e calcular o "melhor caminho" usando A*.

import heapq

class AStarRecommendation:
def init(self):
self.produtos = []

def adicionar_produto(self, produto):
    self.produtos.append(produto)

# Heurística: quanto maior a probabilidade, melhor
def heuristica(self, produto):
    # Negativo porque o A* geralmente minimiza custo, então transformamos
    # probabilidade em "custo" invertido
    return -produto.probabilidade

# Algoritmo A*
def encontrar_melhor_caminho(self, inicio, objetivo):
    # Fila de prioridade: (custo estimado total, custo até aqui, produto, caminho)
    fila = [(self.heuristica(inicio), 0, inicio, [inicio])]
    visitados = set()

    while fila:
        custo_total, custo_atual, produto_atual, caminho = heapq.heappop(fila)

        if produto_atual == objetivo:
            return caminho

        if produto_atual in visitados:
            continue
        visitados.add(produto_atual)

        # Conecta com todos os outros produtos
        for proximo in self.produtos:
            if proximo not in visitados:
                custo = custo_atual + 1  # Cada ligação tem "custo 1"
                estimativa = custo + self.heuristica(proximo)
                heapq.heappush(fila, (estimativa, custo, proximo, caminho + [proximo]))

    return None  # Caso não ache caminho

Passo 3 — Testar o sistema

Agora vamos criar alguns produtos e encontrar o melhor caminho entre eles:

Criar produtos

p1 = Produto("Notebook", "Eletrônicos", 0.7)
p2 = Produto("Mouse", "Eletrônicos", 0.5)
p3 = Produto("Teclado", "Eletrônicos", 0.6)
p4 = Produto("Cadeira Gamer", "Móveis", 0.4)
p5 = Produto("Monitor", "Eletrônicos", 0.8)

Criar recomendador e adicionar produtos

recomendador = AStarRecommendation()
for p in [p1, p2, p3, p4, p5]:
recomendador.adicionar_produto(p)

Encontrar melhor caminho de Notebook até Monitor

caminho = recomendador.encontrar_melhor_caminho(p1, p5)
print("Melhor caminho encontrado:")
for produto in caminho:
print(produto)

Explicação rápida
Cada produto é um nó do grafo.
Todos os produtos estão conectados entre si (grafo completo).
A heurística usa a probabilidade de conversão: maior probabilidade = melhor caminho.
O A* encontra o caminho que maximiza a probabilidade de conversão entre dois produtos, tratando o negativo como "custo mínimo".

1 resposta

Olá, Ronaldo. Como vai?

Sensacional a sua implementação! Você conseguiu transpor um conceito clássico de busca em grafos, o algoritmo A*, para um cenário moderno e prático de sistemas de recomendação.

Sua abordagem merece destaque por alguns pontos técnicos muito bem executados:

  • Modelagem do Problema: Ao tratar cada produto como um nó em um grafo completo, você garante que o sistema possa explorar qualquer combinação de sugestões.
  • Inversão da Heurística: O uso do valor negativo da probabilidade (-produto.probabilidade) é uma sacada de mestre. Como o A* é projetado para minimizar custos, essa inversão faz com que ele busque, na verdade, a maximização da conversão.
  • **Uso de heapq**: A implementação utilizando uma fila de prioridade garante que o algoritmo seja eficiente, sempre expandindo o nó que parece mais promissor primeiro.

Para complementar seu projeto, uma sugestão interessante seria adicionar um peso nas arestas baseado na afinidade entre categorias. Por exemplo, o "custo" de ir de um Notebook para um Mouse (mesma categoria) poderia ser menor do que para uma Cadeira Gamer, tornando a recomendação ainda mais inteligente e contextual.

Espero que possa ter lhe ajudado!