6 Python-Projekte, um mit GenAI durchzustarten

Dank der Flut von Generative-AI-Diensten, die sich in den vergangenen Monaten etabliert haben, sind Chatbots beziehungsweise Webseiten auf Basis von großen Sprachmodellen (Large Language Models; LLMs) fast schon allgegenwärtig. Softwareentwickler ziehen es allerdings vor, selbst zu Werke zu schreiten, um zum gewünschten Ziel zu kommen. Neben der Befriedigung, die sich einstellt, wenn eine Anwendung läuft wie sie soll, bietet die direkte Programmierarbeit schließlich auch die Möglichkeit, Design und Funktionsweise der Applikation je nach Gusto zu optimieren.

In diesem Tutorial bringen wir Ihnen sechs Python-Coding-Projekte näher, die Entwicklern den Einstieg in die generative künstliche Intelligenz (KI) erleichtern.

1. Chatbot erstellen mit Llama 2, Streamlit und Replicate

Falls Sie einen Chatbot betreiben möchten, ohne dabei auf OpenAIs GPT 3.5 oder 4 zu setzen, bietet die Kombination aus Metas Llama-2-Sprachmodell und dem Streamlit-Webframework eine einfache Möglichkeit, das zu tun. Wie das im Detail geht, zeigt Chanin Nantasenamat, Senior Developer Advocate bei Streamlit, in einem GitHub-Repository, einem YouTube-Video und einem Blogbeitrag.

Um dieses Projekt umzusetzen, benötigen Sie einen Account bei Replicate (Login mit GitHub-Konto ist möglich) sowie einen API-Token. Vorausgesetzt, Sie wollen Replicate nur gelegentlich für kleinere Tasks nutzen, reicht dazu auch das kostenlose Angebot. Wenn größere Modelle oder viele Abfragen ins Spiel kommen, sieht das anders aus. Ihr Gratis-Replicate-Konto sollte mit einem Standard-API-Token ausgestattet sein. Falls nicht, können Sie einen neuen generieren.

Projekt einrichten

Zunächst laden Sie den Code mit Git lokal herunter. Das funktioniert mit dem Befehl:

git clone https://github.com/dataprofessor/llama2.git

Sollten Sie Git nicht verwenden, können Sie auch über GitHub ein Zip-Archiv mit den Daten herunterladen und diese auf Ihrem lokalen Recher entpacken. Nachdem Sie Ihr Arbeitsverzeichnis auf den Projektordner ausgerichtet haben, können Sie mit venv eine virtuelle Python-Umgebung erstellen (dafür können Sie ein beliebiges Tool verwenden):

python -m venv env

Anschließend aktivieren Sie diese Umgebung mit dem Befehl:

• source env/bin/activate (Mac) oder

• env\Scripts\activate (Windows).

Im nächsten Schritt gilt es dann, die benötigten Packages zu installieren. Dazu nutzen Sie:

pip install -r requirements.txt

Um eine Streamlit-Datei lokal mit API-Schlüsseln auszuführen, empfiehlt die Dokumentation, diese in einer secrets.toml-Datei in einem .streamlit-Verzeichnis unterhalb Ihres Hauptprojektverzeichnisses zu speichern. Wenn Sie git verwenden, müssen Sie die Datei .streamlit/secrets.toml zu Ihrem .gitignore-File hinzufügen. Dabei sollte secrets.toml ein Format wie das folgende aufweisen:

REPLICATE_API_TOKEN = "your_replicate_token"

Das funktioniert, wenn die Benutzer Ihr Token verwenden, um Anfragen zu stellen. Sie können auch versuchen, die Anwendung lokal auszuführen. So sehen Sie, was passiert, wenn die Benutzer ihren eigenen Schlüssel eingeben müssen. Auf unserem Mac läuft die Anwendung nicht ohne secrets.toml. Das lässt sich beheben, indem Sie keinen Wert für REPLICATE_API_TOKEN setzen und secrets.toml um einen kleinen Zusatz erweitern:

FAKE_TOKEN = "some fake token"

So sollten Sie nun in der Lage sein, die Streamlit-App lokal mit folgendem Terminal-Befehl auszuführen:

streamlit run streamlit_app_v2.py

Wenn Sie Ihre Applikation im Netz bereitstellen möchten, ist ein kostenloses Konto bei der Streamlit Community Cloud eine der einfachsten Optionen, um das zu bewerkstelligen. Es ermöglicht, Anwendungen direkt über Ihren GitHub-Account bereitzustellen. Für Setup und Deployment stehen jeweils ausführliche Anleitungen zur Verfügung. Um dabei eklatante Kosten für die Replicate-API zu vermeiden, sollten Sie unbedingt darauf achten, Ihr GitHub-Repository auf "Private" zu stellen - oder die User dazu auffordern, ihre eigenen API Keys zu nutzen.

Eine weitere simple Option, um Streamlit-Anwendungen gemeinsam zu nutzen, besteht darin, sie über Hugging Face Streamlit Spaces bereitzustellen. Falls Sie Docker-User sind, empfiehlt sich dazu das Dockerize-Tool, das von Brian Hess (Field CTO bei Snowflake und Analytics-Spezialist bei Amazon Web Services) entwickelt wurde.

2. Daten visualisieren mit Matplotlib, Streamlit und OpenAI

Das folgende Tutorial führt Sie zu einer Anwendung, mit der Sie .csv-Dateien uploaden und Fragen dazu stellen können. Im Gegenzug erhalten Sie als Antwort ein Matplotlib-generiertes Diagramm. Um die App umzusetzen, ist ein OpenAI-API-Schlüssel erforderlich - ein Klick auf den nachfolgenden Button führt Sie zur Account-Erstellung:

Zum OpenAI-Konto

Projekt einrichten

Ist das erledigt, erstellen Sie einen Git-Clone des Repository mit dem Befehl:

git clone https://github.com/michaelweiss/chat-with-your-data.git

Anschließend wechseln Sie ins Projektverzeichnis und erstellen und aktivieren eine virtuelle Python-Umgebung (siehe vorheriges Projekt). Wenn Sie die Anwendung lokal ausführen, setzen Sie Ihren OpenAI-Key mit dem Befehl:

export OPENAI_API_KEY="your_open_ai_key"

Als nächstes installieren Sie die benötigten Packages:

pip install openai pandas streamlit matplotlib

Schließlich führen Sie die Anwendung aus mit:

streamlit run chat_data.py

Damit das Large Language Model aus Ihrer Anfrage brauchbaren Python-Code erzeugen kann, sollte der Ouput ein Diagramm wie im obenstehenden Screenshot beinhalten. Wie bei allen LLM-gesteuerten Anwendungen müssen Sie Ihren Prompt möglicherweise optimieren, damit der Code richtig funktioniert.

Weil Projektautor Michael Weiss sein Repository unter der MIT-Open-Source-Lizenz veröffentlicht hat, können Sie es für jeden Zweck verwenden oder verändern.

3. Dokumente abfragen mit OpenAI, LangChain und Chainlit

Mit diesem Python-Projekt können Sie eine simple App erstellen, um ein Textdokument hochzuladen und Fragen zu dessen Inhalt zu stellen. Diese Anwendung eignet sich zum Beispiel, um möglichst schnell eine einmalige Zusammenfassung eines neu erhaltenen Dokuments anzufertigen. Oder diese Möglichkeit anderen zur Verfügung zu stellen.

Das Projekt verwendet das relativ neue Framework Chainlit, das speziell für LLM-gestützte Chat-Anwendungen entwickelt wurde. Jedes Mal, wenn Sie ein Dokument in die App hochladen, wird dieses von einem großen Sprachmodell verarbeitet. Das transformiert das Dokument in Zahlen, die seine Semantik darstellen. Sollten Sie Ihr Dokument in Zukunft mehrfach abfragen wollen (zum Beispiel zur Softwaredokumentation) wäre diese Anwendung nicht effizient. Für dieses Szenario empfiehlt sich das nächste Projekt, das den Input zur späteren Verwendung speichert.

Projekt einrichten

Auch für diese Anwendung brauchen Sie eine (aktivierte) virtuelle Python-Umgebung. Insofern Sie den Quellcode nicht ändern, um ein anderes LLM zu verwenden, benötigen Sie zudem einen OpenAI API-Key. Sind die Voraussetzungen erfüllt, installieren Sie die benötigten Packages:

pip install python-dotenv langchain chromadb tiktoken chainlit openai

Kopieren Sie im nächsten Schritt den Beispielcode von Chainlit, den Sie mit einem Klick auf den nachfolgenden Button abrufen.

Zum Chainlit-Codebeispiel

Dann tragen Sie Ihren OpenAI-Key ein - oder aktualisieren den Code mit einer anderen, sichereren Methode, um Ihren Key zu laden. Zum Beispiel mit der python-dotenv-Bibliothek und einer .env-Datei.

Chainlit bringt einige spezielle Funktionen mit: Die Standard-Webanwendung zeigt die Schritte an, die das LLM unternimmt, um die Benutzerfrage zu beantworten, sowie die endgültige Antwort. Darüber hinaus verfügt das Framework auch über Dekoratoren mit Chatbot-Fokus:

• @cl.on_message spezifiziert alles, was ausgeführt werden soll, wenn ein Benutzer eine Frage eingibt,

• @cl.on_chat_start ist zuständig für jeden Code, der ausgeführt werden soll, wenn die App startet.

Folgender Terminalbefehl startet die Anwendung (die auf einem Browser auf localhost geöffnet werden sollte):

chainlit run -w qa.py

Mit dem Argument -w wird die App jedes Mal automatisch neu geladen, wenn die zugrundeliegende Datei app.py aktualisiert und gespeichert wird.

Wenn Sie die Anwendung ausführen, erzeugt Chainlit eine neue chainlit.md-Datei in Ihrem Projektverzeichnis, insofern noch keine vorhanden ist. Diese Datei wird in der Readme-Registerkarte Ihrer Anwendung angezeigt und lässt sich nach Belieben bearbeiten. Darüber hinaus beinhaltet der Output der Applikation auch Links zu den relevanten Quelldokumenten. So lässt sich direkt überprüfen, ob die Antwort korrekt ist.

Wenn Sie mit LangChain vertraut sind, können Sie den Code der Anwendung auch aktualisieren, um weitere Dateityp-Optionen hinzuzufügen. Dazu empfehlen sich einige zusätzliche LangChain Document Loader, zum Beispiel für .pdf-Dateien.

Da Chainlit noch relativ neu ist, ist es nicht für Produktionsanwendungen zu empfehlen. Wenn Sie allerdings nur eine schnelle Möglichkeit suchen, um eine simples, generatives Chat-Interface zu programmieren, ist das Framework einen Blick wert. Im Chainlit Cookbook Repository finden Sie noch ein paar Dutzend anderer Applikationen zum Testen.

Um Chainlit-Anwendungen gemeinsam zu nutzen, soll demnächst ein Cloud-Service verfügbar sein. Im Moment beschränken sich die Empfehlungen in Sachen Deployment auf eine Handvoll Tutorials - zum Beispiel dieses YouTube-Video.

4. Dokumente abfragen mit LangChain, OpenAI und Gradio

Die Chatbot-Anwendung, um die es in diesem Abschnitt geht, ermöglicht es, mehrere Dokumente zu verarbeiten und zu speichern. Im Anschluss beantwortet ein LLM die Benutzerfragen ausschließlich auf Grundlage dieses Inputs. Diese Methode wird auch als Retrieval Augmented Generation (RAG) bezeichnet.

Der Code für die Anwendung entstammt dem GitHub-Repository von LangChain-Erfinder Harrison Chase und enthält standardmäßig eine Textdatei, die eine "State of the Union"-Rede der US-Regierung aus dem Jahr 2022 beinhaltet. Um loszulegen, klonen Sie den Code (oder laden ihn mit Klick auf den nachfolgenden Button herunter:

Zum Code-Download

Projekt einrichten

Im Anschluss richten Sie wie bei den vorherigen Projekten Ihre virtuelle Python-Umgebung ein - und folgen dann den Schritten 0, 1 und 2 der README-Datei zum Projekt. Nun sollten Sie die Gradio-Webanwendung lokal mit dem Standardtext über folgenden Befehl starten können:

python app.py

Bei Gradio handelt es sich um ein Web-Framework, das für Data-Science-Zwecke entwickelt wurde und integrierte Funktionen für Streaming-Chatbots enthält. Gradio realisiert eine gute Balance zwischen Benutzerfreundlichkeit und Anpassbarkeit - und seine Dokumentation ist nicht nur umfangreich, sondern auch leicht zu verstehen. Neben der Gradio-UI verfügt die App auch über eine Befehlszeilenanwendung, um Dokumente abzufragen:

python cli_app.py

Sobald die Standardanwendung gestartet ist, können Sie sie mit den Dokumenten Ihrer Wahl anpassen. Eine Möglichkeit, das umzusetzen, führt über die folgenden fünf Schritte:

1. Löschen Sie die Dateien vectorstore.pkl und state_of_the_union.txt.

2. Erstellen Sie einen docs-Ordner und legen Sie dort eines oder mehrere der Dokumente ab, die Sie abfragen möchten. Wir haben dazu die PDF-Dateien "8 Things to know about Large Language Models" von Samuel Bowman und "A Beginner´s Guide to Large Language Models" von Nvidia genutzt.

3. Ändern Sie innerhalb der Datei ingest_data_.py die folgenden Zeilen (9 und 10, direkt nach print("Loading data....")):

loader = UnstructuredFileLoader("state_of_the_union.txt")

raw_documents = loader.load()

zu

raw_documents = []

for file in os.listdir('docs'):

if file.endswith('.pdf'):

pdf_path = './docs/' + file

loader = PyPDFLoader(pdf_path)

raw_documents.extend(loader.load())

elif file.endswith('.docx') or file.endswith('.doc'):

doc_path = './docs/' + file

loader = Docx2txtLoader(doc_path)

raw_documents.extend(loader.load())

elif file.endswith('.txt'):

doc_path = './docs/' + file

loader = TextLoader(doc_path)

raw_documents.extend(loader.load())

Fügen Sie außerdem am Anfang der Datei hinzu:

import os

from langchain.document_loaders import PyPDFLoader, Docx2txtLoader

from langchain.document_loaders import TextLoader

4. Ändern Sie in query_data.py jede der Phrasen "the most recent state of the union address" oder "the most recent state of the union" entsprechend in das Thema ab, das Ihre Dokumente behandeln.

5. Der Titel in app.py (Zeile 57) muss ebenfalls geändert werden. Der ursprüngliche Code:

"<h3><center>Chat-Your-Data (State-of-the-Union)</center></h3>"

Auch hier tragen Sie das Thema ein, um das es gehen soll. Ändern Sie zudem auch den Platzhaltertext in Zeile 71 und die Beispiele ab Zeile 78. Wenn Sie auch PDF-Dateien verwenden, müssen Sie zusätzlich die pypdf-Bibliothek installieren. Das funktioniert mit dem Befehl:

pip install pypdf

Führen Sie nun erneut python ingest_data.py aus und starten Sie dann die Anwendung mit python app.py.

Es ist simpel, eine Gradio-Anwendung auf Hugging Face Spaces bereitzustellen. Dabei sollten Sie davon absehen, eine Anwendung mit Ihrem API-Schlüssel auf einer öffentlichen Seite zugänglich zu machen. Eine Option: Fügen Sie einen einfachen Passwortschutz hinzu. Das bewerkstelligen Sie, indem Sie folgenden Code bearbeiten:

gr.ChatInterface(predict).queue().launch()

Wird zu:

gr.ChatInterface(predict).queue().launch(auth=("theUserName", "thePassword"))

Darüber hinaus gibt es auch andere Deployment-Optionen als Hugging Face, zum Beispiel über einen Cloud Service oder als Docker Container.

5. LLM-basierte Web-Recherche mit LangChain, OpenAI und FastAPI

Das Projekt GPT Researcher stammt von von Assaf Elovic, Leiter der Forschungs- und Entwicklungsabteilung beim israelischen Webhoster Wix. Die resultierende Anwendung verwendet die Suchmaschine Tavily, die speziell für LLM-Projekte entwickelt wurde. Sie ist derzeit kostenlos, allerdings wird der Input laut den Verantwortlichen dazu genutzt, die Modelle und Algorithmen zu optimieren.

Projekt einrichten

Dafür gibt es eine hochwertige Schritt-für-Schritt-Installationsanleitung in Form der offiziellen README-Datei. Außerdem steht auch ein Tutorial in Videoform zur Verfügung. Wichtig: Damit dieses Projekt läuft, brauchen Sie mindestens Python-Version 3.11. Sollten Sie auch andere Python-Distributionen nutzen, stellen Sie sicher, dass Sie Ihre virtuelle Umgebung mit der richtigen Version erstellen und diese aktivieren.

Dann installieren Sie die benötigten Packages:

pip install -r requirements.txt

Erstellen Sie dann eine .env-Datei und fügen Sie Ihren OpenAI-API-Schlüssel wie folgt hinzu:

OPENAI_API_KEY="your-key-here"

Dann starten Sie die Anwendung mit:

uvicorn main:app -reload

Über einen Browser (http://localhost:8000) sollten Sie nun den Startbildschirm sehen und mit einem Klick auf den "Get Started"-Button loslegen können. Sobald Sie eine Anfrage eingeben, sucht ein Agent nach mehreren Quellen und erstellt dann einen Report. Letzteren zu kompilieren, nimmt einige Zeit in Anspruch. Dafür bietet die App den Vorteil, dass der Report auch Quellenlinks enthält.

Aufgrund aktueller Vorkommnisse haben wir unseren LLM-Chatbot gefragt, wie man einen Specht davon abhalten kann, seinen Instinkten nachzugehen.

Das Ergebnis der Anfrage war eine ausführliche Abhandlung zum Thema, inklusive Gliederung, Einleitung, mehreren Themenabschnitten (etwa "nicht-tödliche Vergrämungsmethoden" und "proaktive Anti-Picking-Maßnahmen") sowie Fazit und Referenzen. Zusätzlich zu einem Report, der die Frage beantwortet, ist es auch möglich, einen Quellenbericht anzufordern, der diverse Details zu den wichtigsten Ressourcen liefert.

Darüber hinaus können Sie auch das LLM ändern, das GPT Researcher verwendet - was allerdings nicht empfohlen wird, da OpenAIs Modelle für diesen Task als am besten geeignet gelten. Neben der Möglichkeit, GPT Researcher lokal auszuführen, gibt es auch eine Anleitung, um es in einem Docker-Container auszuführen.

6. Von NLP zu SQL mit LlamaIndex, SQLAlchemy und OpenAI

Um Text in SQL umzuwandeln, gibt es verschiedene Möglichkeiten. Eine führt über dieses Beispielprojekt, das Llamaindex und SQLAlchemy zum Einsatz bringt. Ersteres wurde entwickelt, um LLM-Applikationen mit Daten anzureichern. Bei SQLAlchemy handelt es sich um ein Toolkit für Python-Datenbanken. Wichtig: Dieses Projekt enthält kein Web-Frontend und wird über die Kommandozeile ausgeführt. Was den Python-Code angejht, haben wir uns hauptsächlich aus dem Beispiel-Notebook von Llamaindex bedient.

Projekt einrichten

Wie bei den ersten fünf Projekten gilt es zunächst, ein neues Verzeichnis zu erstellen, eine virtuelle Python-Umgebung zu erstellen und zu aktivieren und anschließend die erforderlichen Packages zu installieren:

pip install openai sqlalchemy llama-index

Sollten Sie OpenAI nicht verwenden wollen, bietet LlamaIndex andere LLM-API-Optionen. Sie können die Standard-LLMs auch lokal ausführen. Das Beispiel-Notebook speichert Ihren API-Schlüssel explizit in der Hauptdatei. Als Teil eines Git-Repository ist das ungünstig, wenn Sie Ihren Schlüssel nicht auf GitHub öffentlich teilen möchten. Stattdessen empfiehlt sich:

pip install python-dotenv

Anschließend erstellen Sie eine .env-Datei:

OPENAI_API_KEY="my_api_key"

Dann fügen Sie folgenden Code in ein neues app.py-Skript ein:

import os

import openai

from dotenv import load_dotenv

load_dotenv()

openai.api_key = os.getenv("OPENAI_API_KEY")

Im nächsten Schritt haben wir einen Teil des Beispielcodes in ein app.py-Skript eingefügt:

from llama_index.indices.struct_store.sql_query import NLSQLTableQueryEngine

from sqlalchemy import text

from sqlalchemy import insert

from llama_index.llms import OpenAI

from llama_index import SQLDatabase, ServiceContext

from sqlalchemy import (

create_engine,

MetaData,

Table,

Column,

String,

Integer,

select,

)

# Create a sample database and table

engine = create_engine("sqlite:///:memory:")

metadata_obj = MetaData()

table_name = "city_stats"

city_stats_table = Table(

table_name,

metadata_obj,

Column("city_name", String(16), primary_key=True),

Column("population", Integer),

Column("country", String(16), nullable=False),

)

metadata_obj.create_all(engine)

# Set up an LLM

llm = OpenAI(temperature=0.1, model="gpt-3.5-turbo")

service_context = ServiceContext.from_defaults(llm=llm)

# Create a database object from that table that sqlalchemy can use

sql_database = SQLDatabase(engine, include_tables=["city_stats"])

# Add some sample data to the table

sql_database = SQLDatabase(engine, include_tables=["city_stats"])

rows = [

{"city_name": "Toronto", "population": 2930000, "country": "Canada"},

{"city_name": "Tokyo", "population": 13960000, "country": "Japan"},

{"city_name": "Chicago", "population": 2679000, "country": "United States"},

{"city_name": "Seoul", "population": 9776000, "country": "South Korea"},

]

for row in rows:

stmt = insert(city_stats_table).values(**row)

with engine.begin() as connection:

cursor = connection.execute(stmt)

# Check to see if the table exists and is usable

stmt = select(

city_stats_table.c.city_name,

city_stats_table.c.population,

city_stats_table.c.country,

).select_from(city_stats_table)

with engine.connect() as connection:

results = connection.execute(stmt).fetchall()

print(results)

# Try running a basic SQL query on this table using sqlalchemy

with engine.connect() as con:

rows = con.execute(text("SELECT city_name, country from city_stats"))

for row in rows:

print(row)

# At last! Time to try a natural language query

query_engine = NLSQLTableQueryEngine(

sql_database=sql_database,

tables=["city_stats"],

)

query_str = "Which city has the largest population, and what is that population??"

response = query_engine.query(query_str)

print(f"Answer: {response}")

# You can also see the query in the sqlalchemy metadata

print("Generated from the following SQL:")

print(response.metadata["sql_query"])

Sie können die Anwendung nun mit einem einfachen python app.py-Terminalbefehl ausführen, nachdem Sie die Abfrage und die Daten entsprechend Ihren Bedürfnissen angepasst haben.

Weitere GenAI-Python-Projekte

Wenn Sie weitere Generative-AI-Projekte in Python angehen möchten, lohnt sich ein Blick auf folgende Online-Ressourcen:

• Shiny für Python Chatstream

• Streamlit-Projekte und -Blog

• WASM-Chatbot

• LangChain-Projekte

• Chainlit-Projekte

(fm)

Dieser Beitrag basiert auf einem Artikel unserer US-Schwesterpublikation Infoworld.