Witam w kolejnym poradniku. Tym razem pokażę jak generować obrazki w lepszej jakości bądź zwiększać jakość zdjęć.
Pierwsza część poradnika znajdziesz tutaj
https://jbzd.com.pl/obr/3397022/jak-generowac-obrazki-ai

Czyli masz swój podstawowy workflow do generowania obrazków 512x768 i pierwsze efekty pracy. Co teraz zrobić dalej?
Od swojego KSamplera przeciągnij "LATENT" na puste miejsce i dodaj węzeł "Upscale Latent" są do wyboru dwa:

Pierwszy daje ci możliwość zwiększenia rozdzielczości procentowo, a drugi daje możliwość konkretnych rozdzielczości, więc na przykład możesz dokładnie napisać jakie wymiary ma mieć obrazek.
Następnie od tego kafelka pociągnij nitkę i dodaj kolejny węzeł KSampler, z ustawieniami tak jak poprzednio (czyli nitki od model, positive i negative również można użyć te same bądź nowe jeśli chcesz), lecz tym razem "denoise" ustawiamy dość nisko. W zależności od tego jak bardzo chcemy by obrazek się zmienił możemy wybrać wartości od 0.05 do nawet 0.7 - im większa wartość tym bardziej obrazek się zmienia i staje się tylko "sugestią" dla AI. Często większy denoising pomaga również z niedoskonałościami jak za duża ilość palców, dziwne sutki itd. Najczęściej wybieram wartości pomiędzy 0.2 a 0.45, choć używam 0.1 jeśli grafika jest super a chcę tylko zwiększyć ilość pikseli i ostrość. Oto przykład i fragment workflow (btw, robię to na laptopie na CPU bez GPU i pierwszy obrazek zajął mi 1:44 a upscale do 800x1200 zajął 6:17, pochłaniając 12GB RAMu):

Nie powiedziałbym żeby był to jakiś udany upscale, ale porównując obrazki obok siebie, różnice widać bardzo wyraźnie - a nawet zbyt wyraźnie, na przykład dziwne artefakty na dłoniach.

Tyle z podstawowego upscale przy generowaniu txt2img. A jeśli masz już fotki/grafiki które chcesz upscale'ować?
Wtedy zamiast "Empty Latent Image" trzeba użyć kilku innych węzłów:

W przypadku img2img polecam używać "Upscale Image" zamiast "Upscale Latent" z racji że o wiele lepiej na chwilę obecną działa zmiana rozmiarów plików jpg lub png niż Latent, który może powodować jakieś zniekształcenia na zdjęciu. Następnie zdjęcie konwertowane jest na Latent i podawane do KSamplera. Ponownie używamy denoising między 0.05 a 0.7 w zależności od potrzeb.
Cały workflow przy img2img ma tylko jednego KSamplera i wygląda mniej-więcej tak (model, LCM oraz prompty są schowane poza screenshotem by screenshot był czytelny):

Tutaj mi wyszedł o wiele lepszy upscale, który przy okazji naprawił kilka rzeczy - na przykład zęby lekko lepiej wyglądają no i dłoń jest o wiele lepsza, choć kosmyki włosów mogłby być lepsze.

Jak już jestem przy img2img to przy okazji pokażę lekko inpainting. Zaczynamy od ściągnięcia checkpointu (w części 1 było pokazane jak ściągać checkpointy i Lora) który wspiera inpainting, najczęściej mają to napisane w nazwie, np ten:

Następnie nasz img2img workflow edytujemy w ten sposób (1) (grow_mask_by decyduje jak wiele pikseli jest poświęcanych jako efekt przejścia między istniejącym obrazekiem, a tym który zostanie wygenerwowany. Jeśli widzisz linię odcięcia na gotowym obrazku to zwiększ tą wartość), klikamy prawym przyciskiem na obrazku i wybieramy opcję "Open in Mask Editor" - otwórz w edytorze maski (2) oraz zaznaczamy fragment obrazku który chcemy zmienić (3).

W edytorze maski mamy na dole suwadło którym możemy zwiększyć lub zmiejszyć rozmiar pędzla. Na koniec klikamy "Save to node" by nasz przycięty obrazek został zapisany.
W KSamplerze denoising musi być 1 (w końcu nadpisujemy fragment obrazka szumem i AI będzie go odszumać w 100% od zera). Pamiętajcie jeszcze zmienić model na ten który obsługuje inpainting oraz w prompt pozytywnym i negatywnym napisać co chcemy by zaznaczonym fagmencie się pojawiło. W moim przypadku napisałem "white blanket" - biały koc.

Należy pamiętać że konwertowanie z img do Latent i w drugą stronę jest stratne (tak jak konwertowanie filmów czy zdjęć) - i za każdym razem kiedy to robisz to obrazek traci trochę na jakości. Więc twój porzątkowy obrazek możę się nieznacznie zmienić po img2img, nawet fragmenty których nie miałeś zaznaczonych do edycji. By dowiedzieć się więcej możesz wyszukać w google "kompresja stratna".
Oto mój gotowy obrazek, przed i po inpaintingiem.

Początkowo miałem ustawione "grow_mask_by" = 6 i było widać takie linie gdzie był oryginalny obrazek a gdzie zaczyna się ten edytowany. Ten obrazek powyżej powstał po zwiększeniu tej wartości do 10, przez co efekt przejścia był delikatniejszy i efekt wyszedł ok :)

Pozdrawiam i życzę samych sukcesów w generowaniu obrazków :)
Pamiętajcie podzielić się rezultatami.

Siema, tym razem chciałbym się podzielić prostą implementacją A.I generującego obrazki z tekstu lokalnie, używając zasobów komputera.

Na górze: "Dog on the moon" 
wygenerowany przez ten model.

Ta opcja jest przewidziana dla średnich komputerów i jest dziecinnie prosta w implementacji.

Jedyne czego potrzebujesz to 
- procesora, 
- Pythona3 (najlepiej Py3.11)
- Bibliotek PyTorch oraz Diffusers które możesz zainstalować przez pip install torch diffusers

Wygenerowanie jednego obrazka używając:
AMD Ryzen 5 PRO 5650G with Radeon Graphics (12) @ 3.900GHz
trwa około 5 minut

sam model też nie waży sporo, bo zaledwie 5GB

Ogólnie jest możliwość zoptymalizowania go używając karty graficznej zamiast procesora, np Nvidia z technologią cuda, lub ROCm w przypadku AMD.

Cuda: https://developer.nvidia.com/cuda-zone
ROCm: https://rocm.docs.amd.com/en/latest/

Moja implementacja która pozwala sprecyzować prompt oraz ilość wygenerowanych nim obrazków:
https://pastebin.com/KEtTaHia

Tutaj macie dokumentacje modelu:
https://huggingface.co/runwayml/stable-diffusion-v1-5

Jak się nauczę to wrzucę lepszy, bardziej szczegółowy tutorial do różnych modeli.

Póki co mogę tylko zaprosić osoby zainteresowane technicznymi bajerami typu programowanie, A.I, systemy operacyjne itp,
na naszego Discorda.
https://discord.gg/aHCsbfCEcV

Prompt do Stable-Diffusion:
two animals: a maine coon cat and a seagull standing on a beach close to each other

Rezultat:

Witam, zachęcony wrzutą użytkownika AstreaZero: https://jbzd.com.pl/obr/2678382/poradnik-jak-zmajstrowac-sobie-wlasna-ai-witkorianska-dziewczyne
chciałem sam coś zmajstrować, niestety jako że używam karty graficznej od AMD to dany poradnik u mnie nie zadziała.
Udało mi się użyć Stable Diffusion na windowsie wykorzystując wersję direct-ml: https://github.com/lshqqytiger/stable-diffusion-webui-directml
niestety jego wydajnośc na AMD jest dość niska, na mojej karcie graficznej RX6600 XT 8GB to zaledwie: 0.2it/s.
Jeste też wersja wykorzystująca Vulkan: https://github.com/nod-ai/SHARK
Wydajnośc znacznie lepsza bo nawet 2.4it/s, niestety jest ona mocno ograniczona, tzw. brak możliwości instalacji nowych modułów(controlnet, mov2mov itd.) a sama zmiana modelu do generacji obrazków trwa dobrych 10 minut.
Okazuje się jednak że jakiś czas temu AMD zapewniło wspracie ROCM dla kart konsumenckich, coś ala CUDA od NVIDII, niestety narazie jedynie pod Linuxem. Na Linuxie udało mi się osiągnąć wydajność na poziomie 4.3-4.9it/s z zachowaniem wszystkich możliwości Stable Diffusion.

Niestety nie udało mi się to na maszynie wirtualnej więc osobiście dołożyłem stary dysk HDD 500gb z laptopa do swojego pc, dysk wymagany dla całości to przynajmniej 100gb, sam SD z 3 modelami oraz wszystkimi modelami controlnet zajmuje około 50gb.
To teraz w punktach opisze wam całą procedurę instalacji:
1. zainstalować lub posiadać Linux'a, osobiście wybrałem Linux Mint
2. Zainstalować sterowniki AMD z oficjalnej strony: https://www.amd.com/en/support/linux-drivers
3. Zaktualizować system  Linux za pomocą komend terminala:

sudo apt update
sudo apt upgrade

4 Za pomocą terminala dodać swoje konto użytkownika do grup video i render:

sudo usermod -a -G render twojanazwauzytkownika   
sudo usermod -a -G video twojanazwauzytkownika

5. Zainstalować ROCM:

sudo amdgpu-install --usecase=rocm –no-dkms

6. Zresetować komputer

sudo reboot

7. jeśli poprzednie komendy się udały po wpisaniu komendy rocminfo powinien wam taki tekst się pojawić:

8. Instalujemy GIT oraz klonujemy repozytorium SD webui:

sudo apt-get install git
git clone https://github.com/AUTOMATIC1111/stable-diffusion-webui

9. Instalujemy venv dla pythona:

apt install python3-venv

10. Instalujemy pip

sudo apt install python3-pip
python3 -m pip install –upgrade pip wheel

11. Instalujemy ibstdc++-12-dev:

sudo apt install ibstdc++-12-dev

12. Przechodzimy do folderu z stable diffusion i w plikach requirements.txt oraz requirements_versions.txt dodajemy znak # przy torch jak na załączonym obrazku

13. Modyfikujemy zawartość pliku webui-user.sh:
Na samym końcu dodajemy wpis:

export HSA_OVERRIDE_GFX_VERSION=10.3.0

a 13 wiersz zmieniamy na:

export COMMANDLINE_ARGS="--opt-sub-quad-attention --medvram --disable-nan-check --always-batch-cond-uncond –opt-sdp-attention"

oczywiście możecie użyć innych argumentów jakie znajdziecie na stronach, manualu czy jakiś forach, te jak na razie dały mi największa wydajność

14. Modyfikujemy plik webui.sh dokładnie interesuje nas 129 linijka kodu zmieniamy ją na:

    export TORCH_COMMAND="pip install torch torchvision torchaudio --extra-index-url https://download.pytorch.org/whl/rocm5.4.2"

15. W terminalu przechodzimy do miejsca gdzie mamy sklonowanego SD i nadajemy możliwość wykonywania pliku webui.sh:

cd stable-diffusion-webui

sudo chmod +x webui.sh


16. Pobieramy interesujący nas model do naszego SD ze strony: https://civitai.com/ i kopiujemy do katalogu stable-diffusion-webui/models/Stable-diffusion

17. Tworzymy venv jest to zabezpieczenie że to co SD potrzebuje zostanie stworzone w nim a nie zmienione w całym systemie, najlepiej obydwie linijki wkleić do terminala równocześnie za pomocą ctrl+shift+v:

python3 -m venv venv
source venv/bin/activate

jeżeli się nam powiodło powinien się pojawić napis (venv) przed naszą nazwą użytkownika:

18. Teraz zostało nam zwyczajnie uruchomienie webui co robimy za pomocą komendy:

./webui.sh

w tym momencie webui zacznie pobierać wszystkie niezbędne rzeczy do jego poprawnego działania co może chwile potrwać. Gdy w terminalu wyświetli się nam już informacja z adresem lokalnym możemy zacząć korzystać z SD webui.

Za każdym razem jak chcecie uruchomić SD ponownie należy wejść terminalem do foledru Sd i użyć komend:

python3 -m venv venv
source venv/bin/activate
./webui.sh

Dlatego polecam osobiście stworzyć plik w folderze SD o nazwie jakiej chcecie ja użyłem run-webui.sh i zawartości:

#!/usr/bin/bash
python3 -m venv venv
source venv/bin/activate
./webui.sh

i uruchamiać go tym skryptem, na Linux mint zwyczajnie podwójnym kliknięciem wybieracie uruchom w terminalu. Oczywiście musicie mu wcześniej nadać prawo wykonywania za pomocą komendy:

sudo chmod +x run-webui.sh

Mam nadzieję że ten poradnik przyda się kilku osobom z kartami graficznymi AMD podobno powinno zadziałać na kartach od VEGI w górę gdy macie między 4-6GB ramu nalezy zmienić w webui-user.sh medvram na lowvram.
Dla użytkowników kart graficznych NVIDIi używających Linuxa też powinien być przydatny, tzw. na pewno należy pominąć instalację sterowników AMD, ROCM, modyfikacje pliku webui.sh oraz w pliku webui-user.sh nie dodawać linijki "export HSA_OVERRIDE_GFX_VERSION=10.3.0" na końcu pliku.

W celu stworzenia tego poradnika posiłkowałem się stroną:
https://github.com/fullopsec/stable-deffusion-AMD-LINUX-low-VRAM
https://github.com/RadeonOpenCompute/ROCm/issues/1889
oraz jakimś wątkiem na Reddicie który zgubiłem xD