So führen Sie FLUXor Free aus: Eine Schritt-für-Schritt-Anleitung

Flux.1 ist das neueste Text-zu-Bild-Modell auf dem Markt, das uns von Black Forest Labs zur Verfügung gestellt wurde. Es handelt sich um ein hochmodernes Modell, das aus Textbeschreibungen hochwertige Bilder generieren kann, komplexe Beschreibungen verarbeitet und hochwertige Bilder mit feinen Details generiert.

Wer steckt hinter Flux.1?

Flux.1 wird von Black Forest Labs entwickelt, einem Unternehmen, das von einer Gruppe ehemaliger Mitarbeiter von Stability AI gegründet wurde.

Wie funktioniert es?

Im Gegensatz zu anderen Diffusionsmodellen wie Stable Diffusion, die Bilder durch schrittweises Entfernen von Rauschen von einem zufälligen Startpunkt aus erzeugen, generiert Flux.1 Bilder mithilfe einer Technik namens „Flow Matching“, die einen direkteren Ansatz verfolgt und die genauen Transformationen erlernt, die dazu erforderlich sind Wandeln Sie Rauschen in ein realistisches Bild um. Dadurch können qualitativ hochwertige Bilder schneller und mit weniger Schritten als bei herkömmlichen Diffusionsmodellen generiert werden.

Außerdem kann Flux.1 mit diesem anderen Ansatz Bilder mit darin enthaltenem Text verarbeiten, wie das folgende:

Ein fotorealistisches Bild eines modernen, eleganten Laptops mit geöffneter Webseite, auf der der Text „codestackme“ in einem klaren, minimalistischen Design angezeigt wird. Der Laptop sollte auf einem weißen Schreibtisch mit sanfter Beleuchtung aufgestellt werden, um das Leuchten des Bildschirms und die subtilen Reflexionen auf dem Metallgehäuse hervorzuheben. Die allgemeine Atmosphäre sollte professionell und einladend sein und ein Gefühl von Innovation und technologischem Fortschritt vermitteln.

Wie schreibe ich eine gute Eingabeaufforderung für Flux.1?

Eine der herausragenden Funktionen von Flux.1 ist der benutzerfreundliche Eingabeaufforderungsmechanismus. Durch die Integration der Textkodierer CLIP (von OpenAI) und T5 (von GoogleAI) kann das Modell Beschreibungen mit einem hohen Maß an Nuancen interpretieren. CLIP zeichnet sich durch die Ausrichtung von Text an visuellen Inhalten aus, während T5 die Fähigkeit des Modells verbessert, strukturierte Texteingaben zu verarbeiten. Zusammen ermöglichen sie es Flux.1, Bilder zu generieren, die den detaillierten Eingabeaufforderungen der Benutzer genau entsprechen.

Welche Modelltypen gibt es für Flux.1?

Flux.1 gibt es in drei verschiedenen Versionen: Schnell, Dev und Pro.

• Schnell ist das schnellste Modell, optimiert für Geschwindigkeit und Effizienz. Die kommerzielle Nutzung ist erlaubt, da es unter der Apache 2.0-Lizenz veröffentlicht wurde.
• Dev bietet ein flexibleres und experimentelleres Framework und richtet sich an Entwickler und Forscher, die bestimmte Funktionen des Modells verfeinern oder anpassen möchten. Es wurde mit einer nichtkommerziellen Lizenz veröffentlicht.
• Pro ist die fortschrittlichste und ressourcenintensivste Version. Es bietet Ausgaben mit höherer Auflösung und kann komplexere Bilder erzeugen, ist jedoch nur über die Black Forest Labs API verfügbar.

Wie kann ich Flux.1 kostenlos nutzen?

Für diejenigen, die die Möglichkeiten von Flux.1 ohne finanzielle Verpflichtung erkunden möchten, ist die Nutzung von modal.com als Ressourcenanbieter eine praktikable Option. Modal.com bietet ein monatliches Rechenleistungskontingent von 30 US-Dollar, das die Erstellung zahlreicher Bilder jeden Monat unterstützen kann. Weitere Informationen zu den Preisen und Angeboten finden Sie unter Modal.com Pricing.

Diese Empfehlung wird nicht von der Plattform gesponsert oder unterstützt.

Zu Beginn müssen Sie zunächst ein Konto auf modal.com erstellen, indem Sie sich mit Ihren GitHub-Anmeldeinformationen anmelden.

Als nächstes müssen Sie die Modal CLI installieren. Stellen Sie sicher, dass Python auf Ihrem Computer installiert ist. Sobald Python eingerichtet ist, öffnen Sie Ihr Terminal und führen Sie den Befehl pip install modal aus. Führen Sie nach Abschluss der Installation das Modal-Setup aus, um die CLI mit Ihrem Modal-Konto zu verknüpfen.

Fahren Sie fort, indem Sie dieses GitHub-Repository auf Ihren Computer klonen und zum geklonten Verzeichnis navigieren.

Erstellen Sie aus Sicherheitsgründen in Ihrem modalen Dashboard ein Geheimnis namens „flux.1-secret“ mit einer Umgebungsvariablen namens „API_KEY“ und weisen Sie ihm eine zufällige Zeichenfolge zu.

Stellen Sie abschließend Ihren Dienst bereit, indem Sie in Ihrem Terminal modal deploy app.py --name flux1 ausführen. Nach erfolgreicher Bereitstellung stellt Modal eine URL für den Zugriff auf den Webdienst bereit:

✓ Created objects.
├── ? Created mount PythonPackage:app
├── ? Created function Model.build.
├── ? Created function Model.*.
├── ? Created function Model._inference.
└── ? Created web function Model.web_inference => <PUBLIC_URL>
✓ App deployed in 3.206s! ?

Um den Dienst zu nutzen, stellen Sie eine GET-Anfrage an die angegebene PUBLIC-URL. Fügen Sie den x-API-Schlüssel, den Sie zuvor festgelegt haben, in die Header ein und kodieren Sie Ihre Eingabeaufforderung in den Abfrageparametern. Sie können die gewünschten Bildabmessungen auch über Abfrageparameter angeben. Hier ist ein Beispiel für die Strukturierung Ihrer Anfrage:

curl -H "x-api-key: <API_KEY>" <PUBLIC_URL>?width=<WIDTH>&height=<HEIGHT>&prompt=<PROMPT>

Den Kodex verstehen

Lassen Sie uns die app.py-Datei analysieren, die für die Ausführung unseres Flux.1-Bildgenerierungsdienstes auf der Modal-Plattform von entscheidender Bedeutung ist. Hier ist eine Aufschlüsselung der Einrichtung und Funktionalität:

import modal

image = modal.Image.debian_slim(python_version="3.10").apt_install(
    "libglib2.0-0", 
    "libsm6", 
    "libxrender1", 
    "libxext6", 
    "ffmpeg", 
    "libgl1",
    "git"
).pip_install(
    "git+https://github.com/huggingface/diffusers.git",
    "invisible_watermark",
    "transformers",
    "accelerate",
    "safetensors",
    "sentencepiece",
)

Dieser Block definiert das Docker-Image für unsere Anwendung und gibt das Betriebssystem, die erforderlichen Bibliotheken und Python-Pakete an. Diese Umgebung unterstützt die Ausführung des Flux.1-Modells und zugehöriger Dienstprogramme.

app = modal.App('flux1')

with image.imports():
    import os
    import io
    import torch
    from diffusers import FluxPipeline
    from fastapi import Response, Header

Here, we initialize our app and import necessary Python libraries within the context of our previously defined Docker image. These imports are essential for image processing and handling web requests.

@app.cls(gpu=modal.gpu.A100(), container_idle_timeout=15, image=image, timeout=120, secrets=[modal.Secret.from_name("flux.1-secret")])
class Model:
    @modal.build()
    def build(self):
        from huggingface_hub import snapshot_download

        snapshot_download("black-forest-labs/FLUX.1-schnell")

    @modal.enter()
    def enter(self):
        print("Loading model...")
        self.pipeline = FluxPipeline.from_pretrained("black-forest-labs/FLUX.1-schnell", torch_dtype=torch.bfloat16).to('cuda')
        print("Model loaded!")

    def inference(self, prompt: str, width: int = 1440, height: int = 1440):
        print("Generating image...")
        image = self.pipeline(
            prompt, 
            output_type='pil', 
            width=width, 
            height=height, 
            num_inference_steps=8,
            generator=torch.Generator("cpu").manual_seed(
                torch.randint(0, 1000000, (1,)).item()
            )
        ).images[0]

        print("Image generated!")

        byte_stream = io.BytesIO()
        image.save(byte_stream, format="PNG")

        return byte_stream.getvalue()

    @modal.web_endpoint(docs=True)
    def web_inference(self, prompt: str, width: int = 1440, height: int = 1440, x_api_key: str = Header(None)):
        api_key = os.getenv("API_KEY")
        if x_api_key != api_key:
            return Response(content="Unauthorized", status_code=401)

        image = self.inference(prompt, width, height)
        return Response(content=image, media_type="image/png")

This section defines the main functionality of our service:

• @modal.build(): Downloads the model when the application builds.
• @modal.enter(): Loads the model into GPU memory the first time the service is invoked.
• @modal.web_endpoint(): Serves as the web endpoint for our service using FastAPI.

If you just want to run it as a local service, you can add @modal.method() and define it as following inside the class.

        @modal.method()
    def _inference(self, prompt: str, width: int = 1440, height: int = 1440):
        return self.inference(prompt, width, height)

And outside it, define a local entry point

@app.local_entrypoint()
def main(prompt: str = "A beautiful sunset over the mountains"):
    image_bytes = Model()._inference.remote(prompt)

    with open("output.png", "wb") as f:
        f.write(image_bytes)

Local entry point will run locally on your machine calling the _inference method remotely, so you still using the modal’s service, without exposing it to the internet.

Conclusion

Flux.1 is not just another tech breakthrough - it's a game-changer for anyone who's ever dreamed of bringing their ideas to life visually. Imagine being able to describe a scene in words and watch as it materializes into a stunning, detailed image right before your eyes. That's the magic of Flux.1. It's like having a super-talented artist at your fingertips, ready to paint your thoughts with incredible precision. Whether you're an artist looking to speed up your creative process, a designer in need of quick visual concepts, or just someone who loves playing with new tech, Flux.1 opens up a world of possibilities. It's not about replacing human creativity - it's about enhancing it, making the journey from imagination to reality smoother and more exciting than ever before.

Das obige ist der detaillierte Inhalt vonSo führen Sie FLUXor Free aus: Eine Schritt-für-Schritt-Anleitung. Für weitere Informationen folgen Sie bitte anderen verwandten Artikeln auf der PHP chinesischen Website!