Usando o GPT-3.5 e o GPT-4 por meio da API OpenAI em Python

Quando você deve usar a API em vez da interface da Web?

O aplicativo da Web ChatGPT é uma ótima interface para os modelos GPT. No entanto, se você quiser incluir a IA em um pipeline de dados ou em um software, a API é mais apropriada. Alguns casos de uso possíveis para profissionais de dados incluem:

• Extrair dados de um banco de dados ou de outra API e, em seguida, pedir ao GPT para resumi-los ou gerar um relatório sobre eles
• Incorporar a funcionalidade GPT em um painel para fornecer automaticamente um resumo de texto dos resultados
• Fornecer uma interface de linguagem natural para seu data mart
• Realizar pesquisas obtendo artigos de periódicos por meio do pacote scholarly(PyPI, Conda) e fazendo com que o GPT resuma os resultados

Configurar uma conta de desenvolvedor da OpenAI

Para usar a API, você precisa criar uma conta de desenvolvedor na OpenAI. Você precisará ter em mãos seu endereço de e-mail, número de telefone e detalhes do cartão de débito ou crédito.

Siga estas etapas:

1. Vá para a página de registro da API.
2. Crie sua conta (você precisará fornecer seu endereço de e-mail e seu número de telefone).
3. Vá para a página de chaves de API.
4. Crie uma nova chave secreta.
5. Faça uma cópia dessa chave. (Se você a perder, exclua a chave e crie uma nova).
6. Vá para a página Métodos de pagamento.
7. Clique em "Add payment method" (Adicionar método de pagamento) e preencha os detalhes do seu cartão.

Armazene com segurança as credenciais de sua conta

A chave secreta precisa ser mantida em segredo! Caso contrário, outras pessoas poderão usá-lo para acessar a API, e você pagará por isso. As etapas a seguir descrevem como armazenar com segurança sua chave no DataLab, o notebook de dados habilitado para IA do DataCamp. Se você estiver usando uma plataforma diferente, consulte a documentação dessa plataforma. Você também pode pedir conselhos ao ChatGPT. Aqui está uma sugestão de solicitação:

> Você é um especialista em segurança de TI. Você está falando com um cientista de dados. Explicar as práticas recomendadas para armazenar com segurança as chaves privadas usadas para acesso à API.

1. Em sua pasta de trabalho do DataLab, clique em "Environment" (Ambiente)
2. Clique no sinal de mais ao lado de "Environment" (Ambiente)
3. No campo "Nome", digite "OPENAI". No campo "Value" (Valor), cole sua chave secreta
4. Dê um nome ao conjunto de variáveis de ambiente (pode ser qualquer coisa, na verdade)
5. Clique em "Create" (Criar) e conecte a nova integração

Configuração do Python

Para usar o GPT por meio da API, você precisa importar os pacotes Python os e openai.

Se você estiver usando uma solução Jupyter Notebook (como o DataLab), também será útil importar algumas funções do site IPython.display.

Um exemplo também usa o pacote yfinance para recuperar os preços das ações.

# Import the os package
import os

# Import the openai package
import openai

# From the IPython.display package, import display and Markdown
from IPython.display import display, Markdown

# Import yfinance as yf
import yfinance as yf

A outra tarefa de configuração é colocar a variável de ambiente que você acabou de criar em um local em que o pacote openai possa vê-la.

# Set openai.api_key to the OPENAI environment variable
openai.api_key = os.environ["OPENAI"]

O padrão de código para chamar o GPT por meio da API

O padrão de código para chamar a API da OpenAI e obter uma resposta de bate-papo é o seguinte:

response = openai.ChatCompletion.create(
              model="MODEL_NAME",
              messages=[{"role": "system", "content": 'SPECIFY HOW THE AI ASSISTANT SHOULD BEHAVE'},
                        {"role": "user", "content": 'SPECIFY WANT YOU WANT THE AI ASSISTANT TO SAY'}
              ])

Há vários aspectos que você deve analisar aqui.

Nomes de modelos da API da OpenAI para GPT

Os nomes dos modelos estão listados na página Visão geral do modelo da documentação do desenvolvedor. Neste tutorial, você usará gpt-3.5-turbo, que é o modelo mais recente usado pelo ChatGPT que tem acesso público à API. (Quando ele estiver amplamente disponível, você deverá mudar para gpt-4.)

Tipos de mensagem GPT da API da OpenAI

Há três tipos de mensagem documentados na Introdução à documentação do Chat:

• system As mensagens descrevem o comportamento do assistente de IA. Uma mensagem útil do sistema para casos de uso de ciência de dados é "Você é um assistente útil que entende de ciência de dados".
• user as mensagens descrevem o que você deseja que o assistente de IA diga. Abordaremos exemplos de mensagens de usuário ao longo deste tutorial
• assistant As mensagens descrevem respostas anteriores na conversa. Falaremos sobre como ter uma conversa interativa em tarefas posteriores

A primeira mensagem deve ser uma mensagem do sistema. Mensagens adicionais devem ser alternadas entre o usuário e o assistente.

Sua primeira conversa: Geração de um conjunto de dados

A geração de conjuntos de dados de amostra é útil para você testar seu código em diferentes cenários de dados ou para demonstrar o código a outras pessoas. Para obter uma resposta útil do GPT, você precisa ser preciso e especificar os detalhes do seu conjunto de dados, incluindo:

• o número de linhas e colunas
• os nomes das colunas
• uma descrição do que cada coluna contém
• o formato de saída do conjunto de dados

Aqui está um exemplo de mensagem de usuário para criar um conjunto de dados.

Create a small dataset about total sales over the last year. 
The format of the dataset should be a data frame with 12 rows and 2 columns. 
The columns should be called "month" and "total_sales_usd". 
The "month" column should contain the shortened forms of month names 
from "Jan" to "Dec". The "total_sales_usd" column should 
contain random numeric values taken from a normal distribution 
with mean 100000 and standard deviation 5000. Provide Python code to 
generate the dataset, then provide the output in the format of a markdown table.

Vamos incluir essa mensagem no padrão de código anterior.

# Define the system message
system_msg = 'You are a helpful assistant who understands data science.'

# Define the user message
user_msg = 'Create a small dataset about total sales over the last year. The format of the dataset should be a data frame with 12 rows and 2 columns. The columns should be called "month" and "total_sales_usd". The "month" column should contain the shortened forms of month names from "Jan" to "Dec". The "total_sales_usd" column should contain random numeric values taken from a normal distribution with mean 100000 and standard deviation 5000. Provide Python code to generate the dataset, then provide the output in the format of a markdown table.'

# Create a dataset using GPT
response = openai.ChatCompletion.create(model="gpt-3.5-turbo",
                                        messages=[{"role": "system", "content": system_msg},
                                         {"role": "user", "content": user_msg}])

Verifique se a resposta do GPT está OK

As chamadas de API são "arriscadas" porque podem ocorrer problemas fora do seu notebook, como problemas de conectividade com a Internet, ou um problema com o servidor que está enviando dados, ou porque você ficou sem crédito de API. Você deve verificar se a resposta recebida está correta.

Os modelos GPT retornam um código de status com um de quatro valores, documentados na seção Formato de resposta da documentação do Chat.

• stop: A API retornou a saída completa do modelo
• length: Saída incompleta do modelo devido ao parâmetro max_tokens ou ao limite de tokens
• content_filter: Conteúdo omitido devido a um sinalizador de nossos filtros de conteúdo
• null: Resposta da API ainda em andamento ou incompleta

A API do GPT envia dados para o Python no formato JSON, portanto, a variável de resposta contém listas e dicionários profundamente aninhados. É um pouco chato trabalhar com isso!

Para uma variável de resposta denominada response, o código de status é armazenado no seguinte local.

response["choices"][0]["finish_reason"]

Extraia a mensagem do assistente de IA

Dentro da variável de resposta está o texto que pedimos ao GPT para gerar. Felizmente, ele está sempre no mesmo lugar.

response["choices"][0]["message"]["content"]

O conteúdo da resposta pode ser impresso como de costume com print(content), mas é um conteúdo Markdown, que os notebooks Jupyter podem renderizar, por meio de display(Markdown(content))

Here's the Python code to generate the dataset:

import numpy as np
import pandas as pd
# Set random seed for reproducibility
np.random.seed(42)
# Generate random sales data
sales_data = np.random.normal(loc=100000, scale=5000, size=12)
# Create month abbreviation list
month_abbr = ['Jan', 'Feb', 'Mar', 'Apr', 'May', 'Jun', 'Jul', 'Aug', 'Sep', 'Oct', 'Nov', 'Dec']
# Create dataframe
sales_df = pd.DataFrame({'month': month_abbr, 'total_sales_usd': sales_data})
# Print dataframe
print(sales_df)

And here's the output in markdown format:

| month | total_sales_usd |

|-------|----------------|

| Jan | 98728.961189 |

| Feb | 106931.030292 |

| Mar | 101599.514152 |

| Apr | 97644.534384 |

| May | 103013.191014 |

| Jun | 102781.514665 |

| Jul | 100157.741173 |

| Aug | 104849.281004 |

| Sep | 100007.081991 |

| Oct | 94080.272682 |

| Nov | 96240.993328 |

| Dec | 104719.371461 |

Use uma função auxiliar para chamar a GPT

Você precisa escrever um monte de código repetitivo para fazer essas três coisas simples. É útil que você tenha uma função de proteção para abstrair as partes chatas. Dessa forma, podemos nos concentrar nos casos de uso da ciência de dados.

Esperamos que a OpenAI aprimore a interface de seu pacote Python para que esse tipo de coisa seja incorporado. Enquanto isso, fique à vontade para usar isso em seu próprio código.

A função recebe dois argumentos.

• system: Uma cadeia de caracteres que contém a mensagem do sistema.
• user_assistant: Uma matriz de cadeias de caracteres que alternam a mensagem do usuário e a mensagem do assistente.

O valor de retorno é o conteúdo gerado.

def chat(system, user_assistant):
  assert isinstance(system, str), "`system` should be a string"
  assert isinstance(user_assistant, list), "`user_assistant` should be a list"
  system_msg = [{"role": "system", "content": system}]
  user_assistant_msgs = [
      {"role": "assistant", "content": user_assistant[i]} if i % 2 else {"role": "user", "content": user_assistant[i]}
      for i in range(len(user_assistant))]

  msgs = system_msg + user_assistant_msgs
  response = openai.ChatCompletion.create(model="gpt-3.5-turbo",
                                          messages=msgs)
  status_code = response["choices"][0]["finish_reason"]
  assert status_code == "stop", f"The status code was {status_code}."
  return response["choices"][0]["message"]["content"]

Um exemplo de uso dessa função é

response_fn_test = chat("You are a machine learning expert.",["Explain what a neural network is."])

display(Markdown(response_fn_test))

A neural network is a type of machine learning model that is inspired by the architecture of the human brain. It consists of layers of interconnected processing units, called neurons, that work together to process and analyze data.

Each neuron receives input from other neurons or from external sources, processes that input using a mathematical function, and then produces an output that is passed on to other neurons in the network.

The structure and behavior of a neural network can be adjusted by changing the weights and biases of the connections between neurons. During the training process, the network learns to recognize patterns and make predictions based on the input it receives.

Neural networks are often used for tasks such as image classification, speech recognition, and natural language processing, and have been shown to be highly effective at solving complex problems that are difficult to solve with traditional rule-based programming methods.

Reutilização de respostas do assistente de IA

Em muitas situações, você desejará ter uma conversa mais longa com a IA. Ou seja, você envia um prompt para o GPT, recebe uma resposta de volta e envia outro prompt para continuar o bate-papo. Nesse caso, você precisa incluir a resposta anterior do GPT na segunda chamada à API, para que o GPT tenha o contexto completo. Isso melhorará a precisão da resposta e aumentará a consistência em toda a conversa.

Para reutilizar a mensagem do GPT, você a recupera da resposta e a passa para uma nova chamada ao chat.

Exemplo: Analisando o conjunto de dados de amostra

Vamos tentar calcular a média da coluna de vendas do conjunto de dados que foi gerado anteriormente. Observe que, como não usamos a função chat() na primeira vez, temos que usar o código de subconjunto mais longo para obter o texto da resposta anterior. Se você usar chat(), o código será mais simples.

# Assign the content from the response in Task 1 to assistant_msg
assistant_msg = response["choices"][0]["message"]["content"]

# Define a new user message
user_msg2 = 'Using the dataset you just created, write code to calculate the mean of the `total_sales_usd` column. Also include the result of the calculation.'

# Create an array of user and assistant messages
user_assistant_msgs = [user_msg, assistant_msg, user_msg2]

# Get GPT to perform the request
response_calc = chat(system_msg, user_assistant_msgs)

# Display the generated content
display(Markdown(response_calc))

Sure! Here's the code to calculate the mean of the `total_sales_usd` column: 

```python 
mean_sales = sales_df['total_sales_usd'].mean() 
print("Mean sales: $", round(mean_sales, 2)) 
``` 

And here's the output of this code: 

``` 
Mean sales: $ 100077.57 
``` 

Therefore, the mean of total sales over the last year is about $100,077.57. 

Uso do GPT em um pipeline

Uma grande vantagem de usar a API em vez da interface da Web é que você pode combinar o GPT com outras APIs. A extração de dados de uma ou mais fontes e a aplicação de IA a eles é um fluxo de trabalho poderoso.

Aplicação de IA GPT a dados meteorológicos

Aqui, você obterá uma previsão do tempo com o pacote weather2(PyPI) e usará o GPT para ter ideias de atividades.

# Import the weather2 package
import weather

# Get the forecast for Miami
location = "Miami"
forecast = weather.forecast(location)

# Pull out forecast data for midday tomorrow
fcast = forecast.tomorrow["12:00"]

# Create a prompt
user_msg_weather = f"In {location} at midday tomorrow, the temperature is forecast to be {fcast.temp}, the wind speed is forecast to be {fcast.wind.speed} m/s, and the amount of precipitation is forecast to be {fcast.precip}. Make a list of suitable leisure activities."

# Call GPT
response_activities = chat("You are a travel guide.", [user_msg_weather])

display(Markdown(response_activities))

With mild temperatures and calm winds, Miami is the perfect place for leisure activities. Here are some suggestions:

1. Visit Miami's beaches and soak up some sun or take a dip in the ocean!

2. Explore Miami's art scene with a visit to the Perez Art Museum Miami or the Wynwood Walls.

3. Take a stroll along the famous Ocean Drive and enjoy the colorful Art Deco architecture.

4. Head to Little Havana to experience the Cuban culture and delicious cuisine.

5. Enjoy a scenic walk or bike ride through one of Miami's many parks, such as Bayfront Park or South Pointe Park.

6. Visit the Miami Seaquarium and see some incredible marine life up close.

7. Take a boat tour to see the stunning Miami skyline from the water.

8. Shopping enthusiasts can explore the many high-end boutiques and outdoor shopping malls, such as Lincoln Road Mall.

9. Foodies can venture to one of the many food festivals happening throughout the year.

10. Finally, there are plenty of nightclubs and live music venues to keep the night going.

Legal! Parte de mim gostaria de estar em Miami amanhã!

Leve-o para o próximo nível

Você pode saber mais sobre o uso do GPT no curso Introdução ao ChatGPT. (Em breve, você terá um curso completo sobre como trabalhar com a API da OpenAI!)

Para ter uma referência do que você acabou de aprender, pegue uma cópia da folha de dicas da API OpenAI em Python ou assista à gravação do treinamento ao vivo Getting Started with the OpenAI API and ChatGPT.

Se você estiver interessado em transcrição de texto para fala, leia o tutorial Conversão de fala em texto com a API OpenAI Whisper.