Twórz wysokiej jakości obrazy za pomocą modeli stabilnej dyfuzji i wdrażaj je w ekonomiczny sposób za pomocą Amazon SageMaker | Usługi sieciowe Amazona

Generowanie tekstu na obraz to zadanie, w którym model uczenia maszynowego (ML) generuje obraz z opisu tekstowego. Celem jest wygenerowanie obrazu, który będzie ściśle odpowiadał opisowi, uchwyciwszy szczegóły i niuanse tekstu. To zadanie jest trudne, ponieważ wymaga od modelu zrozumienia semantyki i składni tekstu oraz generowania fotorealistycznych obrazów. Istnieje wiele praktycznych zastosowań generowania tekstu na obraz w fotografii AI, grafikach koncepcyjnych, architekturze budynków, modzie, grach wideo, projektowaniu graficznym i wielu innych.

Stabilna dyfuzja to model zamiany tekstu na obraz, który umożliwia tworzenie wysokiej jakości obrazów w ciągu kilku sekund. Gdy celem jest interakcja w czasie rzeczywistym z tego typu modelem, zapewnienie płynnego doświadczenia użytkownika zależy od użycia przyspieszonego sprzętu do wnioskowania, takiego jak GPU lub Inferencja AWS2, własny akcelerator wnioskowania ML firmy Amazon. Wysokie koszty związane z używaniem procesorów graficznych zwykle wymagają optymalizacji wykorzystania podstawowych mocy obliczeniowych, tym bardziej, gdy trzeba wdrożyć różne architektury lub spersonalizowane (dopracowane) modele. Amazon Sage Maker wielomodelowe punkty końcowe (MME) pomagają rozwiązać ten problem, pomagając skalować tysiące modeli w jednym punkcie końcowym. Korzystając ze współdzielonego kontenera do obsługi, możesz hostować wiele modeli w ekonomiczny i skalowalny sposób w tym samym punkcie końcowym, a nawet na tym samym GPU.

W tym poście dowiesz się o architekturach modeli stabilnej dyfuzji, różnych typach modeli stabilnej dyfuzji oraz technikach poprawiania jakości obrazu. Pokazujemy również, jak oszczędnie wdrażać modele stabilnej dyfuzji przy użyciu oprogramowania SageMaker MME i serwera wnioskowania NVIDIA Triton.

Podpowiedź: portret uroczego berneńczyka, grafika Elke Vogelsang, 8k ultrarealistyczny, zyskujący popularność na artstation, 4k	Prompt: projekt architektoniczny salonu, 8k ultrarealistyczny, 4k, hiperrealistyczny, skupiony, ekstremalne detale	Podpowiedź: panoramę Nowego Jorku nocą, 8k, długie ujęcie, silnik unreal engine 5, film, arcydzieło

Stabilna architektura dyfuzyjna

Stabilna dyfuzja to model typu open source zamiany tekstu na obraz, którego można używać do tworzenia obrazów o różnych stylach i treściach, po prostu wyświetlając monit tekstowy. W kontekście generowania tekstu na obraz model dyfuzji jest modelem generatywnym, którego można użyć do generowania wysokiej jakości obrazów z opisów tekstowych. Modele dyfuzji to rodzaj modelu generatywnego, który może uchwycić złożone zależności między modalnościami wejściowymi i wyjściowymi, tekstem i obrazami.

Na poniższym diagramie przedstawiono architekturę wysokiego poziomu modelu stabilnej dyfuzji.

Składa się z następujących kluczowych elementów:

• Koder tekstu – CLIP to oparty na transformatorach model kodera tekstu, który pobiera tekst zachęty i konwertuje go na osadzenie tokenów, które reprezentują każde słowo w tekście. CLIP jest szkolony na zbiorze danych obrazów i ich podpisów, kombinacji kodera obrazu i kodera tekstu.
• U-Net – Model U-Net pobiera osadzanie tokenów z CLIP wraz z tablicą zaszumionych wejść i generuje odszumione dane wyjściowe. Dzieje się tak poprzez serię iteracyjnych kroków, w których każdy krok przetwarza wejściowy tensor utajony i tworzy nowy utajony tensor przestrzeni, który lepiej reprezentuje tekst wejściowy.
• Automatyczny enkoder-dekoder – Ten model tworzy ostateczne obrazy. Pobiera ostateczny odszumiony ukryty wynik z modelu U-Net i konwertuje go na obrazy reprezentujące wprowadzany tekst.

Rodzaje modeli stabilnej dyfuzji

W tym poście omawiamy następujące wstępnie wytrenowane modele Stable Diffusion opracowane przez Stability AI z centrum modeli Hugging Face.

stabilna dyfuzja-2-1-zasada

Użyj tego modelu do generowania obrazów na podstawie monitu tekstowego. Jest to podstawowa wersja modelu, na którym trenowano LAION-5B. Model został przeszkolony na podzbiorze zbioru danych na dużą skalę LAION-5B, i głównie z angielskimi napisami. Używamy StableDiffusionPipeline z diffusers biblioteka do generowania obrazów z monitów tekstowych. Ten model może tworzyć obrazy o wymiarach 512 x 512. Wykorzystuje następujące parametry:

• podpowiedź – Monitem może być słowo tekstowe, fraza, zdania lub akapity.
• negatywna_prompt – Można również przekazać monit negatywny, aby wykluczyć określone elementy z procesu generowania obrazu i poprawić jakość generowanych obrazów.
• skala_wskazówek – Wyższa skala prowadzenia powoduje, że obraz jest bardziej zbliżony do monitu, kosztem jakości obrazu. Jeśli określono, musi to być liczba zmiennoprzecinkowa.

stabilna-dyfuzja-2-głębokość

Ten model służy do generowania nowych obrazów z istniejących przy jednoczesnym zachowaniu kształtu i głębi obiektów w oryginalnym obrazie. Ten stable-diffusion-2-depth model jest dostrojony od stabilna dyfuzja-2-zasada, dodatkowy kanał wejściowy do przetwarzania (względnej) prognozy głębokości. Używamy StableDiffusionDepth2ImgPipeline z diffusers bibliotekę, aby załadować potok i wygenerować obrazy głębi. Poniżej przedstawiono dodatkowe parametry charakterystyczne dla modelu głębokości:

• obraz – Początkowy obraz warunkujący generowanie nowych obrazów.
• liczba_kroków_wnioskowania (opcjonalne) – Liczba kroków odszumiania. Więcej kroków odszumiania zwykle prowadzi do uzyskania obrazu o wyższej jakości kosztem wolniejszego wnioskowania. Ten parametr jest modulowany przez strength.
• siła (opcjonalnie) – Koncepcyjnie wskazuje to, jak bardzo należy przekształcić obraz referencyjny. Wartość musi mieścić się w zakresie od 0 do 1. image jest używany jako punkt wyjścia, dodając do niego więcej szumu, im większa siła. Liczba etapów odszumiania zależy od ilości szumu dodawanego początkowo. Gdy strength wynosi 1, dodany szum będzie maksymalny, a proces usuwania szumów będzie przebiegał przez pełną liczbę iteracji określoną w num_inference_steps. Dlatego wartość 1 zasadniczo ignoruje image. Aby uzyskać więcej informacji, zapoznaj się z poniższymi informacjami kod.

stabilne-dyfuzyjne-2-malowanie

Możesz użyć tego modelu do przypadków użycia przywracania obrazu AI. Możesz go również użyć do tworzenia nowatorskich projektów i obrazów na podstawie podpowiedzi i dodatkowych argumentów. Ten model również wywodzi się z modelu podstawowego i ma strategię generowania masek. Określa maskę oryginalnego obrazu reprezentującą segmenty do zmiany i segmenty do pozostawienia bez zmian. Używamy StableDiffusionUpscalePipeline z diffusers biblioteka, aby zastosować zmiany malowania na oryginalnym obrazie. Poniższy dodatkowy parametr jest specyficzny dla modelu głębokości:

• wejście_maski – Obraz, w którym zaciemniona część pozostaje niezmieniona podczas generowania obrazu, a biała część jest zastępowana

stabilna dyfuzja-x4-upscaler

Ten model również wywodzi się z modelu podstawowego, dodatkowo trenowanego na 10M podzbiorze LAION zawierającym obrazy 2048 x 2048. Jak sama nazwa wskazuje, można go użyć do przeskalowania obrazów o niższej rozdzielczości do wyższych rozdzielczości

Omówienie przypadków użycia

W tym poście wdrażamy usługę obrazu AI z wieloma możliwościami, w tym generowaniem nowych obrazów z tekstu, zmienianiem stylów istniejących obrazów, usuwaniem niechcianych obiektów z obrazów i skalowaniem obrazów o niskiej rozdzielczości do wyższych rozdzielczości. Używając kilku wariantów modeli stabilnej dyfuzji, możesz zająć się wszystkimi tymi przypadkami użycia w jednym punkcie końcowym SageMaker. Oznacza to, że będziesz musiał hostować dużą liczbę modeli w wydajny, skalowalny i ekonomiczny sposób. W tym poście pokazujemy, jak w ekonomiczny sposób wdrożyć wiele modeli stabilnej dyfuzji przy użyciu oprogramowania SageMaker MME i serwera wnioskowania NVIDIA Triton. Dowiesz się o szczegółach implementacji, technikach optymalizacji i najlepszych praktykach pracy z modelami zamiany tekstu na obraz.

Poniższa tabela podsumowuje modele stabilnej dystrybucji, które wdrażamy w SageMaker MME.

Omówienie rozwiązania

Wdrażanie modeli Stable Diffusion w SageMaker MME obejmuje następujące kroki:

1. Użyj hubu Hugging Face, aby pobrać modele Stable Diffusion do lokalnego katalogu. To się pobierze scheduler, text_encoder, tokenizer, unet, and vae dla każdego modelu stabilnej dystrybucji do odpowiedniego katalogu lokalnego. Używamy revision="fp16" wersja modelu.
2. Skonfiguruj repozytorium modeli NVIDIA Triton, konfiguracje modeli i logikę udostępniania modeli model.py. Triton używa tych artefaktów do obsługi prognoz.
3. Spakuj środowisko conda z dodatkowymi zależnościami i repozytorium modeli pakietów, które mają zostać wdrożone w SageMaker MME.
4. Spakuj artefakty modelu w formacie specyficznym dla NVIDIA Triton i prześlij model.tar.gz do Usługa Amazon Simple Storage (Amazon S3). Model posłuży do generowania obrazów.
5. Skonfiguruj model SageMaker, konfigurację punktu końcowego i wdróż SageMaker MME.
6. Uruchom wnioskowanie i wyślij monity do punktu końcowego SageMaker, aby wygenerować obrazy przy użyciu modelu stabilnej dyfuzji. Określamy TargetModel zmiennej i wywoływać różne modele stabilnej dyfuzji, aby wizualnie porównywać wyniki.

Opublikowaliśmy kod implementujący architekturę tego rozwiązania w środowisku GitHub repo. Postępuj zgodnie z instrukcjami README, aby rozpocząć.

Obsługuj modele za pomocą zaplecza NVIDIA Triton Inference Server w języku Python

Używamy zaplecza Triton Python do wdrożenia modelu potoku Stable Diffusion w SageMaker MME. Backend Pythona pozwala obsługiwać modele napisane w Pythonie przez Triton Inference Server. Aby korzystać z backendu Pythona, musisz utworzyć plik Pythona model.py który ma następującą strukturę: Każdy backend Pythona może zaimplementować cztery główne funkcje w TritonPythonModel klasa:

import triton_python_backend_utils as pb_utils
class TritonPythonModel: """Your Python model must use the same class name. Every Python model
that is created must have "TritonPythonModel" as the class name. """
def auto_complete_config(auto_complete_model_config):
def initialize(self, args):
def execute(self, requests):
def finalize(self):

Każdy backend Pythona może zaimplementować cztery główne funkcje w TritonPythonModel klasa: auto_complete_config, initialize, execute, finalize.

initialize jest wywoływana podczas ładowania modelu. Realizowanie initialize jest opcjonalne. initialize umożliwia wykonanie wszelkich niezbędnych inicjalizacji przed uruchomieniem wnioskowania. w initialize funkcji, tworzymy potok i ładujemy potoki za pomocą from_pretrained punkty kontrolne. Konfigurujemy harmonogramy z konfiguracji harmonogramu potoku pipe.scheduler.config. Na koniec określamy xformers optymalizacje, aby umożliwić xformer parametr wydajności pamięci enable_xformers_memory_efficient_attention. Więcej szczegółów udzielamy nt xformers później w tym poście. Możesz odwołać się do model.py każdego modelu, aby zrozumieć różne szczegóły potoku. Ten plik można znaleźć w repozytorium modelu.

Połączenia execute funkcja jest wywoływana za każdym razem, gdy wysyłane jest żądanie wnioskowania. Każdy model Pythona musi implementować execute funkcjonować. w execute funkcji, otrzymasz listę InferenceRequest obiekty. Przekazujemy monit o tekst wejściowy do potoku, aby uzyskać obraz z modelu. Obrazy są dekodowane, a wygenerowany obraz jest zwracany z tego wywołania funkcji.

Tensor wejściowy otrzymujemy od nazwy zdefiniowanej w konfiguracji modelu config.pbtxt plik. Z żądania wnioskowania otrzymujemy prompt, negative_prompt, gen_argsi rozszyfrować je. Przekazujemy wszystkie argumenty do obiektu potoku modelowego. Zakoduj obraz, aby zwrócić wygenerowane prognozy obrazu. Możesz odnieść się do config.pbtxt plik każdego modelu, aby zrozumieć różne szczegóły potoku. Ten plik można znaleźć w repozytorium modelu. Na koniec zawijamy wygenerowany obraz w InferenceResponse i zwróć odpowiedź.

Wdrożenie finalize jest opcjonalne. Ta funkcja pozwala na wykonanie wszelkich niezbędnych porządków przed wyładowaniem modelu z Triton Inference Server.

Podczas pracy z zapleczem Pythona obowiązkiem użytkownika jest upewnienie się, że dane wejściowe są przetwarzane w sposób wsadowy i że odpowiedzi są odpowiednio odsyłane. Aby to osiągnąć, zalecamy wykonanie następujących kroków:

1. Przejrzyj wszystkie żądania w pliku requests sprzeciwić się utworzeniu a batched_input.
2. Uruchom wnioskowanie na batched_input.
3. Podziel wyniki na wiele InferenceResponse obiektów i połącz je jako odpowiedzi.

Patrz: Dokumentacja zaplecza Triton Python or Hostuj modele ML w Amazon SageMaker za pomocą zaplecza Triton: Python by uzyskać więcej szczegółów.

Repozytorium i konfiguracja modelu NVIDIA Triton

Repozytorium modelu zawiera skrypt obsługujący model, artefakty modelu i artefakty tokenizera, spakowane środowisko Conda (z zależnościami potrzebnymi do wnioskowania), plik konfiguracyjny Triton oraz skrypt Pythona używany do wnioskowania. To ostatnie jest obowiązkowe, gdy używasz backendu Pythona i powinieneś używać pliku Pythona model.py. Przyjrzyjmy się plikowi konfiguracyjnemu modelu stabilnej dyfuzji inpaint i zapoznajmy się z różnymi określonymi opcjami:

name: "sd_inpaint"
backend: "python"
max_batch_size: 8
input [ { name: "prompt" data_type: TYPE_STRING dims: [ -1 ] }, { name: "negative_prompt" data_type: TYPE_STRING dims: [ -1 ] optional: true }, { name: "image" data_type: TYPE_STRING dims: [ -1 ] }, { name: "mask_image" data_type: TYPE_STRING dims: [ -1 ] }, { name: "gen_args" data_type: TYPE_STRING dims: [ -1 ] optional: true }
]
output [ { name: "generated_image" data_type: TYPE_STRING dims: [ -1 ] }
]
instance_group [ { kind: KIND_GPU }
]
parameters: { key: "EXECUTION_ENV_PATH", value: {string_value: "/tmp/conda/sd_env.tar.gz" }
}

Poniższa tabela wyjaśnia różne parametry i wartości:

Aby uzyskać szczegółowe informacje na temat repozytorium modeli i konfiguracji innych modeli stabilnej dyfuzji, zapoznaj się z kodem w pliku GitHub repo. Każdy katalog zawiera artefakty dla określonych modeli stabilnej dystrybucji.

Spakuj środowisko conda i rozszerz kontener SageMaker Triton

Obrazy kontenerów SageMaker NVIDIA Triton nie zawierają bibliotek takich jak transformer, accelerate, and diffusers wdrażać i obsługiwać modele stabilnej dystrybucji. Jednak Triton pozwala na wprowadzenie dodatkowych zależności za pomocą pakiet conda. Zacznijmy od utworzenia środowiska conda z niezbędnymi zależnościami opisanymi w pliku environment.yml plik i utwórz artefakt modelu tar sd_env.tar.gz plik zawierający środowisko conda z zainstalowanymi w nim zależnościami. Uruchom następujący plik YML, aby utworzyć plik conda-pack artefakt i skopiuj artefakt do lokalnego katalogu, z którego zostanie przesłany do Amazon S3. Zauważ, że będziemy przesyłać artefakty conda jako jeden z modeli w MME i wywoływać ten model w celu skonfigurowania środowiska conda w instancji hostującej ML SageMaker.

%%writefile environment.yml
name: mme_env
dependencies: - python=3.8 - pip - pip: - numpy - torch --extra-index-url https://download.pytorch.org/whl/cu118 - accelerate - transformers - diffusers - xformers - conda-pack !conda env create -f environment.yml –force

Prześlij artefakty modelu do Amazon S3

SageMaker oczekuje, że plik .tar.gz zawierający repozytorium każdego modelu Triton będzie hostowany na wielomodelowym punkcie końcowym. Dlatego tworzymy artefakt tar z zawartością z repozytorium modelu Triton. Możemy użyć tego zasobnika S3 do hostowania tysięcy artefaktów modeli, a SageMaker MME użyje modeli z tej lokalizacji do dynamicznego ładowania i obsługi dużej liczby modeli. Przechowujemy wszystkie modele Stable Diffusion w tej lokalizacji Amazon S3.

Wdróż SageMaker MME

W tej sekcji przeprowadzimy Cię krok po kroku, aby wdrożyć SageMaker MME, definiując specyfikację kontenera, model SageMaker i konfiguracje punktów końcowych.

Zdefiniuj pojemnik do serwowania

W definicji kontenera zdefiniuj ModelDataUrl aby określić katalog S3, który zawiera wszystkie modele, których SageMaker MME będzie używać do ładowania i udostępniania prognoz. Ustawić Mode do MultiModel aby wskazać, że SageMaker utworzy punkt końcowy ze specyfikacją kontenera MME. Ustawiliśmy kontener z obrazem, który obsługuje wdrażanie MME z GPU. Widzieć Obsługiwane algorytmy, struktury i instancje by uzyskać więcej szczegółów.

Widzimy wszystkie trzy artefakty modelu w następującym Amazon S3 ModelDataUrl lokalizacja:

container = {"Image": mme_triton_image_uri, "ModelDataUrl": model_data_url, "Mode": "MultiModel"}

Utwórz obiekt MME

Używamy klienta SageMaker Boto3 do stworzenia modelu za pomocą utwórz_model API. Definicję kontenera przekazujemy do API tworzenia modelu wraz z ModelName i ExecutionRoleArn:

create_model_response = sm_client.create_model( ModelName=sm_model_name, ExecutionRoleArn=role, PrimaryContainer=container
)

Zdefiniuj konfiguracje dla MME

Utwórz konfigurację MME przy użyciu pliku stwórz_konfigurację_punktu końcowego Boto3 API. Określ przyspieszoną instancję obliczeń GPU w InstanceType (używamy tego samego typu instancji, którego używamy do hostowania naszego notatnika SageMaker). Zalecamy skonfigurowanie punktów końcowych z co najmniej dwiema instancjami z rzeczywistymi przypadkami użycia. Dzięki temu SageMaker może zapewnić wysoce dostępny zestaw prognoz w wielu strefach dostępności dla modeli.

create_endpoint_config_response = sm_client.create_endpoint_config( EndpointConfigName=endpoint_config_name, ProductionVariants=[ { "InstanceType": instance_type, "InitialVariantWeight": 1, "InitialInstanceCount": 1, "ModelName": sm_model_name, "VariantName": "AllTraffic", } ],
)

Utwórz MME

Użyj powyższej konfiguracji punktu końcowego, aby utworzyć nowy punkt końcowy SageMaker i poczekaj na zakończenie wdrażania:

create_endpoint_response = sm_client.create_endpoint( EndpointName=endpoint_name, EndpointConfigName=endpoint_config_name
)

Status zmieni się na InService gdy wdrożenie zakończy się pomyślnie.

Generuj obrazy przy użyciu różnych wersji modeli stabilnej dyfuzji

Zacznijmy od wywołania modelu podstawowego z monitem i pobrania wygenerowanego obrazu. Dane wejściowe przekazujemy do modelu podstawowego za pomocą prompt, negative_prompt, and gen_args jako słownik. Ustawiamy typ danych i kształt każdego elementu wejściowego w słowniku i przekazujemy go jako dane wejściowe do modelu.

inputs = dict(prompt = "Infinity pool on top of a high rise overlooking Central Park", negative_prompt = "blur,low detail, low quality", gen_args = json.dumps(dict(num_inference_steps=50, guidance_scale=8))
)
payload = { "inputs": [{"name": name, "shape": [1,1], "datatype": "BYTES", "data": [data]} for name, data in inputs.items()]
}
response = runtime_sm_client.invoke_endpoint( EndpointName=endpoint_name, ContentType="application/octet-stream", Body=json.dumps(payload), TargetModel="sd_base.tar.gz", )
output = json.loads(response["Body"].read().decode("utf8"))["outputs"]
decode_image(output[0]["data"][0])

Podpowiedź: basen bez krawędzi na szczycie wieżowca z widokiem na Central Park

Pracując z tym obrazem, możemy go zmodyfikować za pomocą wszechstronnego modelu głębokości stabilnej dyfuzji. Na przykład możemy zmienić styl obrazu na obraz olejny lub zmienić ustawienie z Central Parku na Park Narodowy Yellowstone, po prostu przekazując oryginalny obraz wraz z monitem opisującym zmiany, które chcielibyśmy zobaczyć.

Wywołujemy model głębi poprzez określenie sd_depth.tar.gz TargetModel ukończenia invoke_endpoint wywołanie funkcji. Zwróć uwagę, jak zachowana jest orientacja oryginalnego obrazu na wydrukach, ale na przykład budynki Nowego Jorku zostały przekształcone w formacje skalne o tym samym kształcie.

inputs = dict(prompt = "highly detailed oil painting of an inifinity pool overlooking central park", image=image, gen_args = json.dumps(dict(num_inference_steps=50, strength=0.9)) )
payload = { "inputs": [{"name": name, "shape": [1,1], "datatype": "BYTES", "data": [data]} for name, data in inputs.items()]
}
response = runtime_sm_client.invoke_endpoint( EndpointName=endpoint_name, ContentType="application/octet-stream", Body=json.dumps(payload), TargetModel="sd_depth.tar.gz", )
output = json.loads(response["Body"].read().decode("utf8"))["outputs"]
print("original image")
display(original_image)
print("generated image")
display(decode_image(output[0]["data"][0]))

Oryginalny obraz	Obraz olejny	Park Yellowstone

Kolejnym przydatnym modelem jest inpainting Stable Diffusion, za pomocą którego możemy usunąć pewne fragmenty obrazu. Załóżmy, że chcesz usunąć drzewo z poniższego przykładowego obrazu. Możemy to zrobić, wywołując model inpaint sd_inpaint.tar.gz. Aby usunąć drzewo, musimy przejść a mask_image, który wskazuje, które obszary obrazu powinny zostać zachowane, a które wypełnione. Część czarnego piksela obrazu maski wskazuje obszary, które powinny pozostać niezmienione, a białe piksele wskazują, co należy zastąpić.

image = encode_image(original_image).decode("utf8")
mask_image = encode_image(Image.open("sample_images/bertrand-gabioud-mask.png")).decode("utf8")
inputs = dict(prompt = "building, facade, paint, windows", image=image, mask_image=mask_image, negative_prompt = "tree, obstruction, sky, clouds", gen_args = json.dumps(dict(num_inference_steps=50, guidance_scale=10)) )
payload = { "inputs": [{"name": name, "shape": [1,1], "datatype": "BYTES", "data": [data]} for name, data in inputs.items()]
}
response = runtime_sm_client.invoke_endpoint( EndpointName=endpoint_name, ContentType="application/octet-stream", Body=json.dumps(payload), TargetModel="sd_inpaint.tar.gz", )
output = json.loads(response["Body"].read().decode("utf8"))["outputs"]
decode_image(output[0]["data"][0])

Oryginalny obraz	Obraz maski	Pomaluj obraz

W naszym ostatnim przykładzie zmniejszamy rozmiar oryginalnego obrazu, który został wygenerowany wcześniej, z rozdzielczości 512 x 512 do 128 x 128. Następnie wywołujemy model skalowania Stable Diffusion, aby przeskalować obraz z powrotem do 512 x 512. Używamy tego samego monitu do skalowania w górę obraz jako to, czego użyliśmy do wygenerowania obrazu początkowego. Chociaż nie jest to konieczne, podanie monitu opisującego obraz pomaga pokierować procesem skalowania i powinno prowadzić do lepszych wyników.

low_res_image = output_image.resize((128, 128))
inputs = dict(prompt = "Infinity pool on top of a high rise overlooking Central Park", image=encode_image(low_res_image).decode("utf8")
) payload = { "inputs": [{"name": name, "shape": [1,1], "datatype": "BYTES", "data": [data]} for name, data in inputs.items()]
} response = runtime_sm_client.invoke_endpoint( EndpointName=endpoint_name, ContentType="application/octet-stream", Body=json.dumps(payload), TargetModel="sd_upscale.tar.gz", )
output = json.loads(response["Body"].read().decode("utf8"))["outputs"]
upscaled_image = decode_image(output[0]["data"][0])

Obraz o niskiej rozdzielczości	Przeskalowany obraz

Chociaż przeskalowany obraz nie jest tak szczegółowy jak oryginał, jest to wyraźna poprawa w stosunku do obrazu o niskiej rozdzielczości.

Zoptymalizuj pod kątem pamięci i szybkości

Połączenia xformers biblioteka to sposób na przyspieszenie generowania obrazu. Ta optymalizacja jest dostępna tylko dla procesorów graficznych NVIDIA. Przyspiesza generowanie obrazu i zmniejsza zużycie pamięci VRAM. Korzystaliśmy z xformers biblioteka zapewniająca efektywną pamięć i szybkość. Kiedy enable_xformers_memory_efficient_attention opcja jest włączona, należy zaobserwować mniejsze zużycie pamięci GPU i potencjalne przyspieszenie w czasie wnioskowania.

Sprzątać

Postępuj zgodnie z instrukcjami zawartymi w sekcji czyszczenia notatnika, aby usunąć część tego bloga z udostępnionymi zasobami, aby uniknąć niepotrzebnych opłat. Wspominać Cennik Amazon SageMaker aby uzyskać szczegółowe informacje na temat kosztów instancji wnioskowania.

Wnioski

W tym poście omówiliśmy modele Stable Diffusion oraz sposoby efektywnego kosztowo wdrażania różnych wersji modeli Stable Diffusion przy użyciu wielomodelowych punktów końcowych SageMaker. Możesz użyć tego podejścia do zbudowania narzędzia do generowania i edytowania obrazów twórców. Sprawdź przykłady kodu w GitHub repo na początek i daj nam znać o fajnym generatywnym narzędziu sztucznej inteligencji, które tworzysz.

O autorach

Szymon Zamarin jest architektem rozwiązań AI / ML, którego głównym celem jest pomoc klientom w wydobyciu wartości z ich zasobów danych. W wolnym czasie Simon lubi spędzać czas z rodziną, czytając sci-fi i pracując nad różnymi projektami domowymi.

Vikrama Elango jest Starszym Architektem Rozwiązań Specjalistycznych AI/ML w AWS z siedzibą w Wirginii w USA. Obecnie koncentruje się na generatywnej sztucznej inteligencji, LLM, szybkiej inżynierii, optymalizacji wnioskowania dużych modeli i skalowaniu uczenia maszynowego w przedsiębiorstwach. Vikram pomaga klientom z branży finansowej i ubezpieczeniowej w projektowaniu i architekturze w celu tworzenia i wdrażania aplikacji ML na dużą skalę. W wolnym czasie lubi podróżować, wędrować, gotować i biwakować z rodziną.

Joao Moura jest Architektem Rozwiązań Specjalistycznych AI/ML w AWS z siedzibą w Hiszpanii. Pomaga klientom w szkoleniu modeli głębokiego uczenia i optymalizacji wnioskowania, a szerzej w budowaniu platform ML na dużą skalę na AWS. Jest również aktywnym orędownikiem sprzętu wyspecjalizowanego w ML i niskokodowych rozwiązań ML.

Saurabha Trikande jest starszym menedżerem produktu w firmie Amazon SageMaker Inference. Pasjonuje go praca z klientami i motywuje go cel, jakim jest demokratyzacja uczenia maszynowego. Koncentruje się na podstawowych wyzwaniach związanych z wdrażaniem złożonych aplikacji ML, wielodostępnych modeli ML, optymalizacji kosztów oraz zwiększaniem dostępności wdrażania modeli uczenia głębokiego. W wolnym czasie Saurabh lubi wędrować, poznawać innowacyjne technologie, śledzić TechCrunch i spędzać czas z rodziną.

• Dystrybucja treści i PR oparta na SEO. Uzyskaj wzmocnienie już dziś.
• PlatoAiStream. Analiza danych Web3. Wiedza wzmocniona. Dostęp tutaj.
• Wybijanie przyszłości w Adryenn Ashley. Dostęp tutaj.
• Kupuj i sprzedawaj akcje spółek PRE-IPO z PREIPO®. Dostęp tutaj.
• Źródło: https://aws.amazon.com/blogs/machine-learning/create-high-quality-images-with-stable-diffusion-models-and-deploy-them-cost-efficiently-with-amazon-sagemaker/