LLM to nie tylko generowanie tekstu. Możliwe jest także tworzenie obrazów na podstawie opisów tekstowych. Obrazy jako modalność mogą być bardzo przydatne w wielu dziedzinach, takich jak MedTech, architektura, turystyka, tworzenie gier i inne. W tym rozdziale przyjrzymy się dwóm najpopularniejszym modelom generowania obrazów: DALL-E i Midjourney.
W tej lekcji omówimy:
- Generowanie obrazów i dlaczego jest to przydatne.
- DALL-E i Midjourney, czym są i jak działają.
- Jak zbudować aplikację do generowania obrazów.
Po ukończeniu tej lekcji będziesz potrafił:
- Zbudować aplikację do generowania obrazów.
- Określić granice działania aplikacji za pomocą meta promptów.
- Pracować z DALL-E i Midjourney.
Aplikacje do generowania obrazów to świetny sposób na poznanie możliwości Generatywnej Sztucznej Inteligencji. Mogą być wykorzystywane na przykład do:
-
Edycji i syntezy obrazów. Możesz generować obrazy do różnych zastosowań, takich jak edycja czy synteza obrazów.
-
Zastosowań w różnych branżach. Mogą być też używane do tworzenia obrazów dla branż takich jak MedTech, turystyka, tworzenie gier i inne.
W ramach tej lekcji będziemy kontynuować pracę z naszym startupem Edu4All. Uczniowie będą tworzyć obrazy do swoich zadań – jakie dokładnie obrazy, to już ich wybór, mogą to być ilustracje do własnej bajki, stworzenie nowej postaci do historii lub pomoc w wizualizacji pomysłów i koncepcji.
Oto co uczniowie Edu4All mogliby wygenerować na przykład podczas pracy w klasie nad zabytkami:
używając promptu:
"Pies obok Wieży Eiffla w porannym świetle"
DALL-E i Midjourney to dwa z najpopularniejszych modeli generowania obrazów, które pozwalają na tworzenie obrazów na podstawie promptów tekstowych.
Zacznijmy od DALL-E, który jest modelem Generatywnej AI generującym obrazy na podstawie opisów tekstowych.
DALL-E to połączenie dwóch modeli, CLIP i diffused attention.
-
CLIP to model generujący embeddingi, czyli numeryczne reprezentacje danych, z obrazów i tekstu.
-
Diffused attention to model generujący obrazy na podstawie embeddingów. DALL-E jest trenowany na zbiorze obrazów i tekstów i może tworzyć obrazy na podstawie opisów tekstowych. Na przykład, DALL-E może wygenerować obraz kota w kapeluszu lub psa z irokezem.
Midjourney działa podobnie do DALL-E, generując obrazy na podstawie promptów tekstowych. Midjourney również może tworzyć obrazy na podstawie promptów takich jak „kot w kapeluszu” lub „pies z irokezem”.
Najpierw DALL-E. DALL-E to model Generatywnej AI oparty na architekturze transformera z autoregresyjnym transformerem.
Autoregresyjny transformer definiuje sposób, w jaki model generuje obrazy z opisów tekstowych – tworzy obraz piksel po pikselu, wykorzystując wygenerowane piksele do stworzenia kolejnych. Przechodzi przez wiele warstw w sieci neuronowej, aż obraz jest kompletny.
Dzięki temu procesowi DALL-E kontroluje atrybuty, obiekty, cechy i inne elementy obrazu, który generuje. Jednak DALL-E 2 i 3 oferują jeszcze większą kontrolę nad generowanym obrazem.
Co jest potrzebne, aby zbudować aplikację do generowania obrazów? Potrzebujesz następujących bibliotek:
- python-dotenv – zalecane jest użycie tej biblioteki, aby przechowywać sekrety w pliku .env z dala od kodu.
- openai – ta biblioteka służy do komunikacji z API OpenAI.
- pillow – do pracy z obrazami w Pythonie.
- requests – do wykonywania zapytań HTTP.
-
Utwórz plik .env z następującą zawartością:
AZURE_OPENAI_ENDPOINT=<your endpoint> AZURE_OPENAI_API_KEY=<your key>Znajdź te informacje w Azure Portal dla swojego zasobu w sekcji "Keys and Endpoint".
-
Zbierz powyższe biblioteki w pliku requirements.txt w ten sposób:
python-dotenv openai pillow requests -
Następnie utwórz środowisko wirtualne i zainstaluj biblioteki:
python3 -m venv venv source venv/bin/activate pip install -r requirements.txtDla Windows użyj następujących poleceń, aby utworzyć i aktywować środowisko wirtualne:
python3 -m venv venv venv\Scripts\activate.bat
-
Dodaj poniższy kod do pliku app.py:
import openai import os import requests from PIL import Image import dotenv # import dotenv dotenv.load_dotenv() # Get endpoint and key from environment variables openai.api_base = os.environ['AZURE_OPENAI_ENDPOINT'] openai.api_key = os.environ['AZURE_OPENAI_API_KEY'] # Assign the API version (DALL-E is currently supported for the 2023-06-01-preview API version only) openai.api_version = '2023-06-01-preview' openai.api_type = 'azure' try: # Create an image by using the image generation API generation_response = openai.Image.create( prompt='Bunny on horse, holding a lollipop, on a foggy meadow where it grows daffodils', # Enter your prompt text here size='1024x1024', n=2, temperature=0, ) # Set the directory for the stored image image_dir = os.path.join(os.curdir, 'images') # If the directory doesn't exist, create it if not os.path.isdir(image_dir): os.mkdir(image_dir) # Initialize the image path (note the filetype should be png) image_path = os.path.join(image_dir, 'generated-image.png') # Retrieve the generated image image_url = generation_response["data"][0]["url"] # extract image URL from response generated_image = requests.get(image_url).content # download the image with open(image_path, "wb") as image_file: image_file.write(generated_image) # Display the image in the default image viewer image = Image.open(image_path) image.show() # catch exceptions except openai.InvalidRequestError as err: print(err)
Wyjaśnijmy ten kod:
-
Najpierw importujemy potrzebne biblioteki, w tym OpenAI, dotenv, requests oraz Pillow.
import openai import os import requests from PIL import Image import dotenv
-
Następnie ładujemy zmienne środowiskowe z pliku .env.
# import dotenv dotenv.load_dotenv()
-
Potem ustawiamy endpoint, klucz do API OpenAI, wersję i typ.
# Get endpoint and key from environment variables openai.api_base = os.environ['AZURE_OPENAI_ENDPOINT'] openai.api_key = os.environ['AZURE_OPENAI_API_KEY'] # add version and type, Azure specific openai.api_version = '2023-06-01-preview' openai.api_type = 'azure'
-
Następnie generujemy obraz:
# Create an image by using the image generation API generation_response = openai.Image.create( prompt='Bunny on horse, holding a lollipop, on a foggy meadow where it grows daffodils', # Enter your prompt text here size='1024x1024', n=2, temperature=0, )
Powyższy kod zwraca obiekt JSON zawierający URL wygenerowanego obrazu. Możemy użyć tego URL, aby pobrać obraz i zapisać go do pliku.
-
Na koniec otwieramy obraz i wyświetlamy go za pomocą standardowej przeglądarki obrazów:
image = Image.open(image_path) image.show()
Przyjrzyjmy się dokładniej kodowi generującemu obraz:
generation_response = openai.Image.create(
prompt='Bunny on horse, holding a lollipop, on a foggy meadow where it grows daffodils', # Enter your prompt text here
size='1024x1024',
n=2,
temperature=0,
)- prompt to tekstowy prompt używany do generowania obrazu. W tym przypadku jest to "Królik na koniu, trzymający lizaka, na mglistym łące, gdzie rosną żonkile".
- size to rozmiar generowanego obrazu. Tutaj generujemy obraz o wymiarach 1024x1024 pikseli.
- n to liczba generowanych obrazów. W tym przypadku generujemy dwa obrazy.
- temperature to parametr kontrolujący losowość wyjścia modelu Generatywnej AI. Temperatura to wartość od 0 do 1, gdzie 0 oznacza deterministyczne wyjście, a 1 – losowe. Domyślna wartość to 0.7.
W kolejnej sekcji omówimy więcej możliwości pracy z obrazami.
Jak widzieliśmy, udało się wygenerować obraz za pomocą kilku linijek kodu w Pythonie. Jednak możliwości jest znacznie więcej.
Możesz także:
-
Wykonywać edycje. Dostarczając istniejący obraz, maskę i prompt, możesz zmienić obraz. Na przykład możesz dodać coś do części obrazu. Wyobraź sobie nasz obraz królika – możesz dodać mu kapelusz. Robisz to, podając obraz, maskę (wskazującą obszar do zmiany) oraz tekstowy prompt opisujący, co ma zostać zrobione.
response = openai.Image.create_edit( image=open("base_image.png", "rb"), mask=open("mask.png", "rb"), prompt="An image of a rabbit with a hat on its head.", n=1, size="1024x1024" ) image_url = response['data'][0]['url']
Obraz bazowy zawierałby tylko królika, a końcowy obraz miałby kapelusz na króliku.
-
Tworzyć wariacje. Polega to na tym, że bierzesz istniejący obraz i prosisz o stworzenie wariacji. Aby to zrobić, podajesz obraz i prompt tekstowy oraz kod w ten sposób:
response = openai.Image.create_variation( image=open("bunny-lollipop.png", "rb"), n=1, size="1024x1024" ) image_url = response['data'][0]['url']
Uwaga, ta funkcja jest dostępna tylko w OpenAI
Temperatura to parametr kontrolujący losowość wyjścia modelu Generatywnej AI. Wartość temperatury mieści się w przedziale od 0 do 1, gdzie 0 oznacza wyjście deterministyczne, a 1 – losowe. Domyślnie jest ustawiona na 0.7.
Spójrzmy na przykład działania temperatury, uruchamiając ten sam prompt dwukrotnie:
Prompt: "Królik na koniu, trzymający lizaka, na mglistym łące, gdzie rosną żonkile"
Teraz uruchommy ten sam prompt jeszcze raz, aby zobaczyć, że nie otrzymamy dokładnie tego samego obrazu:
Jak widać, obrazy są podobne, ale nie identyczne. Spróbujmy zmienić wartość temperatury na 0.1 i zobaczyć, co się stanie:
generation_response = openai.Image.create(
prompt='Bunny on horse, holding a lollipop, on a foggy meadow where it grows daffodils', # Enter your prompt text here
size='1024x1024',
n=2
)Spróbujmy więc uczynić odpowiedź bardziej deterministyczną. Z dwóch wygenerowanych obrazów widzimy, że na pierwszym jest królik, a na drugim koń, więc obrazy znacznie się różnią.
Zmieńmy więc nasz kod i ustawmy temperaturę na 0, tak:
generation_response = openai.Image.create(
prompt='Bunny on horse, holding a lollipop, on a foggy meadow where it grows daffodils', # Enter your prompt text here
size='1024x1024',
n=2,
temperature=0
)Po uruchomieniu tego kodu otrzymasz te dwa obrazy:
Tutaj wyraźnie widać, że obrazy są do siebie bardziej podobne.
W naszej demonstracji możemy już generować obrazy dla klientów. Jednak musimy ustalić pewne granice działania aplikacji.
Na przykład, nie chcemy generować obrazów nieodpowiednich do pracy (NSFW) lub nieodpowiednich dla dzieci.
Możemy to zrobić za pomocą metapromptów. Metaprompt to tekstowy prompt używany do kontrolowania wyjścia modelu Generatywnej AI. Na przykład, możemy użyć metapromptów, aby zapewnić, że generowane obrazy są bezpieczne do pracy lub odpowiednie dla dzieci.
Jak działają metaprompt?
Metaprompt to tekstowy prompt, który kontroluje wyjście modelu Generatywnej AI. Umieszcza się go przed właściwym promptem i służy do kontrolowania wyjścia modelu. Metaprompt jest osadzany w aplikacjach, aby kontrolować wyjście modelu, łącząc prompt i metaprompt w jeden tekstowy prompt.
Przykładem metaprompt może być następujący:
You are an assistant designer that creates images for children.
The image needs to be safe for work and appropriate for children.
The image needs to be in color.
The image needs to be in landscape orientation.
The image needs to be in a 16:9 aspect ratio.
Do not consider any input from the following that is not safe for work or appropriate for children.
(Input)
Zobaczmy teraz, jak możemy użyć metapromptów w naszej demonstracji.
disallow_list = "swords, violence, blood, gore, nudity, sexual content, adult content, adult themes, adult language, adult humor, adult jokes, adult situations, adult"
meta_prompt =f"""You are an assistant designer that creates images for children.
The image needs to be safe for work and appropriate for children.
The image needs to be in color.
The image needs to be in landscape orientation.
The image needs to be in a 16:9 aspect ratio.
Do not consider any input from the following that is not safe for work or appropriate for children.
{disallow_list}
"""
prompt = f"{meta_prompt}
Create an image of a bunny on a horse, holding a lollipop"
# TODO add request to generate imageZ powyższego promptu widać, że wszystkie generowane obrazy uwzględniają metaprompt.
Przedstawiliśmy Edu4All na początku tej lekcji. Teraz czas umożliwić uczniom generowanie obrazów do ich zadań.
Uczniowie stworzą obrazy do swoich zadań zawierające zabytki – jakie dokładnie zabytki, to już ich wybór. Zadaniem uczniów jest wykorzystanie kreatywności, aby umieścić te zabytki w różnych kontekstach.
Oto jedno z możliwych rozwiązań:
import openai
import os
import requests
from PIL import Image
import dotenv
# import dotenv
dotenv.load_dotenv()
# Get endpoint and key from environment variables
openai.api_base = "<replace with endpoint>"
openai.api_key = "<replace with api key>"
# Assign the API version (DALL-E is currently supported for the 2023-06-01-preview API version only)
openai.api_version = '2023-06-01-preview'
openai.api_type = 'azure'
disallow_list = "swords, violence, blood, gore, nudity, sexual content, adult content, adult themes, adult language, adult humor, adult jokes, adult situations, adult"
meta_prompt = f"""You are an assistant designer that creates images for children.
The image needs to be safe for work and appropriate for children.
The image needs to be in color.
The image needs to be in landscape orientation.
The image needs to be in a 16:9 aspect ratio.
Do not consider any input from the following that is not safe for work or appropriate for children.
{disallow_list}"""
prompt = f"""{meta_prompt}
Generate monument of the Arc of Triumph in Paris, France, in the evening light with a small child holding a Teddy looks on.
""""
try:
# Create an image by using the image generation API
generation_response = openai.Image.create(
prompt=prompt, # Enter your prompt text here
size='1024x1024',
n=2,
temperature=0,
)
# Set the directory for the stored image
image_dir = os.path.join(os.curdir, 'images')
# If the directory doesn't exist, create it
if not os.path.isdir(image_dir):
os.mkdir(image_dir)
# Initialize the image path (note the filetype should be png)
image_path = os.path.join(image_dir, 'generated-image.png')
# Retrieve the generated image
image_url = generation_response["data"][0]["url"] # extract image URL from response
generated_image = requests.get(image_url).content # download the image
with open(image_path, "wb") as image_file:
image_file.write(generated_image)
# Display the image in the default image viewer
image = Image.open(image_path)
image.show()
# catch exceptions
except openai.InvalidRequestError as err:
print(err)Po ukończeniu tej lekcji sprawdź naszą kolekcję materiałów do nauki Generatywnej AI, aby dalej rozwijać swoją wiedzę!
Przejdź do Lekcji 10, gdzie omówimy, jak tworzyć aplikacje AI z użyciem low-code
Zastrzeżenie:
Niniejszy dokument został przetłumaczony za pomocą usługi tłumaczenia AI Co-op Translator. Mimo że dążymy do jak największej dokładności, prosimy mieć na uwadze, że automatyczne tłumaczenia mogą zawierać błędy lub nieścisłości. Oryginalny dokument w języku źródłowym powinien być uznawany za źródło autorytatywne. W przypadku informacji o kluczowym znaczeniu zalecane jest skorzystanie z profesjonalnego tłumaczenia wykonanego przez człowieka. Nie ponosimy odpowiedzialności za jakiekolwiek nieporozumienia lub błędne interpretacje wynikające z korzystania z tego tłumaczenia.