Tutorial de chamada de função do OpenAI

O que é chamada de função OpenAI?

A API OpenAI é excelente para gerar a resposta de forma sistemática. Você pode gerenciar seus prompts, otimizar a saída do modelo e executar, criar e linguagear aplicativos com poucas linhas de código.

Mesmo com todas as vantagens, a API da OpenAI foi um pesadelo para os desenvolvedores e engenheiros. Por quê? Eles estão acostumados a trabalhar com tipos de dados estruturados, e trabalhar com dados não estruturados, como strings, é difícil.

Para obter resultados consistentes, os desenvolvedores precisam usar expressões regulares (RegEx) ou engenharia de prompt para extrair as informações da string de texto.

É aqui que entra o recurso de chamada de função da OpenAI. Ele permite que os modelos GPT-3.5 e GPT-4 recebam funções definidas pelo usuário como entrada e gerem saída de estrutura. Com isso, você não precisa escrever RegEx ou executar engenharia de prompt.

Neste tutorial, exploraremos como a chamada de função do OpenAI pode ajudar a resolver problemas comuns de desenvolvedores causados por resultados irregulares de modelos.

Se estiver começando a usar o ChatGPT e a API OpenAI, considere dar uma olhada no webinar Getting Started with the OpenAI API and ChatGPT. Esse recurso pode orientá-lo na geração de linguagem e codificação e ajudá-lo a executar tarefas básicas usando a API do Python.

Uso do OpenAI sem chamada de função

Nesta seção, geraremos respostas usando o modelo GPT-3.5-Turbo sem chamada de função para ver se obtemos resultados consistentes ou não.

Antes de instalar a API OpenAI Python, você deve obter uma chave de API e configurá-la em seu sistema local. Siga o tutorial GPT-3.5 e GPT-4 por meio da API OpenAI em Python para saber como obter a chave da API e configurá-la. O tutorial também inclui exemplos de configuração de variáveis de ambiente no DataCamp Workspace.

Para obter mais assistência, consulte o Notebook com saídas no OpenAI Function Calling Workspace.

Atualize a API do OpenAI Python para a V1 usando:

pip install --upgrade openai -q

Depois disso, inicie o cliente OpenAI usando a chave da API.

import os
from openai import OpenAI

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

Observação: A OpenAI não oferece mais créditos gratuitos para novos usuários, portanto, é necessário comprá-los para usar a API.

Escreveremos uma descrição aleatória do aluno. Você pode criar seu próprio texto ou usar o ChatGPT para gerar um para você.

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."

Na próxima parte, escreveremos um prompt para extrair as informações do aluno do texto e retornaremos a saída como um objeto JSON. Extrairemos o nome, a especialização, a escola, as notas e os clubes na descrição do aluno.

# 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}
'''

Adicione o prompt ao módulo de conclusão de bate-papo da API da OpenAI para gerar a resposta.

# 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

A resposta é muito boa. Vamos convertê-lo em JSON para entendê-lo melhor.

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

Usaremos a biblioteca `json` para converter o texto em um objeto JSON.

import json

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

O resultado final é praticamente perfeito. Então, por que precisamos do Function Calling?

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

Vamos tentar o mesmo prompt, mas usando uma descrição diferente do aluno.

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."

Apenas alteraremos o texto de descrição do aluno no prompt.

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}
'''

E execute a função de conclusão do chat usando o segundo prompt.

# 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

Como você pode ver, ele não é consistente. Em vez de retornar um clube, ele retornou a lista de clubes aos quais Ravi se juntou. Ele também é diferente do primeiro aluno.

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

Exemplo de chamada de função OpenAI

Para resolver esse problema, usaremos um recurso introduzido recentemente chamado Function Calling. É essencial criar uma função personalizada para adicionar as informações necessárias a uma lista de dicionários para que a API da OpenAI possa entender sua funcionalidade.

• name: escreva o nome da função Python que você criou recentemente.
• descrição: a funcionalidade da função.
• parâmetros: nas "propriedades", escreveremos o nome dos argumentos, o tipo e a descrição. Isso ajudará a API da OpenAI a identificar o mundo que estamos procurando.

Observação: Certifique-se de que está seguindo o padrão correto. Saiba mais sobre chamadas de função lendo a documentação oficial.

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. '
                }
                
            }
        }
    }
]

Em seguida, geraremos respostas para duas descrições de alunos usando uma função personalizada adicionada ao argumento "functions". Depois disso, converteremos a resposta de texto em um objeto JSON e a imprimiremos.

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)

Como podemos ver, obtivemos um resultado uniforme. Recebemos até mesmo notas numéricas em vez de strings. O resultado consistente é essencial para criar aplicativos de IA sem bugs.

{'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'}

Várias funções personalizadas

Você pode adicionar várias funções personalizadas à função de conclusão de bate-papo. Nesta seção, veremos os recursos mágicos da API da OpenAI e como ela seleciona automaticamente a função correta e retorna os argumentos corretos.

Na lista Python do dicionário, adicionaremos outra função chamada "extract_school_info", que nos ajudará a extrair informações sobre a universidade do texto.

Para isso, você precisa adicionar outro dicionário de uma função com nome, descrição e parâmetros.

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.'
                }
            }
        }
    }
]

Vamos gerar uma descrição da "Universidade de Stanford" usando o ChatGPT para testar nossa função.

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. "

Crie a lista de descrições de alunos e escolas e passe-a pela função de conclusão de bate-papo do OpenAI para gerar a resposta. Certifique-se de que você forneceu a função personalizada atualizada.

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)

O modelo GPT-3.5-Turbo selecionou automaticamente a função correta para diferentes tipos de descrição. Obtemos uma saída JSON perfeita para o aluno e a escola.

{'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}

Podemos até mesmo verificar o nome em que o repouso é gerado usando a função "extract_school_info".

Aplicativos de chamada de função

Nesta seção, criaremos um resumidor de texto estável que resumirá as informações da escola e do aluno de uma determinada maneira.

Primeiro, criaremos duas funções Python, extract_student_info e extract_school_info,, que recebem os argumentos da chamada da função e retornam uma string resumida.

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. Crie a lista Python, que consiste em uma descrição do aluno, um prompt aleatório e uma descrição da escola. O prompt aleatório é adicionado para validar a mecânica de chamada de função automática.
2. Vamos gerar a resposta usando cada texto da lista `descriptions`.
3. Se uma chamada de função for usada, obteremos o nome da função e, com base nele, aplicaremos os argumentos relevantes à função usando a resposta. Caso contrário, retorne a resposta normal.
4. Imprima os resultados de todas as três amostras.

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)

• Amostra#1: O modelo GPT selecionou "extract_student_info", e obtivemos um breve resumo sobre o aluno.
• Amostra#2: O modelo GPT não selecionou nenhuma função e tratou o prompt como uma pergunta normal e, como resultado, obtivemos a biografia de Abraham Lincoln.
• Amostra#3: O modelo GPT selecionou "extract_school_info" e obtivemos um breve resumo sobre a Universidade de Stanford.

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.

Conclusão

A chamada de função da OpenAI abre novas e empolgantes possibilidades para os desenvolvedores que criam aplicativos de IA. Ao permitir que modelos como o GPT-3.5 e o GPT-4 gerem dados JSON estruturados por meio de funções personalizadas, ele resolve os principais problemas relacionados a saídas de texto inconsistentes e imprevisíveis.

A chamada de função pode ser usada para acessar APIs externas da Web, executar consultas SQL personalizadas e desenvolver aplicativos de IA estáveis. Ele pode extrair informações relevantes do texto e fornecer respostas consistentes para comandos de API e SQL.

Neste tutorial, aprendemos sobre o novo recurso da OpenAI, a chamada de função. Também aprendemos a usá-lo para gerar resultados consistentes, criar várias funções e criar um resumidor de texto confiável.

Se quiser saber mais sobre a API OpenAI, considere fazer o curso Trabalhando com a API OpenAI e usar a folha de dicas da API OpenAI em Python para criar seu primeiro projeto com tecnologia de IA.