UNO : Prise en charge des outils de génération d'images personnalisées à sujet unique et à sujets multiples (adaptés aux graphiques de commerce électronique)

Dernières ressources sur l'IAPosté il y a 4 mois Cercle de partage de l'IA

Introduction générale

UNO est un cadre de génération d'images open source développé par l'équipe de création intelligente ByteDance. Il est basé sur FLUX.1, qui se concentre sur la génération d'images personnalisées à partir d'un sujet unique et de plusieurs sujets grâce à une approche de généralisation "moins pour plus", UNO résout les défis de l'extension des données et de la cohérence des sujets dans les scénarios multi-sujets en tirant parti de la capacité de génération de contexte du Diffusion Transformer (DiT) en conjonction avec un processus de synthèse de données hautement cohérent. Il permet aux utilisateurs de générer des images de haute qualité à partir de descriptions textuelles et d'images de référence, ce qui est largement applicable à la création d'images personnalisées, à la conception de personnages virtuels et à d'autres scénarios. Le code du projet est sous licence Apache 2.0 et les poids du modèle sont sous licence CC BY-NC 4.0, adaptés à la recherche universitaire et à l'utilisation non commerciale.

Liste des fonctions

Génération d'une image à sujet unique : génère une image conforme à la description sur la base d'une image de référence unique, en préservant les caractéristiques du sujet.
Génération d'images multi-sujets : génère plusieurs sujets spécifiques dans la même scène, en conservant leurs caractéristiques respectives.
Génération de contexte : exploitation de la capacité d'apprentissage du contexte du transformateur de diffusion pour générer des images très cohérentes.
Optimisation de la faible mémoire : Prise en charge du mode fp8 avec une empreinte mémoire maximale d'environ 16 Go pour les GPU grand public.
Ajustement du modèle : fournit des stratégies de pré-entraînement et d'entraînement en plusieurs étapes pour soutenir l'optimisation itérative des modèles de texte et d'image.
Support open source : le code d'entraînement, le code d'inférence et les poids du modèle sont fournis pour permettre aux chercheurs d'étendre l'application.

Utiliser l'aide

Processus d'installation

Pour utiliser UNO, vous devez installer et configurer les dépendances dans votre environnement local. Voici les étapes détaillées de l'installation pour les environnements Python 3.10 à 3.12.

Créer un environnement virtuel
Tout d'abord, créez un environnement virtuel Python distinct afin d'éviter les conflits de dépendance. Vous pouvez utiliser la commande suivante :
```
python -m venv uno_env
source uno_env/bin/activate  # Linux/MacOS
uno_env\Scripts\activate  # Windows
```
Ou utilisez Conda pour créer un environnement :
```
conda create -n uno_env python=3.10 -y
conda activate uno_env
```
Installation de PyTorch
Si vous utilisez un GPU AMD, NVIDIA RTX 50 series, ou macOS MPS, vous devrez installer manuellement la version appropriée de PyTorch. Consultez le site web de PyTorch (https://pytorch.org/) Sélectionnez la version correcte. Par exemple :
```
pip install torch torchvision torchaudio
```
Installation des dépendances de l'ONU
Clonez le dépôt UNO et installez les dépendances :
```
git clone https://github.com/bytedance/UNO.git
cd UNO
pip install -e .  # 仅用于推理
pip install -e .[train]  # 用于推理和训练
```
Note : Assurez-vous que requirements.txt sont correctement installées. Si vous rencontrez des problèmes, vérifiez s'il manque des bibliothèques système (telles que la bibliothèque ffmpeg) et par l'intermédiaire de conda install -c conda-forge ffmpeg Installation.
Télécharger les points de contrôle du modèle
UNO repose sur le modèle FLUX.1-dev et les points de contrôle associés. Il peut être téléchargé de la manière suivante :
- téléchargement automatiqueLors de l'exécution de scripts d'inférence, les points de contrôle sont automatiquement transmis par l'intermédiaire de l'outil d'inférence. hf_hub_download Télécharger vers le chemin d'accès par défaut (~/.cache/huggingface).
- téléchargement du manuelPour télécharger des modèles, il faut utiliser l'interface de programmation de Hugging Face :
```
huggingface-cli download black-forest-labs/FLUX.1-dev
huggingface-cli download xlabs-ai/xflux_text_encoders
huggingface-cli download openai/clip-vit-large-patch14
huggingface-cli download bytedance-research/UNO
```
Après le téléchargement, placez le modèle dans le répertoire spécifié (par ex. models/unet répondre en chantant models/loras).
Vérifier l'installation
Une fois l'installation terminée, exécutez la commande suivante pour vérifier que l'environnement est correctement configuré :
```
python -c "import torch; print(torch.cuda.is_available())"
```
Si le retour TrueVoici un exemple de configuration réussie de l'environnement GPU.

Utilisation

L'UNO fournit une interface Gradio (app.py) est utilisé pour la génération interactive d'images et peut également être utilisé pour exécuter des scripts d'inférence à partir de la ligne de commande (inference.py). Les principales procédures d'utilisation sont les suivantes.

Génération d'images via l'interface Gradio

Lancement de l'application Gradio
Assurez-vous que Gradio est installé (inclus dans l'archive requirements.txt (en). Exécutez la commande suivante pour démarrer l'interface :
```
python app.py
```
Au démarrage, le navigateur ouvre une page locale (généralement la page http://127.0.0.1:7860).
paramètre d'entrée
Dans l'interface de Gradio :
- Saisir une invite de texte (prompt), décrivez la scène d'image que vous souhaitez générer, par exemple "un chat et un chien jouant dans un parc".
- Télécharger 1 à 4 images de référence (image_ref1 jusqu'à image_ref4), ces images définissent l'apparence du sujet.
- Définir la valeur d'amorçage (seed) pour contrôler le caractère aléatoire des résultats générés, la valeur par défaut étant 3407.
- Sélectionnez le type de modèle (flux-dev,flux-dev-fp8 peut-être flux-schnell), recommandé flux-dev-fp8 pour réduire les besoins en mémoire graphique.
Générer des images
Cliquez sur le bouton Generate et UNO générera les résultats en fonction des invites et de l'image de référence. Le temps de génération dépend des performances du matériel et prend généralement de quelques secondes à quelques minutes sur les GPU grand public tels que la RTX 3090.

Exécuter un raisonnement à partir de la ligne de commande

Se préparer à entrer
Créez un fichier de configuration contenant les chemins d'accès à l'invite et à l'image de référence, ou spécifiez les paramètres directement sur la ligne de commande. Exemple :
```
python inference.py --prompt "A man in a suit, standing in a city" --image_paths "./assets/examples/man.jpg" --model_type "flux-dev-fp8" --save_path "./output"
```
Description des paramètres communs
- --prompt: Une description textuelle qui définit le contenu de l'image générée.
- --image_pathsChemin d'accès à l'image : Chemin d'accès à l'image de référence avec prise en charge d'images multiples.
- --model_typeType de modèle, recommandé flux-dev-fp8.
- --offloadActiver le délestage de la mémoire vidéo pour réduire l'utilisation de la mémoire vidéo.
- --num_stepsNombre d'étapes de diffusion : le nombre d'étapes de diffusion, par défaut 25, influe sur la qualité de la génération.
- --guidance: le facteur d'orientation, par défaut 4, permet de contrôler le degré d'adéquation du texte à l'image.
Voir les résultats
L'image générée est enregistrée dans le fichier --save_path Le répertoire spécifié (par exemple output/inference).

Fonction en vedette Fonctionnement

Génération d'un seul sujet

procédure: :
1. Téléchargez une image du sujet (par exemple, la photo d'une personne).
2. Saisissez un texte décrivant la scène cible (par exemple, "Cette personne se promène sur la plage").
3. La résolution de l'image de référence est fixée à 512 (valeur par défaut).
4. Pour générer une image, l'ONU conserve l'apparence des caractéristiques du sujet (par exemple, le visage, les vêtements).
mise en gardeL'image de référence doit être claire et le sujet doit être bien caractérisé, en évitant les images floues ou de mauvaise qualité.

Génération de sujets multiples

procédure: :
1. Téléchargez plusieurs images de référence (par exemple, une photo d'un chat et une photo d'un chien).
2. Saisir des invites textuelles pour décrire des scènes à sujets multiples (par exemple, "Le chat et le chien jouent dans l'herbe").
3. Réglez la résolution de l'image de référence sur 320 (valeur par défaut pour les sujets multiples).
4. Pour générer l'image, UNO évite la confusion des caractéristiques du sujet grâce à la technique UnoPE (Universal Rotational Position Embedding).
mise en gardeLe nombre d'images de référence ne doit pas dépasser 4 et chaque sujet doit être clairement distingué dans l'image.

Optimisation de la mémoire faible

utiliser flux-dev-fp8 l'empreinte mémoire est ramenée à environ 16 Go.
commencer à utiliser --offload ce qui permet de décharger l'unité centrale d'une partie des calculs et de réduire encore les besoins en mémoire graphique.
Pour les utilisateurs de GPU grand public tels que la RTX 3090 ou la RTX 4090.

Problèmes courants résolus...

mémoire vidéo insuffisanteLa résolution de l'image est réduite (--width répondre en chantant --height) à 512x512, ou utiliser l'option flux-dev-fp8 Modèles.
échec de l'installationVérifier que la version de PyTorch est compatible avec le GPU et installer manuellement une version spécifique si nécessaire.
Génération de résultats insatisfaisants: Ajustements --guidance(augmenté à 5 ou 6) ou --num_steps(augmenté à 50) pour améliorer la qualité de l'image.

scénario d'application

Création d'images personnalisées
Les utilisateurs peuvent télécharger leurs propres photos et les combiner avec des descriptions textuelles pour générer des images de scénarios spécifiques. Par exemple, le téléchargement d'un selfie génère une image de "vous-même marchant dans la ville du futur", qui convient à la création de contenu pour les médias sociaux.
Conception de personnages virtuels
Les développeurs de jeux ou les animateurs peuvent télécharger des croquis de personnages afin de générer des images de personnages pour différents scénarios et de conserver une apparence cohérente, adaptée au développement de mangas, d'animations ou de jeux.
Publicité et marketing
Les équipes marketing peuvent télécharger des images de mascottes de produits ou de marques pour créer divers scénarios publicitaires (par exemple, des produits présentés à différentes saisons) et améliorer la diversité du contenu visuel.
recherche universitaire
Les chercheurs peuvent utiliser le code source ouvert et le flux de formation de UNO pour explorer l'application des modèles de diffusion à la génération de sujets multiples, valider de nouveaux algorithmes ou optimiser des modèles existants.

QA

Quel est le matériel pris en charge par l'UNO ?
UNO recommande les GPU NVIDIA (tels que RTX 3090 ou 4090) avec un minimum de 16 Go de mémoire vidéo. Les GPU AMD et macOS MPS sont pris en charge, mais PyTorch doit être configuré manuellement.
Comment améliorer la qualité des images générées ?
L'ajout d'une étape de diffusion (--num_steps fixé à 50) ou ajuster le facteur d'amorçage (--guidance (réglé sur 5-6). Veillez à ce que l'image de référence soit claire et que les textes soient précis.
UNO bénéficie-t-il d'un soutien commercial ?
Les poids des modèles sont sous licence CC BY-NC 4.0 pour un usage non commercial uniquement. L'utilisation commerciale est soumise aux termes de la licence FLUX.1-dev originale.
Comment gérer la confusion des caractéristiques dans la génération de sujets multiples ?
UNO Réduire la confusion en utilisant la technique UnoPE. Assurez-vous que les caractéristiques du sujet de chaque image de référence sont claires et que la résolution est réduite de manière appropriée (par exemple 320) pour optimiser l'effet.