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!

1
resposta

[Sugestão] (Fundamentos de IA: explorando a estrutura e abordagens de sistemas inteligentes) Faça como eu fiz: construindo um sistema inteligente de recomendação

import heapq

class Curso:
    def __init__(self, id_curso, nome, conversao):
        self.id = id_curso
        self.nome = nome
        self.conversao = conversao

    # Método necessário para o heapq comparar objetos caso haja empate nos custos
    def __lt__(self, outro):
        return self.conversao > outro.conversao

class RecomendacaoTrilha:
    def __init__(self, conexoes):
        # Aqui o grafo não é totalmente conectado. Recebemos as conexões lógicas prontas.
        self.grafo = conexoes 

    def heuristica(self, curso):
        # Multiplicamos por -1 pois o heapq do Python retorna o menor valor por padrão
        return -curso.conversao

    def a_star(self, inicio, objetivo):
        fila = []
        # Tupla: (Custo Total f, Custo Real g, Nó Atual)
        heapq.heappush(fila, (0 + self.heuristica(inicio), 0, inicio))
        caminhos = {}
        custo_acumulado = {inicio: 0}

        while fila:
            _, g, atual = heapq.heappop(fila)

            if atual == objetivo:
                break

            for vizinho in self.grafo.get(atual, []):
                novo_custo_g = g + 1
                
                # Se achamos um caminho mais curto para o vizinho, atualizamos
                if vizinho not in custo_acumulado or novo_custo_g < custo_acumulado[vizinho]:
                    custo_acumulado[vizinho] = novo_custo_g
                    f = novo_custo_g + self.heuristica(vizinho)
                    heapq.heappush(fila, (f, novo_custo_g, vizinho))
                    caminhos[vizinho] = atual

        return self._reconstruir_caminho(caminhos, inicio, objetivo)

    def _reconstruir_caminho(self, caminhos, inicio, objetivo):
        atual = objetivo
        trilha = [atual]
        while atual in caminhos:
            atual = caminhos[atual]
            trilha.append(atual)
        trilha.reverse()
        return trilha

# Criando os produtos focados em infraestrutura e segurança
c1 = Curso("C1", "Introdução ao Ubuntu", 0.9)
c2 = Curso("C2", "Configuração do WSL2", 0.8)
c3 = Curso("C3", "Automação com Shell Script", 0.7)
c4 = Curso("C4", "Criptografia com OpenSSL", 0.6)
c5 = Curso("C5", "Fundamentos de Cibersegurança", 0.85)

# Definindo conexões lógicas (Afinidade de conteúdo)
conexoes = {
    c1: [c2, c3],
    c2: [c3, c4],
    c3: [c5],
    c5: [c4]
}

sistema = RecomendacaoTrilha(conexoes)
resultado = sistema.a_star(c1, c4)

print("--- Abordagem 1 ---")
for curso in resultado:
    print(curso.nome)
1 resposta

Oi, Carlos Magno! Tudo bem?

Muito legal ver você desenvolvendo seu proprio sistema inteligente de recomendação!

Fiquei impressionada com a sua implementação do algoritmo A* para conectar os cursos de infraestrutura e segurança. Organizar o grafo com base na conversão e usar a fila de prioridades foi uma excelente escolha estrutural. Uma dica interessante para o futuro e usar o método setdefault para otimizar a inicialização de listas ou dicionários de conexões no grafo de forma limpa. Veja este exemplo:


grafo = {}
grafo.setdefault('curso_base', []).append('proximo_curso')
print(grafo)

Esse metodo adiciona a chave com o valor padrão apenas se ela nao existir. Como voce planeja adaptar essa heurística se o volume de dados de interação dos alunos aumentar?

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