Finjustera stabila diffusionsmodeller för text-till-bild med Amazon SageMaker JumpStart

Återutgiven av Platon

anhängare: 0

I november 2022, vi meddelade som AWS-kunder kan generera bilder från text med Stabil diffusion modeller i Amazon SageMaker JumpStart. Stable Diffusion är en djupinlärningsmodell som låter dig generera realistiska bilder av hög kvalitet och fantastisk konst på bara några sekunder. Även om att skapa imponerande bilder kan komma till användning i branscher som sträcker sig från konst till NFTs och vidare, förväntar vi oss idag också att AI ska kunna anpassas. Idag meddelar vi att du kan anpassa bildgenereringsmodellen till ditt användningsfall genom att finjustera den på din anpassade datauppsättning i Amazon SageMaker JumpStart. Detta kan vara användbart när du skapar konst, logotyper, anpassade mönster, NFT:er och så vidare, eller roliga saker som att skapa anpassade AI-bilder av dina husdjur eller avatarer av dig själv.

I det här inlägget ger vi en översikt över hur man finjusterar den stabila diffusionsmodellen på två sätt: programmatiskt genom JumpStart API:er tillgängligt i SageMaker Python SDK, och JumpStarts användargränssnitt (UI) i Amazon SageMaker Studio. Vi diskuterar också hur man gör designval inklusive datauppsättningskvalitet, storlek på träningsdatauppsättning, val av hyperparametervärden och tillämpbarhet på flera datauppsättningar. Slutligen diskuterar vi de över 80 allmänt tillgängliga finjusterade modellerna med olika inmatningsspråk och stilar som nyligen lagts till i JumpStart.

Stabil diffusions- och överföringsinlärning

Stable Diffusion är en text-till-bild-modell som gör att du kan skapa fotorealistiska bilder från bara en textuppmaning. En diffusionsmodell tränas genom att lära sig att ta bort brus som lagts till i en verklig bild. Denna avbrusningsprocess genererar en realistisk bild. Dessa modeller kan också generera bilder från enbart text genom att villkora genereringsprocessen på texten. Till exempel är Stable Diffusion en latent diffusion där modellen lär sig känna igen former i en ren brusbild och gradvis bringar dessa former i fokus om formerna matchar orden i inmatningstexten. Texten måste först bäddas in i ett latent utrymme med hjälp av en språkmodell. Sedan utförs en serie av brustilläggs- och brusborttagningsoperationer i det latenta utrymmet med en U-Net-arkitektur. Slutligen avkodas den brusfria utsignalen till pixelutrymmet.

Källa: https://jalammar.github.io/illustrated-stable-diffusion/

Inom maskininlärning (ML) kallas förmågan att överföra kunskapen som lärs från en domän till en annan överför lärande. Du kan använda överföringsinlärning för att producera exakta modeller på dina mindre datauppsättningar, med mycket lägre utbildningskostnader än de som är involverade i att träna den ursprungliga modellen. Med transfer learning kan du finjustera den stabila diffusionsmodellen på din egen datauppsättning med så lite som fem bilder. Till vänster finns till exempel träningsbilder av en hund som heter Doppler som används för att finjustera modellen, i mitten och till höger finns bilder som genereras av den finjusterade modellen när man uppmanas att förutsäga Dopplers bild på stranden och en blyertsskiss.

Till vänster finns bilder på en vit stol som används för att finjustera modellen och en bild av stolen i rött genererad av den finjusterade modellen. Till höger finns bilder på en ottoman som används för att finjustera modellen och en bild på en katt som sitter på en ottoman.

Att finjustera stora modeller som Stable Diffusion kräver vanligtvis att du tillhandahåller träningsskript. Det finns en mängd problem, inklusive problem med slut på minne, problem med nyttolaststorlek och mer. Dessutom måste du köra end-to-end-tester för att säkerställa att skriptet, modellen och den önskade instansen fungerar tillsammans på ett effektivt sätt. JumpStart förenklar denna process genom att tillhandahålla färdiga skript som har testats ordentligt. JumpStart-finjusteringsskriptet för stabila diffusionsmodeller bygger på finjusteringsskriptet från drömbås. Du kan komma åt dessa skript med ett enda klick genom Studio UI eller med väldigt få rader kod genom JumpStart API:er.

Observera att genom att använda den stabila diffusionsmodellen godkänner du CreativeML Open RAIL++-M-licens.

Använd JumpStart programmatiskt med SageMaker SDK

Det här avsnittet beskriver hur man tränar och distribuerar modellen med SageMaker Python SDK. Vi väljer en lämplig förutbildad modell i JumpStart, tränar denna modell med ett SageMaker-utbildningsjobb och distribuerar den tränade modellen till en SageMaker-slutpunkt. Dessutom kör vi slutledning om den distribuerade slutpunkten, allt med SageMaker Python SDK. Följande exempel innehåller kodavsnitt. För den fullständiga koden med alla steg i denna demo, se Introduktion till JumpStart – Text till bild exempel anteckningsbok.

Träna och finjustera den stabila diffusionsmodellen

Varje modell identifieras av en unik model_id. Följande kod visar hur man finjusterar en Stable Diffusion 2.1-basmodell identifierad av model_id model-txt2img-stabilityai-stable-diffusion-v2-1-base på en anpassad träningsdatauppsättning. För en fullständig lista över model_id värden och vilka modeller som är finjusterbara, se Inbyggda algoritmer med förtränad modellbord. För varje model_id, för att lansera ett SageMaker-utbildningsjobb genom Uppskattare klass av SageMaker Python SDK måste du hämta Docker-bild-URI, träningsskript-URI och förtränad modell-URI genom verktygsfunktionerna i SageMaker. Utbildningsskriptets URI innehåller all nödvändig kod för databehandling, laddning av den förtränade modellen, modellträning och lagring av den tränade modellen för slutledning. Den förtränade modellens URI innehåller den förtränade modellarkitekturens definition och modellparametrarna. Den förtränade modellens URI är specifik för den specifika modellen. De förtränade modelltjärbollarna har förnedladdats från Hugging Face och sparats med lämplig modellsignatur i Amazon enkel lagringstjänst (Amazon S3) hinkar, så att träningsjobbet körs i nätverksisolering. Se följande kod:

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 dessa modellspecifika träningsartefakter kan du konstruera ett objekt av Uppskattare klass:

# 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)

Utbildningsdataset

Följande är instruktionerna för hur träningsdata ska formateras:

Ingång – En katalog som innehåller instansbilderna, dataset_info.json, med följande konfiguration:
- Bilder kan ha formatet .png, .jpg eller .jpeg
- Smakämnen dataset_info.json filen måste ha formatet {'instance_prompt':<<instance_prompt>>}
Produktion – En utbildad modell som kan användas för slutledning

S3-banan ska se ut s3://bucket_name/input_directory/. Notera släpningen / krävs.

Följande är ett exempelformat på 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

För instruktioner om hur du formaterar data medan du använder tidigare bevarande, se avsnittet Tidigare konservering i det här inlägget.

Vi tillhandahåller en standarduppsättning av kattbilder. Den består av åtta bilder (instansbilder som motsvarar instansprompten) av en enda katt utan klassbilder. Den kan laddas ner från GitHub. Om du använder standarddatauppsättningen, prova prompten "ett foto av en riobugger-katt" medan du gör slutsatser i demo-anteckningsboken.

Licens: MIT.

Hyperparametrar

Därefter, för att överföra inlärning på din anpassade datauppsättning, kan du behöva ändra standardvärdena för träningshyperparametrarna. Du kan hämta en Python-ordlista med dessa hyperparametrar med deras standardvärden genom att anropa hyperparameters.retrieve_default, uppdatera dem vid behov och skicka dem sedan till klassen Estimator. Se följande kod:

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öljande hyperparametrar stöds av finjusteringsalgoritmen:

med_före_konservering – Flagga för att lägga till tidigare förlust av konservering. Förkonservering är en regularizer som undviker överanpassning. (Val: [“True”,“False”], standard: “False”.)
num_class_images – Minsta klassbilder för förlust av tidigare bevarande. Om with_prior_preservation = True och det finns inte tillräckligt många bilder redan i class_data_dir, kommer ytterligare bilder att samplas med class_prompt. (Värden: positivt heltal, standard: 100.)
epoker – Antalet pass som finjusteringsalgoritmen tar genom träningsdatauppsättningen. (Värden: positivt heltal, standard: 20.)
Max_steg – Det totala antalet träningssteg som ska utföras. Om inte None, åsidosätter epoker. (Värden: “None” eller en sträng av heltal, standard: “None”.)
Satsstorlek –: Antalet träningsexempel som genomarbetas innan modellvikterna uppdateras. Samma som batchstorleken under generering av klassbilder if with_prior_preservation = True. (Värden: positivt heltal, standard: 1.)
learning_rate – Den hastighet med vilken modellvikterna uppdateras efter att man har arbetat igenom varje grupp med träningsexempel. (Värden: positivt flytande, standard: 2e-06.)
föregående_förlust_vikt – Vikten av förlust av tidigare konservering. (Värden: positivt flytande, standard: 1.0.)
center_crop – Om bilderna ska beskäras innan storleken ändras till önskad upplösning. (Val: [“True”/“False”], standard: “False”.)
lr_scheduler – Typen av inlärningshastighetsschemaläggare. (Val: ["linear", "cosine", "cosine_with_restarts", "polynomial", "constant", "constant_with_warmup"], standard: "constant".) För mer information, se Inlärningshastighetsschemaläggare.
adam_weight_decay – Viktminskningen som ska appliceras (om inte noll) på alla lager utom alla bias och LayerNorm vikter in AdamW optimerare. (Värde: flytande, standard: 1e-2.)
adam_beta1 – Hyperparameter beta1 (exponentiell avklingningshastighet för uppskattningar av första ögonblicket) för AdamW optimerare. (Värde: flytande, standard: 0.9.)
adam_beta2 – Hyperparameter beta2 (exponentiell avklingningshastighet för uppskattningar av första ögonblicket) för AdamW optimerare. (Värde: flytande, standard: 0.999.)
adam_epsilon - Den epsilon hyperparameter för AdamW optimerare. Det är vanligtvis inställt på ett litet värde för att undvika division med 0. (Värde: float, standard: 1e-8.)
gradient_ackumulation_steps – Antalet uppdateringssteg som ska samlas innan ett bakåt-/uppdateringspass utförs. (Värde: heltal, standard: 1.)
max_grad_norm – Maximal gradientnorm (för gradientklippning). (Värde: flytande, standard: 1.0.)
frö – Fixa det slumpmässiga tillståndet för att uppnå reproducerbara resultat i träningen. (Värde: heltal, standard: 0.)

Implementera den fintränade modellen

När modellutbildningen är klar kan du distribuera modellen direkt till en beständig, realtidsslutpunkt. Vi hämtar de nödvändiga Docker Image-URIerna och skript-URIerna och distribuerar modellen. Se följande kod:

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

Till vänster är träningsbilderna av en katt som heter riobugger som används för att finjustera modellen (standardparametrar utom max_steps = 400). I mitten och till höger finns bilderna som genereras av den finjusterade modellen när de uppmanas att förutsäga riobuggers bild på stranden och en pennskiss.

För mer information om slutledning, inklusive parametrar som stöds, svarsformat och så vidare, se Generera bilder från text med den stabila diffusionsmodellen på Amazon SageMaker JumpStart.

Få åtkomst till JumpStart via Studio UI

I det här avsnittet visar vi hur man tränar och distribuerar JumpStart-modeller genom Studio UI. Följande video visar hur du hittar den förtränade stabila diffusionsmodellen på JumpStart, tränar den och sedan distribuerar den. Modellsidan innehåller värdefull information om modellen och hur man använder den. Efter att ha konfigurerat SageMaker-utbildningsinstansen, välj Tåg. Efter att modellen har tränats kan du distribuera den tränade modellen genom att välja Distribuera. När slutpunkten är i "i drift"-stadiet är den redo att svara på slutledningsförfrågningar.

För att påskynda tiden till slutledning tillhandahåller JumpStart en exempelanteckningsbok som visar hur man kör inferens på den nyskapade slutpunkten. För att komma åt anteckningsboken i Studio, välj Öppna Notebook i Använd Endpoint från Studio avsnittet på modellens slutpunktssida.

JumpStart tillhandahåller också en enkel anteckningsbok som du kan använda för att finjustera den stabila diffusionsmodellen och distribuera den resulterande finjusterade modellen. Du kan använda den för att skapa roliga bilder av din hund. För att komma åt anteckningsboken, sök efter "Generera roliga bilder av din hund" i JumpStart-sökfältet. För att köra anteckningsboken kan du använda så lite som fem träningsbilder och ladda upp till den lokala studiomappen. Om du har fler än fem bilder kan du ladda upp dem också. Notebook laddar upp träningsbilderna till S3, tränar modellen på din datauppsättning och distribuerar den resulterande modellen. Träningen kan ta 20 minuter att avsluta. Du kan ändra antalet steg för att påskynda träningen. Notebook ger några exempel på uppmaningar att prova med den distribuerade modellen, men du kan prova vilken prompt du vill. Du kan också anpassa anteckningsboken för att skapa avatarer av dig själv eller dina husdjur. Till exempel, istället för din hund, kan du ladda upp bilder av din katt i det första steget och sedan ändra uppmaningarna från hundar till katter och modellen kommer att generera bilder av din katt.

Finjusterande överväganden

Träningsstabila diffusionsmodeller tenderar att överanpassas snabbt. För att få bilder av god kvalitet måste vi hitta en bra balans mellan de tillgängliga träningshyperparametrarna som antal träningssteg och inlärningshastigheten. I det här avsnittet visar vi några experimentella resultat och ger vägledning om hur du ställer in dessa parametrar.

Rekommendationer

Tänk på följande rekommendationer:

Börja med bra kvalitet på träningsbilder (4–20). Om du tränar på mänskliga ansikten kan du behöva fler bilder.
Träna i 200–400 steg när du tränar på hundar eller katter och andra icke-mänskliga ämnen. Om du tränar på mänskliga ansikten kan du behöva fler steg. Om övermontering inträffar, minska antalet steg. Om underpassning inträffar (den finjusterade modellen kan inte generera målmotivets bild), öka antalet steg.
Om du tränar på icke-mänskliga ansikten kan du ställa in with_prior_preservation = False eftersom det inte påverkar prestandan nämnvärt. På mänskliga ansikten kan du behöva ställa in with_prior_preservation=True.
Om inställning with_prior_preservation=True, använd instanstypen ml.g5.2xlarge.
När du tränar i flera ämnen i följd, om ämnena är väldigt lika (till exempel alla hundar), behåller modellen det sista ämnet och glömmer de tidigare ämnena. Om motiven är olika (till exempel först en katt och sedan en hund), behåller modellen båda motiven.
Vi rekommenderar att du använder en låg inlärningshastighet och att du successivt ökar antalet steg tills resultatet är tillfredsställande.

Utbildningsdataset

Kvaliteten på den finjusterade modellen påverkas direkt av kvaliteten på träningsbilderna. Därför måste du samla in bilder av hög kvalitet för att få bra resultat. Suddiga eller lågupplösta bilder påverkar kvaliteten på den finjusterade modellen. Tänk på följande ytterligare parametrar:

Antal träningsbilder – Du kan finjustera modellen på så lite som fyra träningsbilder. Vi experimenterade med träningsdatauppsättningar av storlek så lite som 4 bilder och så många som 16 bilder. I båda fallen kunde finjusteringen anpassa modellen till ämnet.
Datauppsättningsformat – Vi testade finjusteringsalgoritmen på bilder i formaten .png, .jpg och .jpeg. Andra format kan också fungera.
Bildupplösning – Träningsbilder kan ha vilken upplösning som helst. Finjusteringsalgoritmen kommer att ändra storlek på alla träningsbilder innan finjusteringen påbörjas. Med detta sagt, om du vill ha mer kontroll över beskärningen och storleksändringen av träningsbilderna rekommenderar vi att du själv ändrar storleken på bilderna till modellens basupplösning (i det här exemplet 512×512 pixlar).

Experimentinställningar

I experimentet i det här inlägget, medan vi finjusterar, använder vi standardvärdena för hyperparametrarna om inget annat anges. Dessutom använder vi en av de fyra datamängderna:

Hund 1-8 – Hund 1 med 8 bilder
Hund 1-16 – Hund 1 med 16 bilder
Hund 2-4 – Hund 2 med fyra bilder
Katt-8 – Katt med 8 bilder

För att minska röran visar vi bara en representativ bild av datasetet i varje sektion tillsammans med datasetets namn. Du hittar hela träningssetet i avsnittet Experimentdatauppsättningar i det här inlägget.

Överanpassning

Stabila diffusionsmodeller tenderar att överanpassa sig när man finjusterar på några få bilder. Därför måste du välja parametrarna som t.ex epochs, max_epochsoch inlärningshastigheten noggrant. I det här avsnittet använde vi datasetet Dog1-16.

För att utvärdera modellens prestanda utvärderar vi den finjusterade modellen för fyra uppgifter:

Kan den finjusterade modellen generera bilder av motivet (Dopplerhund) i samma miljö som den tränades på?
- Observation – Ja det kan det. Det är värt att notera att modellens prestanda ökar med antalet träningssteg.
Kan den finjusterade modellen generera bilder av motivet i en annan miljö än den tränades på? Kan den till exempel generera bilder av Doppler på en strand?
- Observation – Ja det kan det. Det är värt att notera att modellens prestanda ökar med antalet träningssteg upp till en viss punkt. Om modellen tränas för länge försämras dock modellens prestanda eftersom modellen tenderar att överanpassas.
Kan den finjusterade modellen generera bilder av en klass som utbildningsämnet tillhör? Kan det till exempel generera en bild av en generisk hund?
- Observation – I takt med att vi ökar antalet träningssteg börjar modellen att överfita. Som ett resultat glömmer den bort hundens generiska klass och producerar bara bilder relaterade till ämnet.
Kan den finjusterade modellen generera bilder av en klass eller ett ämne som inte finns med i träningsdatauppsättningen? Kan det till exempel generera en bild av en katt?
- Observation – I takt med att vi ökar antalet träningssteg börjar modellen att överfita. Som ett resultat kommer det bara att producera bilder relaterade till ämnet, oavsett vilken klass som anges.

Vi finjusterar modellen för ett annat antal steg (genom att ställa in max_steps hyperparametrar) och för varje finjusterad modell genererar vi bilder på var och en av följande fyra prompter (visas i följande exempel från vänster till höger:

“Ett foto av en Dopplerhund”
“Ett foto av en Dopplerhund på en strand”
"Ett foto på en hund"
"Ett foto på en katt"

Följande bilder är från modellen tränad med 50 steg.

Följande modell tränades med 100 steg.

Vi tränade följande modell med 200 steg.

Följande bilder är från en modell tränad med 400 steg.

Slutligen är följande bilder resultatet av 800 steg.

Träna på flera datamängder

När du finjusterar kanske du vill finjustera på flera motiv och låta den finjusterade modellen kunna generera bilder av alla motiv. Tyvärr är JumpStart för närvarande begränsad till träning i ett enda ämne. Du kan inte finjustera modellen på flera ämnen samtidigt. Vidare, finjustering av modellen för olika ämnen sekventiellt resulterar i att modellen glömmer det första ämnet om ämnena är likartade.

Vi överväger följande experiment i det här avsnittet:

Finjustera modellen för ämne A.
Finjustera den resulterande modellen från steg 1 för ämne B.
Generera bilder av ämne A och ämne B med hjälp av utdatamodellen från steg 2.

I följande experiment observerar vi att:

Om A är hund 1 och B är hund 2, så liknar alla bilder som genereras i steg 3 hund 2
Om A är hund 2 och B är hund 1, så liknar alla bilder som genereras i steg 3 hund 1
Om A är hund 1 och B är katt, liknar bilder som genereras med hunduppmaningar hund 1 och bilder som genereras med kattuppmaningar liknar katt

Träna på hund 1 och sedan hund 2

I steg 1 finjusterar vi modellen för 200 steg på åtta bilder av hund 1. I steg 2 finjusterar vi modellen ytterligare för 200 steg på fyra bilder av hund 2.

Följande är bilderna som genereras av den finjusterade modellen i slutet av steg 2 för olika uppmaningar.

Träna på hund 2 och sedan hund 1

I steg 1 finjusterar vi modellen för 200 steg på fyra bilder av hund 2. I steg 2 finjusterar vi modellen ytterligare i 200 steg på åtta bilder av hund 1.

Följande är bilderna som genereras av den finjusterade modellen i slutet av steg 2 med olika uppmaningar.

Träna på hundar och katter

I steg 1 finjusterar vi modellen för 200 steg på åtta bilder av en katt. Sedan finjusterar vi modellen ytterligare i 200 steg på åtta bilder av hund 1.

Följande är bilderna som genereras av den finjusterade modellen i slutet av steg 2. Bilder med kattrelaterade uppmaningar ser ut som katten i steg 1 av finjusteringen, och bilder med hundrelaterade uppmaningar ser ut som hunden i Steg 2 av finjusteringen.

Förhandskonservering

Förhandskonservering är en teknik som använder ytterligare bilder av samma klass som vi försöker träna på. Om träningsdata till exempel består av bilder av en viss hund, med tidigare bevarande, inkluderar vi klassbilder av generiska hundar. Den försöker undvika överanpassning genom att visa bilder på olika hundar medan den tränar för en viss hund. En tagg som indikerar den specifika hunden som finns i instansprompten saknas i klassprompten. Till exempel kan instansuppmaningen vara "ett foto av en riobugger-katt" och klassprompten kan vara "ett foto av en katt." Du kan aktivera tidigare bevarande genom att ställa in hyperparametern with_prior_preservation = True. Om inställning with_prior_preservation = True, måste du inkludera class_prompt in dataset_info.json och kan innehålla alla klassbilder som är tillgängliga för dig. Följande är träningsdatauppsättningsformatet vid inställning with_prior_preservation = True:

Ingång – En katalog som innehåller instansbilderna, dataset_info.json och (valfritt) katalog class_data_dir. Observera följande:
- Bilder kan ha formatet .png, .jpg, .jpeg.
- Smakämnen dataset_info.json filen måste ha formatet {'instance_prompt':<<instance_prompt>>,'class_prompt':<<class_prompt>>}.
- Smakämnen class_data_dir katalogen måste ha klassbilder. Om class_data_dir inte finns eller så finns det inte tillräckligt med bilder redan i class_data_dir, kommer ytterligare bilder att samplas med class_prompt.

För datauppsättningar som katter och hundar påverkar tidigare bevarande inte nämnvärt prestandan för den finjusterade modellen och kan därför undvikas. Men när man tränar på ansikten är detta nödvändigt. För mer information, se Träna stabil diffusion med Dreambooth med hjälp av diffusorer.

Instanstyper

Finjustering av stabila diffusionsmodeller kräver accelererad beräkning som tillhandahålls av GPU-stödda instanser. Vi experimenterar med vår finjustering med ml.g4dn.2xlarge (16 GB CUDA-minne, 1 GPU) och ml.g5.2xlarge (24 GB CUDA-minne, 1 GPU). Minneskravet är högre vid generering av klassbilder. Därför, om inställning with_prior_preservation=True, använd instanstypen ml.g5.2xlarge, eftersom träning körs in i problemet med CUDA utan minne på ml.g4dn.2xlarge-instansen. JumpStart-finjusteringsskriptet använder för närvarande en enda GPU och därför kommer finjustering på multi-GPU-instanser inte att ge prestandavinst. För mer information om olika instanstyper, se Amazon EC2 instansstyper.

Begränsningar och partiskhet

Även om Stable Diffusion har imponerande prestanda när det gäller att generera bilder, lider den av flera begränsningar och fördomar. Dessa inkluderar men är inte begränsade till:

Modellen kanske inte genererar exakta ansikten eller lemmar eftersom träningsdatan inte innehåller tillräckligt med bilder med dessa funktioner
Modellen utbildades på LAION-5B dataset, som har vuxet innehåll och kanske inte är lämplig för produktanvändning utan ytterligare överväganden
Modellen kanske inte fungerar bra med icke-engelska språk eftersom modellen tränades på engelskspråkig text
Modellen kan inte generera bra text i bilder

För mer information om begränsningar och fördomar, se Stabil Diffusion v2-1-bas modellkort. Dessa begränsningar för den förtränade modellen kan också överföras till de finjusterade modellerna.

Städa upp

När du är klar med att köra anteckningsboken, se till att ta bort alla resurser som skapats i processen för att säkerställa att faktureringen stoppas. Kod för att rensa slutpunkten finns i den tillhörande Introduktion till JumpStart – Text till bild exempel anteckningsbok.

Allmänt tillgängliga finjusterade modeller i JumpStart

Även om Stable Diffusion modeller släpptes av StabilitetAI har imponerande prestanda, de har begränsningar när det gäller språket eller domänen den tränades på. Till exempel, stabila diffusionsmodeller tränades på engelsk text, men du kan behöva generera bilder från icke-engelsk text. Alternativt har Stable Diffusion-modeller tränats för att generera fotorealistiska bilder, men du kan behöva generera animerade eller konstnärliga bilder.

JumpStart tillhandahåller över 80 allmänt tillgängliga modeller med olika språk och teman. Dessa modeller är ofta finjusterade versioner från Stable Diffusion-modeller släppta av StabilityAI. Om ditt användningsfall matchar en av de finjusterade modellerna behöver du inte samla in din egen datauppsättning och finjustera den. Du kan helt enkelt distribuera en av dessa modeller via Studio UI eller använda lättanvända JumpStart API:er. För att distribuera en förutbildad stabil diffusionsmodell i JumpStart, se Generera bilder från text med den stabila diffusionsmodellen på Amazon SageMaker JumpStart.

Följande är några av exemplen på bilder som genereras av de olika modellerna som finns tillgängliga i JumpStart.

Observera att dessa modeller inte är finjusterade med JumpStart-skript eller DreamBooth-skript. Du kan ladda ner hela listan över allmänt tillgängliga finjusterade modeller med exempelmeddelanden från här..

För fler exempelgenererade bilder från dessa modeller, se avsnittet Finjusterade modeller med öppen källkod i bilagan.

Slutsats

I det här inlägget visade vi hur man finjusterar den stabila diffusionsmodellen för text-till-bild och sedan distribuerar den med JumpStart. Dessutom diskuterade vi några av de överväganden du bör göra när du finjusterar modellen och hur det kan påverka den finjusterade modellens prestanda. Vi diskuterade också de över 80 färdiga finjusterade modellerna som finns tillgängliga i JumpStart. Vi visade kodavsnitt i det här inlägget – för hela koden med alla steg i den här demon, se Introduktion till JumpStart – Text till bild exempel anteckningsbok. Prova lösningen på egen hand och skicka oss dina kommentarer.

För att lära dig mer om modellen och DreamBooth-finjusteringen, se följande resurser:

För att lära dig mer om JumpStart, kolla in följande blogginlägg:

Om författarna

Dr. Vivek Madan är en tillämpad forskare med Amazon SageMaker JumpStart-teamet. Han tog sin doktorsexamen från University of Illinois i Urbana-Champaign och var postdoktor vid Georgia Tech. Han är en aktiv forskare inom maskininlärning och algoritmdesign och har publicerat artiklar på EMNLP-, ICLR-, COLT-, FOCS- och SODA-konferenser.

Heiko Hotz är en Senior Solutions Architect för AI & Machine Learning med särskilt fokus på naturlig språkbehandling (NLP), stora språkmodeller (LLM) och generativ AI. Innan den här rollen var han chef för datavetenskap för Amazons EU Customer Service. Heiko hjälper våra kunder att bli framgångsrika i sin AI/ML-resa på AWS och har arbetat med organisationer i många branscher, inklusive försäkring, finansiella tjänster, media och underhållning, hälsovård, allmännyttiga företag och tillverkning. På fritiden reser Heiko så mycket som möjligt.

Bilaga: Experimentdatauppsättningar

Det här avsnittet innehåller datauppsättningarna som används i experimenten i det här inlägget.

Hund 1-8

Hund 1-16

Hund 2-4

Hund 3-8

Bilaga: Finjusterade modeller med öppen källkod

Följande är några av exemplen på bilder som genereras av de olika modellerna som finns tillgängliga i JumpStart. Varje bild är textad med en model_id börjar med ett prefix huggingface-txt2img- följt av prompten som används för att skapa bilden på nästa rad.