Solucionado (ver solução)

Importante

Você está vendo a versão anterior da nova experiência da Alura que estamos preparando para você. Em breve, ela ganha uma identidade visual novinha totalmente pensada em potencializar seus estudos!

Solucionado
(ver solução)
1
resposta

Faça como eu fiz: construindo um sistema inteligente de recomendação | Fundamentos de IA: explorando a estrutura e abordagens de sistemas inteligentes

import heapq
from typing import List, Tuple

class Produto:
    def __init__(self, id: int, nome: str, prob_conversao: float):
        self.id = id
        self.nome = nome
        self.prob = prob_conversao
    def __repr__(self):
        return f"{self.nome}({self.prob:.0%})"

class AStarRecommendation:
    def __init__(self, produtos: List[Produto]):
        self.p = {p.id: p for p in produtos}
    
    def encontrar_caminho(self, origem: int, objetivo: int) -> Tuple[List[int], float]:
        aberto = [(0, 0, origem, [origem], 0)]
        visitados = set()
        g = {origem: 0}
        
        while aberto:
            _, _, atual, cam, custo_g = heapq.heappop(aberto)
            
            if atual == objetivo:
                return cam, custo_g
            
            if atual in visitados:
                continue
            visitados.add(atual)
            
            for prox in self.p:
                if prox not in visitados:
                    novo_custo = custo_g + (1 - self.p[prox].prob)
                    if prox not in g or novo_custo < g[prox]:
                        g[prox] = novo_custo
                        h = 1 - self.p[objetivo].prob
                        f = novo_custo + h
                        heapq.heappush(aberto, (f, len(cam), prox, cam + [prox], novo_custo))
        
        return [], float('inf')
    
    def recomendar(self, origem: int, objetivo: int) -> dict:
        cam, custo = self.encontrar_caminho(origem, objetivo)
        if not cam:
            return {"sucesso": False}
        
        seq = [self.p[pid] for pid in cam]
        prob_acum = 1
        for p in seq:
            prob_acum *= p.prob
        
        return {
            "sucesso": True,
            "caminho": [p.nome for p in seq],
            "passos": len(cam) - 1,
            "custo": round(custo, 3),
            "conversao": round(prob_acum, 3)
        }

# Teste
produtos = [
    Produto(1, "Notebook", 0.85),
    Produto(2, "Mouse", 0.92),
    Produto(3, "Teclado", 0.88),
    Produto(4, "Monitor", 0.80),
    Produto(5, "Webcam", 0.75),
]

print("=" * 50)
print("SISTEMA A* - RECOMENDAÇÃO DE PRODUTOS")
print("=" * 50)
print(f"\n Produtos: {produtos}\n")

sistema = AStarRecommendation(produtos)

testes = [(1, 2), (1, 3), (5, 2)]

for orig, obj in testes:
    res = sistema.recomendar(orig, obj)
    print(f" {sistema.p[orig].nome} → {sistema.p[obj].nome}")
    if res["sucesso"]:
        print(f"   Caminho: {' → '.join(res['caminho'])}")
        print(f"   Passos: {res['passos']} | Custo: {res['custo']} | Conversão: {res['conversao']:.1%}\n")
    else:
        print("   Sem caminho\n")

::

RESULTADO:

==================================================
SISTEMA A* - RECOMENDAÇÃO DE PRODUTOS

Produtos: [Notebook(85%), Mouse(92%), Teclado(88%), Monitor(80%), Webcam(75%)]

Notebook → Mouse
Caminho: Notebook → Mouse
Passos: 1 | Custo: 0.08 | Conversão: 78.2%

Notebook → Teclado
Caminho: Notebook → Teclado
Passos: 1 | Custo: 0.12 | Conversão: 74.8%

Webcam → Mouse
Caminho: Webcam → Mouse
Passos: 1 | Custo: 0.08 | Conversão: 69.0%

1 resposta
solução!

Oi, Estudante! Como vai?

Agradeço por compartilhar suas reflexões e aprendizados com a comunidade Alura.

Parabéns pela sua implementação do sistema inteligente de recomendação, principalmente ao aplicar o algoritmo A* para resolver um problema de busca em grafos e relacioná-lo com probabilidade de conversão. Do jeito que você explicou, fica claro que você conseguiu estruturar bem a lógica do sistema de recomendação, entendendo como o custo acumulado influencia diretamente na escolha do caminho e na definição da melhor rota dentro do grafo.

Além disso, é interessante observar como você utilizou a ideia de conversão para dar mais sentido prático ao algoritmo, aproximando o modelo de um cenário real de recomendação. Esse tipo de raciocínio mostra evolução na forma de conectar teoria e aplicação, o que é essencial em inteligência artificial.

Sua ideia faz sentido e está bem estruturada. Continue explorando como ajustes no modelo podem melhorar ainda mais o desempenho do sistema inteligente de recomendação, especialmente ao testar diferentes formas de heurística e pesos de custo.

Conte com o apoio do Fórum na sua jornada. Abraços e bons estudos!

De forma geral, como você acha que a escolha da função de custo pode impactar outros tipos de problemas além de sistemas de recomendação?

Alura Conte com o apoio da comunidade Alura na sua jornada. Abraços e bons estudos!