Autoren-Archiv: Johannes

Wie kann ich extrem schnell schöne Grafiken auf Basis eines Textes mit KI erstellen?

Ein hochgeschätzter Kunde / Kontakt kippte bei mir erst heute einen interessanten Fall ein. Der sieht so aus: „Lieber Johannes, ich habe hier einen Text mit technischen Inhalten und da brauche ich unbedingt / ganz schnell schöne Grafiken!“ + „Bitte besorge mir eine Lösung!“

Die Lösung ist simpel und die nennt sich „napkin.ai„. Hier besorgt man sich einen Account (via Google bspw.) und man wird direkt auf eine Fläche, die einen an WordPress erinnert, umgeleitet.

Codebeispiel: Auswertung extrem großer Dokumente.

Grobe Funktionsdarstellung:

  1. Dokument einlesen
  2. Inhalt(e) auswerten
  3. „Fragen“ an die Inhalte „stellen“ und geeignete Antworten identifizieren
  4. Reporting.

import fitz  # PyMuPDF
from transformers import pipeline, AutoModelForQuestionAnswering, AutoTokenizer
import re
import pandas as pd
from io import BytesIO

# Funktion zum Einlesen des Kontextes aus einer PDF-Datei
def read_text_from_pdf(file_path):
    document = http://fitz.open(file_path)
    pages = []
    for page_num, page in enumerate(document):
        text = page.get_text()
        pages.append((text, page_num + 1))  # Speichert den Text und die Seitennummer
    document.close()
    return pages

# Funktion zum Einlesen der Fragen aus einer Textdatei
def read_questions_from_file(file_path):
    with open(file_path, 'r', encoding='utf-8') as file:
        questions = file.readlines()
    return [question.strip() for question in questions]

# Funktion zur Bereinigung der Zahlenformatierung
def clean_number_format(text):
    # Entfernt Tausendertrennzeichen und stellt Dezimalpunkte sicher
    text = re.sub(r'(\d)(?=(\d{3})+(\.|\b))', r'\1.', text)  # Tausendertrennzeichen entfernen
    text = re.sub(r'(?<!\d)(\d+)(?=\.\d+)', r'\1.', text)  # Dezimalpunkt hinzufügen
    return text

# Funktion zum Finden des relevanten Textabschnitts
def find_relevant_text(context, answer_start, answer_end):
    # Finde die Textstelle um die Antwort herum
    context_len = len(context)
    start = max(answer_start - 100, 0)
    end = min(answer_end + 100, context_len)
    return context[start:end]

# Funktion zum Erstellen von Reports in verschiedenen Formaten
def generate_reports(answers, html_file, csv_file, xlsx_file):
    # Erstellen eines DataFrames für die Berichterstellung
    df = pd.DataFrame(answers, columns=["Frage", "Antwort", "Seite", "Score", "Textstelle"])

    # HTML-Bericht
    html_content = http://df.to_html(index=False, escape=False, formatters={'Textstelle': lambda x: x.replace('\n', '<br>')})

    # HTML-Kopf und -Fuß
    html_header = """
    <!DOCTYPE html>
    <html lang="de">
    <head>
        <meta charset="UTF-8">
        <meta name="viewport" content="width=device-width, initial-scale=1.0">
        <title>Frage-Antwort-Bericht</title>
        <style>
            body { font-family: Arial, sans-serif; margin: 20px; }
            h1 { color: #333; }
            table { width: 100%; border-collapse: collapse; margin-top: 20px; }
            th, td { padding: 12px; text-align: left; border-bottom: 1px solid #ddd; }
            th { background-color: #f4f4f4; }
            tr:hover { background-color: #f1f1f1; }
        </style>
    </head>
    <body>
        <h1>Frage-Antwort-Bericht</h1>
        <p>Erstellt am: {date}</p>
        <p>Bericht über Fragen und Antworten basierend auf dem bereitgestellten Kontext.</p>
    """.format(date=http://pd.Timestamp.now().strftime("%d.%m.%Y %H:%M:%S"))

    html_footer = """
    </body>
    </html>
    """

    full_html_content = html_header + html_content + html_footer

    with open(html_file, 'w', encoding='utf-8') as f:
        f.write(full_html_content)

    # CSV-Bericht
    http://df.to_csv(csv_file, index=False, encoding='utf-8')

    # XLSX-Bericht
    http://df.to_excel(xlsx_file, index=False, engine='openpyxl')

# Pfad zur Datei mit dem Kontext und zur Textdatei mit den Fragen
context_file = "module/content.pdf"  # Pfad zur PDF-Datei mit dem Kontext
questions_file = "module/fragen.txt"  # Pfad zur Datei mit den Fragen

# Pfade zu den Berichtdateien
html_file = "report.html"
csv_file = "report.csv"
xlsx_file = "report.xlsx"

# Laden des Modells und Tokenizers für deutsche Frage-Antwort-Aufgaben
model_name = "deepset/gelectra-base-germanquad"
model = AutoModelForQuestionAnswering.from_pretrained(model_name)
tokenizer = AutoTokenizer.from_pretrained(model_name)

# Erstellen der Frage-Antwort-Pipeline
nlp = pipeline("question-answering", model=model, tokenizer=tokenizer)

# Einlesen des Kontextes aus der PDF-Datei
contexts = read_text_from_pdf(context_file)

# Einlesen der Fragen
questions = read_questions_from_file(questions_file)

# Beantwortung der Fragen und Sammlung der Ergebnisse
answers = []

for question in questions:
    for context, page_num in contexts:
        cleaned_context = clean_number_format(context)  # Bereinigung des Kontextes
        result = nlp(question=question, context=cleaned_context, max_answer_len=100)
        
        if result['score'] > 0.5:  # Optional: Setze einen Schwellenwert für die Mindest-Score
            answer_start = result['start']
            answer_end = result['end']
            relevant_text = find_relevant_text(cleaned_context, answer_start, answer_end)
            answers.append((question, result['answer'], page_num, result['score'], relevant_text))

# Konsolenausgabe und Generierung der Berichte
for question in questions:
    answers_found = [a for a in answers if a[0] == question]

    if answers_found:
        print(f"Frage: {question}")
        for answer, page_num, score, relevant_text in answers_found:
            print(f"Antwort: {answer}")
            print(f"Seite: {page_num}")
            print(f"Score: {score:.2f}")
            print(f"Textstelle: {relevant_text}\n")
    else:
        print(f"Frage: {question}")
        print("Antwort: Keine Antwort gefunden\n")

# Generierung der Berichte
generate_reports(answers, html_file, csv_file, xlsx_file)

Quellcode: Zusammenführung von Videoschnipsel zu einem Gesamtvideo

Funktionen:

  1. Einlesen eines Ordners
  2. Einlesen der Dateinamen
  3. Zusammenführung der Dateien zu einem Gesamtvideo
  4. Einblendung von Untertitel, die sich aus den Datennamen (2) generieren.
import os
from moviepy.editor import VideoFileClip, concatenate_videoclips, CompositeVideoClip, ImageClip
from PIL import Image, ImageDraw, ImageFont

def create_text_clip(text, duration, fontsize=60, color='white'):
    # Erstelle ein leeres Bild mit transparentem Hintergrund
    img = Image.new('RGBA', (640, 100), (0, 0, 0, 0))  # Transparenter Hintergrund
    d = ImageDraw.Draw(img)
    
    # Schriftart laden
    try:
        font = ImageFont.truetype("Arial.ttf", fontsize)
    except IOError:
        font = ImageFont.load_default()

    # Berechne die Größe des Textes
    text_width, text_height = d.textbbox((0, 0), text, font=font)[2:]

    # Text in die Mitte zeichnen
    d.text(((640 - text_width) // 2, (100 - text_height) // 2), text, fill=color, font=font)

    # Speichere das Bild temporär
    img.save("temp_text_clip.png")
    
    # Erstelle einen VideoClip aus dem Bild
    return ImageClip("temp_text_clip.png").set_duration(duration).set_position(('left', 'bottom')).margin(left=10, bottom=10)

# Pfad zum Ordner mit den .mp4-Dateien
ordner_pfad = '_test'

# Liste zum Speichern der einzelnen Clips
clips = []

# Zähler für die Video-Nummerierung
video_counter = 1

# Durchlaufe alle Dateien im Ordner und Unterordnern
for root, dirs, files in os.walk(ordner_pfad):
    for datei_name in sorted(files):  # sortiert nach Dateinamen
        if datei_name.endswith(".mp4"):
            datei_pfad = os.path.join(root, datei_name)
            # VideoClip laden
            clip = VideoFileClip(datei_pfad)

            # Dateiname ohne .mp4 und Nummer hinzufügen
            titel_text = f"{video_counter}: {os.path.splitext(datei_name)[0]}"  # Zähler

            # TextClip für den Dateinamen als Untertitel erstellen
            text_clip = create_text_clip(titel_text, clip.duration)

            # Clip zur Liste hinzufügen
            video_mit_untertitel = CompositeVideoClip([clip, text_clip])
            clips.append(video_mit_untertitel)

            # Zähler erhöhen
            video_counter += 1

# Videos zusammenfügen
if clips:
    final_video = concatenate_videoclips(clips, method="compose")

    # Ausgabe-Datei speichern
    final_video_output = os.path.join(ordner_pfad, "zusammengefuegtes_video.mp4")
    final_video.write_videofile(final_video_output, codec="libx264", fps=24)

    print(f"Video erfolgreich erstellt: {final_video_output}")
else:
    print("Keine .mp4-Dateien gefunden.")

Kling-AI, der letzte Generator aus der Testreihe

Diese Plattform entdeckte ich eher zufällig in den Untiefen von X (Twitter). Beim Testen bespiele ich solche Systeme immer mit zufällig ausgewählten Motiven aus meinem Bestand (i.d.R. Analogscans).

Fazit zu diesem Generator. Im Vergleich zu den anderen Produkten, ist das System ziemlich schlecht. Ich sehe diverse Bugs und gerade die Darstellung von Händen muss zwingend notwendig sauber erfolgen. Sicherlich werde ich das System für kreativere Anwendungen verwenden, oder in die Beobachtung legen. Allerdings eher nicht im Livebetrieb für Marketingzwecke.

LumaLabs – ein Generalist für die Videogenerierung

Der erste Generator, der mir aufgefallen ist, ist LumaLabs. Im Grunde ist hier die Qualität wieder vom Ausgangsmaterial und / oder der Qualität der Arbeitsanweisung (Prompt) abhängig. Die Generierung der Videos kann extrem lang dauern und ich empfehle eine Einbindung und Verwendung, wenn eine Unterfütterung von SocialMedia-Accounts geht. Die Videos lassen sich verlängern und teilweise ist die „Storyline“ durchaus sehr gut.

Hier ein paar Beispiele:

Es sind die üblichen „Bugs“, wie Augen, erkennbar und die Grundlage für die 3 Proben sind hier Analog-Scans (Basis: Lith-Abzüge auf Orwo) und generierte Bilder (Stable Diffusion + Analoglora)

Experimente mit Vertonungen – Gesichtsanimationen

Ein interessantes Werkzeug für diesen „Case“ ist Hedra und diese Plattform ist in der Basis-Variante kostenfrei, erlaubt bis zu 30 Sekunden Vertonung. Es stehen einige Standardstimmen zur Auswahl (in dem Beispiel ist es die Charlotte) und es lässt sich auch etwas Eigenes via Mikro da einspielen. Die Qualität des Videos (Hinweise: Augen, Bewegungen, Mimik und Gestik) ist von Ausgangsmaterial abhängig. Je besser die Kontraste und die Auflösung ist, desto besser ist eben auch das Endresultat.

Bei dem Beispiel wählte ich eine virtuelle Person – generiert via StableDiffusion unter Einbindung eines unserer AnalogLoras.

Experimente mit der Simulation von Emotionen (KI)

Vor einigen Tagen triggerte mich eine große Debatte rund um einen sog. „KI-Influencer“ und das führte dazu, dass ich eine spezielle Testreihe mit „Hailou“ anlegte.

Schritt 1.) Einen Account auf der Plattform anlegen.

Schritt 2.) Ein gutes Foto (Portrait etc.) suchen und da hochladen.

Schritt 3.) Definieren von Prompts und Videogenerierung.

Beispiele:

„amorous facial expression, conversation“

„sad facial expression, conversation“

„frustrated facial expression, conversation“

Hinweise und Gedanken:

  1. Nimm extrem gute und kontrastreiche Fotos.
  2. Die Plattform erlaubt (derzeit) keine Erweiterung der Videos auf >5 Sekunden
  3. Die Performance / die Qualität ist definitiv abhängig von der Qualität der Fotos.
  4. Die Resultate zeigen die typischen „Bugs“ (Augenform und Hände).

Viel Spaß beim Experimentieren.

Frische SEO/Onlinemarketing-Referenz

Ausgangslage: verbrannte Domain -> kein klass. Blackhat, sondern Contentproblematik, Inhalt: ~80k Artikel rund um Wohnen, Deko etc.

Grobskizzierung der Strategie:
(Onpage)
(1) Contentproduktion mit Quelle GPT4All + Exotendatenmodell
(2) Manuelles Feintuning der Inhalte aus (1)
(3) Keywords / Themenrecherche ausschließlich über Instagram -> Fokus auf Comments

(Offpage)
(1) Bildproduktion via StableDiffusion unter Einbindung eigener Loras (Loratraining mit meinem Analogfotomaterial)
(2) Befüllen v. Pinterestaccounts, je Kategorie / Galerie mit max. 25% Verlinkung auf Seite
(3) Shares + Likes innerhalb der Pinterestaccounts
(4) Galeriegestaltung / Benennung nach Scrapen der „Suchvorschläge“, ausgelesen aus Pinterest
(5) Verlinkung der Accounturls in rotierende Blogrolls auf eigene „privat aussehende“ Blogs
(6) Punktuelles Weiterleiten v. Fotos aus Pinterestaccounts auf kleinere Twitter-Accounts, die NICHT in DE / DACH lokalisiert sind.
(7) Push auf Seite via eigene hochgezüchtete Instagram-Accounts (Bio u. teilw. Postings)

Fragen? Kontaktwunsch?