Framework de pré-treinamento visão-linguagem que conecta codificadores de imagem congelados e LLMs. Use quando você precisar de legendagem de imagens, resposta a perguntas visuais, recuperação imagem-texto ou chat multimodal com desempenho zero-shot de última geração.
インストールする前に、エージェントに与えられる指示の中身を確認できます。
Guia completo para usar BLIP-2 do Salesforce em tarefas visão-linguagem com codificadores de imagem congelados e grandes modelos de linguagem.
Use BLIP-2 quando:
Recursos principais:
Use alternativas em vez disso:
# HuggingFace Transformers (recomendado)
pip install transformers accelerate torch Pillow
# Ou biblioteca LAVIS (oficial Salesforce)
pip install salesforce-lavis
import torch
from PIL import Image
from transformers import Blip2Processor, Blip2ForConditionalGeneration
# Carregar modelo e processador
processor = Blip2Processor.from_pretrained("Salesforce/blip2-opt-2.7b")
model = Blip2ForConditionalGeneration.from_pretrained(
"Salesforce/blip2-opt-2.7b",
torch_dtype=torch.float16,
device_map="auto"
)
# Carregar imagem
image = Image.open("photo.jpg").convert("RGB")
# Gerar legenda
inputs = processor(images=image, return_tensors="pt").to("cuda", torch.float16)
generated_ids = model.generate(**inputs, max_new_tokens=50)
caption = processor.batch_decode(generated_ids, skip_special_tokens=True)[0]
print(caption)
# Fazer uma pergunta sobre a imagem
question = "What color is the car in this image?"
inputs = processor(images=image, text=question, return_tensors="pt").to("cuda", torch.float16)
generated_ids = model.generate(**inputs, max_new_tokens=50)
answer = processor.batch_decode(generated_ids, skip_special_tokens=True)[0]
print(answer)
import torch
from lavis.models import load_model_and_preprocess
from PIL import Image
# Carregar modelo
device = torch.device("cuda" if torch.cuda.is_available() else "cpu")
model, vis_processors, txt_processors = load_model_and_preprocess(
name="blip2_opt",
model_type="pretrain_opt2.7b",
is_eval=True,
device=device
)
# Processar imagem
image = Image.open("photo.jpg").convert("RGB")
image = vis_processors["eval"](image).unsqueeze(0).to(device)
# Legenda
caption = model.generate({"image": image})
print(caption)
# VQA
question = txt_processors["eval"]("What is in this image?")
answer = model.generate({"image": image, "prompt": question})
print(answer)
Arquitetura BLIP-2:
┌─────────────────────────────────────────────────────────────┐
│ Q-Former │
│ ┌─────────────────────────────────────────────────────┐ │
│ │ Consultas Aprendidas (32 consultas × 768 dim) │ │
│ └────────────────────────┬────────────────────────────┘ │
│ │ │
│ ┌────────────────────────▼────────────────────────────┐ │
│ │ Cross-Attention com Características de Imagem │ │
│ └────────────────────────┬────────────────────────────┘ │
│ │ │
│ ┌────────────────────────▼────────────────────────────┐ │
│ │ Camadas de Self-Attention (Transformer) │ │
│ └────────────────────────┬────────────────────────────┘ │
└───────────────────────────┼─────────────────────────────────┘
│
┌───────────────────────────▼─────────────────────────────────┐
│ Codificador de Visão Congelado │ LLM Congelado │
│ (ViT-G/14 de EVA-CLIP) │ (OPT ou FlanT5) │
└─────────────────────────────────────────────────────────────┘
| Modelo | Backend LLM | Tamanho | Caso de uso |
|---|---|---|---|
blip2-opt-2.7b | OPT-2.7B | ~4GB | Legendagem geral, VQA |
blip2-opt-6.7b | OPT-6.7B | ~8GB | Melhor raciocínio |
blip2-flan-t5-xl | FlanT5-XL | ~5GB | Seguimento de instruções |
blip2-flan-t5-xxl | FlanT5-XXL | ~13GB | Melhor qualidade |
| Componente | Descrição | Parâmetros |
|---|---|---|
| Consultas aprendidas | Conjunto fixo de embeddings treináveis | 32 × 768 |
| Transformer de imagem | Cross-attention para características visuais | ~108M |
| Transformer de texto | Self-attention para texto | ~108M |
| Projeção linear | Mapeia para dimensão do LLM | Varia |
from PIL import Image
import torch
# Carregar múltiplas imagens
images = [Image.open(f"image_{i}.jpg").convert("RGB") for i in range(4)]
questions = [
"What is shown in this image?",
"Describe the scene.",
"What colors are prominent?",
"Is there a person in this image?"
]
# Processar lote
inputs = processor(
images=images,
text=questions,
return_tensors="pt",
padding=True
).to("cuda", torch.float16)
# Gerar
generated_ids = model.generate(**inputs, max_new_tokens=50)
answers = processor.batch_decode(generated_ids, skip_special_tokens=True)
for q, a in zip(questions, answers):
print(f"Q: {q}\nA: {a}\n")
# Controlar parâmetros de geração
generated_ids = model.generate(
**inputs,
max_new_tokens=100,
min_length=20,
num_beams=5, # Beam search
no_repeat_ngram_size=2, # Evitar repetição
top_p=0.9, # Nucleus sampling
temperature=0.7, # Criatividade
do_sample=True, # Ativar sampling
)
# Para saída determinística
generated_ids = model.generate(
**inputs,
max_new_tokens=50,
num_beams=5,
do_sample=False,
)
# Quantização 8-bit
from transformers import BitsAndBytesConfig
quantization_config = BitsAndBytesConfig(load_in_8bit=True)
model = Blip2ForConditionalGeneration.from_pretrained(
"Salesforce/blip2-opt-6.7b",
quantization_config=quantization_config,
device_map="auto"
)
# Quantização 4-bit (mais agressiva)
quantization_config = BitsAndBytesConfig(
load_in_4bit=True,
bnb_4bit_compute_dtype=torch.float16
)
model = Blip2ForConditionalGeneration.from_pretrained(
"Salesforce/blip2-flan-t5-xxl",
quantization_config=quantization_config,
device_map="auto"
)
# Usar LAVIS para ITM (Image-Text Matching)
from lavis.models import load_model_and_preprocess
model, vis_processors, txt_processors = load_model_and_preprocess(
name="blip2_image_text_matching",
model_type="pretrain",
is_eval=True,
device=device
)
image = vis_processors["eval"](raw_image).unsqueeze(0).to(device)
text = txt_processors["eval"]("a dog sitting on grass")
# Obter score de correspondência
itm_output = model({"image": image, "text_input": text}, match_head="itm")
itm_scores = torch.nn.functional.softmax(itm_output, dim=1)
print(f"Match probability: {itm_scores[:, 1].item():.3f}")
# Extrair características de imagem com Q-Former
from lavis.models import load_model_and_preprocess
model, vis_processors, _ = load_model_and_preprocess(
name="blip2_feature_extractor",
model_type="pretrain",
is_eval=True,
device=device
)
image = vis_processors["eval"](raw_image).unsqueeze(0).to(device)
# Obter características
features = model.extract_features({"image": image}, mode="image")
image_embeds = features.image_embeds # Shape: [1, 32, 768]
image_features = features.image_embeds_proj # Projetado para correspondência
import torch
from PIL import Image
from transformers import Blip2Processor, Blip2ForConditionalGeneration
from pathlib import Path
class ImageCaptioner:
def __init__(self, model_name="Salesforce/blip2-opt-2.7b"):
self.processor = Blip2Processor.from_pretrained(model_name)
self.model = Blip2ForConditionalGeneration.from_pretrained(
model_name,
torch_dtype=torch.float16,
device_map="auto"
)
def caption(self, image_path: str, prompt: str = None) -> str:
image = Image.open(image_path).convert("RGB")
if prompt:
inputs = self.processor(images=image, text=prompt, return_tensors="pt")
else:
inputs = self.processor(images=image, return_tensors="pt")
inputs = inputs.to("cuda", torch.float16)
generated_ids = self.model.generate(
**inputs,
max_new_tokens=50,
num_beams=5
)
return self.processor.decode(generated_ids[0], skip_special_tokens=True)
def caption_batch(self, image_paths: list, prompt: str = None) -> list:
images = [Image.open(p).convert("RGB") for p in image_paths]
if prompt:
inputs = self.processor(
images=images,
text=[prompt] * len(images),
return_tensors="pt",
padding=True
)
else:
inputs = self.processor(images=images, return_tensors="pt", padding=True)
inputs = inputs.to("cuda", torch.float16)
generated_ids = self.model.generate(**inputs, max_new_tokens=50)
return self.processor.batch_decode(generated_ids, skip_special_tokens=True)
# Uso
captioner = ImageCaptioner()
# Imagem única
caption = captioner.caption("photo.jpg")
print(f"Caption: {caption}")
# Com prompt para estilo
caption = captioner.caption("photo.jpg", "a detailed description of")
print(f"Detailed: {caption}")
# Processamento em lote
captions = captioner.caption_batch(["img1.jpg", "img2.jpg", "img3.jpg"])
for i, cap in enumerate(captions):
print(f"Image {i+1}: {cap}")
class VisualQA:
def __init__(self, model_name="Salesforce/blip2-flan-t5-xl"):
self.processor = Blip2Processor.from_pretrained(model_name)
self.model = Blip2ForConditionalGeneration.from_pretrained(
model_name,
torch_dtype=torch.float16,
device_map="auto"
)
self.current_image = None
self.current_inputs = None
def set_image(self, image_path: str):
"""Carregar imagem para múltiplas perguntas."""
self.current_image = Image.open(image_path).convert("RGB")
def ask(self, question: str) -> str:
"""Fazer uma pergunta sobre a imagem atual."""
if self.current_image is None:
raise ValueError("No image set. Call set_image() first.")
# Formatar pergunta para FlanT5
prompt = f"Question: {question} Answer:"
inputs = self.processor(
images=self.current_image,
text=prompt,
return_tensors="pt"
).to("cuda", torch.float16)
generated_ids = self.model.generate(
**inputs,
max_new_tokens=50,
num_beams=5
)
return self.processor.decode(generated_ids[0], skip_special_tokens=True)
def ask_multiple(self, questions: list) -> dict:
"""Fazer múltiplas perguntas sobre imagem atual."""
return {q: self.ask(q) for q in questions}
# Uso
vqa = VisualQA()
vqa.set_image("scene.jpg")
# Fazer perguntas
print(vqa.ask("What objects are in this image?"))
print(vqa.ask("What is the weather like?"))
print(vqa.ask("How many people are there?"))
# Perguntas em lote
results = vqa.ask_multiple([
"What is the main subject?",
"What colors are dominant?",
"Is this indoors or outdoors?"
])
import torch
import numpy as np
from PIL import Image
from lavis.models import load_model_and_preprocess
class ImageSearchEngine:
def __init__(self):
self.device = torch.device("cuda" if torch.cuda.is_available() else "cpu")
self.model, self.vis_processors, self.txt_processors = load_model_and_preprocess(
name="blip2_feature_extractor",
model_type="pretrain",
is_eval=True,
device=self.device
)
self.image_features = []
self.image_paths = []
def index_images(self, image_paths: list):
"""Construir índice de imagens."""
self.image_paths = image_paths
for path in image_paths:
image = Image.open(path).convert("RGB")
image = self.vis_processors["eval"](image).unsqueeze(0).to(self.device)
with torch.no_grad():
features = self.model.extract_features({"image": image}, mode="image")
# Usar características projetadas para correspondência
self.image_features.append(
features.image_embeds_proj.mean(dim=1).cpu().numpy()
)
self.image_features = np.vstack(self.image_features)
def search(self, query: str, top_k: int = 5) -> list:
"""Buscar imagens por query de texto."""
# Obter características de texto
text = self.txt_processors["eval"](query)
text_input = {"text_input": [text]}
with torch.no_grad():
text_features = self.model.extract_features(text_input, mode="text")
text_embeds = text_features.text_embeds_proj[:, 0].cpu().numpy()
# Calcular similaridades
similarities = np.dot(self.image_features, text_embeds.T).squeeze()
top_indices = np.argsort(similarities)[::-1][:top_k]
return [(self.image_paths[i], similarities[i]) for i in top_indices]
# Uso
engine = ImageSearchEngine()
engine.index_images(["img1.jpg", "img2.jpg", "img3.jpg", ...])
# Buscar
results = engine.search("a sunset over the ocean", top_k=5)
for path, score in results:
print(f"{path}: {score:.3f}")
# Geração direta retorna IDs de token
generated_ids = model.generate(**inputs, max_new_tokens=50)
# Shape: [batch_size, sequence_length]
# Decodificar para texto
text = processor.batch_decode(generated_ids, skip_special_tokens=True)
# Retorna: lista de strings
# Saídas Q-Former
features = model.extract_features({"image": image}, mode="image")
features.image_embeds # [B, 32, 768] - Saídas Q-Former
features.image_embeds_proj # [B, 32, 256] - Projetado para correspondência
features.text_embeds # [B, seq_len, 768] - Características de texto
features.text_embeds_proj # [B, 256] - Texto projetado (CLS)
| Modelo | VRAM FP16 | VRAM INT8 | VRAM INT4 |
|---|---|---|---|
| blip2-opt-2.7b | ~8GB | ~5GB | ~3GB |
| blip2-opt-6.7b | ~16GB | ~9GB | ~5GB |
| blip2-flan-t5-xl | ~10GB | ~6GB | ~4GB |
| blip2-flan-t5-xxl | ~26GB | ~14GB | ~8GB |
# Usar Flash Attention se disponível
model = Blip2ForConditionalGeneration.from_pretrained(
"Salesforce/blip2-opt-2.7b",
torch_dtype=torch.float16,
attn_implementation="flash_attention_2", # Requer flash-attn
device_map="auto"
)
# Compilar modelo (PyTorch 2.0+)
model = torch.compile(model)
# Usar imagens menores (se qualidade permitir)
processor = Blip2Processor.from_pretrained("Salesforce/blip2-opt-2.7b")
# Padrão é 224x224, que é ótimo
| Problema | Solução |
|---|---|
| CUDA OOM | Use quantização INT8/INT4, modelo menor |
| Geração lenta | Use decodificação greedy, reduza max_new_tokens |
| Legendas ruins | Tente variante FlanT5, use prompts |
| Alucinações | Diminua temperature, use beam search |
| Respostas erradas | Reformule pergunta, forneça contexto |
まだレビューはありません。使ってみた感想をお寄せください。
概要と使いどころ
Especialista em construir experiências 3D para a web - Three.js, React Three Fiber, Spline, WebGL e cenas 3D interativas. Cobre configuradores de produtos, portfólios 3D, websites imersivos e adição de profundidade às experiências web. Use quando: website 3D, three.js, WebGL, react three fiber, experiência 3D.
日本語の概要は準備中です。原文の説明を表示しています。
Quando o usuário quer planejar, projetar ou implementar um teste A/B ou experimento. Também use quando o usuário menciona "teste A/B", "split test", "experimento", "testar essa mudança", "copy variante", "teste multivariado" ou "hipótese". Para implementação de rastreamento, veja analytics-tracking.
日本語の概要は準備中です。原文の説明を表示しています。
Auditar e melhorar a acessibilidade web seguindo as diretrizes WCAG 2.1. Use quando solicitado para "melhorar acessibilidade", "auditoria a11y", "conformidade WCAG", "suporte a leitor de tela", "navegação por teclado" ou "tornar acessível".
日本語の概要は準備中です。原文の説明を表示しています。
Testes e benchmarking de agentes LLM incluindo testes comportamentais, avaliação de capacidades, métricas de confiabilidade e monitoramento em produção—onde até os melhores agentes alcançam menos de 50% em benchmarks do mundo real. Use quando: testes de agentes, avaliação de agentes, benchmark de agentes, confiabilidade de agentes, teste de agentes.
日本語の概要は準備中です。原文の説明を表示しています。
Criar, gerenciar e orquestrar agentes de IA usando o CLI AI Maestro. Use quando o usuário pedir para "criar agente", "listar agentes", "deletar agente", "hibernar agente", "despertar agente", "instalar plugin", "mostrar agente", "reiniciar agente" ou qualquer tarefa de gerenciamento do ciclo de vida do agente.
日本語の概要は準備中です。原文の説明を表示しています。
Gerencie múltiplos agentes CLI locais via sessões tmux (iniciar/parar/monitorar/atribuir) com agendamento compatível com cron.
日本語の概要は準備中です。原文の説明を表示しています。