Think about enviar seus próprios memes ou desenhos personalizados em vez dos da web. Portanto, transforme suas selfies ou fotos em adesivos divertidos e estilizados usando o novo modelo GPT-Picture-1 da OpenAI. Neste tutorial, construiremos um gerador de adesivos do WhatsApp em Python que aplica vários estilos de arte, incluindo caricatura e filtros estilo Pixar, às suas imagens.
Você aprenderá como configurar a API de edição de imagens OpenAI, capturar ou fazer add de imagens no Colab, definir categorias de texto engraçadas e bem-humoradas ou usar seu próprio texto e processar três adesivos em paralelo usando várias chaves de API para aumentar a velocidade. No ultimate, você terá um criador de adesivos funcional com tecnologia GPT-Picture-1 e prompts de texto personalizados.
Por que GPT-Imagem-1?
Avaliamos vários modelos de geração de imagens de última geração, incluindo Gemini 2.0 Flash, Flux e Phoenix, no Leonardo.ai plataforma. Em explicit, todos esses modelos tiveram dificuldades para renderizar textos e expressões corretamente. Por exemplo:
- do Google Gêmeos 2.0 A API de imagem geralmente produz palavras com erros ortográficos ou confusas, mesmo quando recebem instruções exatas. Por exemplo, com Gêmeos, o texto exato parece ‘Grande promoção hoje!’ e obtemos resultados como “Large Sale Todai” ou jargões aleatórios.
- O Flux oferece alta qualidade de imagem em geral, mas os usuários relatam que ele “introduziu rapidamente pequenos erros” em qualquer texto que renderiza. O Flux também comete pequenos erros ortográficos ou letras distorcidas, especialmente à medida que o comprimento do texto aumenta. O Flux também assume como padrão gerações de faces muito semelhantes, ou seja, “todas as faces têm a mesma aparência”, a menos que sejam fortemente restringidas.
- Phoenix é otimizado para fidelidade e adesão imediata, mas como a maioria dos modelos de difusão, ele ainda visualiza o texto visualmente e pode introduzir erros. Descobrimos que o Phoenix conseguia gerar um adesivo com o texto correto apenas esporadicamente e tendia a repetir a mesma face padrão para um determinado immediate.
Juntas, essas limitações nos levaram a desenvolver GPT-Imagem-1. Ao contrário dos modelos acima, GPT-Picture-1 incorpora um pipeline de immediate especializado que impõe explicitamente alterações corretas de texto e expressão.
Leia mais: Como executar o modelo Flux?
Como GPT-Picture-1 potencializa a edição de imagens
GPT-Picture-1 é o principal modelo multimodal da OpenAI. Ele cria e edita imagens a partir de prompts de texto e imagem para gerar saídas de imagem de alta qualidade. Essencialmente, podemos instruir GPT-Picture-1 a aplicar uma edição a uma imagem de origem com base em um immediate de texto. No nosso caso, usamos as imagens. Edite o endpoint da API com GPT-Picture-1 para aplicar filtros divertidos e bem-humorados e sobreponha texto a uma entrada de foto para criar adesivos.
O immediate é cuidadosamente construído para impor uma saída amigável com adesivos (1024×1024 PNG). Então, GPT-Picture-1 se torna essencialmente o criador de adesivos com tecnologia de IA, onde mudará a aparência do assunto na foto e adicionará texto hilário.
# Arrange OpenAI shoppers for every API key (to run parallel requests)
shoppers = (OpenAI(api_key=key) for key in API_KEYS)Então, para isso, criamos um cliente OpenAI por chave API. Com três chaves, podemos fazer três chamadas de API simultâneas. Essa abordagem multichave e multithread usa ThreadPoolExecutor. Permite gerar 3 adesivos em paralelo para cada corrida. À medida que o código é impresso, ele usa “3 chaves API para geração SIMULTÂNEA”, acelerando drasticamente a criação do adesivo.
Guia passo a passo
A ideia de criar seu próprio gerador de adesivos de IA pode parecer complexa, mas este guia o ajudará a simplificar todo o processo. Você começará com a preparação do ambiente no Google Colab, depois revisaremos a API, entenderemos categorias de frases, validaremos texto, geraremos diferentes estilos artísticos e por fim geraremos adesivos em paralelo. Cada parte é acompanhada por trechos de código e explicações para que você possa acompanhar facilmente. Agora, vamos prosseguir para o código:
Instalando e executando no Colab
Para gerar adesivos, precisamos ter a configuração certa! Este projeto usará bibliotecas Python PIL e rembg para processamento básico de imagens e google-genai será usado para uso na instância do Colab. O primeiro passo é instalar as dependências diretamente no seu pocket book Colab.
!pip set up --upgrade google-genai pillow rembg
!pip set up --upgrade onnxruntime
!pip set up python-dotenvIntegração OpenAI e chaves de API
Após a instalação, importe os módulos e configure as chaves API. O script cria um cliente OpenAI por chave de API. Isso permite que o código distribua solicitações de edição de imagem em várias chaves em paralelo. A lista de clientes é então usada pelas funções de geração de adesivos.
API_KEYS = ( # 3 API keys
"API KEY 1",
"API KEY 2",
"API KEY 3"
)
"""# Stickerverse
"""
import os
import random
import base64
import threading
from concurrent.futures import ThreadPoolExecutor, as_completed
from openai import OpenAI
from PIL import Picture
from io import BytesIO
from rembg import take away
from google.colab import recordsdata
from IPython.show import show, Javascript
from google.colab.output import eval_js
import time
shoppers = (OpenAI(api_key=key) for key in API_KEYS)Add de imagem e captura de câmera (lógica)
Agora o próximo passo é acessar a câmera para tirar uma foto ou fazer add de um arquivo de imagem. O capture_photo() usa JavaScript injetado no Colab para abrir a webcam e retornar uma imagem capturada picture.upload_image() usa o widget de add de arquivo do Colab e verifica o arquivo carregado com PIL.
# Digicam seize by way of JS
def capture_photo(filename="photograph.jpg", high quality=0.9):
js_code = """
async perform takePhoto(high quality) {
const div = doc.createElement('div');
const video = doc.createElement('video');
const btn = doc.createElement('button');
btn.textContent="📸 Seize";
div.appendChild(video);
div.appendChild(btn);
doc.physique.appendChild(div);
const stream = await navigator.mediaDevices.getUserMedia({video: true});
video.srcObject = stream;
await video.play();
await new Promise(resolve => btn.onclick = resolve);
const canvas = doc.createElement('canvas');
canvas.width = video.videoWidth;
canvas.peak = video.videoHeight;
canvas.getContext('2nd').drawImage(video, 0, 0);
stream.getTracks().forEach(monitor => monitor.cease());
div.take away();
return canvas.toDataURL('picture/jpeg', high quality);
}
"""
show(Javascript(js_code))
information = eval_js("takePhoto(%f)" % high quality)
binary = base64.b64decode(information.cut up(',')(1))
with open(filename, 'wb') as f:
f.write(binary)
print(f"Saved: {filename}")
return filename
# Picture add perform
def upload_image():
print("Please add your picture file...")
uploaded = recordsdata.add()
if not uploaded:
print("No file uploaded!")
return None
filename = checklist(uploaded.keys())(0)
print(f"Uploaded: {filename}")
# Validate if it is a picture
attempt:
img = Picture.open(filename)
img.confirm()
print(f"📸 Picture verified: {img.format} {img.dimension}")
return filename
besides Exception as e:
print(f"Invalid picture file: {str(e)}")
return None
# Interactive picture supply choice
def select_image_source():
print("Select picture supply:")
print("1. Seize from digital camera")
print("2. Add picture file")
whereas True:
attempt:
alternative = enter("Choose possibility (1-2): ").strip()
if alternative == "1":
return "digital camera"
elif alternative == "2":
return "add"
else:
print("Invalid alternative! Please enter 1 or 2.")
besides KeyboardInterrupt:
print("nGoodbye!")
return NoneSaída:
Exemplos de categorias e frases
Agora criaremos nossas diferentes categorias de frases para colocar em nossos adesivos. Portanto, usaremos um dicionário PHRASE_CATEGORIES que contém diversas categorias, como corporativa, Bollywood, Hollywood, Tollywood, esportes, memes e outras. Quando uma categoria é escolhida, o código seleciona aleatoriamente três frases exclusivas para os três estilos de adesivos.
PHRASE_CATEGORIES = {
"company": (
"One other assembly? Could the pressure be with you!",
"Monday blues activated!",
"This might have been an e mail, boss!"
),
"bollywood": (
"Mogambo khush hua!",
"Kitne aadmi the?",
"Image abhi baaki hai mere dost!"
),
"memes": (
"Bhagwan bharose!",
"Principal thak gaya hoon!",
"Beta tumse na ho payega!"
)
}Categorias de frases e texto personalizado
O gerador usa um dicionário de categorias de frases. O usuário pode selecionar uma categoria para seleção de frase aleatória ou inserir sua própria frase personalizada. Existem também funções auxiliares para seleção interativa, bem como uma função simples para validar o comprimento de uma frase personalizada.
def select_category_or_custom():
print("nChoose your sticker textual content possibility:")
print("1. Decide from phrase class (random choice)")
print("2. Enter my very own customized phrase")
whereas True:
attempt:
alternative = enter("Select possibility (1 or 2): ").strip()
if alternative == "1":
return "class"
elif alternative == "2":
return "customized"
else:
print("Invalid alternative! Please enter 1 or 2.")
besides KeyboardInterrupt:
print("nGoodbye!")
return None
# NEW: Operate to get customized phrase from consumer
def get_custom_phrase():
whereas True:
phrase = enter("nEnter your customized sticker textual content (2-50 characters): ").strip()
if len(phrase) < 2:
print("Too quick! Please enter at the very least 2 characters.")
proceed
elif len(phrase) > 50:
print("Too lengthy! Please preserve it below 50 characters.")
proceed
else:
print(f"Customized phrase accepted: '{phrase}'")
return phrasePara frases personalizadas, o comprimento da entrada é verificado (2 a 50 caracteres) antes da aceitação.
Validação de frases e proteções ortográficas
def validate_and_correct_spelling(textual content):
spelling_prompt = f"""
Please examine the spelling and grammar of the next textual content and return ONLY the corrected model.
Don't add explanations, feedback, or change the which means.
Textual content to examine: "{textual content}"
"""
response = shoppers(0).chat.completions.create(
mannequin="gpt-4o-mini",
messages=({"function": "consumer", "content material": spelling_prompt}),
max_tokens=100,
temperature=0.1
)
corrected_text = response.decisions(0).message.content material.strip()
return corrected_textAgora vamos criar um exemplo build_prompt função para configurar algumas instruções de nível básico para o agente. Observe também build_prompt() chama o validador ortográfico e, em seguida, incorpora o texto corrigido no immediate estrito do adesivo:
# Concise Immediate Builder with Spelling Validation
def build_prompt(textual content, style_variant):
corrected_text = validate_and_correct_spelling(textual content)
base_prompt = f"""
Create a HIGH-QUALITY WhatsApp sticker in {style_variant} fashion.
OUTPUT:
- 1024x1024 clear PNG with 8px white border
- Topic centered, balanced composition, sharp particulars
- Protect authentic facial identification and proportions
- Match expression to sentiment of textual content: '{corrected_text}'
TEXT:
- Use EXACT textual content: '{corrected_text}' (no adjustments, no emojis)
- Daring comedian font with black define, high-contrast colours
- Place textual content in empty house (prime/backside), by no means overlaying the face
RULES:
- No hallucinated parts or ornamental glyphs
- No cropping of head/face or textual content
- Preserve practical however expressive look
- Guarantee consistency throughout stickers
"""
return base_prompt.strip()Variantes de estilo: Caricatura vs Pixar
Os três modelos de estilo residem em STYLE_VARIANTS. As duas primeiras são transformações de caricatura e a última é um visible 3D no estilo Pixar. Essas strings serão enviadas diretamente para o construtor de immediate e ditarão o estilo visible.
STYLE_VARIANTS = ("Remodel into detailed caricature with barely exaggerated facial options...",
"Remodel into expressive caricature with enhanced persona options...",
"Remodel into high-quality Pixar-style 3D animated character..."
)
Gerando adesivos em paralelo
A verdadeira força do projeto é a geração paralela de adesivos. A geração do adesivo é feita em paralelo com a segmentação dos três ao mesmo tempo, usando chaves de API separadas, de modo que os tempos de espera são drasticamente reduzidos.
# Generate single sticker utilizing OpenAI GPT-image-1 with particular shopper (WITH TIMING)
def generate_single_sticker(input_path, output_path, textual content, style_variant, client_idx):
attempt:
start_time = time.time()
thread_id = threading.current_thread().identify
print(f"(START) Thread-{thread_id}: API-{client_idx+1} producing {style_variant(:30)}... at {time.strftime('%H:%M:%S', time.localtime(start_time))}")
immediate = build_prompt(textual content, style_variant)
consequence = shoppers(client_idx).pictures.edit(
mannequin="gpt-image-1",
picture=(open(input_path, "rb")),
immediate=immediate,
# input_fidelity="excessive"
high quality = 'medium'
)
image_base64 = consequence.information(0).b64_json
image_bytes = base64.b64decode(image_base64)
with open(output_path, "wb") as f:
f.write(image_bytes)
end_time = time.time()
period = end_time - start_time
style_type = "Caricature" if "caricature" in style_variant.decrease() else "Pixar"
print(f"(DONE) Thread-{thread_id}: {style_type} saved as {output_path} | Period: {period:.2f}s | Textual content: '{textual content(:30)}...'")
return True
besides Exception as e:
print(f"(ERROR) API-{client_idx+1} failed: {str(e)}")
return False
# NEW: Create stickers with customized phrase (all 3 kinds use the identical customized textual content)
def create_custom_stickers_parallel(photo_file, custom_text):
print(f"nCreating 3 stickers together with your customized phrase: '{custom_text}'")
print(" • Type 1: Caricature #1")
print(" • Type 2: Caricature #2")
print(" • Type 3: Pixar Animation")
# Map futures to their information
tasks_info = {}
with ThreadPoolExecutor(max_workers=3, thread_name_prefix="CustomSticker") as executor:
start_time = time.time()
print(f"n(PARALLEL START) Submitting 3 API calls SIMULTANEOUSLY at {time.strftime('%H:%M:%S', time.localtime(start_time))}")
# Submit ALL duties without delay (non-blocking) - all utilizing the identical customized textual content
for idx, style_variant in enumerate(STYLE_VARIANTS):
output_name = f"custom_sticker_{idx+1}.png"
future = executor.submit(generate_single_sticker, photo_file, output_name, custom_text, style_variant, idx)
tasks_info(future) = {
'output_name': output_name,
'textual content': custom_text,
'style_variant': style_variant,
'client_idx': idx,
'submit_time': time.time()
}
print("All 3 API requests submitted! Processing as they full...")
accomplished = 0
completion_times = ()
# Course of outcomes as they full
for future in as_completed(tasks_info.keys(), timeout=180):
attempt:
success = future.consequence()
task_info = tasks_info(future)
if success:
accomplished += 1
completion_time = time.time()
completion_times.append(completion_time)
period = completion_time - task_info('submit_time')
style_type = "Caricature" if "caricature" in task_info('style_variant').decrease() else "Pixar"
print(f"({accomplished}/3) {style_type} accomplished: {task_info('output_name')} "
f"(API-{task_info('client_idx')+1}, {period:.1f}s)")
else:
print(f"Failed: {task_info('output_name')}")
besides Exception as e:
task_info = tasks_info(future)
print(f"Error with {task_info('output_name')} (API-{task_info('client_idx')+1}): {str(e)}")
total_time = time.time() - start_time
print(f"n (FINAL RESULT) {accomplished}/3 customized stickers accomplished in {total_time:.1f} seconds!")
# UPDATED: Create 3 stickers in PARALLEL (utilizing as_completed)
def create_category_stickers_parallel(photo_file, class):
if class not in PHRASE_CATEGORIES:
print(f" Class '{class}' not discovered! Obtainable: {checklist(PHRASE_CATEGORIES.keys())}")
return
# Select 3 distinctive phrases for 3 stickers
chosen_phrases = random.pattern(PHRASE_CATEGORIES(class), 3)
print(f" Chosen phrases for {class.title()} class:")
for i, phrase in enumerate(chosen_phrases, 1):
style_type = "Caricature" if i <= 2 else "Pixar Animation"
print(f" {i}. ({style_type}) '{phrase}' → API Key {i}")
# Map futures to their information
tasks_info = {}
with ThreadPoolExecutor(max_workers=3, thread_name_prefix="StickerGen") as executor:
start_time = time.time()
print(f"n (PARALLEL START) Submitting 3 API calls SIMULTANEOUSLY at {time.strftime('%H:%M:%S', time.localtime(start_time))}")
# Submit ALL duties without delay (non-blocking)
for idx, (style_variant, textual content) in enumerate(zip(STYLE_VARIANTS, chosen_phrases)):
output_name = f"{class}_sticker_{idx+1}.png"
future = executor.submit(generate_single_sticker, photo_file, output_name, textual content, style_variant, idx)
tasks_info(future) = {
'output_name': output_name,
'textual content': textual content,
'style_variant': style_variant,
'client_idx': idx,
'submit_time': time.time()
}
print("All 3 API requests submitted! Processing as they full...")
print(" • API Key 1 → Caricature #1")
print(" • API Key 2 → Caricature #2")
print(" • API Key 3 → Pixar Animation")
accomplished = 0
completion_times = ()
# Course of outcomes as they full (NOT in submission order)
for future in as_completed(tasks_info.keys(), timeout=180): # 3 minute complete timeout
attempt:
success = future.consequence() # This solely waits till ANY future completes
task_info = tasks_info(future)
if success:
accomplished += 1
completion_time = time.time()
completion_times.append(completion_time)
period = completion_time - task_info('submit_time')
style_type = "Caricature" if "caricature" in task_info('style_variant').decrease() else "Pixar"
print(f"({accomplished}/3) {style_type} accomplished: {task_info('output_name')} "
f"(API-{task_info('client_idx')+1}, {period:.1f}s) - '{task_info('textual content')(:30)}...'")
else:
print(f"Failed: {task_info('output_name')}")
besides Exception as e:
task_info = tasks_info(future)
print(f"Error with {task_info('output_name')} (API-{task_info('client_idx')+1}): {str(e)}")
total_time = time.time() - start_time
print(f"n(FINAL RESULT) {accomplished}/3 stickers accomplished in {total_time:.1f} seconds!")
if len(completion_times) > 1:
fastest_completion = min(completion_times) - start_time
print(f"Parallel effectivity: Quickest completion in {fastest_completion:.1f}s")Aqui, generate_single_sticker() cria o immediate e chama as imagens. edite o endpoint usando o client_idx especificado. As funções paralelas criam um ThreadPoolExecutor com max_workers=3, enviam as três tarefas e processam os resultados com as_completed. Isso permite que o script registre cada adesivo finalizado rapidamente. Além disso, também podemos visualizar os logs para ver o que está acontecendo em cada thread (tempo, o que foi caricatura ou estilo Pixar).
Bloco de execução principal
Na parte inferior do roteiro, o __main__ guarda padroniza para execução sticker_from_camera(). No entanto, você pode concordar/descomentar conforme desejar para executar interactive_menu(), create_all_category_stickers() ou outras funções.
# Principal execution
if __name__ == "__main__":
sticker_from_camera()Saída:
Imagem de saída:
Para a versão completa deste código gerador de adesivos do WhatsApp, visite este GitHub repositório.
Conclusão
Neste tutorial, explicamos como configurar chamadas GPT-Picture-1, construir um immediate estendido para adesivos, capturar ou fazer add de imagens, selecionar frases divertidas ou texto personalizado e executar 3 variantes de estilo simultaneamente. Em apenas algumas centenas de linhas de código, este projeto converte suas fotos em adesivos em estilo quadrinhos.
Simplesmente combinando o modelo de visão da OpenAI com alguma engenharia criativa e multi-threading, você pode gerar adesivos divertidos e personalizados em segundos. E o resultado será um gerador de adesivos do WhatsApp baseado em IA que pode produzir adesivos compartilháveis instantaneamente com um único clique para qualquer um de seus amigos e grupos. Agora experimente com sua própria foto e sua piada favorita!
Perguntas frequentes
R. Ele transforma suas fotos enviadas ou capturadas em adesivos divertidos e estilizados do WhatsApp com texto usando o modelo GPT-Picture-1 da OpenAI.
R. GPT-Picture-1 lida com precisão de texto e expressões faciais melhor do que modelos como Gemini, Flux ou Phoenix, garantindo que os adesivos tenham palavras corretas e visuais expressivos.
R. Ele usa três chaves de API OpenAI e um ThreadPoolExecutor para gerar três adesivos em paralelo, reduzindo o tempo de processamento.
Olá! Sou Vipin, um entusiasta apaixonado por ciência de dados e aprendizado de máquina, com uma sólida base em análise de dados, algoritmos de aprendizado de máquina e programação. Tenho experiência prática na construção de modelos, gerenciamento de dados confusos e solução de problemas do mundo actual. Meu objetivo é aplicar insights baseados em dados para criar soluções práticas que gerem resultados. Estou ansioso para contribuir com minhas habilidades em um ambiente colaborativo enquanto continuo aprendendo e crescendo nas áreas de Ciência de Dados, Aprendizado de Máquina e PNL.
Faça login para continuar lendo e desfrutar de conteúdo com curadoria de especialistas.