Published

17/07/2026

Modified

17/07/2026

Plano de Aulas Práticas Detalhado - Inteligência Artificial II

Carga Horária: 30 encontros (2 aulas por semana)
Abordagem: Construtiva e Baseada em Projetos (PBL). A cada semana, os alunos codificam um módulo que servirá de alicerce para o próximo. Ao invés de práticas isoladas, eles construirão produtos robustos e aplicáveis no mercado.
Validação (CI/CD): Todos os laboratórios seguirão a premissa de correção via CI/CD no GitLab. Os códigos submetidos via push serão automaticamente testados por pipelines (Pytest ou JUnit no caso do Java) que validam a lógica e a completude do laboratório do dia.

Para visualizar o detalhamento de cada encontro, clique nas abas correspondentes a cada Arco Temático abaixo e expanda as aulas desejadas:

Arco 1: Redes Neurais (Aulas 1 a 8)

Neste arco, vamos desmistificar o que é uma IA. Os alunos sairão com seu primeiro classificador treinado (Trabalho Prático 1).

  • Tópicos Abordados: Perceptron, soma ponderada, pesos sinápticos, matrizes via NumPy, versionamento de código (Git), GitLab.
  • Foco da Aula: A “mágica” da Inteligência Artificial se resume, no fundo, a matemática básica (multiplicação de matrizes) e busca de padrões. É fundamental frisar a importância da cultura Git (DevOps) no mercado de trabalho desde o primeiro momento.
  • Mini-Teoria (20m): O que é um perceptron. Apresentação do ambiente de trabalho (GitLab).
  • Prática (80m): Criação dos usuários no GitLab self-hosted da disciplina e o primeiro commit. Sem bibliotecas de IA! Usar apenas Python e NumPy para programar do zero um perceptron, gerar números aleatórios para os pesos e multiplicar por uma matriz de dados.
  • Entregável / Validação: Repositório inicializado no GitLab com o script de Perceptron “commitado”. A pipeline (CI) validará se o script imprime um array numérico corretamente.
  • Tópicos Abordados: Multilayer Perceptron (MLP), camadas ocultas (Hidden Layers), Funções de Ativação (ReLU, Sigmoid), Forward Propagation.
  • Foco da Aula: O poder de encadear neurônios. Explicar como a matemática linear ganha superpoderes com as funções de ativação, permitindo resolver problemas não lineares.
  • Mini-Teoria (20m): Juntando vários neurônios em camadas e introdução ao ReLU.
  • Prática (80m): Encadeando matrizes NumPy da Aula 1 para formar um MLP rudimentar e passando dados por ela.
  • Entregável / Validação: Script atualizado encapsulando as camadas e aplicando a ativação ReLU, retornando as predições de uma “camada de saída”.
  • Tópicos Abordados: Perceptron de Múltiplas Camadas, função de erro, gradiente, otimizadores e backpropagation.
  • Foco da Aula: O conceito da descida do gradiente: dar passos guiados pelo erro para encontrar o vale (mínimo global). Explicar os riscos de uma taxa de aprendizado muito alta (divergência) ou muito baixa (lentidão).
  • Mini-Teoria (30m): O que significa minimizar o erro e a intuição do gradiente sem cálculos complexos.
  • Prática (70m): Plotar com Matplotlib uma “superfície” de erro e construir um laço de repetição (for) fazendo a perda diminuir aos poucos iterativamente.
  • Entregável / Validação: Script com laço de epochs, gerando e salvando no repositório um gráfico mostrando a curva de perda decaindo ao longo do tempo.
  • Tópicos Abordados: Frameworks de Deep Learning (Keras, PyTorch), abstração, tensores e classificação binária/multiclasse.
  • Foco da Aula: Mostrar como o código exaustivo feito à mão vira 5 elegantes linhas de código utilizando frameworks de mercado consolidados.
  • Mini-Teoria (20m): Introdução aos frameworks e grafos computacionais.
  • Prática (80m): Substituir as matrizes NumPy por instâncias do Keras (TensorFlow) ou PyTorch. Treinar um classificador clássico num dataset de mundo real (ex: CSV de churn de clientes ou diagnóstico clínico).
  • Entregável / Validação: Código com Keras/PyTorch processando um CSV. CI validará se a acurácia no treino alcança um baseline mínimo esperado.
  • Tópicos Abordados: Generalização vs. Memorização, Overfitting, Underfitting, particionamento de dados (Train, Test, Validation).
  • Foco da Aula: IA não pode “decorar” o gabarito. Enfatizar duramente a diferença entre loss (treino) e val_loss (validação) e como interpretar gráficos de treino.
  • Mini-Teoria (30m): Divisão de dados e os perigos de avaliar um modelo em dados conhecidos.
  • Prática (70m): Os alunos provocam Overfitting proposital esticando o treinamento da aula passada num modelo com parâmetros excessivos.
  • Entregável / Validação: Gráfico exportado mostrando as linhas de treino e validação se distanciando (momento em que o modelo começa a decorar e a validação piora).
  • Tópicos Abordados: Técnicas de Regularização (Dropout, penalidades L1/L2), Early Stopping, Otimizadores modernos (Adam, RMSprop).
  • Foco da Aula: O uso prático de Callbacks para interromper o treinamento antes do desperdício de GPU e o apagão de neurônios (Dropout) para evitar redundâncias.
  • Mini-Teoria (20m): O que faz o Dropout e o Early Stopping.
  • Prática (80m): Consertar o Overfitting da Aula 5 implementando Dropout nas camadas e interrompendo o ciclo via Early Stopping.
  • Entregável / Validação: O modelo consertado, salvo e commitado. Pipeline executa o modelo e verifica estabilidade da perda na validação.
  • Tópicos Abordados: Imagens como tensores 3D (R, G, B), Convoluções (Filtros), Transfer Learning.
  • Foco da Aula: Não se deve reinventar a roda e queimar dinheiro e tempo treinando o que já existe; focar no reuso de redes pré-treinadas para focar no problema de negócio.
  • Mini-Teoria (30m): O básico de processamento visual por computadores e a intuição de convolução.
  • Prática (70m): Carregar uma rede gigantesca pré-treinada (como ResNet50) pelo Keras e classificar imagens/fotos da turma em tempo real.
  • Entregável / Validação: Script Python realizando predição com rede pré-treinada em uma imagem arbitrária.
  • Tópicos Abordados: Métricas reais de classificação (Acurácia, Precisão, Recall, F1-Score, Matriz de Confusão).
  • Foco da Aula: Desenvolver o pensamento crítico do aluno ao avaliar o próprio modelo. Discutir por que a acurácia falha em datasets desbalanceados.
  • Prática (100m): Laboratório guiado para finalização do Trabalho Prático 1. Os alunos aplicarão os conceitos em um dataset (Kaggle) de escolha livre da dupla.
  • Entregável / Validação: A entrega final do TP1. Repositório deve conter um Jupyter Notebook ou Markdown narrando a exploração e exibindo as métricas finais obtidas de forma clara.

Arco 2: NLP e Vetores (Aulas 9 a 14)

Transição de imagens/tabelas para texto. O objetivo é construir a infraestrutura de dados que um LLM precisará no futuro.

  • Tópicos Abordados: Representação Vetorial de Palavras (Word2Vec), Espaço Latente, Modelagem Semântica, Spacy.
  • Foco da Aula: Máquinas compreendem números e coordenadas, não letras. É preciso visualizar como a semântica de uma palavra ou sentença ganha uma dimensão espacial (“coordenada”).
  • Mini-Teoria (30m): O conceito de transformar vocabulário em matriz dimensional.
  • Prática (70m): Usando a biblioteca Spacy (ou similar) para obter vetores de palavras e provar operações matemáticas visíveis, ex: similaridade entre ‘rei’ e ‘rainha’ vs ‘rei’ e ‘cadeira’.
  • Entregável / Validação: Script que recebe pares de palavras e imprime na tela suas dimensões vetoriais e relações visíveis.
  • Tópicos Abordados: Similaridade de Cosseno (Cosine Similarity), Busca por Distância versus Busca Léxica (Palavra-chave).
  • Foco da Aula: Mostrar que agora buscas não dependem de a palavra exata (Ctrl+F) existir no texto, mas sim de o sentido existir no texto (Ângulo do vetor).
  • Mini-Teoria (20m): O conceito trigonométrico de Distância de Cosseno entre dois vetores hiperdimensionais.
  • Prática (80m): Implementar um script rudimentar em Python: O aluno escreve um parágrafo de entrada e compara manualmente iterando numa lista para extrair o resultado mais semanticamente parecido.
  • Entregável / Validação: Uma função Python pura em que se passa uma string “query” e ele retorna o match Top-1 usando a fórmula do cosseno.
  • Tópicos Abordados: Vector Databases (ChromaDB, FAISS, Milvus), Indexação para performance (Approximate Nearest Neighbors).
  • Foco da Aula: Um laço for comparando cossenos não escala para milhões de documentos corporativos. Precisamos de um banco de dados desenhado especificamente para lidar com vetores.
  • Mini-Teoria (30m): Por que um banco relacional falha na busca semântica, e a arquitetura de um Vector DB.
  • Prática (70m): Subir um ChromaDB local em memória, injetar 1.000 ou 5.000 sentenças e realizar queries semânticas quase instantâneas.
  • Entregável / Validação: Código que instancie um cliente do ChromaDB, crie uma collection e salve documentos. A pipeline verificará se as queries retornam a contagem adequada de resultados.
  • Tópicos Abordados: Ingestão de Dados (ETL em NLP), Chunking (fatiamento de texto), Overlapping (sobreposição).
  • Foco da Aula: A importância da estratégia de fatiar texto. Textos muito curtos quebram o contexto; textos muito longos diluem o sentido e batem no limite do LLM.
  • Prática (100m): Uso da PyPDF2 ou pdfplumber para varrer normativas e PDFs da faculdade, fatiando corretamente seus parágrafos, criando embeddings e os salvando persistentemente no banco ChromaDB.
  • Entregável / Validação: Script “Data Loader” validado via Git. O artefato gerado deve ser a base local persistida (.sqlite3 do Chroma).
  • Tópicos Abordados: Mecanismo de Auto-Atenção (Self-Attention), Arquitetura Transformer (Attention is All You Need).
  • Foco da Aula: O núcleo do porquê o GPT e seus análogos dominam: o modelo não lê palavras em sequência isolada, mas olha transversalmente para o “peso” de cada palavra no contexto atual.
  • Mini-Teoria (40m): Uma jornada intuitiva por Queries, Keys e Values dentro de uma matriz Transformer.
  • Prática (60m): Usar o ambiente Google Colab com a biblioteca BertViz para inspecionar, de forma visual e colorida, como cabeças de atenção enxergam as frases por debaixo dos panos.
  • Entregável / Validação: Submissão do link/exportação do Colab demonstrando o experimento de visualização de conexões (attention maps).
  • Tópicos Abordados: Hub Hugging Face, Pipelines pré-treinadas (Análise de Sentimentos, Sumarização, NER).
  • Foco da Aula: Acessibilidade extrema. O ecossistema Open-Source hoje permite construir aplicações baseadas em Processamento de Linguagem Natural com ridículas “3 linhas de código”, fomentando inovação ágil.
  • Mini-Teoria (20m): Apresentação da plataforma, licenciamentos dos modelos e o funcionamento do SDK Python.
  • Prática (80m): Brincar com a classe pipeline() consumindo pequenos modelos instalados localmente para traduzir ou classificar uma página de jornal.
  • Entregável / Validação: Script de uso rápido de pipeline. A CI pode prover um texto de teste e avaliar se o classificador logou o sentimento esperado.

Arco 3: RAG e Spring AI (Aulas 15 a 22)

Aqui eles unem os módulos do Arco 2 com a geração criativa e montam um Sistema Especialista corporativo (Trabalho Prático 2).

  • Tópicos Abordados: Large Language Models (LLMs) em Nuvem (Gemini, OpenAI, Groq), Tokenização, Cobrança, Requisições HTTP (REST API).
  • Foco da Aula: Evidenciar que rodar o modelo todo no computador local não é factível, e como é simples e escalável utilizar a nuvem mediante uma “chave de acesso” e requisições HTTP seguras.
  • Mini-Teoria (20m): O que são tokens e os provedores modernos. Cuidados de segurança com API Keys.
  • Prática (80m): Usar Python (requests ou lib oficial do Google Generative AI/OpenAI) para mandar perguntas arbitrárias a um modelo de nuvem.
  • Entregável / Validação: Script funcional que carrega as chaves usando .env (boas práticas) e obtém sucesso no retorno da API em nuvem.
  • Tópicos Abordados: Engenharia de Prompt, System Prompts, Modos de Temperatura, Forçamento de formatação (JSON mode), Few-Shot.
  • Foco da Aula: Em software corporativo o LLM não deve se comportar como um bate-papo verboso e amigável; ele precisa cuspir JSON ou dados estruturados, mantendo o tom técnico, servindo apenas como motor de inferência.
  • Mini-Teoria (20m): Como parametrizar o cérebro da rede. A influência da Temperature.
  • Prática (80m): Construir um laço onde os alunos processam e-mails textuais bagunçados e o modelo é forçado a extrair “Nome, Telefone e Reclamação”, tudo ejetado num .json estrito, sem conversinhas extras.
  • Entregável / Validação: Script Python onde o log impresso é obrigatoriamente e puramente um objeto JSON com campos preenchidos extraídos da string de input.
  • Tópicos Abordados: Retrieval-Augmented Generation (RAG), Alucinações, Injeção Dinâmica de Contexto.
  • Foco da Aula: É aqui que a mágica acontece e as alucinações terminam. Mostrar a arquitetura onde a inteligência criativa (LLM) apenas sumariza fatos verídicos fornecidos pontualmente pela base de dados local (VectorDB).
  • Mini-Teoria (20m): O conceito teórico e o fluxo da arquitetura RAG pura.
  • Prática (80m): Script que recebe pergunta do usuário -> Faz a query no banco ChromaDB montado na aula 12 -> Coloca no template do prompt -> Envia ao LLM na nuvem (Gemini).
  • Entregável / Validação: Arquivo unificado RAG. A aplicação deverá responder a uma pergunta técnica obscura (retirada de um PDF local) a qual o LLM nu não teria conhecimento nativo.
  • Tópicos Abordados: Arquitetura de aplicações corporativas, Spring Boot (Java/Kotlin), Spring AI, Microsserviços e Injeção de Dependências.
  • Foco da Aula: Mostrar a realidade das grandes companhias. O Python faz maravilhas em prova de conceito e engenharia de dados, mas o ecossistema Java/Spring frequentemente é onde essas APIs rodam escalavelmente em grandes bancos e corporações.
  • Mini-Teoria (20m): O framework Spring Boot e a interface ChatClient.
  • Prática (80m): Configurar no Spring Initializr, injetar a dependência de AI e realizar uma conexão equivalente à que o Python fez, agora no universo Java.
  • Entregável / Validação: Projeto Maven/Gradle criado com sucesso no GitLab. O Pipeline compila via mvn clean install e executa rodando um autoteste JUnit.
  • Tópicos Abordados: Adaptadores de Vector Store no Spring, DocumentReader, Transformers, Padrão MVC em REST.
  • Foco da Aula: Reprodução exata da arquitetura RAG (Aula 17), mas usando as classes providas pelo Spring AI (um framework de abstração e padronização que unifica diversos provedores).
  • Mini-Teoria (20m): Como as peças se interligam via Beans no Spring.
  • Prática (80m): Configurar o Vector Store no application.yml, carregar documentos com um loader do Spring, injetar na base e responder chamadas por um @RestController.
  • Entregável / Validação: A classe Controladora ChatController.java mapeada, exposta e persistindo lógicas do banco de vetores.
  • Tópicos Abordados: Front-end, Integração via REST API, CORS, Ferramentas de Consumo (Postman / Insomnia).
  • Foco da Aula: Back-end por si só é invisível. A sensação real de sistema pronto ocorre quando consumido por uma Interface. Demonstrar o ciclo de vida completo de uma aplicação ponta-a-ponta (Full Stack).
  • Mini-Teoria (20m): Como os protocolos HTTP trocam JSON entre diferentes máquinas ou browsers.
  • Prática (80m): Habilitar CORS no Java e escrever um arquivo HTML+JS bruto para fazer um fetch() ou demonstrar o sistema via fluxo interativo no Postman interagindo com o RAG Roteado na aula passada.
  • Entregável / Validação: Comprovação em vídeo ou submissão do HTML simples evidenciando a conexão bem-sucedida e o chat operando no navegador.
  • Tópicos Abordados: Refinamento do projeto, tratamento de erros HTTP (429 Rate Limit, 500), Fallbacks, Monitoramento básico.
  • Foco da Aula: Estabilidade. Se a API do Google/OpenAI cair ou der erro, o back-end Java do aluno desaba? O foco é engenharia de software resiliente aplicável em produção.
  • Prática Livre (200m): Aulas destinadas à mentoria. As duplas consolidam os dados de PDFs, montam a arquitetura, refinam a UI e estabilizam os códigos para o Trabalho Prático 2.
  • Entregável / Validação: Entrega do TP2 consolidado: Projeto Spring funcional provendo suporte/RAG sobre um domínio de dados restrito com boa acurácia nas respostas.

Arco 4: Nível Avançado e Projeto Final (Aulas 23 a 30)

Tópicos de fronteira tecnológica, ética de IA, construção de portfólio e resolução de problemas usando autonomia.

  • Tópicos Abordados: PEFT (Parameter-Efficient Fine-Tuning), LoRA (Low-Rank Adaptation), Unsloth, Hugging Face Hub (Pesos locais).
  • Foco da Aula: Demistificar o mito de que “apenas a OpenAI tem dinheiro para treinar IA”. Com LoRA, alunos com placas de vídeo comuns congelam a grande parte de um modelo e “afinam” apenas ínfimas frações de parâmetros, ensinando comportamento customizado na prática.
  • Mini-Teoria (40m): A matemática super-simplificada do LoRA e congelamento de Gradientes.
  • Prática (60m): Usando biblioteca Unsloth via GPU Grátis no Colab. Pegar um modelo tipo Llama-3-8B e injetar um dialeto (ex: “Mineirês”) baseado em algumas dezenas de exemplos de treino.
  • Entregável / Validação: Arquivo ou link do Colab e/ou os pesos treinados (LoRA adapters) empurrados ou exportados como prova de sucesso.
  • Tópicos Abordados: Agentes Autônomos, Function Calling (Tool Use), ReAct Pattern (Raciocínio + Ação), LangChain.
  • Foco da Aula: Chatbots são passivos (pergunte->responda). Agentes são ativos, o LLM descobre quando algo está além de seu conhecimento, delega a “ferramenta” (uma função de programação) e aguarda o resultado.
  • Mini-Teoria (30m): A transição de LLMs narrativos para orquestradores de código.
  • Prática (70m): Configurar um LLM usando o LangChain conectando-o a uma “Tool” Python customizada (ex: Uma calculadora ou uma API de Clima local). Ele deve responder qual a temperatura hoje de uma cidade rodando código de forma transparente ao usuário.
  • Entregável / Validação: Script Python onde se constata, via logs de debug, a LLM parando a geração, invocando a ferramenta criada pelo aluno, obtendo os dados e formulando a resposta final embasada neles.
  • Tópicos Abordados: Avaliação Métrica Sistêmica, Prompt Injection, Jailbreaks, Ética e Segurança (Red Teaming).
  • Foco da Aula: “Como confiar na inteligência de texto se ela não gera código 100% igual toda vez?”. Abordar a segurança de IA contra hackers psicológicos que convencem as regras sistêmicas a serem ignoradas.
  • Mini-Teoria (30m): Vetores de ataque contra corporações (Vazamento de dados, uso indevido de token).
  • Prática (70m): O laboratório vira uma arena. Alunos trocam de máquinas/endpoints entre duplas e atuam ativamente como atacantes tentando forçar o RAG/Agent do colega a liberar respostas abusivas (Jailbreak). Em seguida, corrigem as falhas com restrições arquiteturais/prompts blindados.
  • Entregável / Validação: Relatório ou Issue aberta no repositório descrevendo o ataque bem sucedido ou a defesa aplicada contra as vulnerabilidades testadas.
  • Tópicos Abordados: Arquitetura de Projetos Reais, Resolução Colaborativa de Problemas, Cloud Deploy.
  • Foco da Aula: Simulação direta de ambiente empresarial. O professor atuará como Engenheiro/Arquiteto Sênior tirando dúvidas e desatando “nós”, enquanto o time cria do zero uma aplicação inovadora baseada nas ferramentas aprendidas (Agentes, RAG, Imagens).
  • Prática Livre: Uma “Fábrica de Software”. Duplas e trios montando seus repositórios, versionando, testando, configurando infra (Ex: Heroku, Render, Vercel ou Streamlit Cloud).
  • Entregável (Contínuo): Fluxo massivo de Commits no GitLab, revisão de código (Merge Requests) de qualidade, CI/CD integrados e aplicação progredindo em complexidade.
  • Tópicos Abordados: Demonstração (Pitch), Soft Skills, Defesa técnica, Produto em Produção.
  • Foco da Aula: Capacidade de vender a própria inteligência e aplicação técnica. Saber justificar o “porquê de ChromaDB sobre o Pinecone” ou “Gemini no lugar de OpenAI”. A transição de Estudante para Profissional Especialista no mercado.
  • Prática Final: Apresentação em formato “Pitch”. Cada grupo apresenta o link hospedado real na nuvem rodando ativamente, expõe seu Github e prova o valor prático.
  • Entregável / Validação: O sistema real hospedado publicamente com repositório documentado. As métricas de sucesso baseiam-se em funcionalidade, estabilidade da chamada e capacidade discursiva do time frente à turma.
Back to top