Finjuster tekst-til-billede stabile diffusionsmodeller med Amazon SageMaker JumpStart

Genudgivet af Platon

Abonnenter: 0

I november 2022 har vi annoncerede som AWS-kunder kan generere billeder fra tekst med Stabil diffusion modeller i Amazon SageMaker JumpStart. Stable Diffusion er en dyb læringsmodel, der giver dig mulighed for at generere realistiske billeder af høj kvalitet og fantastisk kunst på få sekunder. Selvom at skabe imponerende billeder kan finde anvendelse i industrier lige fra kunst til NFT'er og videre, forventer vi i dag også, at AI kan tilpasses. I dag annoncerer vi, at du kan tilpasse billedgenereringsmodellen til din brugssituation ved at finjustere den på dit brugerdefinerede datasæt i Amazon SageMaker JumpStart. Dette kan være nyttigt, når du laver kunst, logoer, brugerdefinerede designs, NFT'er og så videre, eller sjove ting, såsom at generere tilpassede AI-billeder af dine kæledyr eller avatarer af dig selv.

I dette indlæg giver vi et overblik over, hvordan man finjusterer den stabile diffusionsmodell på to måder: programmatisk gennem JumpStart API'er tilgængelig i SageMaker Python SDK, og JumpStarts brugergrænseflade (UI) i Amazon SageMaker Studio. Vi diskuterer også, hvordan man foretager designvalg, herunder datasætkvalitet, størrelse af træningsdatasæt, valg af hyperparameterværdier og anvendelighed på flere datasæt. Til sidst diskuterer vi de over 80 offentligt tilgængelige finjusterede modeller med forskellige inputsprog og stilarter, der for nylig er tilføjet i JumpStart.

Stabil diffusions- og transferlæring

Stable Diffusion er en tekst-til-billede-model, der giver dig mulighed for at skabe fotorealistiske billeder fra blot en tekstprompt. En diffusionsmodel træner ved at lære at fjerne støj, der blev tilføjet til et rigtigt billede. Denne støjdæmpende proces genererer et realistisk billede. Disse modeller kan også generere billeder fra tekst alene ved at betinge genereringsprocessen på teksten. For eksempel er Stable Diffusion en latent diffusion, hvor modellen lærer at genkende former i et rent støjbillede og gradvist bringer disse former i fokus, hvis formerne matcher ordene i inputteksten. Teksten skal først indlejres i et latent rum ved hjælp af en sprogmodel. Derefter udføres en række støjtilsætnings- og støjfjernelsesoperationer i det latente rum med en U-Net-arkitektur. Til sidst afkodes det støjfrie output ind i pixelrummet.

Kilde: https://jalammar.github.io/illustrated-stable-diffusion/

I maskinlæring (ML) kaldes evnen til at overføre den lærte viden i et domæne til et andet overføre læring. Du kan bruge transfer learning til at producere nøjagtige modeller på dine mindre datasæt med meget lavere uddannelsesomkostninger end dem, der er involveret i træning af den originale model. Med transfer learning kan du finjustere den stabile diffusionsmodel på dit eget datasæt med så lidt som fem billeder. For eksempel til venstre er træningsbilleder af en hund ved navn Doppler, der bruges til at finjustere modellen, i midten og til højre er billeder genereret af den finjusterede model, når de bliver bedt om at forudsige Dopplers billede på stranden og en blyantskitse.

Til venstre er billeder af en hvid stol brugt til at finjustere modellen og et billede af stolen i rødt genereret af den finjusterede model. Til højre er billeder af en skammel brugt til at finjustere modellen og et billede af en kat, der sidder på en skammel.

Finjustering af store modeller som Stable Diffusion kræver normalt, at du leverer træningsscripts. Der er et væld af problemer, herunder problemer med manglende hukommelse, problemer med nyttelaststørrelse og mere. Desuden skal du køre ende-til-ende-tests for at sikre, at scriptet, modellen og den ønskede instans arbejder sammen på en effektiv måde. JumpStart forenkler denne proces ved at levere klar-til-brug scripts, der er blevet grundigt testet. JumpStart finjusteringsscriptet til stabile diffusionsmodeller bygger på finjusteringsscriptet fra drømmekabine. Du kan få adgang til disse scripts med et enkelt klik gennem Studio UI eller med meget få linjer kode gennem JumpStart API'er.

Bemærk, at ved at bruge den stabile diffusionsmodel, accepterer du CreativeML Open RAIL++-M-licens.

Brug JumpStart programmatisk med SageMaker SDK

Dette afsnit beskriver, hvordan man træner og implementerer modellen med SageMaker Python SDK. Vi vælger en passende præ-trænet model i JumpStart, træner denne model med et SageMaker-træningsjob og implementerer den trænede model til et SageMaker-slutpunkt. Desuden kører vi inferens på det implementerede slutpunkt, alt ved hjælp af SageMaker Python SDK. Følgende eksempler indeholder kodestykker. For den fulde kode med alle trinene i denne demo, se Introduktion til JumpStart – Tekst til billede eksempel notesbog.

Træn og finjuster Stable Diffusion-modellen

Hver model er identificeret med en unik model_id. Følgende kode viser, hvordan man finjusterer en Stable Diffusion 2.1-basismodel identificeret ved model_id model-txt2img-stabilityai-stable-diffusion-v2-1-base på et tilpasset træningsdatasæt. For en komplet liste over model_id værdier og hvilke modeller der er finjusterbare, henvises til Indbyggede algoritmer med fortrænet modelbord. For hver model_id, for at lancere et SageMaker-uddannelsesjob gennem Estimator klasse af SageMaker Python SDK, skal du hente Docker-image-URI, træningsscript-URI og forudtrænede model-URI gennem hjælpefunktionerne i SageMaker. Træningsscriptets URI indeholder al den nødvendige kode til databehandling, indlæsning af den præ-trænede model, modeltræning og lagring af den trænede model til slutning. Den præ-trænede model-URI indeholder den præ-trænede modelarkitekturdefinition og modelparametrene. Den fortrænede model-URI er specifik for den pågældende model. De fortrænede model-tarballs er blevet forhåndsdownloadet fra Hugging Face og gemt med den passende modelsignatur i Amazon Simple Storage Service (Amazon S3) buckets, sådan at træningsjobbet kører i netværksisolation. Se følgende kode:

from sagemaker import image_uris, model_uris, script_uris # Currently, not all the stable diffusion models in jumpstart support finetuning. Thus, we manually select a model
# which supports finetuning.
train_model_id, train_model_version, train_scope = ( "model-txt2img-stabilityai-stable-diffusion-v2-1-base", "*", "training",
) # Tested with ml.g4dn.2xlarge (16GB GPU memory) and ml.g5.2xlarge (24GB GPU memory) instances. Other instances may work as well.
# If ml.g5.2xlarge instance type is available, please change the following instance type to speed up training.
training_instance_type = "ml.g4dn.2xlarge" # Retrieve the docker image
train_image_uri = image_uris.retrieve(
region=None,
framework=None, # automatically inferred from model_id
model_id=train_model_id,
model_version=train_model_version,
image_scope=train_scope,
instance_type=training_instance_type,
) # Retrieve the training script. This contains all the necessary files including data processing, model training etc.
train_source_uri = script_uris.retrieve(
model_id=train_model_id, model_version=train_model_version, script_scope=train_scope
) # Retrieve the pre-trained model tarball to further fine-tune
train_model_uri = model_uris.retrieve(
model_id=train_model_id, model_version=train_model_version, model_scope=train_scope
)

Med disse modelspecifikke træningsartefakter kan du konstruere et objekt af Estimator klasse:

# Create SageMaker Estimator instance
sd_estimator = Estimator( role=aws_role, image_uri=train_image_uri, source_dir=train_source_uri, model_uri=train_model_uri, entry_point="transfer_learning.py", # Entry-point file in source_dir and present in train_source_uri. instance_count=1, instance_type=training_instance_type, max_run=360000, hyperparameters=hyperparameters, output_path=s3_output_location, base_job_name=training_job_name,
) # Launch a SageMaker Training job by passing s3 path of the training data
sd_estimator.fit({"training": training_dataset_s3_path}, logs=True)

Træningsdatasæt

Følgende er instruktionerne for, hvordan træningsdataene skal formateres:

Input – En mappe, der indeholder instansbillederne, dataset_info.json, med følgende konfiguration:
- Billeder kan være i .png-, .jpg- eller .jpeg-format
- dataset_info.json fil skal være af formatet {'instance_prompt':<<instance_prompt>>}
Produktion – En trænet model, der kan anvendes til slutninger

S3-stien skulle se ud s3://bucket_name/input_directory/. Bemærk efterfølgen / er nødvendigt.

Følgende er et eksempel på et format af træningsdata:

input_directory |---instance_image_1.png |---instance_image_2.png |---instance_image_3.png |---instance_image_4.png |---instance_image_5.png |---dataset_info.json

For instruktioner om, hvordan du formaterer dataene, mens du bruger forudgående bevaring, henvises til afsnittet Forudgående bevaring i dette indlæg.

Vi leverer et standarddatasæt af kattebilleder. Den består af otte billeder (forekomstbilleder svarende til forekomstprompt) af en enkelt kat uden klassebilleder. Den kan downloades fra GitHub. Hvis du bruger standarddatasættet, prøv prompten "et foto af en riobugger kat", mens du laver slutninger i demo-notesbogen.

Licens: MIT.

Hyperparametre

Dernæst, for at overføre læring på dit brugerdefinerede datasæt, skal du muligvis ændre standardværdierne for træningshyperparametrene. Du kan hente en Python-ordbog over disse hyperparametre med deres standardværdier ved at kalde hyperparameters.retrieve_default, opdater dem efter behov, og send dem derefter til Estimator-klassen. Se følgende kode:

from sagemaker import hyperparameters
# Retrieve the default hyper-parameters for fine-tuning the model
hyperparameters = hyperparameters.retrieve_default(
model_id=train_model_id, model_version=train_model_version
) # [Optional] Override default hyperparameters with custom values
hyperparameters["max_steps"] = "400"

Følgende hyperparametre understøttes af finjusteringsalgoritmen:

med_forud_bevaring – Flag for at tilføje tidligere tab af konservering. Forudgående konservering er en regularizer, der undgår overpasning. (Valg: [“True”,“False”], Standard: “False”.)
antal_klasse_billeder – Minimumsklassebilleder for forudgående bevaringstab. Hvis with_prior_preservation = True og der er ikke nok billeder allerede i class_data_dir, vil yderligere billeder blive samplet med class_prompt. (Værdier: positivt heltal, standard: 100.)
Epoker – Antallet af gennemløb, som finjusteringsalgoritmen tager gennem træningsdatasættet. (Værdier: positivt heltal, standard: 20.)
Max_trin – Det samlede antal træningstrin, der skal udføres. Hvis ikke None, tilsidesætter epoker. (Værdier: “None” eller en streng af heltal, standard: “None”.)
Batch størrelse –: Antallet af træningseksempler, der gennemarbejdes, før modelvægtene opdateres. Samme som batchstørrelsen under generering af klassebilleder if with_prior_preservation = True. (Værdier: positivt heltal, standard: 1.)
learning_rate – Den hastighed, hvormed modelvægtene opdateres efter at have gennemgået hver gruppe træningseksempler. (Værdier: positiv flydende, standard: 2e-06.)
tidligere_tab_vægt – Vægten af tidligere konserveringstab. (Værdier: positiv flydende, standard: 1.0.)
center_crop – Om billederne skal beskæres, før størrelsen ændres til den ønskede opløsning. (Valg: [“True”/“False”], Standard: “False”.)
lr_planlægger – Typen af læringshastighedsplanlægger. (Valg: ["linear", "cosine", "cosine_with_restarts", "polynomial", "constant", "constant_with_warmup"], Standard: "constant".) For mere information, se Indlæringssatsplanlæggere.
adam_weight_decay – Den vægtnedgang, der skal påføres (hvis ikke nul) på alle lag undtagen alle bias og LayerNorm vægte ind AdamW optimizer. (Værdi: flydende, standard: 1e-2.)
adam_beta1 – Beta1-hyperparameteren (eksponentiel henfaldshastighed for estimater for det første øjeblik) for AdamW optimizer. (Værdi: flydende, standard: 0.9.)
adam_beta2 – Beta2-hyperparameteren (eksponentiel henfaldshastighed for estimater for det første øjeblik) for AdamW optimizer. (Værdi: flydende, standard: 0.999.)
adam_epsilon - Den epsilon hyperparameter for AdamW optimizer. Den er normalt indstillet til en lille værdi for at undgå division med 0. (Værdi: float, standard: 1e-8.)
gradient_akkumulation_trin – Antallet af opdateringstrin, der skal akkumuleres, før der udføres et tilbage-/opdateringspass. (Værdi: heltal, standard: 1.)
max_grad_norm – Den maksimale gradientnorm (til gradientklipning). (Værdi: flydende, standard: 1.0.)
frø – Ret den tilfældige tilstand for at opnå reproducerbare resultater i træningen. (Værdi: heltal, standard: 0.)

Implementer den fintrænede model

Når modeltræningen er afsluttet, kan du implementere modellen direkte til et vedvarende, real-time slutpunkt. Vi henter de nødvendige Docker Image URI'er og script-URI'er og implementerer modellen. Se følgende kode:

inference_instance_type = "ml.g4dn.2xlarge" # Retrieve the inference docker container uri
deploy_image_uri = image_uris.retrieve( region=None, framework=None, # automatically inferred from model_id image_scope="inference", model_id=train_model_id, model_version=train_model_version, instance_type=inference_instance_type,
) # Retrieve the inference script uri. This includes scripts for model loading, inference handling etc.
deploy_source_uri = script_uris.retrieve( model_id=train_model_id, model_version=train_model_version, script_scope="inference"
) # Use the estimator from the previous step to deploy to a SageMaker endpoint
finetuned_predictor = sd_estimator.deploy( initial_instance_count=1, instance_type=inference_instance_type, entry_point="inference.py", # entry point file in source_dir and present in deploy_source_uri image_uri=deploy_image_uri, source_dir=deploy_source_uri, endpoint_name=endpoint_name,
)

Til venstre er træningsbillederne af en kat ved navn riobugger, der bruges til at finjustere modellen (standardparametre undtagen max_steps = 400). I midten og til højre er billederne genereret af den finjusterede model, når de bliver bedt om at forudsige riobuggers billede på stranden og en blyantskitse.

For flere detaljer om inferens, herunder understøttede parametre, svarformat og så videre, se Generer billeder fra tekst med den stabile diffusionsmodel på Amazon SageMaker JumpStart.

Få adgang til JumpStart gennem Studio UI

I dette afsnit demonstrerer vi, hvordan man træner og implementerer JumpStart-modeller gennem Studio UI. Den følgende video viser, hvordan du finder den forudtrænede stabile diffusionsmodel på JumpStart, træner den og derefter implementerer den. Modelsiden indeholder værdifuld information om modellen og hvordan den bruges. Når du har konfigureret SageMaker træningsinstansen, skal du vælge Tog. Når modellen er trænet, kan du implementere den trænede model ved at vælge Implementer. Når endepunktet er i "i drift"-stadiet, er det klar til at svare på anmodninger om slutninger.

For at fremskynde tiden til inferens giver JumpStart en eksempelnotesbog, der viser, hvordan man kører inferens på det nyoprettede slutpunkt. Vælg for at få adgang til notesbogen i Studio Åbn Notesbog i Brug Endpoint fra Studio sektionen af modellens slutpunktside.

JumpStart giver også en simpel notesbog, som du kan bruge til at finjustere den stabile diffusionsmodel og implementere den resulterende finjusterede model. Du kan bruge det til at generere sjove billeder af din hund. For at få adgang til notesbogen skal du søge efter "Generer sjove billeder af din hund" i JumpStart-søgelinjen. For at udføre notesbogen kan du bruge så lidt som fem træningsbilleder og uploade til den lokale studiemappe. Hvis du har mere end fem billeder, kan du også uploade dem. Notebook uploader træningsbillederne til S3, træner modellen på dit datasæt og implementerer den resulterende model. Træningen kan tage 20 minutter at afslutte. Du kan ændre antallet af trin for at fremskynde træningen. Notebook giver nogle eksempler på prompts til at prøve med den installerede model, men du kan prøve enhver prompt, du vil. Du kan også tilpasse notesbogen til at skabe avatarer af dig selv eller dine kæledyr. For eksempel, i stedet for din hund, kan du uploade billeder af din kat i det første trin og derefter ændre meddelelserne fra hunde til katte, og modellen vil generere billeder af din kat.

Finjusterende overvejelser

Træningsstabile diffusionsmodeller har tendens til at overfitte hurtigt. For at få billeder af god kvalitet skal vi finde en god balance mellem de tilgængelige træningshyperparametre såsom antal træningstrin og indlæringshastigheden. I dette afsnit viser vi nogle eksperimentelle resultater og giver vejledning om, hvordan disse parametre indstilles.

Anbefalinger

Overvej følgende anbefalinger:

Start med god kvalitet af træningsbilleder (4–20). Hvis du træner på menneskeansigter, har du muligvis brug for flere billeder.
Træn i 200-400 skridt, når du træner på hunde eller katte og andre ikke-menneskelige emner. Hvis du træner på menneskelige ansigter, har du muligvis brug for flere trin. Hvis der sker overpasning, skal du reducere antallet af trin. Hvis der sker undertilpasning (den finjusterede model kan ikke generere målmotivets billede), skal du øge antallet af trin.
Hvis du træner på ikke-menneskelige ansigter, kan du indstille with_prior_preservation = False fordi det ikke påvirker ydeevnen væsentligt. På menneskelige ansigter skal du muligvis indstille with_prior_preservation=True.
Hvis indstilling with_prior_preservation=True, brug forekomsttypen ml.g5.2xlarge.
Når du træner i flere emner i rækkefølge, hvis emnerne er meget ens (for eksempel alle hunde), beholder modellen det sidste emne og glemmer de tidligere emner. Hvis emnerne er forskellige (f.eks. først en kat og derefter en hund), beholder modellen begge emner.
Vi anbefaler at bruge en lav indlæringsrate og gradvist øge antallet af trin, indtil resultaterne er tilfredsstillende.

Træningsdatasæt

Kvaliteten af den finjusterede model er direkte påvirket af kvaliteten af træningsbillederne. Derfor skal du samle billeder i høj kvalitet for at få gode resultater. Slørede billeder eller billeder i lav opløsning vil påvirke kvaliteten af den finjusterede model. Husk følgende yderligere parametre:

Antal træningsbilleder – Du kan finjustere modellen på så lidt som fire træningsbilleder. Vi eksperimenterede med træningsdatasæt af størrelse så lidt som 4 billeder og så mange som 16 billeder. I begge tilfælde var finjusteringen i stand til at tilpasse modellen til emnet.
Datasæt formater – Vi testede finjusteringsalgoritmen på billeder i formaterne .png, .jpg og .jpeg. Andre formater kan også fungere.
Billedopløsning – Træningsbilleder kan have enhver opløsning. Finjusteringsalgoritmen vil ændre størrelsen på alle træningsbilleder, før finjusteringen påbegyndes. Når det er sagt, hvis du vil have mere kontrol over beskæringen og størrelsen af træningsbillederne, anbefaler vi selv at ændre størrelsen på billederne til modellens basisopløsning (i dette eksempel 512×512 pixels).

Eksperimentindstillinger

I eksperimentet i dette indlæg, mens vi finjusterer, bruger vi standardværdierne for hyperparametrene, medmindre det er angivet. Derudover bruger vi et af de fire datasæt:

Hund 1-8 – Hund 1 med 8 billeder
Hund 1-16 – Hund 1 med 16 billeder
Hund 2-4 – Hund 2 med fire billeder
Kat-8 – Kat med 8 billeder

For at reducere rod viser vi kun ét repræsentativt billede af datasættet i hver sektion sammen med datasættets navn. Du kan finde det fulde træningssæt i afsnittet Eksperimentdatasæt i dette indlæg.

overfitting

Stabile diffusionsmodeller har en tendens til at passe over, når de finjusterer nogle få billeder. Derfor skal du vælge parametrene som f.eks epochs, max_epochs, og indlæringshastighed omhyggeligt. I dette afsnit brugte vi Dog1-16-datasættet.

For at evaluere modellens ydeevne evaluerer vi den finjusterede model for fire opgaver:

Kan den finjusterede model generere billeder af motivet (Dopplerhund) i samme omgivelser, som den blev trænet i?
- Observation - Ja den kan. Det er værd at bemærke, at modellens ydeevne stiger med antallet af træningstrin.
Kan den finjusterede model generere billeder af motivet i en anden indstilling, end den blev trænet i? Kan den for eksempel generere billeder af Doppler på en strand?
- Observation - Ja den kan. Det er værd at bemærke, at modellens ydeevne stiger med antallet af træningstrin op til et vist punkt. Hvis modellen trænes for længe, forringes modellens ydeevne dog, da modellen har tendens til at overfitte.
Kan den finjusterede model generere billeder af en klasse, som træningsfaget tilhører? Kan den for eksempel generere et billede af en generisk hund?
- Observation – Efterhånden som vi øger antallet af træningstrin, begynder modellen at overfitte. Som et resultat glemmer den den generiske klasse af en hund og vil kun producere billeder relateret til emnet.
Kan den finjusterede model generere billeder af en klasse eller et emne, der ikke er i træningsdatasættet? Kan det for eksempel generere et billede af en kat?
- Observation – Efterhånden som vi øger antallet af træningstrin, begynder modellen at overfitte. Som et resultat vil det kun producere billeder relateret til emnet, uanset den specificerede klasse.

Vi finjusterer modellen til et andet antal trin (ved at indstille max_steps hyperparametre), og for hver finjusteret model genererer vi billeder på hver af de følgende fire prompter (vist i følgende eksempler fra venstre mod højre:

“Et billede af en Doppler-hund”
“Et billede af en Doppler-hund på en strand”
“Et billede af en hund”
“Et billede af en kat”

Følgende billeder er fra modellen trænet med 50 trin.

Følgende model blev trænet med 100 trin.

Vi trænede følgende model med 200 trin.

Følgende billeder er fra en model trænet med 400 trin.

Til sidst er de følgende billeder resultatet af 800 trin.

Træn på flere datasæt

Mens du finjusterer, vil du måske finjustere på flere motiver og få den finjusterede model til at kunne generere billeder af alle motiverne. Desværre er JumpStart i øjeblikket begrænset til træning om et enkelt emne. Du kan ikke finjustere modellen på flere emner på samme tid. Ydermere resulterer finjustering af modellen for forskellige fag sekventielt i, at modellen glemmer det første fag, hvis fagene ligner hinanden.

Vi overvejer følgende eksperimenter i dette afsnit:

Finjuster modellen for emne A.
Finjuster den resulterende model fra trin 1 for emne B.
Generer billeder af emne A og emne B ved hjælp af outputmodellen fra trin 2.

I følgende forsøg observerer vi, at:

Hvis A er hund 1 og B er hund 2, så ligner alle billeder genereret i trin 3 hund 2
Hvis A er hund 2 og B er hund 1, så ligner alle billeder genereret i trin 3 hund 1
Hvis A er hund 1 og B er kat, så ligner billeder genereret med hundeprompter hund 1 og billeder genereret med katteprompter ligner kat

Træn på hund 1 og derefter hund 2

I trin 1 finjusterer vi modellen til 200 trin på otte billeder af hund 1. I trin 2 finjusterer vi modellen yderligere i 200 trin på fire billeder af hund 2.

Følgende er de billeder, der genereres af den finjusterede model i slutningen af trin 2 for forskellige prompter.

Træn på hund 2 og derefter hund 1

I trin 1 finjusterer vi modellen til 200 trin på fire billeder af hund 2. I trin 2 finjusterer vi modellen yderligere i 200 trin på otte billeder af hund 1.

Følgende er billederne genereret af den finjusterede model i slutningen af trin 2 med forskellige meddelelser.

Træn på hunde og katte

I trin 1 finjusterer vi modellen til 200 trin på otte billeder af en kat. Derefter finjusterer vi modellen yderligere i 200 trin på otte billeder af hund 1.

Følgende er de billeder, der genereres af den finjusterede model i slutningen af trin 2. Billeder med katterelaterede prompter ligner katten i trin 1 af finjusteringen, og billeder med hunderelaterede prompter ligner hunden i Trin 2 af finjusteringen.

Forudgående konservering

Forudgående konservering er en teknik, der bruger yderligere billeder af samme klasse, som vi forsøger at træne på. For eksempel, hvis træningsdataene består af billeder af en bestemt hund, med forudgående bevaring, inkorporerer vi klassebilleder af generiske hunde. Den forsøger at undgå overfitting ved at vise billeder af forskellige hunde, mens den træner for en bestemt hund. Et mærke, der angiver den specifikke hund, der er til stede i instansprompten, mangler i klasseprompten. Forekomstprompten kan for eksempel være "et foto af en riobugger-kat", og klasseprompten kan være "et foto af en kat." Du kan aktivere forudgående bevaring ved at indstille hyperparameteren with_prior_preservation = True. Hvis indstilling with_prior_preservation = True, skal du medtage class_prompt in dataset_info.json og kan inkludere alle klassebilleder, der er tilgængelige for dig. Følgende er træningsdatasættets format ved indstilling with_prior_preservation = True:

Input – En mappe, der indeholder instansbillederne, dataset_info.json og (valgfrit) bibliotek class_data_dir. Bemærk følgende:
- Billeder kan være i .png, .jpg, .jpeg-format.
- dataset_info.json fil skal være af formatet {'instance_prompt':<<instance_prompt>>,'class_prompt':<<class_prompt>>}.
- class_data_dir bibliotek skal have klassebilleder. Hvis class_data_dir er ikke til stede, eller der er ikke nok billeder allerede i class_data_dir, vil yderligere billeder blive samplet med class_prompt.

For datasæt såsom katte og hunde påvirker forudgående bevaring ikke den finjusterede models ydeevne væsentligt og kan derfor undgås. Men når man træner på ansigter, er dette nødvendigt. For mere information, se Træning af stabil diffusion med Dreambooth ved hjælp af diffusere.

Instantyper

Finjustering af stabile diffusionsmodeller kræver accelereret beregning leveret af GPU-understøttede instanser. Vi eksperimenterer med vores finjustering med ml.g4dn.2xlarge (16 GB CUDA-hukommelse, 1 GPU) og ml.g5.2xlarge (24 GB CUDA-hukommelse, 1 GPU) forekomster. Hukommelseskravet er højere, når der genereres klassebilleder. Derfor, hvis indstilling with_prior_preservation=True, brug forekomsttypen ml.g5.2xlarge, fordi træning løber ind i CUDA-problemet, der mangler hukommelse på ml.g4dn.2xlarge-forekomsten. JumpStart-finjusteringsscriptet bruger i øjeblikket enkelt GPU, og derfor vil finjustering på multi-GPU-instanser ikke give ydeevneforøgelse. For mere information om forskellige instanstyper henvises til Amazon EC2-instanstyper.

Begrænsninger og bias

Selvom Stable Diffusion har en imponerende ydeevne til at generere billeder, lider den af flere begrænsninger og skævheder. Disse omfatter, men er ikke begrænset til:

Modellen genererer muligvis ikke nøjagtige ansigter eller lemmer, fordi træningsdataene ikke indeholder tilstrækkelige billeder med disse funktioner
Modellen blev trænet på LAION-5B datasæt, som har voksenindhold og muligvis ikke er egnet til produktbrug uden yderligere overvejelser
Modellen fungerer muligvis ikke godt med ikke-engelske sprog, fordi modellen blev trænet i engelsksproget tekst
Modellen kan ikke generere god tekst i billeder

For mere information om begrænsninger og bias, se Stabil Diffusion v2-1-baseret modelkort. Disse begrænsninger for den fortrænede model kan også overføres til de finjusterede modeller.

Ryd op

Når du er færdig med at køre notesbogen, skal du sørge for at slette alle ressourcer oprettet i processen for at sikre, at faktureringen stoppes. Kode til at rydde op i slutpunktet er angivet i det tilknyttede Introduktion til JumpStart – Tekst til billede eksempel notesbog.

Offentligt tilgængelige finjusterede modeller i JumpStart

Selvom Stable Diffusion-modeller udgivet af StabilitetAI har imponerende ydeevne, de har begrænsninger i forhold til det sprog eller domæne, det blev trænet på. For eksempel blev Stable Diffusion-modeller trænet i engelsk tekst, men du skal muligvis generere billeder fra ikke-engelsk tekst. Alternativt blev Stable Diffusion-modeller trænet til at generere fotorealistiske billeder, men du skal muligvis generere animerede eller kunstneriske billeder.

JumpStart tilbyder over 80 offentligt tilgængelige modeller med forskellige sprog og temaer. Disse modeller er ofte finjusterede versioner fra Stable Diffusion-modeller udgivet af StabilityAI. Hvis dit use case matcher en af de finjusterede modeller, behøver du ikke at samle dit eget datasæt og finjustere det. Du kan ganske enkelt implementere en af disse modeller gennem Studio UI eller ved at bruge letanvendelige JumpStart API'er. For at implementere en forudtrænet stabil diffusionsmodel i JumpStart, se Generer billeder fra tekst med den stabile diffusionsmodel på Amazon SageMaker JumpStart.

Det følgende er nogle af eksemplerne på billeder genereret af de forskellige modeller, der er tilgængelige i JumpStart.

Bemærk, at disse modeller ikke finjusteres ved hjælp af JumpStart-scripts eller DreamBooth-scripts. Du kan downloade den fulde liste over offentligt tilgængelige finjusterede modeller med eksempler på prompter fra link..

For flere eksempler genererede billeder fra disse modeller, se venligst afsnittet Open Source Finjusterede modeller i tillægget.

Konklusion

I dette indlæg viste vi, hvordan man finjusterer den stabile diffusionsmodel til tekst-til-billede og derefter implementerer den ved hjælp af JumpStart. Desuden diskuterede vi nogle af de overvejelser, du bør gøre dig, mens du finjusterer modellen, og hvordan det kan påvirke den finjusterede models ydeevne. Vi diskuterede også de over 80 klar-til-brug finjusterede modeller tilgængelige i JumpStart. Vi viste kodestykker i dette indlæg – for den fulde kode med alle trinene i denne demo, se Introduktion til JumpStart – Tekst til billede eksempel notesbog. Prøv løsningen på egen hånd og send os dine kommentarer.

For at lære mere om modellen og DreamBooth-finjusteringen, se følgende ressourcer:

For at lære mere om JumpStart, tjek følgende blogindlæg:

Om forfatterne

Dr. Vivek Madan er en anvendt videnskabsmand hos Amazon SageMaker JumpStart-teamet. Han fik sin ph.d. fra University of Illinois i Urbana-Champaign og var postdoktor ved Georgia Tech. Han er en aktiv forsker i maskinlæring og algoritmedesign og har publiceret artikler i EMNLP, ICLR, COLT, FOCS og SODA konferencer.

Heiko Hotz er en Senior Solutions Architect for AI & Machine Learning med særligt fokus på naturlig sprogbehandling (NLP), store sprogmodeller (LLM'er) og generativ AI. Før denne rolle var han chef for datavidenskab for Amazons EU-kundeservice. Heiko hjælper vores kunder med at få succes i deres AI/ML-rejse på AWS og har arbejdet med organisationer i mange brancher, herunder forsikring, finansielle tjenester, medier og underholdning, sundhedspleje, forsyningsselskaber og fremstilling. I sin fritid rejser Heiko så meget som muligt.

Bilag: Eksperimentdatasæt

Dette afsnit indeholder de datasæt, der er brugt i eksperimenterne i dette indlæg.

Hund 1-8

Hund 1-16

Hund 2-4

Hund 3-8

Bilag: Open Source Finjusterede modeller

Det følgende er nogle af eksemplerne på billeder genereret af de forskellige modeller, der er tilgængelige i JumpStart. Hvert billede har en billedtekst model_id begyndende med et præfiks huggingface-txt2img- efterfulgt af den prompt, der bruges til at generere billedet i næste linje.