OpenAI Funktionsaufruf Tutorial

OpenAI ohne Funktionsaufruf verwenden

In diesem Abschnitt werden wir Antworten mit dem GPT-3.5-Turbo-Modell ohne Funktionsaufrufe erzeugen, um zu sehen, ob wir konsistente Ergebnisse erhalten oder nicht.

Bevor du die OpenAI Python API installierst, musst du dir einen API-Schlüssel besorgen und ihn auf deinem lokalen System einrichten. Folge dem Tutorial GPT-3.5 und GPT-4 über die OpenAI API in Python, um zu erfahren, wie du den API-Schlüssel bekommst und ihn einrichtest. Das Tutorial enthält auch Beispiele für das Einrichten von Umgebungsvariablen in DataLab, dem KI-fähigen Daten-Notizbuch von DataCamp.

Weitere Hilfe findest du in der Arbeitsmappe OpenAI Function Calling auf DataLab.

Aktualisiere die OpenAI Python API auf V1 mit:

pip install --upgrade openai -q

Danach initiierst du den OpenAI-Client mit dem API-Schlüssel.

import os
from openai import OpenAI

client = OpenAI(
  api_key=os.environ['OPENAI_API_KEY'],
)

Hinweis: OpenAI bietet neuen Nutzern keine kostenlosen Credits mehr an, du musst sie also kaufen, um die API zu nutzen.

Wir werden eine zufällige Schülerbeschreibung schreiben. Du kannst dir entweder einen eigenen Text ausdenken oder ChatGPT benutzen, um einen für dich zu erstellen.

student_1_description = "David Nguyen is a sophomore majoring in computer science at Stanford University. He is Asian American and has a 3.8 GPA. David is known for his programming skills and is an active member of the university's Robotics Club. He hopes to pursue a career in artificial intelligence after graduating."

Im nächsten Teil werden wir eine Eingabeaufforderung schreiben, um Schülerinformationen aus dem Text zu extrahieren und die Ausgabe als JSON-Objekt zurückzugeben. Wir extrahieren den Namen, das Hauptfach, die Schule, die Noten und die Vereine aus der Schülerbeschreibung.

# A simple prompt to extract information from "student_description" in a JSON format.
prompt1 = f'''
Please extract the following information from the given text and return it as a JSON object:

name
major
school
grades
club

This is the body of text to extract the information from:
{student_1_description}
'''

Füge die Eingabeaufforderung zum OpenAI API Chat-Vervollständigungsmodul hinzu, um die Antwort zu generieren.

# Generating response back from gpt-3.5-turbo
openai_response = client.chat.completions.create(
    model = 'gpt-3.5-turbo',
    messages = [{'role': 'user', 'content': prompt_1}]
)

openai_response.choices[0].message.content

Die Reaktion ist ziemlich gut. Konvertieren wir sie in JSON, um sie besser zu verstehen.

'{\n  "name": "David Nguyen",\n  "major": "computer science",\n  "school": "Stanford University",\n  "grades": "3.8 GPA",\n  "club": "Robotics Club"\n}'

Wir verwenden die `json`-Bibliothek, um den Text in ein JSON-Objekt zu konvertieren.

import json

# Loading the response as a JSON object
json_response = json.loads(openai_response.choices[0].message.content)
json_response

Das Endergebnis ist so gut wie perfekt. Warum brauchen wir also Function Calling?

{'name': 'David Nguyen',
 'major': 'computer science',
 'school': 'Stanford University',
 'grades': '3.8 GPA',
 'club': 'Robotics Club'}

Versuchen wir es mit der gleichen Aufforderung, aber mit einer anderen Schülerbeschreibung.

student_2_description="Ravi Patel is a sophomore majoring in computer science at the University of Michigan. He is South Asian Indian American and has a 3.7 GPA. Ravi is an active member of the university's Chess Club and the South Asian Student Association. He hopes to pursue a career in software engineering after graduating."

Wir werden einfach den Text der Schülerbeschreibung in der Aufforderung ändern.

prompt2 = f'''
Please extract the following information from the given text and return it as a JSON object:

name
major
school
grades
club

This is the body of text to extract the information from:
{student_2_description}
'''

Und führe die Chat-Vervollständigungsfunktion mit der zweiten Eingabeaufforderung aus.

# Generating response back from gpt-3.5-turbo
openai_response = client.chat.completions.create(
    model = 'gpt-3.5-turbo',
    messages = [{'role': 'user', 'content': prompt_2}]
)

# Loading the response as a JSON object
json_response = json.loads(openai_response.choices[0].message.content)
json_response

Wie du sehen kannst, ist das nicht konsistent. Anstatt einen Verein zurückzugeben, hat es die Liste der Vereine zurückgegeben, denen Ravi beigetreten ist. Er unterscheidet sich auch vom ersten Schüler.

{'name': 'Ravi Patel',
 'major': 'computer science',
 'school': 'University of Michigan',
 'grades': '3.7 GPA',
 'club': ['Chess Club', 'South Asian Student Association']}

OpenAI Funktionsaufruf Beispiel

Um dieses Problem zu lösen, werden wir jetzt eine kürzlich eingeführte Funktion namens Funktionsaufruf verwenden. Es ist wichtig, eine benutzerdefinierte Funktion zu erstellen, die die notwendigen Informationen zu einer Liste von Wörterbüchern hinzufügt, damit die OpenAI-API ihre Funktionalität verstehen kann.

• name: Schreibe den Namen der Python-Funktion, die du kürzlich erstellt hast.
• Beschreibung: die Funktionalität der Funktion.
• Parameter: In die "Eigenschaften" schreiben wir den Namen der Argumente, den Typ und die Beschreibung. Sie hilft der OpenAI API, die Welt zu identifizieren, nach der wir suchen.

Hinweis: Vergewissere dich, dass du dem richtigen Muster folgst. Erfahre mehr über Funktionsaufrufe, indem du die offizielle Dokumentation liest.

student_custom_functions = [
    {
        'name': 'extract_student_info',
        'description': 'Get the student information from the body of the input text',
        'parameters': {
            'type': 'object',
            'properties': {
                'name': {
                    'type': 'string',
                    'description': 'Name of the person'
                },
                'major': {
                    'type': 'string',
                    'description': 'Major subject.'
                },
                'school': {
                    'type': 'string',
                    'description': 'The university name.'
                },
                'grades': {
                    'type': 'integer',
                    'description': 'GPA of the student.'
                },
                'club': {
                    'type': 'string',
                    'description': 'School club for extracurricular activities. '
                }
                
            }
        }
    }
]

Als Nächstes generieren wir Antworten für zwei Schülerbeschreibungen mit Hilfe einer benutzerdefinierten Funktion, die dem Argument "functions" hinzugefügt wird. Danach wandeln wir die Textantwort in ein JSON-Objekt um und drucken es aus.

student_description = [student_1_description,student_2_description]
for i in student_description:
    response = client.chat.completions.create(
        model = 'gpt-3.5-turbo',
        messages = [{'role': 'user', 'content': i}],
        functions = student_custom_functions,
        function_call = 'auto'
    )

    # Loading the response as a JSON object
    json_response = json.loads(response.choices[0].message.function_call.arguments)
    print(json_response)

Wie wir sehen können, haben wir eine einheitliche Ausgabe. Wir haben sogar Noten in numerischer Form statt als String. Eine konsistente Ausgabe ist wichtig, um fehlerfreie KI-Anwendungen zu erstellen.

{'name': 'David Nguyen', 'major': 'computer science', 'school': 'Stanford University', 'grades': 3.8, 'club': 'Robotics Club'} 

{'name': 'Ravi Patel', 'major': 'computer science', 'school': 'University of Michigan', 'grades': 3.7, 'club': 'Chess Club'}

Mehrere benutzerdefinierte Funktionen

Du kannst mehrere benutzerdefinierte Funktionen zur Chat-Vervollständigungsfunktion hinzufügen. In diesem Abschnitt werden wir die magischen Fähigkeiten der OpenAI API sehen und wie sie automatisch die richtige Funktion auswählt und die richtigen Argumente zurückgibt.

In der Python-Liste des Wörterbuchs fügen wir eine weitere Funktion mit dem Namen "extract_school_info" hinzu, die uns hilft, Hochschulinformationen aus dem Text zu extrahieren.

Um dies zu erreichen, musst du ein weiteres Wörterbuch einer Funktion mit Namen, Beschreibung und Parametern hinzufügen.

custom_functions = [
    {
        'name': 'extract_student_info',
        'description': 'Get the student information from the body of the input text',
        'parameters': {
            'type': 'object',
            'properties': {
                'name': {
                    'type': 'string',
                    'description': 'Name of the person'
                },
                'major': {
                    'type': 'string',
                    'description': 'Major subject.'
                },
                'school': {
                    'type': 'string',
                    'description': 'The university name.'
                },
                'grades': {
                    'type': 'integer',
                    'description': 'GPA of the student.'
                },
                'club': {
                    'type': 'string',
                    'description': 'School club for extracurricular activities. '
                }
                
            }
        }
    },
    {
        'name': 'extract_school_info',
        'description': 'Get the school information from the body of the input text',
        'parameters': {
            'type': 'object',
            'properties': {
                'name': {
                    'type': 'string',
                    'description': 'Name of the school.'
                },
                'ranking': {
                    'type': 'integer',
                    'description': 'QS world ranking of the school.'
                },
                'country': {
                    'type': 'string',
                    'description': 'Country of the school.'
                },
                'no_of_students': {
                    'type': 'integer',
                    'description': 'Number of students enrolled in the school.'
                }
            }
        }
    }
]

Wir werden mit ChatGPT eine Beschreibung der "Stanford University" erstellen, um unsere Funktion zu testen.

school_1_description = "Stanford University is a private research university located in Stanford, California, United States. It was founded in 1885 by Leland Stanford and his wife, Jane Stanford, in memory of their only child, Leland Stanford Jr. The university is ranked #5 in the world by QS World University Rankings. It has over 17,000 students, including about 7,600 undergraduates and 9,500 graduates23. "

Erstelle die Liste der Schüler- und Schulbeschreibungen und leite sie durch die OpenAI Chat-Vervollständigungsfunktion, um die Antwort zu generieren. Stelle sicher, dass du die aktualisierte benutzerdefinierte Funktion bereitgestellt hast.

description = [student_1_description, school_1_description]
for i in description:
    response = client.chat.completions.create(
        model = 'gpt-3.5-turbo',
        messages = [{'role': 'user', 'content': i}],
        functions = custom_functions,
        function_call = 'auto'
    )

    # Loading the response as a JSON object
    json_response = json.loads(response.choices[0].message.function_call.arguments)
    print(json_response)

Das Modell GPT-3.5-Turbo hat automatisch die richtige Funktion für verschiedene Beschreibungsarten ausgewählt. Wir erhalten eine perfekte JSON-Ausgabe für den Schüler und die Schule.

{'name': 'David Nguyen', 'major': 'computer science', 'school': 'Stanford University', 'grades': 3.8, 'club': 'Robotics Club'} 

{'name': 'Stanford University', 'ranking': 5, 'country': 'United States', 'no_of_students': 17000}

Mit der Funktion "extract_school_info" können wir sogar unter dem Namen nachsehen, den der Repose erzeugt.

Anwendungen von Funktionsaufrufen

In diesem Abschnitt werden wir einen stabilen Textzusammensetzer erstellen, der die Schul- und Schülerinformationen auf eine bestimmte Weise zusammenfasst.

Zuerst werden wir zwei Python-Funktionen erstellen, extract_student_info und extract_school_info,, die die Argumente aus dem Funktionsaufruf übernehmen und eine zusammengefasste Zeichenkette zurückgeben.

def extract_student_info(name, major, school, grades, club):
    
    """Get the student information"""

    return f"{name} is majoring in {major} at {school}. He has {grades} GPA and he is an active member of the university's {club}."

def extract_school_info(name, ranking, country, no_of_students):
    
    """Get the school information"""

    return f"{name} is located in the {country}. The university is ranked #{ranking} in the world with {no_of_students} students."

1. Erstelle die Python-Liste, die aus einer Schülerbeschreibung, einer zufälligen Aufforderung und einer Schulbeschreibung besteht. Die Zufallsabfrage wird hinzugefügt, um die Mechanik des automatischen Funktionsaufrufs zu überprüfen.
2. Wir werden die Antwort mit jedem Text in der Liste "Beschreibungen" erstellen.
3. Wenn ein Funktionsaufruf verwendet wird, erhalten wir den Namen der Funktion und wenden darauf basierend die entsprechenden Argumente auf die Funktion an, indem wir die Antwort verwenden. Andernfalls gibst du die normale Antwort zurück.
4. Drucke die Ausgaben aller drei Proben aus.

descriptions = [
    student_1_description, 
    "Who was a Abraham Lincoln?",
    school_1_description
                ]

for i, sample in enumerate(descriptions):
    response = client.chat.completions.create(
        model = 'gpt-3.5-turbo',
        messages = [{'role': 'user', 'content': sample}],
        functions = custom_functions,
        function_call = 'auto'
    )
    
    response_message = response.choices[0].message
    
    if dict(response_message).get('function_call'):
        
        # Which function call was invoked
        function_called = response_message.function_call.name
        
        # Extracting the arguments
        function_args  = json.loads(response_message.function_call.arguments)
        
        # Function names
        available_functions = {
            "extract_school_info": extract_school_info,
            "extract_student_info": extract_student_info
        }
        
        fuction_to_call = available_functions[function_called]
        response_message = fuction_to_call(*list(function_args .values()))
        
    else:
        response_message = response_message.content
    
    print(f"\nSample#{i+1}\n")
    print(response_message)

• Sample#1: Das GPT-Modell hat "extract_student_info" ausgewählt, und wir haben eine kurze Zusammenfassung über den Schüler erhalten.
• Sample#2: Das GPT-Modell hat keine Funktion ausgewählt und die Aufforderung als reguläre Frage behandelt, und als Ergebnis erhielten wir die Biografie von Abraham Lincoln.
• Sample#3: Das GPT-Modell hat "extract_school_info" ausgewählt, und wir haben eine kurze Zusammenfassung über die Stanford University erhalten.

Sample#1

David Nguyen is majoring in computer science at Stanford University. He has 3.8 GPA and he is an active member of the university's Robotics Club.

Sample#2

Abraham Lincoln was the 16th President of the United States. He served as president from March 1861 until his assassination in April 1865. Lincoln led the country through its greatest internal crisis, the American Civil War, and his Emancipation Proclamation declared slaves in Confederate territory to be free. He is known for his leadership, his commitment to preserving the Union, and his efforts to abolish slavery. Lincoln's presidency is widely regarded as one of the most transformative in American history.

Sample#3

Stanford University is located in the United States. The university is ranked #5 in the world with 17000 students.

Fazit

Der Funktionsaufruf von OpenAI eröffnet Entwicklern, die KI-Anwendungen erstellen, aufregende neue Möglichkeiten. Indem Modelle wie GPT-3.5 und GPT-4 durch benutzerdefinierte Funktionen strukturierte JSON-Daten erzeugen können, werden die größten Probleme mit inkonsistenten und unvorhersehbaren Textausgaben gelöst.

Mit Funktionsaufrufen kannst du auf externe Web-APIs zugreifen, eigene SQL-Abfragen ausführen und stabile KI-Anwendungen entwickeln. Es kann relevante Informationen aus Text extrahieren und konsistente Antworten für API- und SQL-Befehle liefern.

In diesem Tutorial haben wir die neue Funktion von OpenAI kennengelernt, den Funktionsaufruf. Wir haben auch gelernt, wie man damit konsistente Ausgaben erzeugt, mehrere Funktionen erstellt und einen zuverlässigen Textzusammenfassungsrechner baut.

Wenn du mehr über die OpenAI API erfahren möchtest, solltest du den Kurs Arbeiten mit der OpenAI API besuchen und den Spickzettel OpenAI API in Python verwenden, um dein erstes KI-gestütztes Projekt zu erstellen.