Tag.

Ich melde mich damit wieder aus der Versenkung zurück. Kurz nach der Anmeldung hier, hatte sich irgendwie so ein Drang gebildet, möglichst viel zu Posten bzw. zu schreiben. Dann verursachte das Stress und ich habe den Stecker gezogen. Sollte dieses Projekt / dieser Irrsinn aber tatsächlich jemanden interessieren, dann tut es mir leid für die Funkstille.

Eine Weile lang hatte ich überlegt, dieses Projekt an den Nagel zu hängen. Allerdings hat mich die Sache dann doch nicht mehr so recht losgelassen. So wie ich das damals aufziehen wollte, hätte das hier und da zwar funktioniert, aber das Endergebnis oder besser gesagt Beschreibungstexte und Bilder wären häufig nicht sonderlich brauchbar gewesen. Deshalb habe ich mich dann vor einer Weile dazu entschieden, die Sache ganz anders anzugehen.

Statt also den kompletten Weg zur jeweiligen Film-Page (Cover-Art, Schauspieler, Beschreibungstext und Co.) zu automatisieren, wollte ich einen kuratierten Ansatz angehen. Ich werde daher sämtliche Beschreibungen - mal länger, mal kürzer - selbst schreiben. Außerdem wird jedes Bild manuell generiert. Später kam ich nämlich auch auf den Trichter, dass jede Film-Page auch Screenshots von Szenen beinhalten soll, wie man das von Amazon her kennt. Das ist zwar nicht (mehr?) innerhalb von Prime Video, aber auf den Pages für DVD's und Blurays sieht das noch so aus.

Beispiel:

Schauspieler werden daher eben nun auch nicht mehr zufällig generiert, sondern kommen aus einem Pool an LoRAs, die ich im Vorfeld trainiere (kleinere Rollen/Statisten nicht inbegriffen). Noch ist dieser Pool sehr überschaubar. Im Moment bin ich bei 12 fiktiven Personen. Um eine Person zu erstellen, nutze ich Charakter-Editoren diverser Videospiele. Für den Datensatz mache ich dann Screenshots, die diesen Charakter innerhalb von verschiedenen Szenen und in unterschiedlichen Posen, Winkeln und Belichtung zeigen. Das Training darf nicht zu lange dauern, da der Charakter dann zwar ähnlicher wird, aber zunehmend in dem Stil des Spieles (als stilisiertes 3D-Modell) generiert wird. Außerdem müssen GUI-Elemente und Dinge wie Lebensbalken ausgeblendet werden. Deshalb eignen sich vor allem Spiele mit Fotomodus.

Einer der Screenshots die für's Training genutzt wurden (aus Baldur's Gate 3):

Sample-Bild aus dem Training (Step 700):

Gerade aufgrund von diesem neuen Ansatz, musste ich die ganze Idee stark abändern. Es sollte am Ende nämlich immer noch möglichst glaubhaft wirken. Mir ist allerdings aufgefallen, dass es bei mehreren Schauspielern in einer Szene oder auf einem Cover schnell mal zu Problemen kommt. Eine Style-LoRA + eine Charakter-LoRA zwicken sich häufig nicht wirklich. Die Sache sieht aber anders aus, wenn man mehrere Charakter-LoRAs reinlädt. Da hilft es dann auch häufig nicht viel, die Gewichtung der einzelnen LoRAs ein wenig anzupassen oder sehr lange und explizite Prompts zu schreiben. Bei einem Versuch, drei Charaktere in einer Szene unterzubringen, wurden fast ausschließlich dreimal die gleiche Person generiert, wobei das Gesicht ein Mix aus allen dreien war. Ich kam aber dann auf die Idee, das jeweilige Bild initial nur mit einer Charakter-LoRA zu generieren und die anderen Personen nur vage so beschreibe, wie die anderen Schauspieler aussehen (Größe, Statur usw.). Im Nachhinein nutze ich dann einfach die Inpainting-Funktion von Forge, maskiere den Kopf und lass bei der Person - eben dann mit der jeweiligen LoRA geladen - einfach das Gesicht dieses Schauspielers generieren. Das klappt relativ gut, aber es sind häufig mehrere Versuche nötig. Schon deshalb würde der anfängliche automatisierte Ansatz nicht funktionieren.

Der Plan sieht so aus, dass ich wohl einen ganzen Haufen an fiktiven Schauspielern auf diese Weise erzeugen werde. Eine genaue Zahl habe ich hier nicht festgelegt, aber es könnten ein paar hundert werden. Bei Charakter-LoRAs reicht eine kleine Dimensionierung. Daher nehmen die auch nicht viel Platz auf der Platte weg (zweistelliger MB-Bereich). Für Szenen, Cover etc. werde ich dann noch einzelne Style- und Konzept-LoRAs trainieren.

Hier ein paar Beispiele der Horror-Cover-LoRA, die nach etlichen Fehlschlägen dann doch brauchbar wurde:

Während der letzten Wochen habe ich zwar wieder etwas mehr trainiert, bin aber auf kühles Wetter angewiesen. Meine GPU heizt gut beim Training und wenn es heiß wird, staut sich die warme Luft in der Wohnung ohnehin schon. Läuft das Ding dann auch noch mehrere Stunden bei nahezu 100%, dann ist es ein wenig so, als würde ich zusätzlich zu den hohen Temperaturen auch noch die Heizung anwerfen.

Mist habe ich beim Training viel gebaut. Auch das ein oder andere, das sich anfangs wie eine super Idee angehört hat, entpuppte sich letztendlich als völliger Griff ins Klo. Ich schätze aber mal, so lernt man dazu. Das Ding ist und bleibt am Ende letztendlich nur so etwas wie ein beklopptes Kunstprojekt, in das ich insgesamt wohl mehr Zeit und Energie stecken werde, als notwendig ist. Ich arbeite nur sporadisch daran, also kann das noch sehr lange dauern. Sollte allerdings Interesse an einer Beispiel-Page für einen Film bestehen (gerne auch mit Vorschlag zu Genre, Setting und Titel), werde ich da etwas zusammenbasteln und im Laufe der Tage mal ein paar Screens posten oder die Seite auf Github-Pages packen.

Zitat von PixelPatron

Ich verstehe. Habe mir comfy kurz angeschaut, das ist quasi das Tool was die Images erstellt.

Nicht ganz. ComfyUI bietet die Umgebung dafür. Die Bilder werden von dem jeweiligen Modell via Prompteingabe generiert. Das UI von ComfyUI wird dabei über den localhost Port 8188 im Browser aufgerufen. Dort kann man sich dann eben Workflows zusammenklopfen oder diese auch online herunterladen, wobei sie eben auf vielen Websites als JSON-Datei angeboten werden, die man dann einfach nur in dieses Browserfenster ziehen muss.

Hier wäre beispielsweise ein simpler Workflow für Stable Diffusion 3 Medium:

Das Ganze kann man sich auch einfacher machen, indem man einfach Forge oder A1111 nutzt. Allerdings bietet ComfyUI zwei Vorteile gegenüber diesen WebUI's.

Zum einen kann man sich dort auch ziemlich aufwendige Workflows zusammenbasteln, die eben nicht nur Bilder generieren, sondern diese auch weiterverarbeiten.

Hier wäre beispielsweise ein Workflow, den ich vor ein paar Wochen gebastelt habe:

Das sieht man jetzt nicht, da ComfyUI den Text in den Nodes nicht mehr anzeigt, wenn man zu weit hinauszoomt, aber dieser Workflow beispielsweise (sofern alle Groups aktiviert sind), erstellt erst einen per LLM generierten Prompt, leitet diesen dann an Flux weiter, wo diesem noch zuvor festgelegte Style-Prompts beigefügt werden. Anschließend generiert Flux dieses Bild. Fertiggeneriert wird das Bild dann weiter an einen SDXL Upscaler weitergeleitet. Das Endergebnis wird dann im JPEG-Format abgespeichert.

Das ist so eine der stärken von ComfyUI. Diese ganzen Aufgaben können hier eben mit einem Knopfdruck erledigt werden. Diesen Workflow könnte man auch noch erweitern oder einzelne Nodes durch andere Tauschen.

Der weitere Vorteil ist, dass man solche Workflows eben als JSON abspeichern kann. Dieses JSON kann man dann mit beispielsweise Python öffnen und auf einzelne Keys zugreifen und deren Inhalt ändern, wie den Key, der den eigentlichen Prompt enthält.

Möchte ich dann in meinem Projekt ein Bild generieren, bekommt ComfyUI nicht nur den Prompt zugeschickt (also das, was ich generiert haben möchte), sondern immer den kompletten Workflow als json. Auf diese Weise kann ich dann auch unterschiedliche Workflows mit einer Anwendung nutzen, wie bei mir der eine Workflow zum Generieren der Filmposter und der andere, der die Beschreibungstexte erzeugt.

ComfyUI muss dafür dann zwar laufen, aber eben nicht im Browser geöffnet sein.

Zitat von Syntafin

Für diese ganzen LLMs egal ob am Ende für Text, Bild oder Video werden entsprechend Daten aus dem Internet abgegriffen (teils auch illegal, zu 99%), in einer Datenbank gespeichert (grobe Erklärung) und mit Infos versehen zum wiederfinden (grob könnte man sagen Tags)

Bei einer Anfrage dann wird anhand der Anfrage bestimmt welche Daten es braucht, diese zusammengesetzt und ausgegeben. Nix denken....

Ja, dazu habe ich vorhin online eine Erklärung gefunden. Danke für Klarstellung übrigens.

Das mit dem illegal hört man ja immer wieder. Vor allem, dass auch OpenAI und Co. eher weniger von Urheberrechten halten, diese Modelle aber dann hinter Teils dicken Paywalls ($200 für's ChatGPT Pro Abo zum Beispiel) verstecken.

Zitat von PixelPatron

Spannend? Haha ich verstehe sogar vieles nicht. Kann man das Ganze auch in einfachem php schreiben?

Ich wüsste nicht, was dagegen spricht. Das Python, das ich da im Endeffekt schreibe, stoßt das Generieren ja nur an und übermittelt die Daten dann wiederum ans Frontend. Zum Generieren selbst nutze ich, wie eben oben erwähnt, ComfyUI und die besagten Modelle. ComfyUI ist zwar auch in Python geschrieben, aber eben nicht von mir und funktioniert ja unabhängig von der Programmiersprache, in der diese Requests geschrieben sind. Du würdest ja dann im Endeffekt diese Anfrage (in deinem Fall dann via PHP) an den Port bzw. Endpoint senden, auf dem ComfyUI horcht (8188/prompt per Default).

Zitat von PixelPatron

Krass das man sehen kann wie die KI denkt. Macht es eigentlich einen Unterschied ob die KI weiblich oder männlich bzw. Unisex entwickelt wurde? Man sagt ja immer Männer Logik oder sowas aber gibt es das?

Ich bezweilfle, dass irgendein Modell nur mit Daten gefüttert wurde, die man beispielsweise ausschließlich in die Kategorie 'männlich' packen könnte. Ich bin kein Experte auf dem Gebiet, aber soweit ich weiß, werden hier massenhaft Texte benutzt. Da dürfte dann von Artikeln, über Geschichten (Romane, Kurzgeschichten, etc) bis zu Chat-Konversationen so ziemlich alles dabei sein.

Syntafin
Grundsätzlich sind die Modelle ja in der Lage, beispielsweise Deutsch zu schreiben. Daher waren garantiert auch deutsche Texte unter den Trainingsdaten.
Wenn du damit allerdings meinst, dass eventuell einzelne Worte oder Wissen zu einzelnen Themen nur in bestimmten Sprachen vorhanden sind und das Modell deshalb auf diese Sprache umswitched, dann verstehe, macht Sinn.


Kleines Update zu meinen Versuchen:
Ich habe mir vorhin nochmal ein Video auf YouTube zu dieser ganzen DeepSeek-Situation angesehen. Dort wurde dann auch von einem anderen Modell gesprochen, dass kürzlich als OpenSource veröffentlicht wurde: Qwen2.5
Kommt ebenfalls aus China und stammt scheinbar von einer Tech-Sparte des Konzerns Alibaba.
Ich habe Qwen2.5-Coder-14B getestet. Snake hat es schon mal hinbekommen, im Gegensatz zu Deepseek-8B.

Auszug aus dem Gespräch:
Prompt:
No, i didn't mean a clone or something.
You have to come up with an own simple game idea. You provide the code and explain the rules to me.

Teil der Antwort:
Game Rules:
Matching: Click on any square to select it.
Adjacent Squares: If you click on an adjacent square (up, down, left, right, or diagonal) of the same color, they will disappear from the board.
Falling Squares: After a match, all remaining squares above the empty spaces fall down to fill them up.
Score: You earn points for each match you make based on the number of squares involved in the match.

Der Code:

import tkinter as tk
import random

class ColorMatch:
    def __init__(self, master):
        self.master = master
        self.master.title("Color Match")

        # Initialize game settings
        self.grid_size = 8
        self.cell_size = 50
        self.colors = ["red", "green", "blue", "yellow", "purple", "orange"]
        self.score = 0

        # Create canvas
        self.canvas = tk.Canvas(self.master, width=self.grid_size * self.cell_size, height=self.grid_size * self.cell_size)
        self.canvas.pack()

        # Initialize grid and draw initial state
        self.grid = [[random.choice(self.colors) for _ in range(self.grid_size)] for _ in range(self.grid_size)]
        self.draw_grid()

        # Bind mouse click event
        self.master.bind("<Button-1>", lambda event: self.handle_click(event))

    def draw_grid(self):
        """Draw the grid on the canvas."""
        self.canvas.delete(tk.ALL)
        for i in range(self.grid_size):
            for j in range(self.grid_size):
                x1, y1 = j * self.cell_size, i * self.cell_size
                x2, y2 = x1 + self.cell_size, y1 + self.cell_size
                color = self.grid[i][j]
                self.canvas.create_rectangle(x1, y1, x2, y2, fill=color)

    def handle_click(self, event):
        """Handle mouse click events."""
        col = event.x // self.cell_size
        row = event.y // self.cell_size

        # Get the color of the clicked cell
        current_color = self.grid[row][col]

        # Find all adjacent cells with the same color
        visited = set()
        to_visit = [(row, col)]
        matches = []

        while to_visit:
            r, c = to_visit.pop()
            if (r, c) in visited:
                continue

            visited.add((r, c))
            matches.append((r, c))

            for dr, dc in [(-1, 0), (1, 0), (0, -1), (0, 1), (-1, -1), (-1, 1), (1, -1), (1, 1)]:
                nr, nc = r + dr, c + dc
                if 0 <= nr < self.grid_size and 0 <= nc < self.grid_size and self.grid[nr][nc] == current_color:
                    to_visit.append((nr, nc))

        # If there are at least 3 matches, remove them and update the grid
        if len(matches) >= 3:
            for r, c in matches:
                self.grid[r][c] = None

            # Drop squares above empty spaces
            for j in range(self.grid_size):
                none_count = 0
                for i in range(self.grid_size - 1, -1, -1):
                    if self.grid[i][j] is None:
                        none_count += 1
                    elif none_count > 0:
                        self.grid[i + none_count][j] = self.grid[i][j]
                        self.grid[i][j] = None

            # Fill empty spaces at the top with new random colors
            for j in range(self.grid_size):
                for i in range(none_count):
                    self.grid[i][j] = random.choice(self.colors)

            # Update score and redraw grid
            self.score += len(matches) * 10
            self.master.title(f"Color Match - Score: {self.score}")
            self.draw_grid()

if __name__ == "__main__":
    root = tk.Tk()
    game = ColorMatch(root)
    root.mainloop()

Es startet jedenfalls problemlos. Allerdings habe ich nicht die geringste Ahnung, was da passiert. Zudem kann man unendlich Punkte erzeugen, indem man einfach in leere Felder klickt.

Ja, spannend finde ich das auch. Was die Sprache beim Denken angeht, ist es bei mir auch schon auf Chinesisch geswitched. Das gleiche hat ChatGPT 3o high aber auch gerade gemacht (zumindest denke ich, dass es Chinesisch war).
Ich habe mehreren Modellen gerade eine Matheaufgabe gestellt, die ich auf Reddit gefunden habe. Jedenfalls konnten die alle lösen.

Bei DeepSeek R1 14B fand ich aber einen Absatz im Denken recht komisch:

Wow, that's a sixth-degree polynomial. That sounds complicated because I remember from school that higher degree polynomials can be tricky to solve, especially if they don't factor nicely or have rational roots. But maybe there's a pattern here.

Ich finde jedenfalls cool, dass wirklich jedes der Modelle frei verfügbar ist. Das volle Modell bleibt aber trotzdem in weiter Ferne. Selbst in quantisierter Form ist das eher nicht für Consumer-Hardware gedacht.

Vom BF16-Modell möchte ich gar nicht erst anfangen:

Blacksonny

Ich bin gerade am Testen und mich haut es da gerade irgendwo aus den Socken.

Zu Testzwecken wollte ich mehrere Modelle ausprobieren. Im Moment hänge ich noch an dem Modell Deepseek-R1-Distill-Llama-8B-GGUF (also einem ziemlich kleinen Modell).

Das wäre mein erster Prompt:
Schreibe mir bitte einen längeren deutschen Text.

Ich bekam folgende Antwort:
Die Berge sind immer ein besonderes Erlebnis. Sie ergeben eine Vielzahl von Landschaften, von steilen Gipfeln bis zu sanften Hügeln. In den Bergen gibt es viele Tierarten, die sich an der rauhen Natur angepasst haben, wie z.B. Schneehasen oder Murmeltiere. Außerdem sind die Berge ein idealer Ort, um ruhig zu werden und die Natur in all ihren Formen zu genießen.

Auch die Stadtlandschaften sind einzigartig. Große Städte wie Berlin, München oder Köln bieten eine Mischung aus modernen Gebäuden und historischen Straßenzügen. In diesen Städten leben Millionen von Menschen, die jeden Tag neue Erfahrungen machen und die Kultur des Stadtlebens erleben können.

Die Natur hat so viel zu bieten, unabhängig davon, ob man in den Bergen oder in der Stadt lebt. Sie erfüllt den Menschen mit Eindrücken und erinnert ihn daran, wie vielfältig das Leben ist.

Was ich ebenfalls interessant finde, ist dass man sich auch die Denkprozesse der KI ansehen kann. Für diesen Prompt sah das wie folgt aus:
Okay, the user just asked me to write a longer German text. In the previous message, they confirmed that I speak German.

They might be looking for an example of how I can provide a detailed response in German. Maybe they're testing my language abilities or need assistance with a specific topic.

I should respond by offering a variety of subjects so they can choose one they're interested in. That way, I cover different areas like nature, technology, food, and history to show versatility.

I'll make sure the text is engaging and informative, keeping it natural since they mentioned using markdown but then told me to avoid it. So, I'll keep it simple without any formatting.

Der Text weist ein paar Fehler auf. Nachfolgend hatte ich die KI auch gefragt, ob sie mir Snake in Python (mit tkinter) programmieren könnte. Leider hatte auch noch der dritte Versuch zum Start Fehler geworfen.
Es ist allerdings wirklich interessant, die Denkprozesse der KI zu beobachten, während sie die Antwort vorbereitet.

Jetzt teste ich DeepSeek-R1-Distill-Qwen-32B-Q4_K_M.gguf. Hier läuft es schon deutlich langsamer, da das Modell eben nicht mehr komplett in meinen VRAM passt. Bei dem 8B-Parameter-Modell hatte ich ~35 tok/sec. Hier sind es ~5 tok/sec.

Im Vergleich mit anderen Open-Source-Modellen, die ich bisher lokal getestet hatte, finde ich das aber in jedem Fall beindruckend.

Als Umgebung nutze ich übrigens LM Studio.

Kleines Update:

Ich habe jetzt ein paar Modelle getestet und bin insgesamt ziemlich beeindruckt. Allerdings wirft die KI häufig auch das ein oder andere chinesische Zeichen mit in den Text, unabhängig, ob man auf Deutsch oder Englisch mit ihr kommuniziert.

Guten Morgen,

das hat mir jetzt doch keine Ruhe gelassen und ich habe jetzt so weit weitergemacht, dass zumindest schon mal die momentan vorhandenen Film-Daten ans Frontend übermittelt werden und eben die Film-Poster in Form von Cards im Main angezeigt werden.

Das ist so nicht final, aber ich wollte wenigstens schauen, ob es bis hierhin fehlerfrei funktioniert, so wie ich mir das gedacht habe. Kleine Info am Rande, hat es nicht. Idiotischerweise hatte ich das so zusammengeklopft, dass die Bildpfade nach dem generieren und verschieben als absolute Pfade in der JSON-Datei abgespeichert wurden, wodurch das Frontend dann keinen Zugriff darauf hatte. Das ließ sich aber recht einfach beheben.

Im späteren Verlauf möchte das so regeln, dass die Cards unterhalb von zufällig ausgewählten Kategorien in Form von scrollbaren Rows auftreten, wie das eben beispielsweise bei Netflix oder Prime der Fall ist. Potentielle Kategorien wie Subgenres oder Urpsrungsländer hätte ich ja schon. Bei Monstern oder Themen, die sehr häufig vorkommen, könnte man dann auch das als Kategorie nehmen. In dem Bild sieht man auch gut das von mir vorher angesprochene Problem mit den zusätzlichen kleinen Texten, die häufig auf den Bildern vorkommen. Außerdem kommt es auch immer mal wieder vor, dass ein Bild ohne Titeltext generiert wird, obwohl spezifiziert. Ich hoffe, dass die LoRa die Ergebnisse dann soweit verbessert. Perfekt wird es sicher nicht, aber wenn dadurch solche Fehler minimiert werden können, dann war es die Sache schon wert.

Am Captions schreiben bin ich zwar bereits, habe aber zum jetzigen Stand gerademal 17 von 400 Bilder fertig. Ich habe zwar im Laufe der letzten drei Monate bereits drei LoRas trainiert, hatte aber bei jeder lediglich rund 40 Bilder fürs Training hergenommen. Hier wollte ich aber möglichst viele Stile unterbringen, weshalb das wohl ein längerfristiges Unterfangen wird. Daher dachte ich mir auch, dass ich mich die nächste Zeit nicht einzig und allein auf's Captions schreiben konzentriere, sondern auch am Projekt selbst arbeite. Außerdem werde ich den ersten Trainingslauf der LoRa schon nach 100-150 Bildern beginnen. Sollten die Ergebnisse dann bereits zufriedenstellend sein, werde ich mir gar nicht erst die Mühe machen, weitere Daten für ein zweites Training vorzubereiten.

Das wäre dann der Plan bis jetzt. Sollte jemand Vorschläge für's Frontend haben, würde ich mich darüber sehr freuen.

PS: Ich hoffe es ist in Ordnung, dass ich diesen Thread hier jetzt mehr oder weniger als Tagebuch für dieses Projekt nutze.

Gestartet bin ich mit Mint. Eine Weile lang war ich auch bei Pop!OS, da ich damit begonnen hatte, auch Gaming auf Linux zu verlegen. Dort hatte ich aber dann so manches Spiel erst nach ziemlich viel herumprobieren zum Laufen gebracht und jeder neue Patch für das jeweilige Spiel, konnte das komplette Setup wieder kaputtmachen. Was Gaming angeht, bin ich dann wieder zurückgerudert und habe einfach Windows auf eine andere Platte gepackt. Somit habe ich immer noch eine gewisse Trennung. Nachdem ich einige andere Distros getestet hatte, bin ich letztendlich bei Kubuntu gelandet. Der Multi-Monitor-Support ist ist super und funktionierte bei mir, anders als beispielsweise bei Mint, ab Werk. Außerdem mag ich den KDE-Plasma Desktop.

Zitat von Blacksonny

Hat jemand von euch schon DeepSeek benutzt bei mir ist es extrem langsam und kommt jede zweite prompt ins timeout

Ich wollte das die nächsten Tage auch testen, allerdings Lokal, sofern das auf meiner Hardware möglich ist. Auf YouTube habe ich dazu bereits ein Video gefunden, welches ich mir im Laufe der nächsten Zeit mal ansehen werde.

Zitat von Syntafin

Wie gesagt, finde das Projekt recht spannend, gibt es schon paar Mockups vom Frontend?

(Ich wäre fast ins Englische gerutscht beim schreiben xD)

Nein, tatsächlich nicht. Ich mache das immer so mehr oder weniger aus dem Bauch heraus, habe also keine Vorlagen, falls du das meinst.

Mir dient lediglich ein Bild von einem Nachbau des Netflix-Frontends, welches ich auf Github gefunden habe, als Referenz.

Im Moment sieht das noch so aus:

Der "Debug Menu"-Button würde dann ein Menü öffnen, in dem man neue Film- oder Schauspieler-Einträge zu generieren oder eben auch bestehende Einträge manuell abändern kann, z.B. Beschreibungen, Mitwirkende. Außerdem würde es dann auch die Möglichkeit geben, Film-Poster für vorhandene Filme neu zu generieren. Header und Footer sollen hierbei fix bleiben und von Profil-Einstellungen, über die Auswahl der Filme oder aber auch das erwähnte Debug Menü würden dann eben im Main angezeigt werden, je nachdem, was gerade ausgewählt ist. Dafür kann ich ja dann eine data()-Variable in Vue anlegen, die das regelt. Das wäre zumindest der Plan soweit.

Als Inspirationsquelle nutze ich folgendes Bild:

(Quelle: https://github.com/Relirk/netflix…ter/netflix.png)

Zitat von Syntafin

Wollte auch nichts gegen ComfyUI als Wahl sagen, war ja nur eine Frage

Keine Sorge, ich habe mich nicht angegriffen gefühlt.

Ich dachte mir aber, ich könnte ein paar Einblicke gewähren und meine Beweggründe für diese Wahl ein wenig erläutern.

Der Grund, weshalb ich mich hier für ComfyUI entschieden habe, ist der, dass ich auch komplexere Workflows, wie diesen hier auf den Bildern, einfach als JSON abspeichern kann. Nach dem Laden dieser JSON-Datei, kann ich dann mittels Python einfach ein paar der Values für Inputs wie prompt oder width&height ändern und den ganzen Käse an den Port senden, auf dem ComfyUI läuft. Da muss ich nicht jedes Mal das Rad neu erfinden, wenn ich irgendwo eine Änderung brauche, sondern klebe bei Bedarf einfach zusätzliche Nodes dran oder tausche andere aus und speichere das dann eben unter neuem Namen wieder ab. ComfyUI muss für das Generieren selbst ja nicht einmal im Browser offen sein. Es läuft einfach im Hintergrund und wartet, bis ich ihm den jeweiligen Workflow schicke.

Zum Stand jetzt läuft das bei mir in der Anwendung dann eben so ab, dass erst ein Prompt mit zufällig ausgewählten Genre, Subgenre, Land, Antagonist und Co an ComfyUI geschickt wird. Python wartet dann mittels time.sleep von jeweils einer Sekunde so lange, bis die Text Datei mit der Filmbeschreibung in einem Ordner für temporäre Dateien vorhanden ist. Sobald die Beschreibung da ist, wird der Titel des Filmes aus dem Ganzen extrahiert. Genauso wie die Filmbeschreibung/Zusammenfassung des Filmes selbst, kommt der Titel dann auch von Mistral-7b-Instruct. Sofern dieser in doppelten Anführungszeichen steht, wie in den Instructions vorgegeben, wird er extrahiert und zusammen mit einer zufälligen Anzahl an weiteren Attributen wie eben Filmgenre, Styles und optional auch Personen, Gebäude oder Gegenstände in einen Prompt für Flux verpackt. Die Textdatei wird gelöscht und der Prompt wird dann eben wiederum an ComfyUI gesendet, diesmal aber mit dem Workflow für Film-Poster. Die Listen mit diesen ganzen Einträgen für die Prompts befinden sich in dem Ordner lists (sichtbar im Bild) als JSON-Dateien mit verschiedenen Kategorien. Bildpfad, Dinge wie Genre, Ursprungsland, Titel, Filmbeschreibung und Co. landen dann in einer JSON Datei, die als Datenbank für die Filme fungiert und später via Python ans Frontend übermittelt wird. Das Bild wird dann, sobald vorhanden, automatisch verschoben und unbenannt. Das wäre der jetzige Stand. Da ist auch noch nichts mit dem Frontend verbunden, welches momentan lediglich ein Logo innerhalb eines Headers ist, mit Buttons und einer Suchleiste ohne Funktion daneben, einem leeren Main und einem ebenso leeren Footer. Später soll es dann in ähnlicher Manier auch möglich sein, Schauspieler zu generieren, welche Filmen dann zufällig zugewiesen werden, sofern deren Geburts- und Sterbedatum (optional) nicht mit dem Erscheinungsdatum des Filmes kolidiert. Auch hier wird das dann ähnlich ablaufen, wobei ich aber dann eher auf SDXL für die Schauspieler-Portraits zurückgreife, da es dort sehr leicht ist, unterschiedlich aussehende Personen zu generieren, indem man dem Prompt einfach einen Fantasienamen anhängt, der aus zwei Vornamen und einem Nachnamen besteht. Auch hier werde ich dann einfach Namenslisten für verschiedene Nationen anlegen.

Führe ich die Funktion zum Generieren eines neuen zufälligen Filmes aus, kommt dann eben so etwas bei raus:

Film-Poster:

Auszug für diesen Film aus der JSON-Datei:

    "0000001": {
       "Name": "Hilarious Havoc: Unleashed",
       "Main Genre": "Horror",
       "Sub Genres": [
           "Comedy"
       ],
       "Tropes": [
           "Slapstick"
       ],
       "Year": "1994",
       "Country": "United Kingdom",
       "Venues": [
           "United Kingdom"
       ],
       "Monsters": [
           "mutant",
           "evil ancient god"
       ],
       "Description": "\"Hilarious Havoc: Unleashed\" unfolds a tale of comedic chaos in the quaint villages and cities of England. The story centers around an ancient, evil god who has been accidentally awakened by a group of bumbling archaeologists. In their desperation to return him to his slumber, they unwittingly unleash a horde of mutant creatures upon the unsuspecting populace.\n\nAs panic and pandemonium ensue, the government enlists an unlikely team to stop the invasion: a ragtag group of comedians who stumble into the fray by chance. Armed with wit, humor, and unconventional tactics, they use slapstick antics to take down the mutant horde and ultimately confront the ancient god in his lair. Along the way, they encounter eccentric townsfolk, absurd obstacles, and outrageous scenarios that push the boundaries of comedy while delivering thrilling action-packed sequences. In the end, with their unique brand of humor and camaraderie, the team manages to save the day, making \"Hilarious Havoc: Unleashed\" a memorable mashup of laughs, scares, and unforgettable moments.",
       "Actors": [],
       "Poster Path": "XXXXXXXX/02_Movie_Platform/data/img/movies/posters/Movie_Poster_0000001_1.jpeg"
   }

Nicht wundern über den Key "Monsters". Stand jetzt ist das als reine fiktive Horror-Streaming-Seite geplant. Egal ob neu und aufwändig oder alter Trash, ich liebe Horrorfilme.

Zitat von Syntafin

ComfyUI ist nur ein UI für SDXL, und SDXL setzt schon lange kein CUDA mehr ein

Ich kann nur sagen, was bei mir zum Start in der Konsole steht. Wie bereits erwähnt, da habe ich zu wenig Ahnung von.

ComfyUI ist aber mithilfe von Custom-Nodes sehrwohl in der Lage, auch andere Modelle zu nutzen (siehe Bilder).

Zitat von Blacksonny

Danke fürs Teilen und ausführliche beschreiben. Die Idee ist ziemlich gut, als App wäre die Idee sogar vielleicht ein Hit

Daran zweifle ich und hoffe auch, dass ich damit recht behalten werde. Zu viel Druck und potentielle Aufmerksamkeit.

Zitat von Blacksonny

Wäre es eine Idee, dass du dein Projekt auf git schon hochlädst und open source machst, dann könnten andere Entwickler mitwirken und dich dabei unterstützen. Würde dir auch mehrere Anhaltspunkte/Lösungen bringen und du interagierst dann mit deiner „Community“ später.

Vorerst nicht. Das sieht alles noch ziemlich chaotisch aus und keiner der Bestandteile ist auch nur im Ansatz fertig. Es wäre mir jedenfalls unangenehm, das so hochzuladen. Ich bin es nicht gewohnt, in diesem Bereich mit anderen zusammenzuarbeiten. Ich schätze, mal abgesehen vom Interesse, war einer der Hauptgründe, warum ich jetzt nach mehreren Jahren immer noch an dieser ganzen Kiste hier hänge, dass ich in dem Fall der einzige bin, der mir ständig das Gefühl gibt, zu nichts gut zu sein.

Sollte ich meine Meinung aber im Laufe der Zeit ändern und das es doch hochladen, stelle ich hier einen Link zur Github-Page rein.

Zum jetzigen Zeitpunkt aber nicht. Es sollte wenigstens halbwegs vorzeigbar sein, vor allem was den Code selbst angeht.

Die nächsten Tage bin ich dann eh erstmal mit den Captions beschäftigt.

Zitat von Syntafin

Willst du eigentlich den Python Teil auf offenen Standards für GPU Beschleunigung setzen oder eher auf propitäre Lösungen wie CUDA beschränken?

Da werde ich mich auf CUDA beschränken. Zur Nutzung der Modelle nutze ich ja keinen eigenen Code, sondern ComfyUI, welche standardmäßig CUDA verwendet (zumindest bei meiner NVidia GPU). Da pfusche ich dann lieber nicht drinnen herum. Da fehlt mir die Ahnung.

Der Python Teil, der von mir stammt, kümmert sich lediglich um die Anfragen an ComfyUI, generiert die Prompts für Mistral und Flux und fungiert als Backend für die Webseite selbst (Auslesen der Datenbanken z.B.).

Hallo Alexander,

grundsätzlich wäre so eine öffentliche Demo kein Problem. Was den Webspace angeht, komme ich eventuell darauf zurück. Allerdings würde das dann eben ohne die Möglichkeit auskommen müssen, neue Einträge zu generieren, da das dann eine brauchbare GPU mit ordentlich VRAM benötigen würde (oder im Falle einer öffentlichen Website, die dann unter Umständen von mehreren Personen gleichzeitig genutzt wird, eher mehrere GPUs). Ich habe die Workflows hier ohnehin schon um einen Node erweitert, der nach jedem Generieren, das gerade genutzte Modell wieder aus dem VRAM schmeißt, um 'Out of Memory'-Errors zu vermeiden. Später habe ich vor, ein kleines Installer-Skript zu schreiben, das automatisch das bestmöglich quantisierte Flux Modell für die Hardware des Nutzers herunterlädt, da ich hier bei meinen Experimenten das Q8-Modell verwende, welches noch die höchsten Anforderungen unter den GGUF-Modellen hat. Daher dann eben auch der Weg über Github, wo sich dann auch jeder, der über die nötige Hardware verfügt, diesen Ganzen Irrsinn selbst herunterladen kann.

Ich melde mich sicherlich wieder. Heute habe ich zumindest weiter daran gearbeitet, was schonmal gut ist. Jetzt geht's jedenfalls ans Captions schreiben. Da ich ein paar hundert Bilder zu beschreiben habe, wird das eine Weile dauern. Ich werde nach erfolgreichem Training der LoRa eventuell ein paar Ergebnisse teilen.

Danke jedenfalls für die netten Worte und ebenfalls liebe Grüße.

Guten Morgen,

momentan arbeite ich an einem kleinen Webprojekt und wollte Fragen, ob ich das dann hier (genaugenommen dann unter 'Projekte und Showcase') teilen darf.

Ursprünglich wollte ich das hier unter 'Projekte und Showcase' packen, hatte allerdings die Beiträge ein wenig überflogen und musste feststellen, dass die dort vorgestellten Projekte bereits vorzeigbar bzw. nutzbar waren. Da ich mir dadurch etwas unsicher war, wollte ich das lieber hier vorstellen, wo ich mit einem fehlerhaft platzierten Beitrag wahrscheinlich noch den kleinsten Schaden anrichten könnte.

Kurzzusammenfassung:

Bei dem Projekt handelt es sich genaugenommen um ein Webprojekt, bei dem ich das Frontend eines Streaming-Services bastle (angelehnt an Netflix, Prime und Co.). Die dort enthaltenen Filme wären aber allesamt fiktiv. Wie auch bei den Frontends der Inspirationsquellen, wird es dann Cards mit den jeweiligen Film-Postern als Bild geben. Mit einem Klick auf die jeweilige Card gelangt man dann eben zu der Film-Seite selbst, die Namen, Beschreibung, Ursprungsländer, Beteiligte usw. enthält. Sämtliche die Filme betreffenden Inhalte würden zufällig über ein Python Skript oder im Falle der Bilder und Beschreibungen eben von KI (FLUX (evtl. SDXL für Schauspieler Portraits) für die Bilder und Mistral-7b für Beschreibungen) generiert werden. Die Datenbank (stand jetzt: lediglich zwei JSON-Dateien, die über Python ausgelesen werden) würde dann eben sämtliche Inhalte zu den jeweiligen fiktiven Filmen und Schauspielern enthalten, womit auch Suchen möglich wären. Außerdem soll es auch eine Schauspieler-Datenbank geben, in der diese dann auch alle in Form von Cards anklickbar wären, mit Infos wie den Filmen, in denen sie mitgespielt haben, Geburtsdatum und auch einer kleinen Beschreibung, die ebenfalls per KI-Generiert wäre. Ansehen kann man dann selbstverständlich keinen der Filme. Allerdings dachte ich mir, dass ich im späteren Verlauf dann auch einen kleinen Videoplayer basteln könnte, der beim Starten eines Filmes einfach eine Ladeanimation zeigt und nach einer Weile eine Fehlermeldung ala "Der abgerufene Film kann leider nicht gestartet werden (Fehlercode: xxxxx)" anzeigt. Das würde die Illusion ein wenig aufrecht erhalten.

Hosten würde ich die Seite dann wahrscheinlich nirgends, das Projekt aber dann auf Github anbieten, mitsamt Installationsanleitungen für Linux und Windows. Wer dann über die nötige Hardware verfügt, könnte dann eben zusätzlich neue Filme lokal generieren. Dies dann komplett zufallsbasiert oder aber mit eigenen Eingaben, was Genre, Titel, Mitwirkende und Co. angeht.

Genutzte Technologien:

- Python mit FastAPI und Uvicorn (Backend)

- VueJS (Frontend )

- ComfyUI mit selbst gebastelten Workflows (zur Verwendung der KI-Modelle - verfügbar auf Github)

- Flux1.dev GGUF (Bildgenerierung - verfügbar auf Huggingface)

- Mistral-7b (Textgenerierung - verfügbar auf Huggingface)

- Eine selbst trainierte LoRa (Zur Verbesserung der Ergebnisse beim Generieren der Film-Poster - dann verfügbar auf Huggingface)

Momentaner Status:

Die ComfyUI-Workflows sind schon fertig und das Generieren neuer Film-Einträge, der Beschreibungstexte und Film-Poster via API-Anfrage funktioniert bereits. Die dadurch erzeugten Bilder werden dann auch schon im richtigen Pfad mit der Film-ID im Namen abgespeichert und die Beschreibung und anderen Informationen in die Datenbank aufgenommen. Mit dem Frontend selbst habe ich auch bereits begonnen. Allerdings wollte ich mich vorerst auf das Trainieren einer LoRa konzentrieren. Mit den Ergebnissen von Flux (Standard und ohne LoRa) bin ich nicht besonders zufrieden. Hier finden sich nämlich häufig massenhaft Hieroglyphen-Texte im unteren oder oberen Bereich des Film-Posters, die wohl die Erwähnung der Mitwirkenden und Studios imitieren sollen, wie man sie häufig auf Werbe-Postern von Filmen findet. Das möchte ich aber nicht auf den Postern haben. Man sieht es bei den Cards auf Netflix und Co. schließlich auch nicht.

Nutzen und Gründe:

Einen Zweck hat das genaugenommen keinen. Ich sehe das eher als eine Art Kunstprojekt. Hiermit möchte ich mich dann eher kreativ ein wenig austoben und an meinen Fähigkeiten feilen.

Der Grund, warum ich das hier poste, hängt genaugenommen damit zusammen, dass ich (wie bereits in meiner Vorstellung erwähnt), ein wenig Probleme damit habe, bei einer Sache zu bleiben. Ich erhoffe mir durch das Teilen des Projektes, dass das so einen sanften Druck auf mich ausübt und ich dadurch dann eben dabei bleibe, statt im Affekt dann wieder etwas neues zu beginnen. Ob hier nun irgendwer auch nur die geringste Spur an Interesse ausdrückt, wird dabei keinen großen Unterschied machen. Hiermit habe ich es nämlich in die Welt gerufen und muss nun damit leben, dass das hier zu jeder Zeit jemand lesen könnte.

Das wäre es dann soweit.

Hallo zusammen,

ich bin 33 Jahre alt und beschäftige mich nun seit gut 5 Jahren halbwegs ernsthaft mit diversen Bereichen der IT. Gelernt habe ich einen Handwerksberuf, konnte mich aber nie so richtig damit identifizieren. Nachdem das Angebot an Online-Kursen mittlerweile (und eben auch schon vor 5 Jahren) lesefaulen wie mir (zumindest im Falle von Fachbüchern), nun auch die Möglichkeit gibt, in neue Themen einzusteigen, legte ich mir damals einen reduzierten Kurs zum Thema Webentwicklung zu. Um's kurz zu machen, der Kurs war nichts. Fertiggemacht habe ich diesen nie. Es folgten aber etliche andere Kurse auf verschiedenen Plattformen, die ich dann eben auch beendet habe. Zu den Themen, die mich am meisten interessieren, gehören: Python-Programmierung (weitestgehend Automatisierung, als Backend in Webprojekten und KI), Frontend-Webentwicklung (VanillaJS / Vue), Linux und Cybersecurity.

Meinen ersten Computer hatte ich damals mit 9 Jahren bekommen. Als Teenager dachte ich, ich würde mich wirklich gut mit Computern auskennen, da ich ja zumindest in der Lage war, mir so ein Ding selbst zusammenzubasteln und auch wusste, wie ich ein Videospiel mit Mods ausstatten konnte. Mittlerweile kann ich aber immerhin behaupten, genug zu Wissen, um mit Sicherheit sagen zu können, dass ich absolut keine Ahnung habe. Gerne beginne ich irgendwelche Projekte, von denen ich allerdings in den seltensten Fällen mal eines fertigmache und stattdessen wieder etwas neues beginne. Genauso schwierig ist es für mich, längere Zeit bei einem Thema zu bleiben. Ich bin so etwas wie ein Quell an gefährlichem Halbwissen. Trotzdem kann ich nicht aufhören, mich mit diesen Themen zu beschäftigen und empfinde den damaligen Kauf dieses Online-Kurses als eine der besten Entscheidungen, die ich jemals getroffen hatte. Hin und wieder lege ich zwar auch mal wochenlange Pausen ein, habe aber nun auch ein paar sinnvolle Hobbies, zu denen ich immer wieder zurückkehre.

Auf den Austausch hier freue ich mich jedenfalls sehr und wünsche allen einen schönen Morgen.