- Identifique as camadas de uma pilha tecnológica e explique o que cada camada faz.
- Compare diferentes abordagens de pilha tecnológica e escolha uma adequada para o seu MVP.
- Distinguir entre as abordagens LLM (IA generativa) e IA preditiva
- Aplique o caminho de IA adequado às necessidades da sua empresa
Com base no caminho de IA que você escolher:
- Se LLM Path: Analisador de feedback otimizado com configurações de temperatura e token
- Se Caminho Preditivo: Um analisador de sentimentos que classifica o feedback com pontuações de confiança
- estudantes a síntese dos comentários das partes interessadas e realizaram uma pesquisa de mercado para o seu projeto.
- estudantes experiência com GitHub, Codespaces, localStorage e integração com a API Gemini.
Você criou dois módulos funcionais no seu Kit de Ferramentas do Fundador: um Coletor de Feedback que armazena entrevistas com as partes interessadas e um Analisador de Feedback que usa IA para encontrar padrões em sua pesquisa.
Agora é hora de dar um passo atrás e entender o panorama geral de como os aplicativos são criados e qual abordagem tecnológica e de IA se adapta melhor à sua solução.
Nesta unidade, abordaremos duas escolhas importantes ao criar aplicativos com tecnologia de IA:
- Pilha de tecnologia: a combinação de ferramentas e plataformas para o app
- Caminho da IA: se você precisa de IA para geração de texto ou imagem (LLM) ou IA baseada em padrões (IA preditiva)
Fundamentos da pilha tecnológica
Todos os aplicativos que você pode usar – WhatsApp, YouTube, Instagram e Google – são construídos com uma pilha de tecnologias. Essa é a combinação de tecnologias que trabalham juntas para fazer o aplicativo funcionar.
Pense nisso como celular seu celular : você precisa de uma tela para ver as coisas, um processador para pensar, armazenamento para guardar suas fotos, uma bateria para fornecer energia e aplicativos para fazer coisas úteis. Cada parte tem uma função diferente, mas todas elas trabalham juntas para criar algo útil.
Como fundador de uma empresa de tecnologia, é importante que você tenha um entendimento completo da sua pilha de tecnologia, como ela funciona e por que você a escolheu.
Cada aplicativo com tecnologia de IA possui 5 camadas:
Front-end
A interface do usuário (UI) – tudo o que o usuário vê, clica e interage em seu navegador ou telefone.
Exemplos:
- Web: HTML/CSS/Javascript, React, Vue, Angular, Svelte, Next.js
- Dispositivos móveis: React Native, Flutter, Swift (iOS), Kotlin (Android)
- Estilo: CSS, Bootstrap, Tailwind
Back-end
A lógica e os cérebros – o código do lado do servidor que processa as solicitações dos usuários, executa algoritmos e se comunica com o banco de dados
Exemplos:
- Javascript:Node.js
- Python: Django, FastAPI
- Java: Springboot
Armazenamento
A Memória – onde os dados residem
Exemplos:
- armazenamento local
- PostgreSQL
- MongoDB
- Supabase
- Firebase
Plataforma de implantação
A infraestrutura – as ferramentas e serviços que pegam seu código e o app na internet
Exemplos:
- Vercel
- Netlify
- Ferrovia
- Google Cloud
- Lojas de aplicativos e jogos (aplicativos)
Serviços de IA
A Inteligência – recursos de inteligência
Exemplos:
- Gêmeos
- OpenAI
- Antrópico
- HuggingFace
Em uma lição anterior, falamos sobre aplicativos como Notion, Duolingo e Grammarly, que utilizam pilhas de tecnologia complexas com várias opções de front-end, back-end e armazenamento. Essa complexidade requer uma infraestrutura extensa, pois eles atendem a milhões de usuários em todo o mundo. atendem a milhões de usuários em todo o mundo.
Mas você não precisa desse nível de complexidade para o seu MVP, nem mesmo para o pós-MVP.
Pilhas de tecnologia MVP comuns
Não existe uma única maneira “certa” de criar um MVP. Aqui estão três abordagens comuns:
JavaScript básico
Tecnologias: HTML , CSS, JavaScript, Node.js
React/ Typescript
Tecnologias: React , TypeScript, Vite ou Next.js
Python/Streamlit
Tecnologias: Python , Streamlit, pandas
O Kit de Ferramentas do Fundador usa a abordagem Vanilla JavaScript, pois é simples, requer configuração mínima e ensina os fundamentos que se aplicam a qualquer pilha.
Ao escolher uma pilha de tecnologia, é recomendável começar com o que você conhece. Seu MVP precisa de algo que funcione, seja fácil de aprender e possa crescer com a sua ideia. Você sempre pode mudar mais tarde.
Nesta atividade, você identificará as camadas da pilha de tecnologia no seu Kit de Ferramentas do Fundador e as comparará com o Modo de Criação do Google AI Studio, que adota uma abordagem diferente para criar aplicativos com tecnologia de IA.
ATIVIDADE 1
Explore as pilhas de tecnologia
Tempo estimado: 20 minutos
1. Abra o Github e seu repositório do Kit de Ferramentas do Fundador
- Acesse o GitHub e abra seu repositório Founder’s Toolkit.
- Navegue até o branch principal para visualizar o código. Não há necessidade de abri-lo no Codespaces, pois estamos apenas visualizando os arquivos.
- Procure seus arquivos principais no código:
- index.html: sua estrutura HTML
- Arquivos com extensão .js, como script.js ou server.js : é aqui que fica o seu código Javascript
- Arquivos CSS: a interface do usuário que define a aparência do aplicativo
Observe que sua estrutura de arquivos pode ser diferente. Por exemplo, o Copilot pode ter incluído CSS e Javascript em seu arquivo HTML. Mas o projeto código HTML, CSS e Javascript.
O seu Kit de Ferramentas do Fundador provavelmente está em uma pilha JavaScript básica que consiste em:
- Front-end: HMTL + Javascript + CSS
- Backend: Node.js ou Python
- Armazenamento: armazenamento local do navegador
- Implantação: ambiente sandbox Codespaces
- IA: Gemini AI
Este é um ótimo ponto de partida, pois funciona diretamente em qualquer navegador, não requer ferramentas de compilação complexas e pode ser modificado facilmente.
2. Veja uma abordagem alternativa usando o Google AI Studio
- Acesse aistudio.google.com, e procure por “Build” no menu à esquerda da tela. Clique nele.
- Digite este prompt no campo abaixo de “Construa suas ideias com o Gemini”.Este é o mesmo prompt que usamos no Codespaces.
Criar um aplicativo simples que ajude os empreendedores a coletar feedback de duas partes interessadas sobre minhas ideias preliminares de negócios.
O aplicativo deve ter:
Um título no topo: “Kit de ferramentas para fundadores de IA”.
Um subtítulo: “Comece a coletar feedback sobre o meu problema.”
Uma área de texto onde posso inserir meu problema
Áreas de texto onde posso inserir os comentários para cada uma das perguntas abaixo:
Esse problema é relevante para eles?
Quais aspectos eles consideram mais importantes?
Que perguntas ou preocupações vêm à sua mente?
O que você não está entendendo sobre esse problema?
Um botão com a indicaçãosubmeter e feedbacksubmeter ”.
Uma área de saída que exibe o problema e o feedback
- Aguarde até que o aplicativo gere o código (isso pode demorar alguns minutos).
3. Explore os arquivos gerados pelo AIStudio
- Clique no botão Código na parte superior da tela para visualizar os arquivos e o código gerado.
Deve ficar parecido com a imagem abaixo.
Em nosso aplicativo, a Gemini foi além e já incluiu a chamada de API para sintetizar e resumir, sem qualquer solicitação nossa.
Aqui está uma explicação sobre os arquivos gerados, que são uma pilha de tecnologia React.
- Os arquivos .tsx são Typescript, uma forma de Javascript.
index.html & index.tsx configure o ambiente e monte a aplicação React.
App.tsx gerencia o estado global, lida com interações e renderiza o layout de alto nível.
components/FeedbackSection.tsx é um componente da interface do usuário para o formulário de feedback das partes interessadas.
serviços/geminiService.ts é a lógica para se comunicar com a IA do Google, definindo o prompt e solicitando ao modelo que retorne um objeto JSON estruturado.
types.ts define as interfaces TypeScript para dados no aplicativo.
metadata.json contém informações sobre o aplicativo, como o título e a descrição do ambiente.
4. Compare as duas abordagens
- Mantenha a guia Código aberta no AIStudio.
- Em outra janela, abra seu repositório GitHub Founder’s Toolkit e clique em Código para visualizar os arquivos.
- Analise as diferenças entre o código dos dois aplicativos.
Codespaces do Github
Estúdio de IA do Google
Front-end
JavaScript básico
React + Tailwind CSS (pré-configurado)
Back-end
React + Tailwind CSS (pré-configurado)
Gerenciado pelo Google
Armazenamento
localStorage (navegador)
localStorage (navegador)
Implantação (embora ainda não tenhamos chegado lá)
Configurar plataforma de implantação externa e atualizações automáticas a partir do repositório Github
Um clique para o Google Cloud
Serviços de IA
API Gemini, conforme especificado em seu prompt para o Copilot
API Gemini (adicionada automaticamente pelo AI Studio)
Você consegue encontrar outras diferenças no código?
5. Compare o código de integração da IA
Agora vamos nos aprofundar nas diferenças específicas do código, com foco no código de integração da IA.
- Localize os arquivos específicos onde as chamadas da API são feitas em ambas as plataformas.
- Repositório Github: procure por server.js
- Google AI Studio: procure por algo como services/geminiServices.ts
- Abra os dois arquivos e observe a estrutura da chamada da API.
Ambas as plataformas:
- definir o prompt
- enviar a solicitação e receber uma resposta
- verificar se há erros
- analisar a resposta em JSON
O código ao redor parece diferente (JavaScript vs TypeScript), mas o padrão de integração da IA principal é o mesmo.mas o padrão central de integração da IA é o mesmo.
Solução de problemas:
Se você não conseguir encontrar a chamada da API no seu código: Procure por fetch ou gemini nos seus arquivos JavaScript ou simplesmente peça ao Copilot e ao Google AI Studio Code Assistant para ajudá-lo a encontrá-la.
Se o app não o app devidamente criado no Google AI Studio: Peça ajuda ao Assistente de Código.
Você já viu duas plataformas diferentes com programação assistida por IA. Cada uma delas produz diferentes pilhas de tecnologia que, essencialmente, fazem a mesma coisa.
A diferença mais importante entre essas plataformas não é a sintaxe do código, mas sim a forma como elas lidam com sua chave API Gemini.
O Google AI Studio executa suas chamadas de API através dos servidores DELES, adicionando sua chave de API de forma segura no backend.
Seu navegador
↓ (envia solicitação com entrada do usuário)
Front-end doAI Studio (seu código React)
↓ (encaminha para o backend do AI Studio)
AI Studio(infraestrutura do Google)
↓ (adiciona SUA chave API do armazenamento seguro do Google)
Gêmeos API
↓ (retorna resposta)
Servidor doAI Studio
↓ (responder para a frente)
Seu navegador (exibe o resultado)
O GitHub Codespaces usa uma arquitetura cliente-servidor, na qual você controla tudo.
Seu navegador(front-end)
↓ (envia solicitação para o SEU backend)
Seu Express Express (backend que você cria)
↓ (adiciona chave API do arquivo .env)
Gêmeos API
↓ (retorna resposta)
Seu Express Express
↓ (resposta encaminhada)
Seu navegador (exibe o resultado)
Observação: se você usar o AI Studio como plataforma de desenvolvimento, eventualmente terá que replicar a arquitetura cliente-servidor do Codespaces para garantir a segurança da sua chave API Gemini. A “magia” do AI Studio funciona apenas dentro do AI Studio e, eventualmente, você sairá dessa plataforma, mesmo que seja apenas para implantar seu MVP.
Considere algumas vantagens e desvantagens de cada plataforma.
Controle
Conveniência
Aprendizagem
Velocidade
Flexibilidade
Simplicidade
Escolhendo sua pilha de tecnologia e caminho de IA
Agora que você já tem uma noção sobre as camadas da pilha tecnológica, é hora de tomar duas decisões importantes para o seu MVP:
- Decisão sobre a pilha tecnológica: Qual abordagem de desenvolvimento atende às suas necessidades?
- Decisão sobre o caminho da IA: Você deve usar LLM (IA generativa) ou IA preditiva?
Essas decisões determinam como você desenvolve o app. Não existe uma resposta “certa” e cada abordagem tem suas vantagens e desvantagens.
A atividade abaixo solicitará que você preencha uma planilha, respondendo a algumas perguntas que devem direcioná-lo para a pilha de tecnologia e o caminho de IA corretos para o projeto. Não se preocupe em tomar a decisão errada. Você sempre pode alterar as pilhas de tecnologia posteriormente. Trata-se de construir seu MVP nas próximas semanas e obter algo que funcione e esteja nas mãos dos seus usuários.
A mentalidade MVP
Seu objetivo é a pilha de tecnologia mais simples que permita testar sua ideia. Você ainda não está criando um aplicativo de produção para milhões de usuários. Você está criando algo para aprender rapidamente com usuários reais.
Regra geral:
Se você não tiver certeza do que precisa, não se preocupe, pois sempre poderá alterar mais tarde. Isso acontece em aplicativos reais, onde eles mudam as pilhas de tecnologia à medida que passam da ideia à produção e suas necessidades mudam com o tempo.
Guia de decisão – Pilha tecnológica
Se o seu MVP precisa de...
Considere
Por que um acelerador?
coletar texto, mostrar resultados, layout básico
JavaScript básico (o que você tem no GitHub)
O “teste de fumaça” mais rápido
lidar com várias telas ou estados complexos da interface do usuário
React/TypeScript (o que você tem no Google AI Studio)
Ideal para MVPs, funciona em computadores e dispositivos móveis através do navegador
ser construído muito rapidamente com o mínimo de código
Modo de construção do Google AI Studio
Validação imediata de um prompt/lógica
executar como aplicativo
React Native / Flutter
Uma base de código que funciona tanto no iOS quanto no Android
Para a maioria dos MVPs, sua pilha atual de JavaScript vanilla é suficiente.
Guia de Decisão – IA
Se o seu MVP precisa de...
Considere
gerar textos, resumos ou explicações
LLM
Converse
LLM
analisar textos não estruturados, como documentos ou e-mails
LLM
classificar itens em categorias (como se um texto é positivo ou negativo)
Caminho preditivo da IA com modelos de classificação
fazer previsões a partir de dados (utilizados em marketing e segmentação)
Caminho da IA preditiva
classificar ou pontuar itens
Caminho da IA preditiva com sistemas de recomendação
Para a maioria dos MVPs, sua abordagem atual usando LLMs pré-treinados, como os do seu Kit de Ferramentas do Fundador, deve ser suficiente.
ATIVIDADE 2
Selecione a pilha tecnológica e o caminho de IA para o seu MVP
Tempo estimado: 30 minutos
Agora que você compreende suas ferramentas atuais e alternativas, preencha a Planilha de Decisão de Pilha Tecnológica MVP para determinar sua pilha tecnológica e abordagem de IA.
Pratique com os caminhos da IA
As atividades a seguir permitirão que você pratique os dois tipos de caminhos de IA.
Você só precisa concluir uma atividade, dependendo da sua decisão sobre o Caminho da IA na planilha.
- Se o seu Caminho de IA for LLM → complete a Atividade 3a
- Se o seu caminho de IA for IA preditiva → conclua a Atividade 3b
- Se o seu caminho de IA for IA preditiva E você planeja construir seu próprio modelo → complete a Atividade 3c
A atividade 3b chama uma API usando um modelo pré-treinado , o que é uma boa opção para a maioria dos projetos, desde que exista um modelo que atenda às suas necessidades. E esse deve ser o caso da maioria dos projetos.
Na Atividade 3c, também abordaremos o treinamento do seu próprio modelo para quaisquer projetos que precisem seguir esse caminho.
Configurações e custos do AI LLM
Existem algumas configurações que você pode definir ao chamar uma API LLM que afetam a forma como o LLM gera a saída.
- Temperatura: Quão criativa e consistente é a IA
- Tokens: Unidades de texto (cerca de 3-4 caracteres em inglês); como a IA mede a entrada/saída
- topK / topP: Controla a diversidade do vocabulário (normalmente deixe os valores padrão)
Para a maioria dos casos de uso, concentre-se na temperatura e no maxOutputTokens.
Outras configurações, como topK e topP, são opções avançadas que você pode explorar mais tarde.
Temperatura
A temperatura controla o quão “aleatórias” ou “focadas” são as escolhas de palavras do modelo. Pense nisso como um botão entre “jogar pelo seguro” e “assumir riscos criativos”. Pode ser considerado uma das configurações mais importantes a entender:
- Baixa temperatura (0,1-0,3): O modelo seleciona a palavra seguinte mais provável quase sempre. Os resultados são consistentes e previsíveis.
- Alta temperatura (0,7-1,0): O modelo está mais inclinado a escolher palavras menos óbvias. Os resultados são mais variados e criativos.
Observação importante: Modelos diferentes podem usar escalas diferentes. O Gemini usa 0,0-2,0, enquanto a maioria dos outros modelos usa 0,0-1,0, portanto, certifique-se de sempre verificar a documentação do seu modelo.
Fichas
Os tokens são a forma como os LLMs medem o texto. Um token tem aproximadamente 3-4 caracteres em inglês, mas isso varia de acordo com o idioma.
~100 palavras equivalem a:
- Português: 75-100 tokens
- Espanhol: 80-100 tokens
- Mandarim: 150-200 tokens
- Hindi: 120-150 tokens
Os tokens são extremamente importantes, especialmente porque geralmente são a forma como os provedores de modelos de IA cobram pelas solicitações de API. Portanto, garantir que você esteja usando tokens de maneira eficaz e eficiente é essencial para controlar os custos.
Modelos diferentes também cobram de forma diferente com base nos tokens enviados na solicitação (tokens de entrada) e nos enviados na saída (tokens de saída).
- Tokens de entrada: O que você envia para o modelo (seu prompt + contexto)
- Tokens de saída: O que o modelo gera de volta
- Preços: A maioria das APIs cobra por 1.000 tokens (entrada e saída separadamente)
- Limites: Os modelos têm janelas de contexto máximas janelas de contexto (número total de tokens contando o prompt do sistema, entrada e saída) e solicitações de API (quantas chamadas podemos fazer por período, geralmente por minuto).
Os níveis gratuitos geralmente são generosos o suficiente para os modelos Gemini e possuem janelas de contexto muito grandes, que são mais do que suficientes até mesmo para aplicativos de nível de produção, mas devem ser suficientes para o seu MVP.
Regra geral do token MVP
Instruções curtas → mais barato, mais rápido, mais confiável
Resultados curtos → mais fáceis de testar e comparar
Menos chamadas de API → mais simples de depurar
Para o seu MVP, tenha como objetivo:
- 1–2 chamadas de IA por ação do usuário
- Resultados com menos de 300 palavras, a menos que seja absolutamente necessário
Exemplo: Mesmo recurso, custo de token diferente
Aviso de custo elevado:
Analise todas as transcrições das entrevistas e gere um relatório detalhado de duas páginas sempre que o usuário clicar em submeter”.
Sugestão de menor custo:
Analise o feedback e apresente três insights principais e uma pergunta aberta.
A segunda versão é mais barata, mais rápida, mais fácil de avaliar e ainda assim útil para os usuários.
Não se preocupe muito com os custos da API de IA, pois você pode executá-la bastante, mesmo na versão gratuita.
Aqui está um exemplo de custo com o Avaliador de Ideias no Kit de Ferramentas do Fundador.
Tokens de entrada:
- Solicitação do sistema: ~200 tokens
- 3 soluções com detalhes: ~500 tokens cada = 1.500 tokens
- Entrada total ~1.700 tokens
Tokens de saída:
- Análise e recomendação: ~800 tokens
Total por análise: ~2.500 tokens
Custo com Gemini Flash: ~$0,0009 (menos de 1 centavo)
Mensalmente, com 100 usuários analisando 3 vezes cada:
- – 300 análises × 2.500 tokens = 750.000 tokens
- Custo: ~R$ 0,27/mês
Isso está bem dentro dos limites da camada gratuita.
ATIVIDADE 3a
Caminho da IA - LLM
Tempo estimado: 30 minutos
Conclua esta atividade se você escolheu o Caminho LLM AI na sua planilha.
No seu Kit de Ferramentas do Fundador, você criou um Analisador de Feedback que usa a API Gemini. Nesta atividade, você personalizará as configurações de IA do seu Analisador de Feedback para melhorar a qualidade da saída. Você aprenderá como controlar o comportamento do LLM usando configurações de temperatura e token. Saber como configurar ambos é um conhecimento essencial para criar recursos de IA com qualidade de produção.
1. Configure uma nova ramificação no Github Codespace
- Acesse o GitHub e abra seu repositório Founder’s Toolkit.
- Crie uma nova ramificação a partir da principal e nomeie-a: llm-customization
- Abra seu espaço de código existente das atividades anteriores.
- Verifique o novo ramo em seu espaço de código existente. Isso preserva o armazenamento local de execuções anteriores o app
- Na janela do Terminal, na parte inferior da tela, digite (em linhas separadas):
git checkout main
git pull origem principal
git checkout -b llm-customization
- Na janela do Terminal, na parte inferior da tela, digite (em linhas separadas):
2. Encontre o código de integração da IA
- Encontre o arquivo JavaScript que faz chamadas de IA (provavelmente server.js)
- Encontre a parte do código onde você está fazendo a chamada da API para o Gemini LLM, que deve incluir uma instrução do sistema (instrução LLM) e as configurações do LLM.
Você deve encontrar algo como:
Veja a configuração generationConfig no código const result. No nosso caso, temperatura foi a única configuração definida automaticamente pelo Copilot. Muitos LLMs, como o Gemini, têm configurações padrão usadas quando os parâmetros de configuração não são fornecidos. No entanto, recomendamos adicionar temperatura e maxOutputTokens como boa prática.
3. Adicione o código de configuração LLM
- Atualize o código para definir os parâmetros de configuração da seguinte forma:
- temperatura: 0,8
- maxOutputTokens: 1024
Este é o aspecto do nosso código:
generationConfig: {
temperature: 0.8,
maxOutputTokens: 1024,
}
- Verifique no server.js se o código está correto.
4. Execute vários testes
Vamos realizar vários testes para compreender o impacto.
- Execute o Feedback Analyzer com as configurações atuais.
- Copie e cole os resultados em um documento separado cada vez que executar o analisador para poder comparar cada resultado.
- Execute novamente com as mesmas configurações.
- Compare os resultados. Eles devem ser muito semelhantes.
- Defina a temperatura para 0,2 (criativo) e execute novamente.
- Compare os resultados. Os resultados devem ser mais variados.
- Tente novamente, desta vez alterando o maxOutputTokens para um valor menor, como 300.
- Compare os resultados das respostas mais longas.
5. Encontre a sua temperatura ideal
Decida:
Para o seu Feedback Analyzer, qual temperatura funciona melhor?
- Se você deseja uma análise consistente e confiável: use 0,3-0,4
- Se você deseja insights mais criativos: use 0,6-0,7
Atualize seu código para a temperatura desejada.
6. Confirme, envie e mescle suas alterações
- Confirme suas alterações no seu espaço de código.
- Acesse o Github, crie uma solicitação de pull e mescle as alterações no branch principal.
- Você pode excluir sua ramificação, mas manter seu espaço de código.
Agora você compreende as principais configurações que controlam o comportamento do LLM. Ao criar seu próprio MVP completo, você aplicará esses conceitos para projetar recursos de IA que se comportem exatamente como seus usuários precisam.
Se você não estiver fazendo nenhum tipo de IA preditiva em o app, pode pular para a seção Reflexão.
modelos de machine learning pré-treinados modelos de machine learning
Um modelo pré-treinado é um modelo que outra pessoa já treinou com grandes quantidades de dados. Você pode usá-lo sem coletar seus próprios dados de treinamento. Usar um modelo para fazer previsões sobre novos dados é chamado de inferência. Portanto, fazer uma solicitação de API para prever algo é uma inferência.
Considerações sobre custos: Preços da IA preditiva
A IA preditiva cobra por chamada de API ou tem um custo único de treinamento. A IA preditiva é significativamente mais barata do que os LLMs para tarefas de classificação. Os níveis gratuitos são generosos o suficiente para todos os MVPs neste acelerador.
A IA preditiva tem um modelo de preços diferente do das LLMs:
O Hugging Face, uma plataforma que utilizaremos nesta atividade, oferece generosas solicitações de API gratuitas por dia, 1000-2000 por dia (dependendo do modelo).
Os custos de treinamento são únicos, e a inferência (fazer previsões) é mais barata em escala do que com um LLM. Enquanto os custos com GPU (unidade de processamento gráfico) são um fator importante no treinamento e na previsão de IA, os modelos pré-treinados não exigem custos de GPU. O custo veio no treinamento e foi pago por outra pessoa.
Esta tabela dá uma ideia do custo da classificação/previsão usando um modelo pré-treinado em comparação com o uso de um LLM para fazer previsões.
Aspecto
IA preditiva
LLM (para comparação)
Modelo de precificação
Por chamada API OU taxa mensal fixa
Por token (entrada + saída)
Custo do treinamento
Gratuito (Hugging Face, Teachable Machine)
~$0,0001 por classificação
Custo de inferência
Gratuito (1K/dia) ou US$ 9/mês ilimitado
N/A (pré-treinado)
É necessária uma GPU?
Não (o provedor cuida disso)
Não (o provedor cuida disso)
Em escala (10 mil/dia)
$9/mês (taxa fixa)
~$30-40/mês (variável)
Modelo de análise de sentimentos
Para a Atividade 3b, usaremos(cardiffnlp/twitter-roberta-base-sentiment-latest), um modelo que foi treinado com 124 milhões de tweets. Ele classifica o texto em três categorias:
- Positivo:feliz, animado, satisfeito
- Negativo: irritado, triste, frustrado
- Neutro: factual, nem positivo nem negativo
Os modelos de IA baseados em textos do Twitter são muito eficazes na análise de sentimentos, pois se baseiam na linguagem real dos usuários e são em grande escala.
Muitas empresas de atendimento ao cliente utilizam a análise de sentimentos para analisar a opinião dos clientes com o objetivo de melhorar seus aplicativos, como chatbots, ou mesmo apenas para melhorar a experiência do cliente. Esse deve ser um bom modelo para analisar os sentimentos expressos nos comentários das partes interessadas.
ATIVIDADE 3b
Caminho da IA - Preditivo (Análise de Sentimentos)
Tempo estimado: 40 minutos
Conclua esta atividade se você escolheu o Caminho da IA Preditiva em sua planilha.
Nesta atividade, adicionaremos um analisador de sentimentos ao seu Kit de Ferramentas do Fundador usando um modelo pré-treinado, com um padrão de código semelhante ao que temos usado para fazer chamadas de API com os modelos Gemini.
1. Crie uma conta Hugging Face e crie um token API
- Acesse huggingface.co e crie uma conta gratuita (caso ainda não tenha uma).
- Clique em seu perfil → Configurações → Tokens de acesso
- Clique para criar um novo token, selecione o tipo de token “Leitura” e atribua um nome apropriado.
- Copie o valor do token e salve-o em um local seguro.
2. Configure uma nova ramificação no Github Codespace
- Acesse o GitHub e abra seu repositório Founder’s Toolkit.
- Crie uma nova ramificação a partir da principal e nomeie-a: análise-de-sentimentos
- Abra seu espaço de código existente das atividades anteriores.
- Verifique o novo ramo em seu espaço de código existente. Isso preserva o armazenamento local de execuções anteriores o app
- Na janela do Terminal, na parte inferior da tela, digite (em linhas separadas):
git checkout main
git pull origem principal
git checkout -b análise de sentimentos
- Na janela do Terminal, na parte inferior da tela, digite (em linhas separadas):
3. Adicione o token ao o projeto
No seu ambiente Codespaces, adicione o token ao seu ambiente.
- No seu arquivo .env, adicione uma linha: HUGGINGFACE_API_KEY=seu_token_aqui
- Cole seu token no código acima.
Outro método
O Codespaces possui um recurso chamado Codespaces Secrets para adicionar itens como chaves de API e mantê-los seguros durante o desenvolvimento do projeto.
- Acesse seu repositório no Github.
- Clique no ícone de engrenagem para abrir as Configurações.
- No menu à esquerda, clique em Segredos e Variáveis e, em seguida, em Espaços de código.
- Adicione um novo segredo para HUGGINGFACE_API_KEY com o valor do seu token.
Para esta atividade, vamos nos limitar a adicionar a chave no arquivo .env. No entanto, você aprenderá mais sobre GitHub Secrets em unidades posteriores para aumentar a segurança do o app.
4. Adicione o código de análise de sentimentos
Peça ao Copilot para adicionar esse recurso colando este prompt.
Adicione análise de sentimentos usando um modelo de análise de sentimentos pré-treinado para o feedback das partes interessadas.
- Crie uma nova guia chamada “Analisador de Sentimentos”.
- Adicione um campo de texto onde os usuários possam digitar ou colar comentários.
- Adicione um botão “Analisar sentimento”
- Quando clicado, chame a API Hugging Face Inference:
“https://router.huggingface.co/hf-inference/models/cardiffnlp/twitter-roberta-base-sentiment-latest“
- Exiba o resultado mostrando:
– Etiqueta (POSITIVO ou NEGATIVO ou NEUTRO)
– Pontuação de confiança em porcentagem (multiplique a pontuação por 100)
Adicionei HUGGINGFACE_API_KEY ao meu arquivo .env.
5. Instale todos os pacotes necessários e execute
- Siga todas as instruções do Copilot para instalar os pacotes.
- Digite npm start na janela do terminal para iniciar o app.
6. Teste com feedback das partes interessadas
Assim que o Copilot terminar, você poderá testar o resultado com feedback real das entrevistas com as partes interessadas.
- Copie a resposta de uma parte interessada dos seus dados salvos,
- Execute-o no Analisador de Sentimentos.
- A verdade é que o sentimento corresponde ao que você esperava.
O aplicativo deve mostrar a resposta da API como “positiva”, “negativa” ou “neutra”, com uma pontuação de confiança.
- Se você encontrar erros, peça ajuda ao Copilot ou a um LLM externo (o ChatGPT é bom para diagnosticar problemas com a API Hugging Face). Aqui estão alguns problemas possíveis.
- A API retorna um erro: O modelo pode estar carregando ou você pode ter problemas de autenticação. Aguarde 20 a 30 segundos e tente novamente ou verifique suas configurações de API.
- Os rótulos sentimentais não parecem corresponder: O texto neutro é mais difícil de classificar. Experimente exemplos mais opinativos.
Para obter mais informações sobre como usar este modelo, consulte a documentação oficial aqui: https://huggingface.co/cardiffnlp/twitter-roberta-base-sentiment-latest
7. Confirme, envie e mescle suas alterações
- Confirme suas alterações no seu espaço de código.
- Acesse o Github, crie uma solicitação de pull e mescle as alterações no branch principal.
- Você pode excluir sua ramificação, mas manter seu espaço de código.
Treinamento e uso do seu próprio modelo
Para a maioria dos participantes deste acelerador, não será necessário construir seu próprio modelo. Existem muitos modelos disponíveis que podem funcionar para a maioria das soluções. No entanto, se sua solução depender da classificação ou previsão de algo muito específico para o problema que você está resolvendo — por exemplo, identificar uma planta específica que só existe na sua região —, talvez seja necessário coletar um conjunto de dados e usá-lo para treinar um modelo de machine learning você possa implementar em sua solução.
No desafio abaixo, você seguirá todo o processo em um exemplo com o aplicativo Founder’s Toolkit.
- Limpe um conjunto de dados simples
- Treine um classificador de sentimentos usando o AutoTrain da Hugging Face e um conjunto de dados local.
- Use o modelo do Kit de Ferramentas do Fundador para classificar o sentimento do feedback das partes interessadas. Esse é um processo que envolve várias etapas.
- Crie um espaço Hugging Face Gradio
- Crie uma demonstração simples do seu modelo (entrada -> saída) no seu espaço.
- O Space é executado em Python e usamos o SDK @gradio/client em nosso aplicativo React para conectar os dois.
- Adicione o código de conexão do cliente gradio no Founder's Toolkit para acessar o modelo e exibir os resultados da previsão.
Isso ensina todo o fluxo de trabalho do aprendizado de máquina:
dados → treinar → avaliar → implementar
ATIVIDADE 3c
Caminho da IA - Preditivo - Treinando seu próprio modelo
Tempo estimado: 60-90 minutos
Conclua esta atividade se você escolheu o Caminho da IA Preditiva em sua planilha E se você possui seus próprios dados.
Neste desafio, treinaremos nosso próprio classificador de sentimentos usando o AutoTrain da Hugging Face.
1. Crie uma conta Hugging Face e crie um token API
Você já deve ter feito isso se realizou a Atividade 3B. Caso contrário, siga as etapas abaixo.
- Acesse huggingface.co e crie uma conta gratuita (caso ainda não tenha uma).
- Clique em seu perfil → Configurações → Tokens de acesso
- Clique para criar um novo token, selecione o tipo de token “Leitura” e atribua um nome apropriado.
- Copie o valor do token e salve-o em um local seguro.
2. Pratique a limpeza de um conjunto de dados
Para esta atividade, usaremos um grande conjunto de dados existente da HuggingFace. No entanto, quando você estiver trabalhando em seu próprio projeto, provavelmente usará seus próprios dados. Estas etapas mostram alguns passos básicos para garantir dados “limpos” para um modelo melhor.
- Crie uma pasta no seu computador e nomeie-a análise-de-sentimentos.
- Abra esta planilha do Google e veja os dados nela contidos.
- Você consegue identificar algum problema?
- Verifique se há dados vazios ou ausentes, IDs duplicados e rótulos inconsistentes.
- Baixe o arquivo como .csv (valores separados por vírgulas) na pasta sentiment-analysis. Nomeie-o como raw_data.csv.
- Na mesma pasta, crie um novo arquivo com (TextEdit no Mac, Bloco de Notas no Windows).
- Cole o código a seguir e salve o arquivo como clean_data.py
import pandas as pd
# ---------- CONFIG ----------
INPUT_FILE = "raw_data.csv"
OUTPUT_FILE = "clean_data.csv"
# ---------- LOAD DATA ----------
df = pd.read_csv(INPUT_FILE)
# ---------- CLEANING STEPS ----------
# 1. Remove rows with missing values
df = df.dropna()
# 2. Remove duplicates
df = df.drop_duplicates()
# 3. Remove irrelevant columns (optional)
# Example: keep only "text" and "label" columns
df = df[["text", "label"]]
# 4. Basic formatting
df["text"] = df["text"].str.strip() # remove extra spaces
df["text"] = df["text"].str.replace("\n", " ", regex=False) # remove newlines
# 5. Save cleaned file
df.to_csv(OUTPUT_FILE, index=False)
print(f"Cleaned data saved to {OUTPUT_FILE}")
- Observe o código e aprenda o que cada etapa faz para limpar os dados.
- Abra uma janela do Terminal no seu computador (não no Codespaces).
- Verifique se você tem o Python instalado, digitando python –version
- Se você não tem o Python instalado, acesse aqui para fazer o download e instalá-lo.
- Navegue até a pasta sentiment-analysis na janela do terminal usando o comando cd . Procure ajuda online se precisar.
- Quando estiver na pasta sentiment-analysis, digite pip install pandas (ou pip3 install pandas se não reconhecer pip). Isso instala a biblioteca pandas, a biblioteca de análise de dados python.
- Depois de instalar, digite python clean_data.py ou python3 clean_data.py (dependendo da versão do Python que você instalou). Isso executa o código no arquivo Python que você acabou de criar.
- Aguarde a mensagem “Dados limpos salvos em clean_data.csv” e localize clean_data.csv e abra-o com um editor de texto ou, se tiver o Excel.
- Observe as alterações no arquivo. Dados ausentes, duplicatas e rótulos incorretos devem ser corrigidos.
Esta é apenas uma prática para mostrar as etapas para limpar seus próprios dados. Para o restante da atividade, usaremos um conjunto de dados muito maior que baixaremos do HuggingFace.
3. Baixe um conjunto de dados de texto
Para emular usando seu próprio conjunto de dados, baixaremos um grande conjunto de dados do Hugging Face como arquivos csv que você usará para treinar um modelo usando o Hugging Face AutoTrain. O AutoTrain é uma maneira automática (e de baixo custo/sem custo) de treinar e implantar modelos de machine learning de última geração, perfeitamente integrados ao ecossistema Hugging Face.
- Ir para Conjuntos de dados Hugging Face.
- Ao lado de Conjuntos de dados, onde está escrito Filtrar por nome, digite syedkhalid076/Análise de sentimentos.
Usaremos esse conjunto de dados porque é grande e tem os mesmos rótulos que queremos para o nosso Kit de Ferramentas do Fundador: negativo, neutro e positivo.
- Você deverá ver dois conjuntos de dados listados. Clique no segundo conjunto de dados e examine o cartão do conjunto de dados para saber mais sobre ele e ver alguns exemplos de dados.
- Clique em Arquivos e versões para ver os arquivos associados ao conjunto de dados.
- Precisaremos de dados de treinamento e validação, portanto, clique para baixar train_data.csv e val_data.csv.
- Mova os dois arquivos para a pasta de análise de sentimentos. Abra-os para ver como são os dados.
- O Autotrain requer nomes específicos para os arquivos de dados. Renomeie train_data.csv → train.csv e renomeie val_data.csv → valid.csv.
4. Configure um Google Colab para treinar seu modelo
Você pode tentar usar o HuggingFace AutroTrain Spaces para treinar diretamente na plataforma deles, mas a plataforma pode ser complicada, especialmente se você estiver usando o plano gratuito. Também existe a opção de treinar localmente no seu computador, instalando o autotrain, mas isso requer um computador decente com boa capacidade de CPU disponível. Para evitar quaisquer problemas localmente, usaremos o poder do Google Colab, que permite criar um notebook Colab e executar código Python na nuvem, aproveitando o poder das GPUs do Google.
- Acesse este repositório GitHub para o Autotrain Advanced.
- Role para baixo no README e encontre Classificação de texto em Tarefas suportadas.
- Clique no link Classificação de texto para abrir no Colab.
- Um notebook do Google Colab será aberto. Clique em Copiar para o Drive para salvar uma cópia no seu próprio Google Drive.
- Na parte superior, renomeie o notebook para sentiment-analysis-model.ipynb.
- Clique no menu Runtime na parte superior e selecione Alterar tipo de Runtime.
- Escolha a GPU T4 e clique em Salvar. Pode ser solicitado que você reinicie o notebook. Faça isso se for solicitado. Isso lhe dará poder de GPU para um treinamento mais rápido.
5. Copie seu conjunto de dados para o seu notebook Colab
- No menu de ícones do lado esquerdo, clique no ícone da pasta para abrir o Gerenciador de Arquivos. Você verá uma pasta chamada sample_data. Clique nela e renomeie-a como data.
- Abra a pasta. Você verá vários arquivos csv e json.
- Arraste os arquivos train.csv e valid.csv que você baixou do HuggingFace para dentro da pasta.
6. Configure seu Caderno Colab para treinar o modelo
Embora você receba alguns exemplos de código, é necessário fazer algumas atualizações para configurar seus dados e modelo.
- Passe o cursor entre os dois primeiros blocos de texto/código, chamados células. Você deverá ver os botões +Código e +Texto. Clique em +Código para criar uma célula de código em branco.
- Digite !pip install autotrain-advanced na célula.
Isso instalará o pacote autotrain-advanced no seu notebook. O ! na frente do comando é como executar um comando de terminal de dentro do notebook. - Clique na seta no lado esquerdo da célula para executar os comandos dentro da célula. Aguarde até que o pacote autotrain-advanced seja instalado.
- Clique na seta na célula seguinte abaixo para importar essas bibliotecas.
- Na próxima célula, precisamos configurar nosso nome de usuário e senha para o HuggingFace. Substitua seu_nome_de_usuário_huggingface pelo seu nome de usuário real no HuggingFace.
- Em vez de digitar nosso token diretamente em nosso caderno, vamos ser mais seguros e ocultá-lo. Substitua o
HF_TOKEN = “seu_huggingface_write_token” por
HF_TOKEN = getpass(“Digite seu token HF: “) - Execute o código da célula clicando na seta. Será solicitado que você insira seu token Hugging Face. Copie e cole o token quando solicitado.
O token permanece oculto, mas precisará ser inserido novamente se você fechar e reabrir o notebook.
7. Atualize os parâmetros para treinamento
Aqui está o código fornecido. A maioria das configurações padrão funcionará para nós, mas precisamos alterar algumas coisas.
params = TextClassificationParams(
model="google-bert/bert-base-uncased",
data_path="stanfordnlp/imdb", # path to the dataset on huggingface hub
text_column="text", # the column in the dataset that contains the text
target_column="label", # the column in the dataset that contains the labels
train_split="train",
valid_split="test",
epochs=3,
batch_size=8,
max_seq_length=512,
lr=1e-5,
optimizer="adamw_torch",
scheduler="linear",
gradient_accumulation=1,
mixed_precision="fp16",
project_name="autotrain-model",
log="tensorboard",
push_to_hub=True,
username=HF_USERNAME,
token=HF_TOKEN,
)
- data_path atualmente se refere a um conjunto de dados no Hugging Face. Queremos apontar para nossos arquivos csv “locais”. Portanto, defina o caminho para “data”.
- Adicione duas linhas abaixo da linha data_path.
train_split=”train”,
valid_split=”valid”,
Isso aponta para nossos dois arquivos .csv para os dados de treinamento e validação. - coluna_texto e target_column correspondem ao que temos em nossos arquivos .csv. Portanto, mantenha-os como estão.
- Altere o nome do projeto para um nome apropriado, como sentiment-analysis-model.
- Os demais parâmetros estão corretos como estão. Clique na seta para executar a célula.
- Ignore a próxima célula. Ela é apenas informativa.
- Execute a célula que contém este código:
project = AutoTrainProject(params=params, backend=”local”, process=True)
project.create()
Isso iniciará o treinamento do modelo.
Seja paciente e mantenha a janela aberta no seu computador.
O treinamento do modelo pode levar de 30 minutos a mais de uma hora.
8. Localize seu modelo no Hugging Face
- Quando o modelo terminar o treinamento, acesse sua conta Hugging Face e clique em seu perfil. Você deverá ter um novo modelo com o nome que você deu a ele no notebook Colab.
- Depois de localizar o modelo, clique no nome para abri-lo.
- Clique em Configurações e torne-o Público. Isso o tornará facilmente disponível quando você criar um pipeline para o seu modelo.
9. Crie um novo espaço Hugging Face
- Na parte superior da janela do Hugging Space, clique em Espaços.
- Clique no botão + Novo Espaço.
- Dê ao seu espaço um nome apropriado, como kit-de-ferramentas-dos-fundadores-análise-de-sentimentos.
- Para o Space SDK, selecione Gradio e, para o Space Hardware, selecione CPU Básico.
- Certifique-se de que seu espaço esteja definido como Público e crie o espaço.
- Clique em Arquivos na parte superior da tela. Isso mostra os arquivos em seu espaço. Observe que é muito parecido com um repositório Github.
- Você precisa adicionar os arquivos para executar seu modelo. Clique em Contribuir e Criar um novo arquivo.
8. Cole o seguinte código:
import gradio as gr
from transformers import pipeline
classifier = pipeline("text-classification",
model="HF_USERNAME/HF_MODELNAME")
def predict(text):
return classifier(text)
with gr.Blocks() as demo:
text_input = gr.Textbox(label="Input Text")
output = gr.JSON(label="Prediction")
text_input.submit(predict, inputs=text_input, outputs=output)
demo.launch()
- Na linha de código com model=, digite seu nome de usuário do Hugging Face e o nome do modelo.
Você pode obter essa string facilmente clicando em seu perfil no Hugging Face e, em seguida, clicando no modelo. Você pode copiar seu nome/modelo na parte superior da página do modelo. - Nomeie este arquivo como app.py
- Clique novamente no nome do espaço ao lado do ramo principal para voltar à lista de arquivos. Clique em Contribuir e crie um novo arquivo novamente.
Este será o seu arquivo requirements.txt, que informa ao Python quais bibliotecas carregar ao executar o espaço. - Cole:
transformers
torch
no arquivo. Nomeie-o como requirements.txt.
10. Comece seu Espaço
- Clique em App na parte superior da tela e o aplicativo/espaço será iniciado.
Pode levar alguns minutos para o app executado. Eventualmente, você verá um botão verde em execução na parte superior da tela. - Você pode testar seu modelo digitando algo no bloco de texto de entrada e obter a previsão abaixo.
Observe que, quando você o executa, ele fornece um rótulo e uma pontuação. O rótulo é 0, 1 ou 2. 0 = negativo, 1 = neutro e 2 = positivo. A pontuação é o nível de confiança da previsão. Ela varia de 0 a 1, sendo 1 a confiança total na previsão.
11. Adicionar ao Kit de Ferramentas do Fundador
Essa parte pode ser complicada, mas trabalhe com o Copilot (ou outros LLMs) para implementá-la.
- Abra uma nova ramificação no seu repositório Github.
- Abra seu Github Codespace.
- Confira a nova filial.
- Execute este comando na janela do terminal para instalar a biblioteca gradio.
npm install @gradio/client
- Use o prompt abaixo com o Copilot, alterando MY_HF_USERNAME e MY_HF_SPACE para o seu nome de usuário e espaço no Hugging Face (observe que eles aparecem em dois lugares).
Adicione uma guia “Meu Analisador de Sentimentos” ao aplicativo. Ela deve conter um campo de texto para entrada do usuário e um botão “Analisar Sentimentos”.
Pressionar o botão deve iniciar uma chamada para o Hugging Face Gradio Space MY_HF_USERNAME/MY_HF_SPACE (sem backend).
A resposta do espaço Gradio deve exibir o rótulo e a pontuação.
Restrições:
- Integração apenas para o cliente; não modifique o server.js nem adicione novos pontos finais.
- Use @gradio/client via ESM do jsdelivr; certifique-se de que há apenas um caminho de importação e exponha window.GradioClient.
- Consolide em uma única meta tag CSP. Permitir: connect-src ‘self’ https://generativelanguage.googleapis.com https://*.hf.space https://huggingface.co wss://*.hf.space; script-src ‘unsafe-inline’ https://cdn.jsdelivr.net; style-src ‘unsafe-inline’.
- Chame o Espaço com Client.connect('MY_HF_USERNAME/MY_HF_SPACE') e predict('/predict', [text]).
Mapeamento de saída:
- Rótulos do mapa: 0 → negativo, 1 → neutro, 2 → positivo
- A pontuação varia de 0 a 1. Formate como porcentagem com duas casas decimais.
- Teste o aplicativo assim que o Copilot gerar o código apropriado. Depure quaisquer problemas que surgirem. Digite um comentário negativo aleatório e veja o resultado, depois tente um positivo.
12. Confirme, envie e mescle suas alterações
Quando estiver satisfeito com os resultados:
- Confirme suas alterações no seu espaço de código.
- Acesse o Github, crie uma solicitação de pull e mescle as alterações no branch principal.
- Você pode excluir sua ramificação, mas manter seu espaço de código.
NOTA: Esta atividade e o uso do Hugging Face Spaces têm como objetivo mostrar um método de baixo custo ou gratuito para integrar seu próprio modelo a um aplicativo. Usamos o frontend e a conexão do cliente, mantendo tanto nosso modelo quanto o espaço do Hugging Face públicos para simplificar os testes. No entanto, se você estiver treinando seu próprio modelo usando o Hugging Face AutoTrain e o Spaces, esteja ciente de que precisará de maior segurança, utilizando um servidor backend ( server.js ) e protegendo seu token com um arquivo .env.
Reflexão
Você aprendeu sobre stacks de tecnologia e Caminhos de IA e tomou algumas decisões relacionadas ao seu produto. Aqui estão alguns pontos a considerar:
Termos-chave
- Pilha de tecnologia: A combinação de linguagens de programação, frameworks e serviços usados para construir o app.
- Front-end: O que os usuários veem e com o que interagem (HTML, CSS, JavaScript, React)
- Backend: Código do lado do servidor que processa dados e executa lógica.
- API (Interface de Programação de Aplicativos): Uma maneira de seu código se comunicar com serviços externos.
- LLM (Large Language Model): IA que gera texto, mantém conversas e analisa documentos
- IA preditiva: IA que encontra padrões nos dados para fazer previsões ou classificações.
- Temperatura (configuração da IA): Controla o grau de criatividade e consistência das respostas da IA (0 = previsível, 1 = criativo)
- Inferência: Usar um modelo treinado para fazer previsões sobre novos dados
- Treinamento: Ensinar um modelo a reconhecer padrões, mostrando-lhe exemplos rotulados.
- Modelo pré-treinado: Um modelo já treinado em grandes conjuntos de dados, pronto para uso.
- AutoTrain: Uma plataforma que treina automaticamente modelos de ML sem programação
Recursos adicionais
- Google AI Studio – Modo de construção para protótipos rápidos
- Classificação | Aprendizado de máquina | Google para desenvolvedores
- Analisando o sentimento | API de linguagem natural na nuvem
- Entenda e conte tokens | API Gemini | Google AI para desenvolvedores
- Documentação do cliente Gradio JS
- Hugging Face AutoTrain – Treinamento de modelos sem código
- Conjunto de dados de sentimento do Twitter – Conjunto de dados usado na Atividade 3b
- API de Inferência da Hugging Face – Como chamar modelos via API
- Tutorial de Análise de Sentimentos no Twitter – Tutorial completo com exemplos de código
