EasyDiffusion mit fastAPI auf Webseite

[godlike]

Moin Leute,

ich habe in meinem neuen Job u.A. dafür zu sorgen das unsere Firma interessant wirkt, das Werbung cool ist, das Webseiten interessant sind usw. Und da will ich nun bei den Kunden Punkten in dem ich ihnen beim Erstellen von Prontprodukten etwas zur Hand gehe und sie mit A.I. Bildern bei der Stange und auf dem Shop halten möchte. Soweit so gut.

Easy Diffusion UI:

Was ich möchte:

- auf einem kleinen Server mit dicker GPU der hier im schön klimatisierten Serverraum steht soll EasyDiffusion laufen, von unserem Shop aus möchte ich nun per fastAPI auf EasyDiffusion zugreifen, einen Text Promt und ein paar Variablen übergeben (Seed, Image Size [width, height], Inference Steps usw.) und ein Bild zurück bekommen. Eine UI für EasyDiffusion gibt es ja auch bereits, die beinhaltet aber viel zu viel! Diese kennen die Meisten von euch ja aber auch vmtl

Was bereits geht:

- Testserver läuft mit Python. EasyDiffusion läuft, Bilder können über die UI über alle Rechner im Netzwerk (bisher nur Intern) generiert werden. Alles fein. Neue Hardware ist auch schon bestellt um ihn dann umziehen zu können. Ich habe mit der Stable Diffusion Pipeline, einem entsprechenden Python Script und einer Webseite im Netzwerk erfolgreich über cURL Bilder generiert. Leider beinhaltet diese Möglichkeit sehr viel Hendarbeit, es ist bedeutend langsamer und nicht so durchdacht (bin hier auch kein Profi), darum soll das jetzt über fastAPI und EasyDiffusion passieren. Ich wollte mit der eigenen Lösung nur testen ob das überhaupt machbar ist und ja, es ist machbar.

Meine Frage ist nun: Kennt sich wer mit dieser Thematik aus? Ich finde einfach keine vernünftige Anleitung zur fastAPI von StableDiffusion bzw. EasyDiffusion. Kein Wiki, nix. Bei meinem eigenen Script kann ich per POST und Generate-Image Bilder erzeigen, die fastAPI von EasyDiffusion ist mit jedoch ein Rätsel:

Ich habe Hoffnung das hier jemand sitzt der sowas ggf. sogar schon mal gemacht hat Auch wenn es vmtl aussichtslos ist

Ich bin gespannt

LG

godlike

 

[drfuture]

Hilft dir das evtl?

Stable Diffusion-Based Image Generation Web Application Using Fast API & React

Stable Diffusion is a deep learning model that has been trained to generate images based on text prompts. In this article, we will explore…

medium.com

 

[godlike]

Hey drfuture, ja das geht genau in die Richtung. Genau diesen Artikel habe ich gestern auch gefunden! Das "Problem" hierbei ist das es nur sehr rudimentär funktioniert und jegliche Updates (neues Image Model, Abhängigkeiten wie Torch usw.) manuell gemacht werden müssen. Das würde zur Not also gehen aber ich hätte gerne die Vorteile einer fertigen Version. Diese läuft ja auch, leider eben nicht über die fastAPI.

Ich teste jetzt gerade die UI von automatic1111. Diese hat in der API zumindest eine txt2img Funktion was mich zuversichtlich stimmt. Auch scheint es hier mehr Einstellungsmöglichkeiten zu geben. Leider kann ich es noch nicht richtig testen da mein Test-Server keine Grafikkarte besitzt und auch auch mit set COMMANDLINE_ARGS=--skip-torch-cuda-test immer noch Fehler bekomme was das Testen recht sinnlos gestaltet.

 return torch.layer_norm(input, normalized_shape, weight, bias, eps, torch.backends.cudnn.enabled)
RuntimeError: "LayerNormKernelImpl" not implemented for 'Half'


Stable diffusion model failed to load

Diese Probleme hatte ich mit EasyDiffusion z.B. nicht, und genau das verwundert mich. Obwohl es ja eigentlich nur unterschiedliche UI's sind, scheinen die im Hintergrund dann doch komplett anders zu funktionieren. EasyDiffusion ist da wirklich sehr komfortabel und schnell, leider bekomme ich da wie gesagt keinen API Request hin.

 

[saddy]

Hab mal GPT4 das github repo lesen lassen:

The unofficial stable-diffusion FastAPI has at least two endpoints, `/text2image` and `/image2image`, with the following example API requests:

For the `/text2image` endpoint:
```python
import requests
import json

url = "http://<API_HOST>:<API_PORT>/text2image"
data = {
"prompt": "your_text_prompt_here",
"num_images": 1,
"guidance_scale": 0.5, # guidance scale for stable-diffusion
"height": 256, # image height
"width": 256, # image width
"seed": 42 # generator seed
}
headers = {'Content-Type': 'application/json'}

response = requests.post(url, data=json.dumps(data), headers=headers)
response_data = response.json()

print(response_data)
```

For the `/image2image` endpoint:
```python
import requests

url = "http://<API_HOST>:<API_PORT>/image2image"
data = {
"prompt": "your_text_prompt_here",
"init_image": open('path_to_your_image.jpg', 'rb'), # init image for i2i task
"num_images": 1,
"guidance_scale": 0.5, # guidance scale for stable-diffusion
"seed": 42 # generator seed
}

response = requests.post(url, files=data)
response_data = response.json()

print(response_data)
```
Please replace `<API_HOST>` and `<API_PORT>` with the host and port where your API is running. Similarly, replace `"your_text_prompt_here"` and `'path_to_your_image.jpg'` with your actual text prompt and the path to your image file, respectively【7†source】【8†source】.

For the `/image2image` endpoint, note that the `init_image` parameter is sent as a file in a multipart/form-data request, which is why it is sent in the `files` parameter of the `requests.post` function rather than the `data` parameter. It is also worth noting that the `guidance_scale` values are just examples - you should adjust this according to your needs.

The response from both endpoints will be a JSON object containing the original prompt (`prompt`), a task ID (`task_id`), and a list of URLs for the generated images (`image_urls`).

Remember to handle any potential errors that might occur during the request, such as network errors, API errors, or JSON decoding errors.

Hab selbst keine Erfahrung speziell damit, im Zweifel chatgpt fragen und wenns nicht geht was anderes nutzen aber dabei biste ja schon

Edit: Das hier war die Lektüre (ich krieg den fuck smiley da unten nicht weg, der sollte hinter das schon):

GitHub - rapidrabbit76/stable-diffusion-API: Unofficial Fastapi implementation of Stable-Diffusion API

Unofficial Fastapi implementation of Stable-Diffusion API - GitHub - rapidrabbit76/stable-diffusion-API: Unofficial Fastapi implementation of Stable-Diffusion API

github.com

 

[DandG]

Den eigenen Easy Diffusion Server kann man mittlerweile über das Internet, mit "eigener Adresse" erreichen.
Das sieht dann aus wie lokal.
Schaue dazu in den Einstellungen.

Da braucht man auch kein schnickschnack, die Bilder kann man ja auch dann direkt runterladen, wenn man mag.


MMn die einfache Lösung.

 

[godlike]

Hey, danke für eure Antworten

Hab mal GPT4 das github repo lesen lassen

Das ist klasse, danke für deine Hilfe. Das Probiere ich auch glatt mal aus, ich habe hier leider noch keinen GPT4 Zugang und mit GPT3.5 habe ich auch nach eingehenden Konversationen keine Lösung gefunden

Edit: Das hier war die Lektüre (ich krieg den fuck smiley da unten nicht weg, der sollte hinter das schon):

Das hatte ich auch schon probiert allerdings hatte ich hier große Probleme mit pyTorch und CUDA. Ich konnte das nicht zum laufen bekommen weil der Script so viele Fehler produziert hatte.

Okay, nach diversen Paketproblemen komme ich wieder zu dem Problem mit CUDA. Ich muss einfach warten bis ich nächste Woche den neuen PC mit besserer Grafikkarte dafür nutzen kann und das hoffentlich funktioniert:

C:\Users\AI Desktop\sd.txt2img\venv\lib\site-packages\huggingface_hub\file_download.py:649: FutureWarning: 'cached_download' is the legacy way to download files from the HF hub, please consider upgrading to 'hf_hub_download'
  warnings.warn(
vae\diffusion_pytorch_model.safetensors not found
`text_config_dict` is provided which will be used to initialize `CLIPTextConfig`. The value `text_config["id2label"]` will be overriden.
C:\Users\AI Desktop\sd.txt2img\venv\lib\site-packages\transformers\models\clip\feature_extraction_clip.py:28: FutureWarning: The class CLIPFeatureExtractor is deprecated and will be removed in version 5 of Transformers. Please use CLIPImageProcessor instead.
  warnings.warn(
Traceback (most recent call last):
  File "C:\Users\AI Desktop\sd.txt2img\huggingface_model_download.py", line 3, in <module>
    from core.dependencies import models
  File "C:\Users\AI Desktop\sd.txt2img\core\dependencies\models.py", line 1, in <module>
    from app.stable_diffusion.manager import build_streamer
  File "C:\Users\AI Desktop\sd.txt2img\app\stable_diffusion\manager\__init__.py", line 1, in <module>
    from .manager import (
  File "C:\Users\AI Desktop\sd.txt2img\app\stable_diffusion\manager\manager.py", line 57, in <module>
    build_pipeline(
  File "C:\Users\AI Desktop\sd.txt2img\app\stable_diffusion\manager\manager.py", line 53, in build_pipeline
    pipe = pipe.to(device)
  File "C:\Users\AI Desktop\sd.txt2img\venv\lib\site-packages\diffusers\pipelines\pipeline_utils.py", line 682, in to
    module.to(torch_device, torch_dtype)
  File "C:\Users\AI Desktop\sd.txt2img\venv\lib\site-packages\torch\nn\modules\module.py", line 1145, in to
    return self._apply(convert)
  File "C:\Users\AI Desktop\sd.txt2img\venv\lib\site-packages\torch\nn\modules\module.py", line 797, in _apply
    module._apply(fn)
  File "C:\Users\AI Desktop\sd.txt2img\venv\lib\site-packages\torch\nn\modules\module.py", line 797, in _apply
    module._apply(fn)
  File "C:\Users\AI Desktop\sd.txt2img\venv\lib\site-packages\torch\nn\modules\module.py", line 820, in _apply
    param_applied = fn(param)
  File "C:\Users\AI Desktop\sd.txt2img\venv\lib\site-packages\torch\nn\modules\module.py", line 1143, in convert
    return t.to(device, dtype if t.is_floating_point() or t.is_complex() else None, non_blocking)
  File "C:\Users\AI Desktop\sd.txt2img\venv\lib\site-packages\torch\cuda\__init__.py", line 239, in _lazy_init
    raise AssertionError("Torch not compiled with CUDA enabled")
AssertionError: Torch not compiled with CUDA enabled

Das nervige ist das ich es ja schon mit einem eigenen Script hinbekommen habe aber da fehlen dann so viele Dinge wie Automatisches Update, bessere Performance, Ladebalken, Warteschlange usw. das ich eigentlich schon auf eine fertige Anwendung zurückgreifen würde.

Habe das auch schon angefragt bei einer Fremdfirma, die haben dafür ca 10.000€ veranschlagt was ich komplett drüber finde und somit entschieden habe das ich es selber versuche. Ist ja eigentlich nur eine Spielerei, aber irgendwie auch geil wenn es funktioniert

Den eigenen Easy Diffusion Server kann man mittlerweile über das Internet, mit "eigener Adresse" erreichen.
Das sieht dann aus wie lokal.
Schaue dazu in den Einstellungen.

Ja, die Einstellung kenne ich selbstverständlich und so funktioniert das auch. Ich will das Ganze aber jedoch in eine Webseite einbinden. Und natürlich auch nicht im vollen Funktionsumfang. Normale Kunden fangen mit den ganzen Einstellungen nämlich nichts an und ich habe teilweise auch nur Platz für eine Textbox und das generierte Bild. Diese Möglichkeit fällt also leider weg.

Danke euch, ich probiere mal weiter und melde mich wieder.

LG

godlike

 

[saddy]

Omg ja da ab ich teilweise auch schon geflucht.
Bei den Projekten steht idR dabei welche CUDA Version usw funktionieren.
Ist dann nur doof, weil die oft mit anderen Projekten dann nicht wollen.

Da gleich mit gescheiter Hardware starten kann aber sehr helfen

 

[godlike]

So, ich bin ein Stück weiter, sogar ein großes! Mein Server läuft, EasyDiffusion läuft, ich kann über cURL Anfragen an Stable Diffusion stellen, diese werden auch berechnet, ohne Fehler. Das einzige woran ich jetzt noch scheitere ist die Ausgabe des soeben generierten Bildes. Egal was ich probiere, es kommt einfach nix an! Muss also noch weiter tüfteln.
Sowas funktioniert auf jeden Fall nicht;

// Save the image locally
        $imageFolder = "images";
        $imagePath = $imageFolder . '/' . $imageName;
        file_put_contents($imagePath, base64_decode($encodedImage));

        // Display the image
        echo "<strong>Your generated image:</strong>";
        echo "<div id=\"image_output\"><img src=\"" . $imagePath . "\" alt=\"Generated Image\" class=\"stable_image\"></div>";

 

[alter_Bekannter]

Wie sicher bist du dir dass wirklich ein Bild generiert wird?

Klappt es wenn du direkt die Base64 Daten einbindest?

<div>
  <p>Taken from wikpedia</p>
  <img src="data:image/png;base64, iVBORw0KGgoAAAANSUhEUgAAAAUA
    AAAFCAYAAACNbyblAAAAHElEQVQI12P4//8/w38GIAXDIBKE0DHxgljNBAAO
        9TXL0Y4OHwAAAABJRU5ErkJggg==" alt="Red dot" />
</div>

Wenn das klappt dann bleiben eigentlich nur noch Pfade oder Berechtigungen.

 

[godlike]

Wie sicher bist du dir dass wirklich ein Bild generiert wird?

Klappt es wenn du direkt die Base64 Daten einbindest?

<div>
  <p>Taken from wikpedia</p>
  <img src="data:image/png;base64, iVBORw0KGgoAAAANSUhEUgAAAAUA
    AAAFCAYAAACNbyblAAAAHElEQVQI12P4//8/w38GIAXDIBKE0DHxgljNBAAO
        9TXL0Y4OHwAAAABJRU5ErkJggg==" alt="Red dot" />
</div>

Zu 1.: Ziemlich sicher da ich auf dem Server im laufenden Script ja einerseite die übertragenen Parameter sehe, die Erfogsmeldung welche folgt und auch den Fortschrittsbalken bis das Bild fertiggestellt ist:

Habe es jetzt so probiert, gar kein Ergebnis mehr :/

// Save the image locally
$imageFolder = "images";
$imagePath = $imageFolder . '/' . $imageName;
file_put_contents($imagePath, base64_decode($encodedImage));

// Display the image
echo "<strong>Your generated image:</strong>";
$imageData = base64_encode(file_get_contents($imagePath));
$imageSrc = 'data:image/png;base64,' . $imageData;
echo '<img src="' . $imageSrc . '" alt="" />';

Ich bekomme ja nicht mal eine Fehlermeldung oder so

LG godlike

 

[KingJamez]

Wo müssten die bilder denn dann liegen? siehst du sie auf dem System direkt in dem entsprechenden Ordner, was hat der Ordner und was haben die Bilder für Berechtigungen?

 

[godlike]

Die Bilder liegen im Ordner images (relativ zur Seite welche die cURL Anfrage stellt). Diese haben aber leider alle 0 bis 1KB und sind nicht funktionsfähig. Warum das so ist weiß ich aber nicht, ich bekomme ja keine Fehlermeldung oder kann ich das anderweitig prüfen?

 

[alter_Bekannter]

In dem Fall würde ich beim Repo ein issue eröffnen. Vielleicht stellt sich raus das deine Grafikkarte nicht unterstützt ist. Das wirkt alles noch sehr experimentell und neu und deine Karte ist jetzt nicht das neuste Modell.

 

[godlike]

Meinst du wegen pytorch, CUDa usw.?

Also ich hab ein funktionierendes Script. Das fängt meine Anfrage über eine externe Webseite und cURL ab, schickt diese an mein Python Script und gibt ein Bild aus. Das geht alles. Leider irgendwie sehr langsam (hab ich das Gefühl) und ohne Komfort und meine num_inference_steps werden nicht beachtet. Also kein Ladebalken usw. Ich würde eben lieber Easy Diffusion nutzen anstatt die Stable Diffusion Pipeline.

Das hier funktioniert:

import os
import base64
import torch

from fastapi import FastAPI, File, Query
from diffusers import DiffusionPipeline
from PIL import Image
from io import BytesIO

app = FastAPI()

device = torch.device("cuda" if torch.cuda.is_available() else "cpu")
generator = DiffusionPipeline.from_pretrained("runwayml/stable-diffusion-v1-5").to(device)

@app.post("/generate_image")
async def generate_image(
    prompt: str,
    height: int = Query(default=64, description="Height in pixels of the generated image"),
    width: int = Query(default=64, description="Width in pixels of the generated image"),
    num_inference_steps: int = Query(default=15, description="Number of denoising steps"),
    guidance_scale: float = Query(default=7.5, description="Guidance scale for text prompt"),
    seed: int = Query(default=70182, description="Seed value for random generation"), 
    num_images_per_prompt: int = Query(default=1, description="Number of images to generate per prompt")
):
    # Print or log the parameters
    print("Parameters:")
    print(f"Prompt: {prompt}")
    print(f"Height: {height}")
    print(f"Width: {width}")
    print(f"Number of Inference Steps: {num_inference_steps}")
    print(f"Guidance Scale: {guidance_scale}")
    print(f"Seed: {seed}")
    print(f"Number of Images per Prompt: {num_images_per_prompt}")

    image_kwargs = {}
    if height is not None:
        image_kwargs["height"] = height
    if width is not None:
        image_kwargs["width"] = width

    generator.num_inference_steps = num_inference_steps
    generator.guidance_scale = guidance_scale

    images = generator(prompt, **image_kwargs).images[:num_images_per_prompt]

    # Create a unique filename based on prompt, seed, and iteration
    filename = f"{prompt.replace(' ', '_')}_{seed}_iter{num_inference_steps}.png".lower()

    # Save the image locally
    image_folder = "images"
    if not os.path.exists(image_folder):
        os.makedirs(image_folder)
    image_path = os.path.join(image_folder, filename)
    images[0].save(image_path)

    # Read the saved image and encode it as base64
    with open(image_path, "rb") as image_file:
        encoded_image = base64.b64encode(image_file.read()).decode("utf-8")

    return {"image": encoded_image}

if __name__ == "__main__":
    import uvicorn
    uvicorn.run(app, host="0.0.0.0", port=8000, timeout_keep_alive=1200)

Denke also nicht das es der Kompatibilität liegt :/

LG godlike

 

[alter_Bekannter]

Schon verifiziert das dein sehr langsames funktionierendes Skript auch wirklich die GPU benutzt?

Ich sehe da nämlich was Verdächtiges was alles erklären könnte:

device = torch.device("cuda" if torch.cuda.is_available() else "cpu")

 

[godlike]

Diesen Verdacht hatte ich natürlich auch schon und habe das im Tastkmanager gegengeprüft:

Es wird auf jeden Fall mit der GPU gerechnet, allerdings ist er im Vergleich zu EasyDiffusion nerklich langsamer. Warum? K.A. Ich versuche das mit den num_inference_steps zu lösen, evtl ist da ja der Haken.

device = torch.device("cuda" if torch.cuda.is_available() else "cpu")

Das ist nur der Fallback, wenn CUDA nicht verfügbar ist, aus welchen Gründen auch immer, soll er die CPU nutzen. Diese ist aber SO LANGSAM (AMD ohne Grafik eben) das mein Script bereits ab 256x256 px ein Timehout bekommt. (GPU sind hier evtl 40 Sekunden, CPU 15 Minuten!). Das ist aber auch alles irgendwie zu langsam.

 

[godlike]

Okay, hier mal ein Update zum ganzen Thema.

Mittlerweile musste ich leider von dem ganzen Ideeen-Konstrukt abweichen. Damit das flüssig und somit auch für Endbenutzer zufriedenstellend läuft bräuchte ich vmtl eine viel bessere Grafikkarte. Und ich meine jetzt keine 4090, eher eine A100. Ob das so Sinn macht ist wirklch die Frage. Mittlerweile hab ich einen Midjourney Account und hoffe das es hier eine API Gibt. Mit meinem Abo hab ich 30 Stunden Fast-GPU-Time. das reicht für ca 1500 Bilder, soweit unschlagbar, da kommt man mit eigener Hardware nicht hin.

Das ganze wäre eine Nette Idee gewesen aber ich kann die langen Wartezeiten wirklich keinem zumuten

 

[DandG]

Eventuell ne gebrauchte 3060 12gb besorgen?

Damit kann man 512x512 4x hochskaliert innerhalb Sekunden erstellen.
Ohne natürlich schneller.

Muss man dann halt selbst wissen, ob man da jetzt 260€ rein stecken möchte.

 

[godlike]

Woher kommen deine Werte? Also ich hab daheim ne 3080 und da dauern 512x512 breits bedeutend länger als ein paar Sekunden. Eher in die Richtung von 30 Sekunden mit entsprechenden Einstellungen damit die Ergebnisse entsprechend gut aussehen.

Ich wollte die Tage auch das neue StableDiffusion Model (sdxl) ausprobieren, mit dem alten Model waren die Ergebnisse nämlich oft wirklich lausig!

Das Problem bei der Sache ist nämlich das man bei Stable Diffusion oft 20 Versuche benötigt um ein schönes Ergebnis zu erhalten, das addiert sich am Ende natürlich zu enormen Wartezeiten (Momentan 45 bis 1:30 PRO BILD). Wenn das Ding Live ist darf sowas nicht länger als 10 Sekunden dauern, sonst addieren sich Wartezeiten bei gleichzeitiger Nutzung ja noch mehr. Kein User warte 5 Minuten auf ne Grafik die einigermaßen schlecht ist

Midjourney ist hier einfach state of art, egal was du eingibst, das Ergebnis haut doch vom Hocker und mit Fast GPU Time dauern 4 Bilder ca 10 Sekunden. Hier eine API wäre vmtl die beste Wahl.

Ich gebe Sdxl und Stable Diffucion noch eine Chance

LG godlike

 

[DandG]

Ein guter bekannter wollte das unbedingt auch haben, hab es ihn fix geladen.
Er braucht für 10 Bilder mit den gleichen Einstellungen um die 5 Minuten.
Kann später mal ein Bild einfügen, wie lange das dauert.

In den Einstellungen gibt es eine Option, mir fällt der Name nicht ein, nur das man es auf "schnell/fast" einstellen kann.
Da man genug VRAM zur Verfügung hat, gibt es absolut keine Probleme.

Mit Midjourney habe ich noch nicht wirklich zu tun gehabt, aber wenn es so fix ist und auch gute Ergebnisse liefert, möchte ich es auch ausprobieren