import gradio as gr import torch from transformers import pipeline from datetime import datetime import nltk from nltk.tokenize import word_tokenize from nltk.corpus import stopwords from collections import Counter import logging from typing import Dict, List, Tuple, Optional class GeradorTrilhaAprendizado: def __init__(self): try: self.device = "cuda" if torch.cuda.is_available() else "cpu" self.transcriber = pipeline("automatic-speech-recognition", model="openai/whisper-base", device=self.device) self.generator = pipeline("text-generation", model="gpt2-large", device=self.device) self.historico: List[Dict] = [] for resource in ['punkt', 'stopwords']: try: nltk.data.find(f'tokenizers/{resource}') except LookupError: nltk.download(resource) self.stop_words = set(stopwords.words('portuguese')) except Exception as e: logging.error(f"Initialization error: {str(e)}") raise def processar_audio(self, audio_path: Optional[str], nome_trilha: str, nivel: str = "intermediário", area: str = "geral", duracao: str = "3 meses", incluir_recursos: bool = True) -> Tuple[str, str, str, str]: if not audio_path: return ("", "", self._formatar_historico(), "❌ Nenhum áudio fornecido") try: transcricao = self.transcriber(audio_path)["text"] if not transcricao.strip(): return ("", "", self._formatar_historico(), "❌ Nenhum texto detectado no áudio") analise = self._gerar_trilha_personalizada(transcricao, nivel, area, duracao) if incluir_recursos: recursos = self._gerar_recursos(nivel, area, transcricao) analise += "\n\n" + recursos self.historico.append({ "data": datetime.now().strftime("%d/%m/%Y %H:%M"), "nome": nome_trilha.strip(), "nivel": nivel, "area": area, "duracao": duracao, "transcricao": transcricao, "analise": analise }) return (transcricao, analise, self._formatar_historico(), "✅ Trilha gerada com sucesso!") except Exception as e: logging.error(f"Processing error: {str(e)}") return ("", "", self._formatar_historico(), f"❌ Erro: {str(e)}") # Core change needed in _gerar_trilha_personalizada method: def _gerar_trilha_personalizada(self, transcricao: str, nivel: str, area: str, duracao: str) -> str: try: palavras_chave = self._extrair_palavras_chave(transcricao) modulos = self._get_modulos_por_area(area, nivel) duracao_meses = int(duracao.split()[0]) tempo_por_modulo = duracao_meses / len(modulos) # Generate customized content using the model prompt = f""" Gere uma trilha de aprendizado para a área de {area} (nível {nivel}), duração de {duracao}. Objetivos do usuário: {transcricao} Palavras-chave identificadas: {', '.join(palavras_chave)} """ generated_content = self.generator( prompt, max_length=500, num_return_sequences=1, temperature=0.7 )[0]['generated_text'] # Combine generated content with structured data return f""" 🎯 Objetivos Identificados: {self._formatar_objetivos(palavras_chave, area)} 📚 Trilha Personalizada para {area.title()} - Nível {nivel}: {generated_content} {self._formatar_modulos(modulos, tempo_por_modulo)} 🚀 Projetos Práticos Sugeridos: {self._gerar_projetos(area, nivel)} 📅 Cronograma ({duracao}): {self._gerar_cronograma(duracao_meses, modulos)} 🎖️ Marcos de Avaliação: {self._gerar_marcos_avaliacao(nivel)} """ except Exception as e: logging.error(f"Error generating learning path: {str(e)}") return "Erro ao gerar trilha de aprendizado" def _extrair_palavras_chave(self, texto: str) -> List[str]: try: tokens = word_tokenize(texto.lower()) palavras = [palavra for palavra in tokens if palavra.isalnum() and len(palavra) > 2 and palavra not in self.stop_words] return [palavra[0] for palavra in Counter(palavras).most_common(5)] except Exception as e: logging.error(f"Keyword extraction error: {str(e)}") return ["erro ao extrair palavras-chave"] def _get_modulos_por_area(self, area: str, nivel: str) -> List[str]: modulos = { "programação": { "iniciante": [ "Lógica de Programação Básica", "Introdução a Algoritmos", "Fundamentos de HTML/CSS", "JavaScript Básico" ], "intermediário": [ "Estruturas de Dados", "Programação Orientada a Objetos", "Frameworks Front-end", "Banco de Dados" ], "avançado": [ "Arquitetura de Software", "DevOps e CI/CD", "Microsserviços", "Segurança e Performance" ] }, "data science": { "iniciante": [ "Estatística Básica", "Python para Análise de Dados", "SQL Fundamental", "Visualização de Dados" ], "intermediário": [ "Machine Learning Básico", "Deep Learning Fundamentos", "Big Data Analytics", "Feature Engineering" ], "avançado": [ "MLOps", "Análise Avançada", "IA Generativa", "Pesquisa Aplicada" ] }, "design": { "iniciante": [ "Teoria das Cores", "Tipografia", "UI Básica", "Ferramentas de Design" ], "intermediário": [ "Design Systems", "UX Research", "Prototipagem", "Design Visual" ], "avançado": [ "Design Leadership", "Design Estratégico", "Design para Produto", "Design Thinking Avançado" ] } } if area not in modulos: return [ "Fundamentos da Área", "Conceitos Intermediários", "Práticas Avançadas", "Especialização" ] return modulos[area].get(nivel, modulos[area]["intermediário"]) def _formatar_objetivos(self, palavras_chave: List[str], area: str) -> str: objetivos = { "programação": [ "Desenvolver habilidades técnicas em {}", "Criar projetos práticos usando {}", "Dominar conceitos de {}" ], "data science": [ "Analisar dados usando {}", "Construir modelos de {}", "Implementar soluções com {}" ], "design": [ "Criar interfaces usando {}", "Desenvolver projetos de {}", "Aplicar princípios de {}" ] } templates = objetivos.get(area, objetivos["programação"]) return "\n".join( f"• {template.format(palavra)}" for palavra, template in zip(palavras_chave[:3], templates) ) def _formatar_modulos(self, modulos: List[str], tempo: float) -> str: return "\n".join( f"Módulo {i+1}: {modulo} ({tempo:.1f} meses)" for i, modulo in enumerate(modulos) ) def _gerar_projetos(self, area: str, nivel: str) -> str: projetos = { "iniciante": [ "Projeto Tutorial Guiado", "Mini-Projeto Prático", "Exercícios Fundamentais" ], "intermediário": [ "Projeto Individual", "Projeto em Equipe", "Case Study Prático" ], "avançado": [ "Projeto Complexo", "Contribuição Open Source", "Projeto de Pesquisa" ] } return "\n".join(f"• {projeto}" for projeto in projetos.get(nivel, projetos["intermediário"])) def _gerar_cronograma(self, duracao: int, modulos: List[str]) -> str: meses_por_modulo = duracao / len(modulos) return "\n".join( f"Mês {i*meses_por_modulo+1:.1f}-{(i+1)*meses_por_modulo:.1f}: {modulo}" for i, modulo in enumerate(modulos) ) def _gerar_marcos_avaliacao(self, nivel: str) -> str: marcos = { "iniciante": [ "Quiz de Conceitos Básicos", "Exercícios Práticos", "Projeto Final Básico" ], "intermediário": [ "Avaliação Técnica", "Projeto Individual", "Apresentação de Resultados" ], "avançado": [ "Defesa de Projeto", "Contribuição Técnica", "Artigo/Publicação" ] } return "\n".join(f"• {marco}" for marco in marcos.get(nivel, marcos["intermediário"])) def _gerar_recursos(self, nivel: str, area: str, objetivo: str) -> str: recursos = { "iniciante": { "cursos": ["Fundamentos Básicos", "Introdução Prática"], "livros": ["Guia do Iniciante", "Primeiros Passos"], "projetos": ["Projeto inicial guiado", "Mini-projetos práticos"] }, "intermediário": { "cursos": ["Especialização Prática", "Técnicas Avançadas"], "livros": ["Guia Completo", "Estudos de Caso"], "projetos": ["Projetos médios", "Desafios práticos"] }, "avançado": { "cursos": ["Masterclass", "Especialização Pro"], "livros": ["Técnicas Avançadas", "Estado da Arte"], "projetos": ["Projetos complexos", "Open-source"] } } r = recursos.get(nivel, recursos["intermediário"]) return f""" 📚 Recursos Recomendados: 1. Cursos: - {r['cursos'][0]} - {r['cursos'][1]} 2. Material: - {r['livros'][0]} - {r['livros'][1]} 3. Projetos: - {r['projetos'][0]} - {r['projetos'][1]} 4. Extras: - Comunidades de prática - Mentoria entre pares - Workshops práticos - Avaliações periódicas """ def _formatar_historico(self) -> str: if not self.historico: return "Nenhuma trilha gerada ainda" return "📋 Histórico de Trilhas:\n\n" + "\n".join( f"• {h['data']} - {h['nome']} ({h['nivel']}, {h['area']})" for h in self.historico[-5:] ) def criar_interface() -> gr.Blocks: with gr.Blocks(theme=gr.themes.Soft()) as app: gr.Markdown(""" # 🎓 Gerador de Trilha de Aprendizado Grave ou faça upload de um áudio descrevendo seus objetivos e receba uma trilha personalizada! """) with gr.Row(): with gr.Column(): audio_input = gr.Audio( type="filepath", label="Áudio", sources=["microphone", "upload"] ) nome_trilha = gr.Textbox( label="Nome da Trilha", placeholder="Dê um nome para sua trilha", value="" ) nivel = gr.Dropdown( choices=["iniciante", "intermediário", "avançado"], value="intermediário", label="Nível de Dificuldade" ) area = gr.Dropdown( choices=["programação", "data science", "design", "marketing", "negócios", "geral"], value="geral", label="Área de Conhecimento" ) duracao = gr.Dropdown( choices=["1 mês", "3 meses", "6 meses", "1 ano"], value="3 meses", label="Duração Estimada" ) incluir_recursos = gr.Checkbox( label="Incluir Recursos Recomendados", value=True ) processar_btn = gr.Button("🚀 Gerar Trilha de Aprendizado") with gr.Row(): with gr.Column(): status = gr.Markdown() transcricao = gr.Textbox(label="Transcrição do Áudio", lines=4) analise = gr.Textbox(label="Sua Trilha de Aprendizado", lines=10) historico = gr.Markdown() with gr.Accordion("ℹ️ Como usar"): gr.Markdown(""" 1. Grave um áudio descrevendo seus objetivos de aprendizado 2. Escolha o nome da trilha, nível, área e duração 3. Clique em 'Gerar Trilha de Aprendizado' 4. Revise a transcrição e a trilha gerada 5. O histórico mostra suas últimas 5 trilhas geradas """) gerador = GeradorTrilhaAprendizado() processar_btn.click( fn=gerador.processar_audio, inputs=[audio_input, nome_trilha, nivel, area, duracao, incluir_recursos], outputs=[transcricao, analise, historico, status] ) return app if __name__ == "__main__": logging.basicConfig(level=logging.INFO) app = criar_interface() app.queue() app.launch()