Programa
Desenvolvimento de modelos de idiomas grandes
16 h
Apps multimodais com Gemini 2.0 | Crie uma ferramenta local para criadores no YouTube
Configurando o Gemini 2.0 Pro
Atualmente, o Gemini 2.0 Pro só pode ser acessado pelo Google AI Studio, que exige login com uma conta Google. Para começar, siga estes passos:
1. Acesse o Google AI Studio
Visite o site do Google AI Studio e faça login com suas credenciais da conta Google. Após o login, você será redirecionado ao painel do Google AI Studio.
2. Gere uma chave de API
- No painel, localize e clique no botão “Get API Key” no canto superior esquerdo.
- Em seguida, clique em “Create API Key” para gerar sua primeira chave de API.
Fonte: Google AI Studio
3. Configure a variável de ambiente
Crie uma variável de ambiente chamada GEMINI_API_KEY e defina nela o valor da chave de API que você acabou de gerar.
4. Instale os pacotes necessários do Python
Instale os pacotes necessários do Python executando o comando abaixo no terminal:
pip install google-genai
pip install gradioTestando os recursos do Gemini 2.0 Pro
Agora, vamos usar o cliente Python do Gemini para acessar vários recursos do modelo Gemini 2.0 Pro. Entre eles: compreensão de texto, processamento de imagens, análise de áudio e leitura de documentos.
Também vamos testar a execução de código, que permite gerar código e executá-lo diretamente em um kernel Python na nuvem.
1. Geração de texto
Vamos carregar a chave de API da variável de ambiente e inicializar o cliente com ela. Esse cliente será a interface para acessar diferentes modelos e recursos.
Em seguida, vamos enviar uma pergunta para o modelo e gerar uma resposta em streaming. Isso significa que, conforme os tokens são gerados, eles aparecem gradualmente no terminal, oferecendo feedback em tempo real.
import os
from google import genai
API_KEY = os.environ.get("GEMINI_API_KEY")
client = genai.Client(api_key=API_KEY)
response = client.models.generate_content_stream(
model="gemini-2.0-pro-exp-02-05",
contents=["Explain how Stock Market works"])
for chunk in response:
print(chunk.text, end="")O modelo gerou uma resposta detalhada e precisa.
The stock market is a complex system, but here's a breakdown of how it works in a simplified way, covering the key concepts:
**1. What are Stocks (Shares)?**
* **Ownership:** Stocks, also called shares or equities, represent ownership in a company. When you buy a stock, you're buying a tiny piece of that company.
* **Claim on Assets and Earnings:** As a shareholder, you have a claim on the company's assets and earnings. You're entitled to a portion of the company's profits (often distributed as dividends, though not always) and, in theory, a share of the company's value if it were to be liquidated.
* **Voting Rights (Sometimes):** Many stocks (but not all) come with voting rights, allowing you to have a say in certain company decisions (like electing the board of directors).
**2. Why Companies Issue Stock (Go Public)?**2. Compreensão de imagens
Para entendimento de imagem, vamos carregar a imagem com a biblioteca Pillow em Python e adicioná-la ao argumento contents. O contents incluirá perguntas sobre a imagem junto com o objeto da imagem.
from google import genai
from google.genai import types
import PIL.Image
image = PIL.Image.open('image.png')
response = client.models.generate_content_stream(
model="gemini-2.0-pro-exp-02-05",
contents=["Explain the image", image])
for chunk in response:
print(chunk.text, end="")O modelo entendeu a imagem com precisão e trouxe até detalhes sutis.
The image is a stylized, abstract graphic. It looks like a simplified diagram or node network, with a black background.
Here's a breakdown:
* **Nodes:** There are four circular nodes. Each node is a different color:
* Light Blue (Top Left)
* Light Green (Bottom Left)
* White (Top Right)
* Red (Bottom Right)
* **Node outline:** There is a thick outline around each of the circles.
* **Shadow:** Each circle appears to be casting a white shadow.3. Compreensão de áudio
O Gemini 2.0 Pro entende áudio diretamente, sem precisar converter para texto. Basta carregar o áudio e fornecê-lo no argumento content junto com a pergunta.
with open('audio.wav', 'rb') as f:
audio_bytes = f.read()
response = client.models.generate_content_stream(
model='gemini-2.0-pro-exp-02-05',
contents=[
'Describe this audio',
types.Part.from_bytes(
data=audio_bytes,
mime_type='audio/wav',
)
]
)
for chunk in response:
print(chunk.text, end="")De novo, ele traz uma descrição muito precisa do áudio.
The audio appears to be a collection of short, spoken phrases or sentences. There is only one speaker, a male, and he seems to be reading or reciting these phrases, possibly as part of a list or exercise. The content focuses on food and related concepts like smell and temperature.4. Compreensão de documentos
Em vez de usar Langchain ou qualquer framework de RAG, podemos enviar documentos diretamente ao Gemini 2.0 Pro. Ele faz o parsing e a indexação, permitindo que você faça perguntas sobre o conteúdo.
Carregamos um arquivo PDF e fizemos perguntas com base no conteúdo. Simples assim.
from google import genai
from google.genai import types
import pathlib
prompt = "What the document is about"
response = client.models.generate_content_stream(
model="gemini-2.0-pro-exp-02-05",
contents=[
types.Part.from_bytes(
data=pathlib.Path('cv.pdf').read_bytes(),
mime_type='application/pdf',
),
prompt])
for chunk in response:
print(chunk.text, end="")Como resultado, ele descreveu perfeitamente do que se trata o documento.
Based on the OCR output, the document is **Abid Ali Awan's Curriculum Vitae (CV) or resume**. It details his:
* **Contact Information:** Name, address, email, and phone number.
* **Work Experience:** A chronological list of his professional roles, including job titles, companies, locations, dates of employment, and brief descriptions of his responsibilities. This includes experience in data science, freelancing, research, media, and network engineering.
* **Education:** His academic background, listing degrees earned, institutions attended, graduation dates, GPAs, and areas of specialization.
* **Gap Year:** Explaining the time that have taken for medical/personal issues.
* **Professional Skills:** A list of his technical and soft skills, categorized and rated5. Geração e execução de código
A parte mais impressionante da API do Gemini é poder gerar código e executá-lo pela própria API. Isso significa que seu código será gerado e testado; se houver algum bug, o modelo corrige e executa novamente até obter a resposta correta.
Pedimos ao Gemini 2.0 Pro para responder uma questão de programação e executar o código no final. Se você observar o argumento config, verá que incluímos a ferramenta de execução de código para rodar na nuvem.
from google import genai
from google.genai import types
from IPython.display import Markdown, HTML, Image, display
response = client.models.generate_content(
model='gemini-2.0-pro-exp-02-05',
contents="""
Write a Python program to calculate the sum of the first 50 prime numbers. The program should:
- Use a function to check if a number is prime.
- Use another function to find and sum the first n prime numbers, where n is 50 in this case.
- Ensure the code is efficient and readable.
- Print the result clearly.
After writing the code, execute it to verify that the sum of the first 50 prime numbers is correct.
""",
config=types.GenerateContentConfig(
tools=[types.Tool(
code_execution=types.ToolCodeExecution
)]
)
)
def display_code_execution_result(response):
for part in response.candidates[0].content.parts:
if part.text is not None:
display(Markdown(part.text))
if part.executable_code is not None:
code_html = f'<pre style="background-color: green;">{part.executable_code.code}</pre>' # Change code color
display(HTML(code_html))
if part.code_execution_result is not None:
display(Markdown(part.code_execution_result.output))
if part.inline_data is not None:
display(Image(data=part.inline_data.data, format="png"))
display(Markdown("---"))
display_code_execution_result(response)O modelo gerou o código, mas falhou ao executar. Em seguida, corrigiu os problemas, rodou novamente e exibiu os resultados com sucesso.
Criando um aplicativo com o Gemini 2.0 Pro
Agora vamos construir um app web em Gradio que integra todos os recursos que testamos. Assim, qualquer pessoa pode testar, enviando arquivos e fazendo perguntas sobre imagens, áudio, documentos e até executando código.
O código do app.py está disponível no repositório do GitHub Gemini-2-Pro-Chat. Você pode revisar para entender como cada recurso foi implementado.
Resumindo, o app contém:
- Tratamento de entrada multimodal: o chatbot processa texto, imagens, áudio e documentos.
- Geração dinâmica de respostas: streaming de respostas usando o método
generate_content_streamdo Google GenAI. - Execução de código: usuários podem gerar o código, pedir para o chatbot executar e retornar os resultados.
- Processamento de imagem e áudio: imagens são redimensionadas e convertidas para base64 para embutir em HTML, enquanto arquivos de áudio são codificados e exibidos com um player.
- Upload de documentos: arquivos PDF são processados e adicionados ao histórico da conversa.
Depois de copiar o código do repositório remoto para o seu projeto local, você pode executá-lo localmente.
python app.py
Testando o aplicativo Gemini 2.0 Pro
Vamos testar o app web para garantir que tudo está funcionando como esperado. Vamos passar por todos os recursos na interface do app, um a um.
1. Digite sua pergunta e pressione [Enter]. A resposta começará a ser gerada e, em poucos segundos, você terá o retorno.
2. Para enviar uma imagem, clique em “Upload Images” e selecione o arquivo. Depois, faça uma pergunta sobre a imagem e o Gemini 2.0 Pro começará a gerar uma resposta precisa e detalhada.
3. Para enviar áudio, clique em “Upload Audio” e selecione o arquivo. Depois, faça uma pergunta sobre o áudio. O modelo vai gerar respostas muito precisas.
4. Você também pode enviar documentos. Carregue um PDF clicando em “Upload Documents” e escolhendo o arquivo. Depois, faça uma pergunta sobre o documento.
5. A execução de código é um pouco diferente. Ela não mantém histórico para evitar conflitos; então, você precisa pedir para gerar e executar o código no mesmo prompt.
Por exemplo, pedimos para gerar e executar um código Python de exemplo que cria uma imagem PNG aleatória e, em seguida, clicamos no botão “Run Code Execution”.
Em segundos, ele gerou o código, executou e exibiu as imagens na caixa de chat.
O recurso de execução de código também traz uma conclusão ao final.
Fazendo o deploy do app Gemini 2.0 Pro
Vamos publicar o app na nuvem usando o Hugging Face Spaces. Acesse Hugging Face Spaces e clique em “+ New Space”. Informe o nome, a descrição e a licença do Space e selecione o SDK como Gradio.
Fonte: Hugging Face
Depois de criar o Space, você receberá instruções para clonar o repositório:
git clone https://huggingface.co/spaces/kingabzpro/Gemini-2-Pro-Chat
cd Gemini-2-Pro-ChatDentro do repositório local, crie um arquivo requirements.txt e adicione a seguinte dependência Python:
google-genai==1.0.0Em seguida, edite o arquivo README.md para incluir o conteúdo abaixo:
---
title: Gemini 2 Pro Chat
emoji: ♊💬
colorFrom: green
colorTo: pink
sdk: gradio
sdk_version: 5.15.0
app_file: app.py
pinned: false
license: mit
short_description: 'Image, Audio, and Document understanding + Code Execution. '
---Depois, adicione o arquivo app.py ao repositório. Faça o stage das alterações, crie o commit e envie para o repositório remoto:
git add .
git commit -m "deploying the app"
git push Depois de enviar os commits, você verá que o Space está construindo a imagem Docker e instalando as dependências.
Fonte: Gemini 2 Pro Chat
Quando tudo finalizar, pode aparecer uma mensagem de erro. Não se preocupe: ela está relacionada a variáveis de ambiente ausentes, que vamos adicionar no Spaces.
Fonte: Gemini 2 Pro Chat
Vá nas configurações do seu Space e role até a seção "Variables and Secrets". Crie um novo secret clicando em “New Secret”. Informe o nome e cole sua chave de API do Gemini.
Fonte: Gemini 2 Pro Chat
Após adicionar o secret, o Space será reiniciado automaticamente e seu app vai rodar sem problemas, como rodava localmente.
Fonte: Gemini 2 Pro Chat
Conclusão
Criar um aplicativo de IA de alta performance ficou muito mais simples com a nova API do Gemini 2.0 Pro e seus recursos avançados. Em vez de instalar vários pacotes Python para processar imagens, áudio ou documentos, você pode enviar tudo direto para o endpoint da API. O modelo gera resultados em segundos, deixando o fluxo muito mais ágil.
No momento, o acesso ao Gemini 2.0 Pro é gratuito, mas limitado a 50 requisições por dia. No entanto, é importante reforçar: não use a API para fins comerciais, para evitar risco de suspensão da conta.
Neste tutorial, exploramos o modelo de ponta Gemini 2.0 Pro e seus recursos. Testamos essas capacidades em Jupyter Notebooks e as integramos em um app em Gradio. Por fim, fizemos o deploy na nuvem, tornando-o acessível ao público.
Se você quer aprender mais sobre como criar aplicativos com IA, confira nossa trilha de aprendizado em Developing AI Applications e conheça as ferramentas mais recentes para desenvolvedores de IA.
