Comment exécuter FLUXor Free : un guide étape par étape

Flux.1 est le modèle texte-image le plus récent du marché, présenté par Black Forest Labs. Il s'agit d'un modèle de pointe capable de générer des images de haute qualité à partir de descriptions textuelles, de gérer des descriptions complexes et de générer des images de haute qualité avec des détails fins.

Qui se cache derrière Flux.1 ?

Flux.1 est développé par Black Forest Labs, une entreprise créée par un groupe d'anciens employés de Stability AI.

Comment ça marche ?

Contrairement à d'autres modèles de diffusion, comme la diffusion stable qui crée des images en supprimant progressivement le bruit à partir d'un point de départ aléatoire, Flux.1 génère des images en utilisant une technique appelée « correspondance de flux » qui adopte une approche plus directe, en apprenant les transformations exactes nécessaires pour convertir le bruit en une image réaliste. Cela permet de générer des images de haute qualité plus rapidement et en moins d'étapes que les modèles de diffusion courants.

De plus, avec cette approche différente, Flux.1 peut gérer des images contenant du texte, comme celle ci-dessous :

Une image photoréaliste d'un ordinateur portable moderne et élégant avec une page Web ouverte affichant le texte « codestackme » dans un design épuré et minimaliste. L'ordinateur portable doit être placé sur un bureau blanc avec un éclairage doux, mettant en valeur la lueur de l'écran et les reflets subtils sur le boîtier métallique. L'atmosphère générale doit être professionnelle et invitante, véhiculant un sentiment d'innovation et de progrès technologique.

Comment écrire une bonne invite pour Flux.1 ?

L'une des fonctionnalités les plus remarquables de Flux.1 est son mécanisme d'invite convivial. L'intégration des encodeurs de texte CLIP (d'OpenAI) et T5 (de GoogleAI) permet au modèle d'interpréter les descriptions avec un haut degré de nuance. CLIP excelle dans l'alignement du texte avec le contenu visuel, tandis que T5 améliore la capacité du modèle à traiter les entrées de texte structurées. Ensemble, ils permettent à Flux.1 de générer des images qui correspondent étroitement aux invites détaillées fournies par les utilisateurs.

Quels types de modèles existe-t-il pour Flux.1 ?

Flux.1 se décline en trois versions distinctes : Schnell, Dev et Pro.

• Schnell est le modèle le plus rapide, optimisé pour la vitesse et l'efficacité. Il est autorisé pour un usage commercial, puisqu'il a été publié sous la licence Apache 2.0.
• Dev fournit un cadre plus flexible et expérimental, il s'adresse aux développeurs et aux chercheurs qui souhaitent affiner ou personnaliser certaines fonctionnalités du modèle. Il a été publié avec une licence non commerciale.
• Pro est la version la plus avancée et la plus gourmande en ressources. Il offre des sorties à plus haute résolution et peut générer des images plus complexes, mais il n'est disponible que via l'API Black Forest Labs.

Comment utiliser Flux.1 gratuitement ?

Pour ceux qui souhaitent explorer les capacités de Flux.1 sans engagement financier, utiliser modal.com comme fournisseur de ressources est une option viable. Modal.com offre une allocation mensuelle de puissance de calcul de 30 $, qui peut prendre en charge la génération de nombreuses images chaque mois. Vous pouvez en savoir plus sur leurs tarifs et leurs offres sur Modal.com Pricing.

Cette recommandation n'est ni sponsorisée ni approuvée par la plateforme.

Pour commencer, vous devez d'abord créer un compte sur modal.com en vous connectant à l'aide de vos identifiants GitHub.

Ensuite, vous devrez installer la CLI modale. Assurez-vous que Python est installé sur votre ordinateur. Une fois Python configuré, ouvrez votre terminal et exécutez la commande pip install modal. Une fois l'installation terminée, exécutez la configuration modale pour lier la CLI à votre compte Modal.

Procédez en clonant ce référentiel GitHub sur votre ordinateur et accédez au répertoire cloné.

Pour des raisons de sécurité, créez un secret appelé flux.1-secret dans votre tableau de bord modal avec une variable d'environnement nommée API_KEY et attribuez-lui une chaîne aléatoire.

Enfin, déployez votre service en exécutant modal déployer app.py --name flux1 dans votre terminal. Une fois le déploiement réussi, modal fournira une URL pour accéder au service Web :

✓ 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! ?

Pour utiliser le service, effectuez une requête GET à l'URL PUBLIC fournie. Incluez la clé x-api que vous avez définie précédemment dans les en-têtes et codez votre invite dans les paramètres de requête. Vous pouvez également spécifier les dimensions d'image souhaitées via les paramètres de requête. Voici un exemple de la façon de structurer votre demande :

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

Comprendre le code

Disséquons le fichier app.py, qui est crucial pour exécuter notre service de génération d'images Flux.1 à l'aide de la plateforme modal. Voici un aperçu de la configuration et des fonctionnalités :

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

Ce bloc définit l'image Docker de notre application, en spécifiant le système d'exploitation, les bibliothèques nécessaires et les packages Python. Cet environnement prend en charge l'exécution du modèle Flux.1 et des utilitaires associés.

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.

Ce qui précède est le contenu détaillé de. pour plus d'informations, suivez d'autres articles connexes sur le site Web de PHP en chinois!