Spaces:
Sleeping
Sleeping
| 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 | |
| class GeradorTrilhaAprendizado: | |
| def __init__(self): | |
| self.device = 0 if torch.cuda.is_available() else -1 | |
| 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 = [] | |
| # Inicializa NLTK | |
| nltk.download('punkt') | |
| nltk.download('stopwords') | |
| self.stop_words = set(stopwords.words('portuguese')) | |
| def processar_audio(self, | |
| audio_path: str, | |
| nome_trilha: str, | |
| nivel: str = "intermediário", | |
| area: str = "geral", | |
| duracao: str = "3 meses", | |
| incluir_recursos: bool = True) -> tuple: | |
| try: | |
| transcricao = self.transcriber(audio_path)["text"] | |
| 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, | |
| "nivel": nivel, | |
| "area": area, | |
| "duracao": duracao, | |
| "transcricao": transcricao, | |
| "analise": analise | |
| }) | |
| return ( | |
| transcricao, | |
| analise, | |
| self._formatar_historico(), | |
| "✅ Trilha gerada com sucesso!" | |
| ) | |
| except Exception as e: | |
| return ( | |
| f"Erro: {str(e)}", | |
| "Não foi possível gerar a análise.", | |
| self._formatar_historico(), | |
| "❌ Ocorreu um erro" | |
| ) | |
| def _gerar_trilha_personalizada(self, transcricao: str, nivel: str, area: str, duracao: str) -> str: | |
| palavras_chave = self._extrair_palavras_chave(transcricao) | |
| modulos_por_area = { | |
| "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" | |
| ] | |
| } | |
| } | |
| # Usa módulos padrão se a área não estiver mapeada | |
| if area not in modulos_por_area: | |
| modulos_por_area[area] = { | |
| "iniciante": [ | |
| "Fundamentos Básicos", | |
| "Introdução à Área", | |
| "Ferramentas Essenciais", | |
| "Práticas Iniciais" | |
| ], | |
| "intermediário": [ | |
| "Conceitos Avançados", | |
| "Técnicas Especializadas", | |
| "Projetos Práticos", | |
| "Metodologias" | |
| ], | |
| "avançado": [ | |
| "Especialização Profissional", | |
| "Gestão de Projetos", | |
| "Inovação na Área", | |
| "Liderança Técnica" | |
| ] | |
| } | |
| duracao_meses = int(duracao.split()[0]) | |
| tempo_por_modulo = duracao_meses / 4 | |
| template = f""" | |
| 🎯 Objetivos Identificados: | |
| {self._formatar_objetivos(palavras_chave)} | |
| 📚 Trilha Personalizada para {area.title()} - Nível {nivel}: | |
| {self._formatar_modulos(modulos_por_area[area][nivel], tempo_por_modulo)} | |
| 🚀 Projetos Práticos Sugeridos: | |
| {self._gerar_projetos(area, nivel, palavras_chave)} | |
| 📅 Cronograma ({duracao}): | |
| {self._gerar_cronograma(duracao_meses, modulos_por_area[area][nivel])} | |
| 🎖️ Marcos de Avaliação: | |
| {self._gerar_marcos_avaliacao(nivel)} | |
| """ | |
| return template | |
| def _extrair_palavras_chave(self, texto: str) -> list: | |
| tokens = word_tokenize(texto.lower()) | |
| palavras = [palavra for palavra in tokens | |
| if palavra.isalnum() and | |
| palavra not in self.stop_words] | |
| return [palavra[0] for palavra in Counter(palavras).most_common(5)] | |
| def _formatar_objetivos(self, palavras_chave: list) -> 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 {}" | |
| ] | |
| } | |
| return "\n".join([ | |
| f"• {objetivo.format(palavra)}" | |
| for palavra, objetivo in zip(palavras_chave, objetivos.get("geral", objetivos["programação"])) | |
| ]) | |
| def _formatar_modulos(self, modulos: list, 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, palavras_chave: list) -> 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[nivel] | |
| ]) | |
| def _gerar_cronograma(self, duracao: int, modulos: list) -> str: | |
| meses_por_modulo = duracao / len(modulos) | |
| cronograma = [] | |
| for i, modulo in enumerate(modulos): | |
| inicio = i * meses_por_modulo + 1 | |
| fim = (i + 1) * meses_por_modulo | |
| cronograma.append( | |
| f"Mês {inicio:.1f}-{fim:.1f}: {modulo}" | |
| ) | |
| return "\n".join(cronograma) | |
| 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[nivel] | |
| ]) | |
| def _formatar_historico(self) -> str: | |
| if not self.historico: | |
| return "Nenhuma trilha gerada ainda" | |
| historico_fmt = "📋 Histórico de Trilhas:\n\n" | |
| for h in self.historico[-5:]: | |
| historico_fmt += f"• {h['data']} - {h['nome']} ({h['nivel']}, {h['area']})\n" | |
| return historico_fmt | |
| def _gerar_recursos(self, nivel: str, area: str, objetivo: str) -> str: | |
| recursos_por_nivel = { | |
| "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 de média complexidade", "Desafios práticos"] | |
| }, | |
| "avançado": { | |
| "cursos": ["Masterclass Avançada", "Especialização Profissional"], | |
| "livros": ["Técnicas Avançadas", "Estado da Arte"], | |
| "projetos": ["Projetos complexos", "Contribuições open-source"] | |
| } | |
| } | |
| recursos = recursos_por_nivel[nivel] | |
| return f""" | |
| 📚 Recursos Recomendados para {area} - Nível {nivel}: | |
| 1. Cursos Recomendados: | |
| - {recursos['cursos'][0]} | |
| - {recursos['cursos'][1]} | |
| 2. Material de Estudo: | |
| - {recursos['livros'][0]} | |
| - {recursos['livros'][1]} | |
| 3. Projetos Práticos: | |
| - {recursos['projetos'][0]} | |
| - {recursos['projetos'][1]} | |
| 4. Recursos Adicionais: | |
| - Comunidades de prática | |
| - Mentoria entre pares | |
| - Workshops práticos | |
| - Avaliações periódicas | |
| """ | |
| def criar_interface(): | |
| 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" | |
| ) | |
| 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(label="Histórico") | |
| 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 | |
| """) | |
| processar_btn.click( | |
| fn=GeradorTrilhaAprendizado().processar_audio, | |
| inputs=[audio_input, nome_trilha, nivel, area, duracao, incluir_recursos], | |
| outputs=[transcricao, analise, historico, status] | |
| ) | |
| return app | |
| if __name__ == "__main__": | |
| app = criar_interface() | |
| app.queue() | |
| app.launch() |