Erstellen Sie mit Python einen KI-gestützten WhatsApp-Sticker-Generator

Stellen Sie sich vor, Sie versenden Ihre eigenen benutzerdefinierten Memes oder Cartoons anstelle derer aus dem Web. Verwandeln Sie additionally Ihre Selfies oder Fotos mit dem neuen GPT-Picture-1-Modell von OpenAI in lustige, stilisierte Aufkleber. In diesem Tutorial erstellen wir einen WhatsApp-Sticker-Generator in Python, der verschiedene Kunststile, einschließlich Karikaturen und Filter im Pixar-Stil, auf Ihre Bilder anwendet.

Sie erfahren, wie Sie die OpenAI-Bildbearbeitungs-API einrichten, Bilder in Colab erfassen oder hochladen, lustige und humorvolle Textkategorien definieren oder Ihren eigenen Textual content verwenden und drei Aufkleber parallel mit mehreren API-Schlüsseln verarbeiten, um die Geschwindigkeit zu erhöhen. Am Ende verfügen Sie über einen funktionierenden Sticker-Ersteller, der auf GPT-Picture-1 und benutzerdefinierten Textaufforderungen basiert.

Warum GPT-Picture-1?

Wir haben mehrere hochmoderne Bilderzeugungsmodelle getestet, darunter Gemini 2.0 Flash, Flux und Phoenix Leonardo.ai Plattform. Insbesondere hatten alle diese Modelle Probleme mit der korrekten Wiedergabe von Textual content und Ausdrücken. Zum Beispiel:

• Googles Zwillinge 2.0 Die Bild-API erzeugt häufig falsch geschriebene oder durcheinandergebrachte Wörter, selbst wenn genaue Anweisungen gegeben werden. Bei Gemini sieht der genaue Textual content beispielsweise wie „Großer Ausverkauf heute!“ aus. und wir bekommen Ausgaben wie „Huge Sale Todai“ oder zufälliges Kauderwelsch.
• Flux liefert im Allgemeinen eine hohe Bildqualität, Benutzer berichten jedoch, dass es „schnell kleine Fehler“ in den gerenderten Textual content einführte. Flux macht auch kleine Rechtschreibfehler oder verstümmelte Buchstaben, insbesondere wenn die Textlänge zunimmt. Flux verwendet außerdem standardmäßig sehr ähnliche Gesichtsgenerationen, dh „alle Gesichter sehen gleich aus“, sofern keine starken Einschränkungen bestehen.
• Phoenix ist auf Wiedergabetreue und schnelle Einhaltung optimiert, aber wie die meisten Diffusionsmodelle zeigt es Textual content immer noch visuell an und kann zu Fehlern führen. Wir haben festgestellt, dass Phoenix nur sporadisch einen Aufkleber mit dem richtigen Wortlaut erstellen konnte und dazu neigte, bei einer bestimmten Eingabeaufforderung dasselbe Standardgesicht zu wiederholen.

Gemeinsam führten diese Einschränkungen dazu, dass wir uns weiterentwickelten GPT-Bild-1. Im Gegensatz zu den oben genannten Modellen enthält GPT-Picture-1 eine spezielle Eingabeaufforderungspipeline, die explizit korrekte Textual content- und Ausdrucksänderungen erzwingt.

Mehr lesen: Wie führt man das Flux-Modell aus?

Wie GPT-Picture-1 die Bildbearbeitung unterstützt

GPT-Picture-1 ist das Flaggschiff-Multimodalmodell von OpenAI. Es erstellt und bearbeitet Bilder aus Textual content- und Bildaufforderungen, um qualitativ hochwertige Bildausgaben zu generieren. Im Wesentlichen können wir GPT-Picture-1 anweisen, basierend auf einer Textaufforderung eine Bearbeitung auf ein Quellbild anzuwenden. In unserem Fall verwenden wir die Bilder. Bearbeiten Sie den API-Endpunkt mit GPT-Picture-1, um unterhaltsame und humorvolle Filter anzuwenden, und überlagern Sie Textual content mit einer Fotoeingabe, um Aufkleber zu erstellen.

Die Eingabeaufforderung ist sorgfältig aufgebaut, um eine Aufkleber-freundliche Ausgabe (1024 x 1024 PNG) zu gewährleisten. Dann wird GPT-Picture-1 im Wesentlichen zum KI-gestützten Sticker-Ersteller, der das Erscheinungsbild des Motivs im Foto verändert und urkomischen Textual content hinzufügt.

# Arrange OpenAI shoppers for every API key (to run parallel requests)

shoppers = (OpenAI(api_key=key) for key in API_KEYS)

Dazu erstellen wir einen OpenAI-Shopper professional API-Schlüssel. Mit drei Schlüsseln können wir drei gleichzeitige API-Aufrufe durchführen. Dieser Ansatz mit mehreren Schlüsseln und mehreren Threads verwendet ThreadPoolExecutor. Damit können wir für jeden Lauf 3 Aufkleber parallel generieren. Beim Drucken des Codes werden „3 API-Schlüssel zur GLEICHZEITIGEN Generierung“ verwendet, was die Erstellung des Aufklebers erheblich beschleunigt.

Schritt-für-Schritt-Anleitung

Die Idee, einen eigenen KI-Sticker-Generator zu erstellen, magazine komplex klingen, aber dieser Leitfaden hilft Ihnen, den gesamten Prozess zu vereinfachen. Sie beginnen mit der Vorbereitung der Umgebung in Google Colab, dann überprüfen wir die API, verstehen Kategorien von Phrasen, validieren Textual content, generieren verschiedene künstlerische Stile und generieren schließlich parallel Aufkleber. Jeder Teil wird von Codeausschnitten und Erklärungen begleitet, sodass Sie problemlos mitmachen können. Fahren wir nun mit dem Code fort:

Set up und Ausführung auf Colab

Um Aufkleber zu generieren, müssen wir das richtige Setup haben! Dieses Projekt verwendet Python-Bibliotheken PIL Und rembg für die grundlegende Bildverarbeitung und google-genai wird für die Verwendung in der Colab-Instanz verwendet. Der erste Schritt besteht darin, die Abhängigkeiten direkt in Ihrem Colab-Pocket book zu installieren.

!pip set up --upgrade google-genai pillow rembg

!pip set up --upgrade onnxruntime

!pip set up python-dotenv

OpenAI-Integration und API-Schlüssel

Importieren Sie nach der Set up die Module und richten Sie API-Schlüssel ein. Das Skript erstellt einen OpenAI-Shopper professional API-Schlüssel. Dadurch kann der Code Bildbearbeitungsanfragen parallel auf mehrere Schlüssel verteilen. Die Clientliste wird dann von den Funktionen zur Aufklebergenerierung verwendet.

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)

Bild-Add und Kameraaufnahme (Logik)

Nun besteht der nächste Schritt darin, auf die Kamera zuzugreifen, um ein Foto aufzunehmen oder eine Bilddatei hochzuladen. Der capture_photo() verwendet in Colab injiziertes JavaScript, um die Webcam zu öffnen und eine Aufnahme zurückzugeben picture.upload_image() verwendet das Datei-Add-Widget von Colab und überprüft die hochgeladene Datei mit PIL.

# Digital camera seize by way of JS

def capture_photo(filename="picture.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('second').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 = listing(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.measurement}")

        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 digicam")

    print("2. Add picture file")

    whereas True:

        attempt:

            selection = enter("Choose possibility (1-2): ").strip()

            if selection == "1":

                return "digicam"

            elif selection == "2":

                return "add"

            else:

                print("Invalid selection! Please enter 1 or 2.")

        besides KeyboardInterrupt:

            print("nGoodbye!")

            return None

Ausgabe:

Beispiele für Kategorien und Phrasen

Jetzt erstellen wir unsere verschiedenen Phrasenkategorien, die wir auf unsere Aufkleber kleben. Daher verwenden wir ein PHRASE_CATEGORIES-Wörterbuch, das viele Kategorien enthält, z. B. Unternehmen, Bollywood, Hollywood, Tollywood, Sport, Memes und andere. Wenn eine Kategorie ausgewählt wird, wählt der Code zufällig drei einzigartige Phrasen für die drei Aufkleberstile aus.

PHRASE_CATEGORIES = {

    "company": (

        "One other assembly? Might the power 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!",

        "Primary thak gaya hoon!",

        "Beta tumse na ho payega!"

    )

}

Phrasenkategorien und benutzerdefinierter Textual content

Der Generator verwendet ein Wörterbuch mit Phrasenkategorien. Der Benutzer kann entweder eine Kategorie für die zufällige Auswahl von Phrasen auswählen oder eine eigene benutzerdefinierte Phrase eingeben. Es gibt auch Hilfsfunktionen für die interaktive Auswahl sowie eine einfache Funktion zum Überprüfen der Länge einer benutzerdefinierten Phrase.

def select_category_or_custom():

    print("nChoose your sticker textual content possibility:")

    print("1. Choose from phrase class (random choice)")

    print("2. Enter my very own customized phrase")

    whereas True:

        attempt:

            selection = enter("Select possibility (1 or 2): ").strip()

            if selection == "1":

                return "class"

            elif selection == "2":

                return "customized"

            else:

                print("Invalid selection! Please enter 1 or 2.")

        besides KeyboardInterrupt:

            print("nGoodbye!")

            return None

# NEW: Operate to get customized phrase from person

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 a minimum of 2 characters.")

            proceed

        elif len(phrase) > 50:

            print("Too lengthy! Please maintain it beneath 50 characters.")

            proceed

        else:

            print(f"Customized phrase accepted: '{phrase}'")

            return phrase

Bei benutzerdefinierten Phrasen wird die Eingabelänge vor der Annahme überprüft (2–50 Zeichen).

Phrasenvalidierung und Rechtschreibschutz

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=({"position": "person", "content material": spelling_prompt}),

        max_tokens=100,

        temperature=0.1

    )

    corrected_text = response.decisions(0).message.content material.strip()

    return corrected_text

Jetzt erstellen wir ein Beispiel build_prompt Funktion zum Einrichten einiger grundlegender Anweisungen für den Agenten. Beachten Sie auch build_prompt() ruft den Rechtschreibprüfer auf und bettet dann den korrigierten Textual content in die strikte Aufkleberaufforderung ein:

# 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} model.

    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 modifications, 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 reasonable however expressive look

    - Guarantee consistency throughout stickers

    """

    return base_prompt.strip()

Stilvarianten: Karikatur vs. Pixar

Die drei Stilvorlagen befinden sich in STYLE_VARIANTS. Die ersten beiden sind Karikaturtransformationen und die letzte ist ein Pixar-artiger 3D-Look. Diese Zeichenfolgen werden direkt an den Immediate Builder gesendet und bestimmen den visuellen Stil.

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..."
)

Paralleles Generieren von Aufklebern

Die eigentliche Stärke des Projekts ist die parallele Sticker-Generierung. Die Sticker-Generierung erfolgt parallel zum Threading aller drei gleichzeitig unter Verwendung separater API-Schlüssel, sodass die Wartezeiten drastisch reduziert werden.

# Generate single sticker utilizing OpenAI GPT-image-1 with particular consumer (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)

        end result = shoppers(client_idx).pictures.edit(

            mannequin="gpt-image-1",

            picture=(open(input_path, "rb")),

            immediate=immediate,

            # input_fidelity="excessive"

            high quality = 'medium'

        )

        image_base64 = end result.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()

        length = 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: {length:.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 types 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 data

    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.end result()

                task_info = tasks_info(future)

                if success:

                    accomplished += 1

                    completion_time = time.time()

                    completion_times.append(completion_time)

                    length = 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}, {length:.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! Accessible: {listing(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 data

    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 whole timeout

            attempt:

                success = future.end result()  # 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)

                    length = 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}, {length:.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")

Hier, generate_single_sticker() erstellt die Eingabeaufforderung und ruft die Bilder auf. Bearbeiten Sie den Endpunkt mit der angegebenen client_idx. Die parallelen Funktionen erstellen einen ThreadPoolExecutor mit max_workers=3, übermitteln die drei Aufgaben und verarbeiten die Ergebnisse mit as_completed. Dadurch kann das Skript jeden fertigen Aufkleber schnell protokollieren. Darüber hinaus können wir auch die Protokolle einsehen, um zu sehen, was in jedem Thread passiert (Zeit, was struggle das für eine Karikatur oder im Pixar-Stil).

Hauptausführungsblock

Am Ende des Skripts befindet sich das __main__ Guard wird standardmäßig ausgeführt sticker_from_camera(). Sie können der Ausführung jedoch nach Bedarf zustimmen/auskommentieren interactive_menu(), create_all_category_stickers() oder andere Funktionen.

# Primary execution

if __name__ == "__main__":

    sticker_from_camera()

Ausgabe:

Ausgabebild:

Die vollständige Model dieses WhatsApp-Sticker-Generatorcodes finden Sie auf diesem GitHub Repository.

Abschluss

In diesem Tutorial haben wir das Einrichten von GPT-Picture-1-Aufrufen, das Erstellen einer erweiterten Eingabeaufforderung für Aufkleber, das Erfassen oder Hochladen von Bildern, das Auswählen lustiger Phrasen oder benutzerdefinierten Textes und das gleichzeitige Ausführen von drei Stilvarianten durchlaufen. In nur wenigen hundert Codezeilen wandelt dieses Projekt Ihre Bilder in Aufkleber im Comedian-Stil um.

Durch die einfache Kombination des Imaginative and prescient-Modells von OpenAI mit etwas kreativem Immediate-Engineering und Multithreading können Sie in Sekundenschnelle unterhaltsame, personalisierte Aufkleber erstellen. Und das Ergebnis wird ein KI-basierter WhatsApp-Sticker-Generator sein, der mit einem einzigen Klick sofort Sticker erstellen kann, die Sie an alle Ihre Freunde und Gruppen weitergeben können. Probieren Sie es jetzt für Ihr eigenes Foto und Ihren Lieblingswitz aus!

Häufig gestellte Fragen

Hallo! Ich bin Vipin, ein leidenschaftlicher Fanatic für Datenwissenschaft und maschinelles Lernen mit fundierten Kenntnissen in Datenanalyse, Algorithmen für maschinelles Lernen und Programmierung. Ich verfüge über praktische Erfahrung in der Modellerstellung, der Verwaltung unübersichtlicher Daten und der Lösung realer Probleme. Mein Ziel ist es, datengesteuerte Erkenntnisse anzuwenden, um praktische Lösungen zu schaffen, die zu Ergebnissen führen. Ich bin bestrebt, meine Fähigkeiten in einer kollaborativen Umgebung einzubringen und gleichzeitig weiterhin in den Bereichen Information Science, maschinelles Lernen und NLP zu lernen und mich weiterzuentwickeln.