Pular para o conteúdo
LabS Atlas
AI For Devs
Entrar
Sessões

Sessão de Bancada Testes Autônomos com IA Usando Ollama e Modelos Locais (2024-08-20)

20 ago 20241h 11min
Assistir gravação

Entre para ler os trechos da transcrição de cada capítulo e perguntar ao Labinho sobre esta sessão.

O Labinho é o assistente que responde com as notas e as sessões do LabS e mostra de onde tirou cada resposta.

atualizado há 25 dias
Resumo da sessão

A sessão apresentou o uso de modelos de linguagem locais para apoiar testes autônomos com IA, com foco no Ollama e em modelos como Llama 3 e Phi-3. Foi explicado como instalar e executar os modelos em Linux, Windows e macOS, utilizando CPU ou GPU, além de discutir requisitos de hardware, desempenho, privacidade, custos e possibilidades de integração com aplicações. Modelos menores foram destacados por sua velocidade e capacidade de funcionar em máquinas mais simples, enquanto modelos maiores exigem placas de vídeo ou infraestrutura significativamente mais robusta.

Na parte prática, foi demonstrado o uso de notebooks Jupyter, Python e bibliotecas de integração para fornecer uma URL ou código-fonte ao modelo e gerar testes automatizados. O fluxo incluiu geração de scripts, limpeza e extração do código produzido, revisão automática, execução dos testes e armazenamento de logs. A demonstração mostrou que os modelos conseguem acelerar o processo, mas ainda produzem erros e exigem validação e correção humana; por isso, a automação completa ainda não é confiável.

Como conclusão, reforçou-se que o caminho mais viável é construir scripts e pipelines que orquestrem a IA, a geração de artefatos e a execução dos testes, em vez de esperar que o modelo realize todo o processo de forma autônoma. Também foram comentadas ferramentas como Continue, LM Studio, Google Colab e GitHub Copilot, além da importância de configurar prompts e regras específicas do projeto. Ficou em aberto a evolução para fluxos mais autônomos, a integração com pipelines corporativas e a realização de novos desafios, com a próxima sessão prevista para 3 de setembro.

Gerado por IA a partir da transcrição.
Capítulos · 37
00:11
Abertura e apresentação da sessão
Assistir
02:47
Objetivos do encontro e dinâmica da comunidade
Assistir
05:23
Contexto da iniciativa e testes autônomos com IA
Assistir
07:56
Ciclos de exploração e uso da IA em testes
Assistir
09:13
Interpretação e geração de artefatos de teste
Assistir
10:30
Desafios, participação e compartilhamento de conhecimento
Assistir
13:05
Introdução a modelos de linguagem locais
Assistir
14:21
Executando modelos com Ollama
Assistir
16:57
Requisitos de hardware para modelos locais
Assistir
18:13
Famílias de modelos e aplicações com agentes
Assistir
19:31
Comparação entre Llama e Phi-3
Assistir
20:49
Vantagens de usar modelos localmente
Assistir
24:44
Integração com Jupyter e automação de testes
Assistir
25:59
Gerando testes a partir de páginas web
Assistir
29:49
Execução, streaming e depuração dos testes
Assistir
33:37
Desempenho e uso de GPU na geração
Assistir
36:10
Extração e limpeza do código gerado
Assistir
37:28
Validação e correção dos testes automatizados
Assistir
40:06
Revisão do código e geração iterativa
Assistir
41:23
Automação do fluxo completo com IA
Assistir
42:42
Automação de testes com scripts e pipelines
Assistir
45:18
Logs, execução de comandos e integração com servidores
Assistir
46:35
Execução local de modelos e uso de GPU
Assistir
47:53
Customização de modelos para pipelines de teste
Assistir
49:10
Limites dos testes autônomos com IA
Assistir
50:27
Orquestração entre IA, scripts e código
Assistir
51:44
Notebooks, Google Colab e treinamento de modelos
Assistir
54:19
Ferramentas de desenvolvimento com IA
Assistir
55:35
Comparação de modelos locais e serviços de IA
Assistir
58:08
Continue: integração da IA com o terminal
Assistir
59:26
Configuração de modelos locais e prompts
Assistir
1:00:42
IA como amplificadora do trabalho de desenvolvimento
Assistir
1:03:18
Debate sobre Linux, macOS e Windows
Assistir
1:04:35
Arquitetura ARM e desempenho de processadores
Assistir
1:05:52
Compatibilidade de software e GPUs para IA
Assistir
1:07:08
NVIDIA, AMD e aceleração de modelos
Assistir
1:08:26
Encerramento e próximos passos
Assistir
Cortes · 8
Rodando modelos de IA localmente com Ollama
Apresentação prática do Ollama para executar modelos de linguagem localmente, com exemplos usando Llama 3 e Phi-3 em Linux e Windows. O trecho compara desempenho, requisitos de hardware, velocidade e as vantagens de manter os dados na própria máquina, sem depender de internet ou serviços pagos.
13:05 – 25:59Assistir
Gerando testes automatizados com IA local
Demonstração de um notebook em Python integrado a um modelo local para analisar uma aplicação a partir de uma URL e gerar testes de front-end. O apresentador mostra o uso de streaming, a extração e limpeza do código produzido, além da revisão e correção dos testes gerados automaticamente.
25:59 – 41:23Assistir
Automação de testes com scripts e execução local
Demonstra-se como transformar a geração de testes em um processo automatizado, executável por script ou pipeline, com regras específicas da empresa, limpeza de código, registro das alterações e execução da suíte de testes. Também são discutidas formas de salvar logs, enviar resultados para servidores e integrar chamadas externas ao fluxo.
42:42 – 47:53Assistir
Por que a IA precisa ser orquestrada nos testes
O grupo discute as limitações atuais de usar IA de ponta a ponta para testar software de forma autônoma, sem garantia de qualidade. A conclusão é que um script precisa orquestrar a interação entre a IA, a geração do teste, a execução e a validação dos resultados.
49:10 – 51:44Assistir
Google Colab e notebooks para automação e machine learning
São comparados notebooks de execução, como Jupyter e Google Colab, destacando o uso de créditos e máquinas com GPU para treinar ou ajustar modelos a baixo custo. O trecho também mostra como esses ambientes permitem conectar bancos de dados, executar código e automatizar etapas de trabalho.
51:44 – 54:19Assistir
Ferramentas e modelos locais para desenvolvimento com IA
O apresentador comenta ferramentas como Copilot, LM Studio e Ollama, além de modelos como GPT, Gemini, Mistral e outros modelos locais. Ele explica as possibilidades de trocar o modelo utilizado, conectá-lo como servidor e consultar a base de código para gerar, explicar ou modificar código.
54:19 – 58:08Assistir
Configurando o Continue para programar com IA
É demonstrada a configuração da extensão Continue para conversar com o terminal, usar modelos locais ou serviços externos e definir prompts e comportamentos personalizados. O trecho mostra como instalar o Ollama, baixar modelos, adicionar chaves de API e adaptar a ferramenta à geração de testes.
58:08 – 1:01:57Assistir
Teste autônomo como apoio à entrega segura
O debate diferencia automação de testes e substituição do trabalho de desenvolvimento: a proposta é criar uma base sólida de evidências sobre o comportamento da aplicação. Os resultados dos testes devem ajudar a levar mudanças à produção com mais segurança, sem pressupor que a IA possa agir sozinha.
1:01:57 – 1:03:18Assistir
Perguntas desta sessão
Como executar um modelo local usando o Ollama?
É preciso instalar o Ollama, baixar o modelo desejado e executá-lo pelo terminal com o comando correspondente, como `ollama run llama3`. O procedimento funciona tanto no Linux quanto no Windows, usando o PowerShell neste último.
15:14 – 16:41Assistir
Quais são os requisitos de hardware para executar modelos locais no Ollama?
A memória da GPU deve ser compatível com o tamanho do modelo, considerando sua quantização. Como regra aproximada, modelos maiores exigem mais memória: modelos de 8 bilhões de parâmetros podem ser executados em uma GPU de 4 GB usando 8 bits, enquanto modelos muito grandes exigem várias GPUs ou um cluster.
16:54 – 17:28Assistir
Que hardware é necessário para executar um modelo de 405 bilhões de parâmetros?
É necessário um cluster de GPUs de grande porte. O treinamento desse modelo utilizou cerca de 16 mil GPUs com 80 GB de memória cada, portanto sua execução está muito além da capacidade de um computador comum.
17:16 – 17:28Assistir
Quais são as vantagens de executar modelos de linguagem localmente?
Os modelos locais podem ser integrados a aplicações, executados na própria máquina e usados sem conexão com a internet. Isso oferece mais privacidade, pois os dados permanecem no computador, além de permitir operação offline e evitar custos de serviços externos.
21:48 – 22:10Assistir
É possível executar outros modelos de linguagem além dos modelos apresentados usando o Ollama?
Sim. O Ollama permite executar diversos outros modelos disponíveis em repositórios como o Hugging Face, além dos modelos listados em seu próprio site. A ferramenta simplifica o carregamento e a execução desses modelos localmente.
23:42 – 23:56Assistir
Onde encontrar informações técnicas sobre o potencial dos modelos locais, especialmente dos modelos menores?
Foi indicado um artigo científico, com cerca de 20 páginas, que detalha o potencial dos modelos locais e dá atenção especial aos modelos menores, em vez de focar apenas em modelos grandes como os de 70 bilhões de parâmetros.
24:06 – 24:33Assistir
Como automatizar a criação de scripts de teste usando modelos locais de inteligência artificial?
A abordagem apresentada usa Jupyter Notebook, Python e uma biblioteca de integração com a API do Ollama. O sistema permite enviar prompts, fornecer o contexto da aplicação e pedir ao modelo que gere testes de front-end ou back-end. O código pode ser organizado em um script Python para execução automática, com parâmetros de configuração e etapas separadas para geração e processamento do conteúdo.
25:02 – 26:34Assistir
O modelo Phi-3 também consegue gerar testes a partir do conteúdo de uma página?
Sim. O modelo pode receber uma URL, analisar o conteúdo da página e gerar testes com base nessa análise. A mesma abordagem pode ser aplicada para testes de front-end e, com adaptações, para testes de back-end.
26:25 – 26:34Assistir
O comportamento de exibir a resposta gradualmente ou retorná-la completa no Ollama é controlado por alguma configuração da API?
Sim. A integração pode usar o retorno completo da resposta ou o modo streaming, no qual o modelo envia o texto progressivamente. O comportamento depende da forma como a chamada à API é configurada.
32:52 – 33:10Assistir
O uso de memória RAM aumenta significativamente ao executar modelos locais com Ollama?
O aumento de RAM é pequeno nesse caso. O maior impacto observado ocorre no uso da CPU, que pode deixar o sistema mais lento, enquanto uma GPU compatível ajuda no processamento do modelo.
33:41 – 33:48Assistir
Como criar uma função para limpar e extrair o código de teste gerado por um modelo de IA?
É possível criar uma função que receba a resposta do modelo, remova explicações e comentários desnecessários e extraia apenas o código executável. Esse código limpo pode então ser salvo e executado como teste.
36:18 – 36:34Assistir
Como automatizar a execução do fluxo de geração e execução de testes com modelos locais?
O fluxo pode ser encapsulado em funções ou executado a partir de um Jupyter Notebook tratado como um serviço ou executor. Assim, o processo pode rodar de forma autônoma, inclusive em pipelines, sem depender de uma interação manual contínua ou de uma conexão externa.
42:39 – 42:57Assistir
Como gerar logs dos testes automatizados e salvá-los em outro arquivo?
É possível redirecionar a saída da execução para um arquivo ou fazer uma chamada direta à API e armazenar todo o retorno. O resultado também pode ser enviado a outro servidor usando bibliotecas como Requests ou comandos remotos via SSH.
45:23 – 46:52Assistir
A inteligência artificial já consegue executar testes de software de ponta a ponta de forma totalmente autônoma?
Ainda não há garantia de que a IA produza testes corretos e confiáveis de ponta a ponta sem supervisão. A abordagem proposta exige orquestração em três etapas: interpretar o que deve ser testado, gerar o código do teste e executar o teste, integrando a IA ao código e às automações existentes.
49:49 – 51:16Assistir
É possível usar o Google Colab para executar notebooks e modelos de inteligência artificial?
Sim. O Google Colab oferece uma implementação de notebooks com algumas restrições, mas permite usar diferentes recursos de execução e pode disponibilizar créditos ou máquinas com GPU. Ele também pode ser usado para treinamento de modelos de baixo custo ou sem custo.
52:20 – 52:57Assistir