Let’s bauen wir ein Ein-Personen-Unternehmen mit 100% KI

Einleitung

Die Möglichkeiten, ein eigenes Unternehmen zu gründen, sind riesig und wachsen ständig. Wenn Sie über wertvolle Fähigkeiten verfügen, können Sie eine zahlende Zielgruppe anziehen und ein erfolgreiches Unternehmen in diesem expandierenden Markt aufbauen. Obwohl es auf dem Weg dorthin sicherlich Herausforderungen geben wird, sind die Hindernisse weniger schwierig als die, denen frühere Generationen gegenüberstanden.

Wir haben das Glück, Zugang zu vielen leistungsstarken Tools zu haben, von denen unsere Eltern nur träumen konnten. Neue Software und Plattformen erleichtern die Verteilung und Bereitstellung von Produkten/Dienstleistungen und automatisieren Aufgaben, die früher zeitaufwändig und mühsam waren. Sie können jetzt ganz einfach benutzerdefinierte KI-Assistenten erstellen, komplexe Arbeitsabläufe automatisieren und ganze E-Mail-Marketingkampagnen mit erstaunlicher Leichtigkeit durchführen.

Abbildung: Unser 1-Personen-Buchverlagshaus

Über diesen Artikel

In diesem Artikel wird die Idee untersucht, ein Ein-Personen-Unternehmen aufzubauen, das sich auf die Veröffentlichung von Büchern mit Hilfe von Künstlicher-Intelligenz- (KI-) Tools konzentriert. Der Artikel stellt einen Prozess vor, bei dem Benutzer strukturierte Daten und Informationen zu einem Thema eingeben können, und KI-Sprachmodelle eine umfassende Buchstruktur und -inhalt auf der Grundlage dieser Eingabe generieren. Der generierte Inhalt kann dann formatiert, gestaltet und digital oder gedruckt veröffentlicht werden, wobei der menschliche Aufwand minimal ist.

Der Artikel bietet eine detaillierte Aufschlüsselung des vorgeschlagenen Systems, einschließlich einer Python-Klasse namens Book, die die hierarchische Struktur eines Buches darstellt und dessen Inhalt verwaltet. Außerdem werden Funktionen zum Generieren der Buchstruktur und des Abschnittsinhalts mit KI-Sprachmodellen bereitgestellt. Der Artikel zeigt, wie die Book-Klasse und diese Funktionen in eine Streamlit-Anwendung integriert werden können, mit der Benutzer ein Thema eingeben, eine Buchstruktur und -inhalt generieren und das fertige Buch im Markdown-Format herunterladen können.

Warum sollten Sie diesen Artikel lesen?

Dieser Artikel ist aus mehreren Gründen lesenswert:

Erstens stellt er einen innovativen Ansatz für die Buchveröffentlichung vor, der die Leistungsfähigkeit von KI nutzt, um den Schreib- und Inhaltserstellungsprozess zu straffen. Dies könnte die Verlagsbranche potenziell revolutionieren, indem es für Einzelpersonen kostengünstiger und einfacher wird, hochwertige Publikationen zu erstellen und zu verbreiten.

Zweitens bietet der Artikel eine detaillierte technische Umsetzung mit Python und der Streamlit-Bibliothek. Er enthält Code und Erläuterungen zum Aufbau der Book-Klasse, der Generierung von Buchstrukturen und -inhalten mit KI-Sprachmodellen und der Erstellung einer Benutzeroberfläche für die Anwendung. Dieser Code kann Entwicklern, die an der Erstellung ähnlicher KI-gestützter Anwendungen interessiert sind, als wertvolle Referenz dienen.

Schließlich hebt der Artikel das Potenzial von KI bei der Automatisierung und Skalierung kreativer Aufgaben wie Schreiben und Inhaltserstellung hervor. Da sich die KI-Technologie weiterentwickelt, wird sie wahrscheinlich in verschiedenen Branchen eine immer bedeutendere Rolle spielen, und ein Verständnis ihrer Anwendungen und Grenzen wird entscheidend sein.

Wie man ein Ein-Personen-Unternehmen aufbaut

Bevor wir uns weiter mit dem Artikel befassen, möchte ich einige Gedanken darüber äußern, wie man ein Ein-Personen-Unternehmen aufbaut.

Denken Sie über Bereiche nach, in denen Sie ein erhebliches persönliches Wachstum erfahren haben, wie z. B. die Verwaltung von Finanzen oder die Verbesserung der Gesundheit. Es gab eine Zeit, in der diese Dinge unüberwindbar schienen, aber Sie haben durchgehalten, wirksame Strategien entdeckt und Ihr Leben positiv verändert. Was Ihnen jetzt leicht fällt, ist für andere möglicherweise immer noch eine große Herausforderung. Diese Personen, die derzeit mit den Hindernissen konfrontiert sind, die Sie einst überwunden haben, stellen Ihre ideale Kundenbasis dar. Sie verfügen über die Fähigkeiten und die widerstandsfähige Denkweise, um sie mit dem Wissen und den Tools, die Sie erworben haben, zu befähigen und ihnen zu ähnlichen Erfolgen zu verhelfen.

Abbildung: Unser 1-Personen-Unternehmen

Nutzen Sie Ihre hart erarbeitete Expertise, indem Sie ein Ein-Personen-Unternehmen aufbauen, das von KI angetrieben wird und diese kämpfenden Personen bedient. Verwenden Sie KI-Tools, um Inhalte zu erstellen, Prozesse zu automatisieren und Ihre Angebote effizient zu skalieren. Ihre Erfahrungen aus erster Hand ermöglichen es Ihnen, KI-Lösungen zu entwickeln, die auf ihre Bedürfnisse zugeschnitten sind, und ihr Wachstum zu beschleunigen. Gehen Sie dieses Unternehmen mit der von Ihnen entwickelten Widerstandsfähigkeit an und verändern Sie das Leben anderer, wie Sie einst Ihr eigenes verändert haben.

Aufbau eines Verlagsgeschäfts

Ein Verlagsgeschäft umfasst normalerweise die Recherche, das Schreiben, Bearbeiten, Gestalten und die Verbreitung verschiedener Arten von Inhalten wie Bücher, Zeitschriften, Zeitungen oder digitale Publikationen. Im Kern dreht sich ein Verlagsgeschäft um die Erstellung hochwertiger schriftlicher Inhalte, die informieren, bilden oder unterhalten.

Für unser Vorhaben können wir uns auf das Schreiben und Veröffentlichen kleiner Bücher mit Hilfe von KI-Tools konzentrieren. Wir können KI-Schreibassistenten nutzen, um erste Entwürfe, Gliederungen und Ideen für unsere Bücher zu verschiedenen Genres und Themen zu generieren. KI kann dazu beitragen, den Forschungs- und Schreibprozess zu rationalisieren, so dass wir Inhalte effizienter produzieren können. Zunächst müssen wir diese von KI generierten Bücher möglicherweise nicht verkaufen, aber wir können problemlos einen Vertriebskanal hinzufügen, wenn unser Unternehmen wächst.

Mit KI, die einen erheblichen Teil der Schreibarbeit übernimmt, können wir unsere Bemühungen auf das Bearbeiten, Formatieren und Vermarkten unserer Veröffentlichungen konzentrieren.

Zukünftige Arbeit

Wir können KI-gestützte Design-Tools nutzen, um professionell aussehende Buchcover und -layouts zu erstellen, die unsere Veröffentlichungen optisch ansprechend machen. Durch die Nutzung der Fähigkeiten der KI können wir potenziell eine hohe Menge an Inhalten produzieren, während wir die Qualität aufrechterhalten, was die Grundlage für ein erfolgreiches Verlagsgeschäft bildet.

Los geht’s!

Unser Geschäftsmodell sieht vor, dass KI automatisch Bücher mit minimalem menschlichem Aufwand erstellt. So funktioniert der Prozess:

Zunächst verfügen wir über ein System, das es Benutzern ermöglicht, strukturierte Daten und Informationen zu einem Thema einzugeben, für das sie ein Buch geschrieben haben möchten. Dazu kann die Erstellung von Kapitelüberschriften, die Bereitstellung von Schlüsselpunkten, Beispielen, Referenzen usw. gehören.

Sobald diese strukturierten Daten eingegeben wurden, speisen wir sie in fortschrittliche KI-Sprachmodelle ein, die darauf trainiert sind, diese strukturierten Daten in fließenden, kohärenten Buchinhalt umzuwandeln. Die KI schreibt automatisch die Kapitel, füllt Details aus, liefert Erklärungen und Beispiele, alles auf der Grundlage der ursprünglichen strukturierten Eingaben.

Unsere KI-Systeme sind darauf ausgelegt, in einem klaren, leicht verständlichen Stil zu schreiben, während gleichzeitig die technische Genauigkeit auf dem Thema gewährleistet ist. Wir können die KI auch in verschiedenen Schreibstilen, Genres oder Stimmen schulen, je nach den Vorlieben des Benutzers.

Minimaler menschlicher Aufwand ist erforderlich, über die Bereitstellung der ursprünglichen strukturierten Daten hinaus. Wir werden jedoch menschliche Redakteure haben, die den von der KI generierten Inhalt überprüfen und verfeinern können, wenn gewünscht, bevor er veröffentlicht wird.

Sobald der Buchinhalt fertiggestellt ist, kümmern sich unsere Systeme automatisch um die Formatierung, das Layout-Design, die Cover-Erstellung und die Veröffentlichung in digitalen und gedruckten Formaten. (Dies ist außerhalb des Umfangs dieses Artikels, aber Sie können sich vorstellen, dass dies einfach umgesetzt werden kann: Benutzer können die professionell gebundenen Bücher oder E-Books über unsere Plattform kaufen.)

Im Wesentlichen werden unsere KI-Systeme als „Buchschreibmaschine“ fungieren, die einfache Dateneingaben in komplette, buchhandlungstaugliche Bücher in einer hocheffizienten und kostengünstigen Weise im Vergleich zu traditionellen Veröffentlichungsmethoden umwandelt.

Buchmodul

Klasseninitialisierung

class Book:
    """
    Eine Klasse, die eine Buchstruktur darstellt und deren Inhalte verwaltet.
    """
    def __init__(self, structure):
        """
        Initialisiert das Buch mit einer gegebenen Struktur.
        """
        self.structure = structure
        self.contents = {title: "" for title in self.flatten_structure(structure)}
        self.placeholders = {title: st.empty() for title in self.flatten_structure(structure)}
        st.markdown("## Arbeiten...")
        toc_columns = st.columns(4)
        self.display_toc(self.structure, toc_columns)
        st.markdown("---")

Hier habe ich eine Klasse mit dem Namen Book definiert, die ein Buch mit einer hierarchischen Struktur darstellt. Die Klasse verfügt über eine Dokumentationszeichenkette, die erläutert, was die Klasse tut und welche Attribute und Methoden sie hat.

In der __init__-Methode, die der Konstruktor für die Klasse ist, richte ich die Anfangsattribute für das Book-Objjekt ein. Der structure-Parameter ist ein Wörterbuch, das die hierarchische Struktur des Buches darstellt.

Ich erstelle ein contents-Wörterbuch, um den Inhalt für jeden Abschnittstitel zu speichern. Ich erstelle auch ein placeholders-Wörterbuch, um die Streamlit-Placeholder für jeden Abschnittstitel zu halten. Diese Placeholder werden verwendet, um den Inhalt in der Streamlit-App anzuzeigen.

Ich zeige dann eine Nachricht „Arbeiten…“ in Streamlit an und erstelle vier Spalten, um das Inhaltsverzeichnis für das Buch anzuzeigen.

Flache Struktur-Methode

def flatten_structure(self, structure):
    """
    Verflacht eine geschachtelte Wörterbuchstruktur in eine Liste von Schlüsseln.
    Parameter
    ----------
    structure : dict
        Ein Wörterbuch, das die hierarchische Struktur des Buches darstellelt
    Returns
    -------
    list
        Eine Liste von Schlüsseln, die alle Abschnittstitel in der Struktur darstellen
    """
    sections = []
    for title, content in structure.items():
        sections.append(title)
        if isinstance(content, dict):
            sections.extend(self.flatten_structure(content))
    return sections

Die flatten_structure-Methode nimmt eine geschachtelte Wörterbuchstruktur und verflacht sie in eine Liste von Schlüsseln. Dies ist nützlich, da die Buchstruktur als geschachteltes Wörterbuch dargestellt wird, aber ich eine Liste aller Abschnittstitel benötige, um die contents und placeholders-Wörterbücher zu erstellen.

Aktualisieren Sie die Inhaltsmethode

def update_content(self, title, new_content):
    """
    Aktualisiert den Inhalt für einen gegebenen Titel mit neuem Inhalt.
    Parameter
    ----------
    title : str
        Der Titel des Abschnitts, der aktualisiert werden soll
    new_content : str
        Der neue Inhalt, der dem Abschnitt hinzugefügt werden soll
    Raises
    ------
    TypeError
        Wenn der Titel kein gültiger Zeichenfolgentyp ist oder wenn new_content kein Zeichenfolgentyp ist
    """
    try:
        self.contents[title] += new_content
        self.display_content(title)
    except TypeError as e:
        pass

Die update_content-Methode ermöglicht es mir, den Inhalt für einen gegebenen Abschnittstitel mit neuem Inhalt zu aktualisieren. Sie fügt zunächst den neuen Inhalt zum vorhandenen Inhalt in dem contents-Wörterbuch hinzu. Dann ruft sie die display_content-Methode auf, um den aktualisierten Inhalt in der Streamlit-App anzuzeigen.

Inhaltsanzeigemethode

def display_content(self, title):
    """
    Zeigt den Inhalt eines gegebenen Titels mit Streamlit an.
    Parameter
    ----------
    title : str
        Der Titel des Abschnitts, der angezeigt werden soll
    """
    if self.contents[title].strip():
        self.placeholders[title].markdown(f"## {title}\n{self.contents[title]}")

Die display_content-Methode zeigt den Inhalt eines gegebenen Abschnittstitels mit Streamlit an. Sie überprüft, ob es für diesen Titel einen Inhalt in dem contents-Wörterbuch gibt. Wenn es Inhalt gibt, verwendet sie den entsprechenden Platzhalter in dem placeholders-Wörterbuch, um den Inhalt als Markdown-Zeichenkette anzuzeigen.

Strukturanzeigemethode

def display_structure(self, structure=None, level=1):
    """
    Zeigt rekursiv die Struktur und den Inhalt des Buches mit Streamlit an.
    Parameter
    ----------
    structure : dict, optional
        Ein Wörterbuch, das die hierarchische Struktur des Buches darstellt (Standard ist None)
    level : int, optional
        Die aktuelle Ebene der Tiefe in der Struktur (Standard ist 1)
    """
    if structure is None:
        structure = self.structure
    for title, content in structure.items():
        if self.contents[title].strip():  # Zeige den Titel nur an, wenn es Inhalt gibt
            st.markdown(f"{'#' * level} {title}")
            self.placeholders[title].markdown(self.contents[title])
        if isinstance(content, dict):
            self.display_structure(content, level + 1)

Ich habe diese display_structure-Methode erstellt, um rekursiv die Struktur und den Inhalt des Buches mit Streamlit anzuzeigen. Sie nimmt zwei Parameter: structure (ein optionales Wörterbuch, das die hierarchische Struktur des Buches darstellt, mit dem Standardwert None) und level (eine ganze Zahl, die die aktuelle Ebene der Tiefe in der Struktur darstellt, mit dem Standardwert 1).

if structure is None:
    structure = self.structure

Zunächst überprüfe ich, ob der structure-Parameter None ist. Wenn ja, weise ich structure dem self.structure-Attribut zu, das die Hauptbuchstruktur darstellt.

for title, content in structure.items():
    if self.contents[title].strip():  # Zeige den Titel nur an, wenn es Inhalt gibt
        st.markdown(f"{'#' * level} {title}")
        self.placeholders[title].markdown(self.contents[title])
    if isinstance(content, dict):
        self.display_structure(content, level + 1)

Dann durchlaufe ich jedes title und content-Paar in dem structure-Wörterbuch. Ich überprüfe, ob es für den aktuellen title irgendwelchen Inhalt in dem contents-Wörterbuch gibt (mit der strip()-Methode, um alle führenden/nachfolgenden Leerzeichen zu entfernen). Wenn es Inhalt gibt, zeige ich den Titel als Markdown-Überschrift mit der st.markdown()-Methode an, wobei die Anzahl der #-Symbole der level-Tiefe entspricht. Ich verwende auch den entsprechenden Platzhalter aus dem placeholders-Wörterbuch, um den Inhalt als Markdown anzuzeigen.

Wenn der content für den aktuellen title ein Wörterbuch ist (was bedeutet, dass es geschachtelte Abschnitte gibt), rufe ich die display_structure-Methode rekursiv mit dem geschachtelten content-Wörterbuch und einer um 1 erhöhten level auf.

Inhaltsverzeichnis-Anzeigemethode

def display_toc(self, structure, columns, level=1, col_index=0):
    """
    Zeigt das Inhaltsverzeichnis des Buches mit Streamlit-Spalten an.
    Parameter
    ----------
    structure : dict
        Ein Wörterbuch, das die hierarchische Struktur des Buches darstellt
    columns : list
        Eine Liste von Streamlit-Spalten zum Anzeigen des Inhaltsverzeichnisses
    level : int, optional
        Die aktuelle Ebene der Tiefe in der Struktur (Standard ist 1)
    col_index : int, optional
        Der aktuelle Spaltenindex für das Inhaltsverzeichnis (Standard ist 0)
    Returns
    -------
    int
        Der aktualisierte Spaltenindex nach der Verarbeitung der Struktur
    """
    for title, content in structure.items():
        with columns[col_index % len(columns)]:
            st.markdown(f"{' ' * (level - 1) * 2}- {title}")
        col_index += 1
        if isinstance(content, dict):
            col_index = self.display_toc(content, columns, level + 1, col_index)
    return col_index

Die display_toc-Methode wird verwendet, um das Inhaltsverzeichnis des Buches mit Streamlit-Spalten anzuzeigen. Sie nimmt vier Parameter: structure (das Wörterbuch, das die hierarchische Struktur des Buches darstellt), columns (eine Liste von Streamlit-Spalten, die zum Anzeigen des Inhaltsverzeichnisses verwendet werden), level (eine optionale ganze Zahl, die die aktuelle Ebene der Tiefe in der Struktur darstellt, mit dem Standardwert 1) und col_index (eine optionale ganze Zahl, die den aktuellen Spaltenindex für das Inhaltsverzeichnis darstellt, mit dem Standardwert 0).

In der Methode durchlaufe ich jedes title und content-Paar in dem structure-Wörterbuch. Ich verwende die with-Anweisung und die columns-Liste, um den aktuellen title in der entsprechenden Spalte anzuzeigen, wobei die Einrückung auf der level-Tiefe basiert.

Wenn der content für den aktuellen title ein Wörterbuch ist (was bedeutet, dass es geschachtelte Abschnitte gibt), rufe ich die display_toc-Methode rekursiv mit dem geschachtelten content-Wörterbuch, einer um 1 erhöhten level und dem aktualisierten col_index auf.

Die Methode gibt den endgültigen col_index zurück, nachdem die gesamte Struktur verarbeitet wurde.

Ich habe diese Methode aufgenommen, weil ich ein Inhaltsverzeichnis für das Buch bereitstellen wollte, das in Spalten angezeigt wird, mit geschachtelten Abschnitten, die entsprechend eingerückt sind.

Markdown-Inhalts-Methode

def get_markdown_content(self, structure=None, level=1):
    """
    Gibt den gesamten Inhalt des Buches im Markdown-Format zurück.
    Parameter
    ----------
    structure : dict, optional
        Ein Wörterbuch, das die hierarchische Struktur des Buches darstellt (Standard ist None)
    level : int, optional
        Die aktuelle Ebene der Tiefe in der Struktur (Standard ist 1)
    Returns
    -------
    str
        Die Markdown-formatierte Zeichenkette des Buchinhalts
    """
    if structure is None:
        structure = self.structure
    markdown_content = ""
    for title, content in structure.items():
        if self.contents[title].strip():  # Füge den Titel nur ein, wenn es Inhalt gibt
            markdown_content += f"{'#' * level} {title}\n{self.contents[title]\n\n"}
        if isinstance(content, dict):
            markdown_content += self.get_markdown_content(content, level + 1)
    return markdown_content

Die get_markdown_content-Methode gibt den gesamten Inhalt des Buches im Markdown-Format zurück. Sie nimmt zwei Parameter: structure (ein optionales Wörterbuch, das die hierarchische Struktur des Buches darstellt, mit dem Standardwert None) und level (eine optionale ganze Zahl, die die aktuelle Ebene der Tiefe in der Struktur darstellt, mit dem Standardwert 1).

In der Methode initialisiere ich eine leere Zeichenkette markdown_content, um den Markdown-Inhalt zu speichern.

Ich durchlaufe dann jedes title und content-Paar in dem structure-Wörterbuch. Wenn es für den aktuellen title Inhalt in dem contents-Wörterbuch gibt (mit der strip()-Methode, um alle führenden/nachfolgenden Leerzeichen zu entfernen), füge ich den Titel als Markdown-Überschrift (mit der Anzahl der #-Symbole, die der level-Tiefe entspricht) und den Inhalt zu der markdown_content-Zeichenkette hinzu.

Wenn der content für den aktuellen title ein Wörterbuch ist (was bedeutet, dass es geschachtelte Abschnitte gibt), rufe ich die get_markdown_content-Methode rekursiv mit dem geschachtelten content-Wörterbuch und einer um 1 erhöhten level auf und füge den zurückgegebenen Markdown-Inhalt zu der markdown_content-Zeichenkette hinzu.

Schließlich gibt die Methode die markdown_content-Zeichenkette zurück.

Ich habe diese Methoden aufgenommen, weil ich eine Book-Klasse erstellen wollte, die eine Buchstruktur mit hierarchischen Abschnitten darstellt und es ermöglicht, den Inhalt jedes Abschnitts in einer Streamlit-App zu aktualisieren und anzuzeigen.

Generierungsmodul

generate_book_structure

Ich habe eine Funktion mit dem Namen generate_book_structure erstellt, die eine Zeichenfolge als Eingabe nimmt. Diese Funktion ist dafür verantwortlich, die hierarchische Struktur eines Buches auf der Grundlage der gegebenen Eingabe zu generieren.

def generate_book_structure(prompt: str):
    completion = st.session_state.groq.chat.completions.create(
        model="llama3-70b-8192",
        messages=[
            {"role": "system", "content": "Write in JSON format:\n\n{\"Title of section goes here\":\"Description of section goes here\",\n\"Title of section goes here\":{\"Title of section goes here\":\"Description of section goes here\",\"Title of section goes here\":\"Description of section goes here\",\"Title of section goes here\":\"Description of section goes here\"}}"},
            {"role": "user", "content": f"Write a comprehensive structure, omitting introduction and conclusion sections (forward, author's note, summary), for a long (>300 page) book on the following subject:\n\n<subject>{prompt}</subject>"}
        ],
        temperature=0.3,
        max_tokens=8000,
        top_p=1,
        stream=False,
        response_format={"type": "json_object"},
        stop=None,
    )
    return completion.choices[0].message.content

Hier ist die Erklärung des Codes in einfachen Worten, als ob ich ihn selbst geschrieben hätte.

Ich habe eine Funktion mit dem Namen generate_book_structure erstellt, die eine Zeichenfolge als Eingabe nimmt. Diese Funktion ist dafür verantwortlich, die hierarchische Struktur eines Buches auf der Grundlage der gegebenen Eingabe zu generieren.

completion = st.session_state.groq.chat.completions.create(
    model="llama3-70b-8192",
    messages=[
        {"role": "system", "content": "Write in JSON format:\n\n{\"Title of section goes here\":\"Description of section goes here\",\n\"Title of section goes here\":{\"Title of section goes here\":\"Description of section goes here\",\"Title of section goes here\":\"Description of section goes here\",\"Title of section goes here\":\"Description of section goes here\"}}"},
        {"role": "user", "content": f"Write a comprehensive structure, omitting introduction and conclusion sections (forward, author's note, summary), for a long (>300 page) book on the following subject:\n\n<subject>{prompt}</subject>"}
    ],
    temperature=0.3,
    max_tokens=8000,
    top_p=1,
    stream=False,
    response_format={"type": "json_object"},
    stop=None,
)

In der Funktion verwende ich die st.session_state.groq.chat.completions.create-Methode, um eine Fertigstellung auf der Grundlage der gegebenen Eingabe zu generieren. Diese Methode wird wahrscheinlich von der Streamlit-Bibliothek oder einer externen Bibliothek bereitgestellt.

Ich gebe den model-Parameter als "llama3-70b-8192" an, was der Name des Sprachmodells ist, das ich zur Generierung der Buchstruktur verwenden möchte.

Der messages-Parameter ist eine Liste von Wörterbüchern, wobei jedes Wörterbuch eine Nachricht in der Konversation darstellt. Die erste Nachricht ist eine Systemnachricht, die Anweisungen an das Modell gibt, die Struktur im JSON-Format zu generieren. Die zweite Nachricht ist eine Benutzernachricht, die das Modell auffordert, eine umfassende Struktur für ein langes Buch (über 300 Seiten) zu einem gegebenen Thema zu generieren, wobei die Einleitungs- und Schlussabschnitte (Vorwort, Autorenhinweis, Zusammenfassung) ausgelassen werden.

Ich setze den temperature-Parameter auf 0,3, was die Zufälligkeit der generierten Ausgabe steuert. Ein niedrigerer Temperaturwert macht die Ausgabe deterministischer, während ein höherer Wert sie zufälliger macht.

Der max_tokens-Parameter ist auf 8000 gesetzt, was die maximale Anzahl von Token (Wörtern oder Teilwörtern) angibt, die das Modell generieren kann.

Der top_p-Parameter ist auf 1 gesetzt, was bedeutet, dass das Modell die obersten 1 % der wahrscheinlichsten Token bei der Generierung der Ausgabe berücksichtigen wird.

Der stream-Parameter ist auf False gesetzt, was bedeutet, dass das Modell die gesamte Ausgabe auf einmal generiert, anstatt sie in Stücken zu streamen.

Der response_format-Parameter ist auf {"type": "json_object"} gesetzt, was angibt, dass das Modell die Ausgabe als JSON-Objekt zurückgeben soll.

Schließlich ist der stop-Parameter auf None gesetzt, was bedeutet, dass das Modell die Generierung der Ausgabe fortsetzt, bis es die max_tokens-Grenze erreicht oder ein End-of-Sequence-Token stößt.

return completion.choices[0].message.content

Nach der Generierung der Fertigstellung gebe ich den Inhalt der ersten Wahlmöglichkeit der Nachricht zurück, der die generierte Buchstruktur im JSON-Format sein sollte.

Ich habe diese Funktion aufgenommen, weil ich eine umfassende Struktur für ein langes Buch zu einem gegebenen Thema generieren wollte, unter Verwendung eines Sprachmodells. Die JSON-Formatierung erleichtert das Parsen und Arbeiten mit der generierten Struktur.

generate_section

Ich habe eine weitere Funktion mit dem Namen generate_section erstellt, die eine Zeichenfolge als Eingabe nimmt. Diese Funktion ist dafür verantwortlich, den Inhalt eines bestimmten Abschnitts innerhalb der Buchstruktur zu generieren.

def generate_section(prompt: str):
    stream = st.session_state.groq.chat.completions.create(
        model="llama3-8b-8192",
        messages=[
            {"role": "system", "content": "You are an expert writer. Generate a long, comprehensive, structured chapter for the section provided."},
            {"role": "user", "content": f"Generate a long, comprehensive, structured chapter for the following section:\n\n<section_title>{prompt}</section_title>"}
        ],
        temperature=0.3,
        max_tokens=8000,
        top_p=1,
        stream=True,
        stop=None,
    )
    for chunk in stream:
        tokens = chunk.choices[0].delta.content
        if tokens:
            yield tokens

Hier ist die Erklärung des Codes in einfachen Worten, als ob ich ihn selbst geschrieben hätte.

Ich habe eine weitere Funktion mit dem Namen generate_section erstellt, die eine Zeichenfolge als Eingabe nimmt. Diese Funktion ist dafür verantwortlich, den Inhalt eines bestimmten Abschnitts innerhalb der Buchstruktur zu generieren.

stream = st.session_state.groq.chat.completions.create(
    model="llama3-8b-8192",
    messages=[
        {"role": "system", "content": "You are an expert writer. Generate a long, comprehensive, structured chapter for the section provided."},
        {"role": "user", "content": f"Generate a long, comprehensive, structured chapter for the following section:\n\n<section_title>{prompt}</section_title>"}
    ],
    temperature=0.3,
    max_tokens=8000,
    top_p=1,
    stream=True,
    stop=None,
)

In der Funktion verwende ich die st.session_state.groq.chat.completions.create-Methode erneut, diesmal jedoch mit anderen Parametern.

Ich gebe den model-Parameter als "llama3-8b-8192" an, was ein anderes Sprachmodell als das für die Generierung der Buchstruktur verwendete ist.

Der messages-Parameter ist eine weitere Liste von Wörterbüchern. Die erste Nachricht ist eine Systemnachricht, die das Modell auffordert, ein Experte für das Schreiben zu sein und einen langen, umfassenden, strukturierten Abschnitt für den bereitgestellten Abschnitt zu generieren. Die zweite Nachricht ist eine Benutzernachricht, die den Abschnittstitel in HTML-Tags eingeschlossen bereitstellt.

Die temperature, max_tokens und top_p-Parameter sind auf die gleichen Werte wie zuvor eingestellt.

Der stream-Parameter ist jedoch auf True gesetzt, was bedeutet, dass das Modell die Ausgabe in einem Streaming-Format generiert, so dass ich die Ausgabe verarbeiten kann, wenn sie hereinkommt.

for chunk in stream:
    tokens = chunk.choices[0].delta.content
    if tokens:
        yield tokens

Ich verwende eine for-Schleife, um über die Streaming-Ausgabe zu iterieren. Für jedes chunk in dem Stream extrahiere ich den Inhalt der ersten Wahlmöglichkeit des Deltas (der neu generierten Token in diesem chunk) und weise ihn der tokens-Variable zu.

Wenn es tokens gibt, verwende ich das yield-Schlüsselwort, um diese tokens zurückzugeben. Das yield-Schlüsselwort wird in Python-Generatoren verwendet, die es ermöglichen, Werte einzeln zu generieren und zurückzugeben, anstatt die gesamte Ausgabe auf einmal zu generieren und zurückzugeben.

Ich habe diese Funktion aufgenommen, weil ich den Inhalt für einen bestimmten Abschnitt des Buches generieren wollte, unter Verwendung eines anderen Sprachmodells als dem für die Generierung der Buchstruktur verwendeten. Durch die Verwendung eines Streaming-Ansatzes kann ich die generierte Ausgabe verarbeiten, wenn sie hereinkommt, anstatt darauf zu warten, dass die gesamte Ausgabe generiert wird.

Hauptmodul

Initialisierung und Einrichtung der Umgebung

Ich musste die API-Schlüssel für den Groq-Dienst aus einer Umgebungsdatei mit der load_dotenv()-Funktion laden. Ich habe dann den API-Schlüssel aus den Umgebungsvariablen mit os.environ.get("GROQ_API_KEY") abgerufen und in der GROQ_API_KEY-Variable gespeichert.

Ich habe diesen API-Schlüssel in dem Streamlit-Sitzungszustand unter st.session_state.api_key gesetzt. Schließlich habe ich eine Instanz der Groq-Klasse erstellt und in st.session_state.groq gespeichert, um den Groq-Dienst im gesamten Anwendungsfall zu nutzen.

Sitzungszustandsinitialisierung

# Initialisiere Sitzungszustandsvariablen, wenn sie nicht existieren
if 'button_disabled' not in st.session_state:
    st.session_state.button_disabled = False
if 'button_text' not in st.session_state:
    st.session_state.button_text = "Generate Book"

Ich wollte verfolgen, ob die Schaltfläche „Generate Book“ deaktiviert ist oder nicht, und welcher Text auf der Schaltfläche angezeigt wird. Ich habe überprüft, ob die button_disabled und button_text-Schlüssel im Streamlit-Sitzungszustand vorhanden sind. Wenn nicht, habe ich button_disabled auf False (was bedeutet, dass die Schaltfläche zunächst aktiviert ist) und button_text auf „Generate Book“ gesetzt.

def disable():
    st.session_state.button_disabled = True
def enable():
    st.session_state.button_disabled = False
def empty_st():
    st.empty()

Ich habe drei Hilfsfunktionen definiert: disable(), um button_disabled auf True (was die Schaltfläche deaktiviert) zu setzen, enable(), um button_disabled auf False (was die Schaltfläche aktiviert) zu setzen, und empty_st(), die eine leere Streamlit-Komponente erstellt (ich bin mir nicht sicher, warum ich diese Funktion aufgenommen habe).

st.markdown("""
    <style>
        ...
    </style>
""", unsafe_allow_html=True)

Hier habe ich st.markdown() mit dem unsafe_allow_html=True-Parameter verwendet, um benutzerdefinierte CSS-Stile in die Streamlit-App einzufügen. Diese Stile definieren das Aussehen und die Haptik der Anwendung, einschließlich Schriftart, Hintergrundfarben, Schaltflächenstile und Layout.

try:
    with st.form("groqform"):
        ...

Ich habe einen try-Block begonnen, um alle Ausnahmen zu fangen, die während der Ausführung des Codes auftreten können. Innerhalb des try-Blocks habe ich ein Streamlit-Formular mit dem Schlüssel „groqform“ erstellt.

submitted = st.form_submit_button(st.session_state.button_text, on_click=disable,
                                  disabled=st.session_state.button_disabled)

Ich habe eine Formular-Submit-Schaltfläche mit st.form_submit_button() erstellt. Der Schaltflächentext ist auf den Wert von st.session_state.button_text gesetzt. Wenn die Schaltfläche geklickt wird, wird die disable()-Funktion aufgerufen, um die Schaltfläche zu deaktivieren. Der disabled-Parameter ist auf den Wert von st.session_state.button_disabled gesetzt, der bestimmt, ob die Schaltfläche zunächst deaktiviert ist oder nicht.

if submitted:
    if len(topic_text) < 15:
        raise ValueError("Book topic must be at least 15 characters long")
    st.session_state.button_disabled = True
    if not GROQ_API_KEY:
        st.session_state.groq = Groq(api_key=groq_input_key)
    book_structure = generate_book_structure(topic_text)

Wenn das Formular übermittelt wird (d.h. der Benutzer klickt auf die Schaltfläche „Generate Book“), überprüfe ich zunächst, ob die Länge von topic_text kleiner als 15 Zeichen ist. Wenn ja, wird eine ValueError mit der Meldung „Book topic must be at least 15 characters long“ ausgelöst.

Dann deaktiviere ich die Schaltfläche, indem ich st.session_state.button_disabled auf True setze.

Ich überprüfe, ob GROQ_API_KEY nicht gesetzt ist. Wenn es nicht gesetzt ist, erstelle ich eine neue Instanz der Groq-Klasse mit dem groq_input_key (ich bin mir nicht sicher, wo diese Variable definiert ist).

Schließlich rufe ich die generate_book_structure()-Funktion mit dem topic_text als Eingabe auf und speichere das Ergebnis in der book_structure-Variable.

try:
    book_structure_json = json.loads(book_structure)
    book = Book(book_structure_json)
    if 'book' not in st.session_state:
        st.session_state.book = book
    print(json.dumps(book_structure_json, indent=2))
    st.session_state.book.display_structure()
    def stream_section_content(sections):
        ...
    stream_section_content(book_structure_json)
except json.JSONDecodeError:
    st.error("Failed to decode the book structure. Please try again.")

Ich versuche, die book_structure als JSON-Objekt mit json.loads() zu laden und in der book_structure_json-Variable zu speichern. Ich erstelle dann eine Instanz der Book-Klasse mit der book_structure_json als Eingabe.

Ich überprüfe, ob der 'book'-Schlüssel nicht im Streamlit-Sitzungszustand vorhanden ist. Wenn nicht, füge ich die book-Instanz dem Sitzungszustand unter st.session_state.book hinzu.

Ich drucke die book_structure_json mit der richtigen Einrückung für Debugging-Zwecke aus.

Ich rufe die display_structure()-Methode für die book-Instanz auf, um die Buchstruktur in der Streamlit-App anzuzeigen.

Ich definiere eine Funktion stream_section_content() (die ich noch nicht erklärt habe) und rufe sie mit der book_structure_json als Eingabe auf.

Wenn ein json.JSONDecodeError-Fehler auftritt, zeige ich eine Fehlermeldung in der Streamlit-App mit st.error() an.

if st.button('Download Your Book'):
    if "book" in st.session_state:
        markdown_file = create_markdown_file(st.session_state.book.get_markdown_content())
        st.download_button(
            label='Confirm Download',
            data=markdown_file,
            file_name='generated_book.txt',
            mime='text/plain',
        )
    else:
        raise ValueError("Your Download will be available once you generate Book.")

Ich erstelle eine Schaltfläche mit der Beschriftung „Download Your Book“ mit st.button(). Wenn der Benutzer auf diese Schaltfläche klickt, überprüfe ich zunächst, ob der 'book'-Schlüssel im Streamlit-Sitzungszustand vorhanden ist.

Wenn der 'book'-Schlüssel vorhanden ist, rufe ich die create_markdown_file()-Funktion (die ich noch nicht erklärt habe) mit st.session_state.book.get_markdown_content() als Eingabe auf und speichere das Ergebnis in der markdown_file-Variable.

Dann erstelle ich eine Download-Schaltfläche mit der Beschriftung „Confirm Download“ mit st.download_button(). Die data-Parameter ist auf markdown_file, die file_name-Parameter ist auf 'generated_book.txt' und die mime-Parameter ist auf 'text/plain' gesetzt.

Wenn der 'book'-Schlüssel nicht im Sitzungszustand vorhanden ist, wird eine ValueError mit der Meldung „Your Download will be available once you generate Book.“ ausgelöst.

Let’s Setup

Abbildung: Unser 1-Personen-Geschäftssetup

Abbildung: Unsere 1-Personen-Geschäftsanwendung

Stellen Sie sich vor, dass Sie diese Arbeit erledigt haben und den Dienst auf einer Cloud-Plattform bereitgestellt haben und die Benutzeroberfläche für Ihre Kunden verfügbar gemacht haben. Sie berechnen Ihre Kunden auf der Grundlage der Anzahl der Bücher, die sie generieren.

Angenommen, ein Kunde möchte ein Buch über „Data Engineering“ für sein Selbststudium oder für eine akademische Arbeit erstellen, oder ein Student benötigt es, um seine Hausaufgaben zu erledigen. Die Schritte wären wie folgt:

1. Der Kunde meldet sich auf Ihrer Website an.
2. Der Kunde gibt die Aufforderung ein, „ein Buch über ‚Data Engineering‘ zu schreiben“.
3. Und…

Abbildung: Unser 1-Personen-Buchverlagshaus

4. Am Ende kann der Kunde auf „Download“ klicken und sein Buch im Markdown-Format erhalten.

Zukünftige Arbeit

• Wir können verschiedene Angebote wie 10, 20, 50, 100 Seiten Bücher hinzufügen.
• Wir können ein Authentifizierungsmechanismus hinzufügen.
• Wir können Downloads in verschiedenen Formaten anbieten usw.

Abschließende Gedanken

Sie wissen, ich denke wirklich, dass diese Idee, mit KI zu helfen, dass normale Leute wie Sie und ich ihre eigenen Bücher schreiben und veröffentlichen können, ziemlich cool ist. Ich weiß, dass das Schreiben eines ganzen Buches wie eine unmögliche Aufgabe erscheinen mag, vor allem, wenn man nur eine Einzelperson mit einem Vollzeitjob oder anderen Verpflichtungen ist. Aber mit KI-Technologie, die heutzutage so weit fortgeschritten ist, können wir tatsächlich die KI einen Großteil der schweren Arbeit für uns erledigen lassen, wenn es darum geht, das Buch zusammenzustellen.

So wie ich es sehe, ist der schwierigste Teil, die Fachkenntnisse oder persönlichen Erfahrungen zu haben, die es wert sind, mit anderen geteilt zu werden. Wenn Sie bereits große Lebensherausforderungen gemeistert haben – wie z.B. Ihre Finanzen in den Griff zu bekommen oder Ihre Gesundheit zu verbessern – und dabei stärker geworden sind, haben Sie wertvolle Fähigkeiten und eine widerstandsfähige Denkweise, die Menschen, die heute mit denselben Problemen konfrontiert sind, wirklich helfen können. Mit diesem System können Sie Ihr hart erarbeitetes Wissen und Ihre Erfahrungen nehmen, es mit der Rechenleistung der KI kombinieren und in ein professionell gestaltetes Buch verwandeln, das andere auf ihrem Weg leitet.

Natürlich müssen Sie immer noch die Aufsicht über die KI führen und einige Bearbeitungen vornehmen, um sicherzustellen, dass das Buch gut lesbar ist. Aber die KI kann alle langweiligen und zeitaufwändigen Arbeiten übernehmen, die mit dem Zusammenstellen eines Buches verbunden sind. Wer weiß, vielleicht können Sie sogar ein kleines Nebengeschäft daraus machen, Ihre Erfahrungen auf diese Weise zu teilen!

Die Möglichkeiten sind aufregend, wenn man darüber nachdenkt. Mit Technologie, die sich ständig weiterentwickelt, haben Autoren und Verleger noch nicht einmal damit begonnen, sich alle innovativen Möglichkeiten vorzustellen, die die KI für die Verpackung und Verbreitung von Wissen auf der ganzen Welt bietet. Ich werde auf jeden Fall ein Auge auf diesen Bereich haben. Wenn Sie mich suchen, werde ich wahrscheinlich dabei sein, meinen ersten Bestseller zu planen!

Ich hoffe, Ihnen hat dieser Artikel gefallen! Bleiben Sie informiert und inspiriert, indem Sie mir folgen und sich für E-Mail-Benachrichtigungen anmelden. So erhalten Sie die neuesten Artikel, Tipps und Einblicke direkt in Ihren Posteingang.