Imagem gerada com Ideograma.ai
 

Quem nunca ouviu falar sobre OpenAI? O laboratório de pesquisa de IA mudou o mundo por causa de seu famoso produto, ChatGPT.

Literalmente mudou o cenário da implementação da IA, e muitas empresas agora correm para se tornarem o próximo grande sucesso.

Apesar da grande concorrência, a OpenAI ainda é a empresa ideal para qualquer necessidade de negócios de IA generativa porque possui um dos melhores modelos e suporte contínuo. A empresa fornece muitos modelos de IA generativa de última geração com vários recursos de tarefas: geração de imagens, conversão de texto em fala e muito mais. 

Todos os modelos que a OpenAI oferece estão disponíveis por meio de chamadas de API. Com código Python simples, você já pode usar o modelo. 

Neste artigo, exploraremos como usar a API OpenAI com Python e várias tarefas que você pode realizar. Espero que você aprenda muito com este artigo.

Para acompanhar este artigo, há algumas coisas que você precisa preparar.

A coisa mais importante que você precisa são as chaves de API do OpenAI, pois você não pode acessar os modelos OpenAI sem a chave. Para adquirir acesso, você deve se cadastrar em uma conta OpenAI e solicitar a API Key no site página da conta. Depois de receber a chave, salve-a em algum lugar que você possa lembrar, pois ela não aparecerá novamente na interface do OpenAI.

A próxima coisa que você precisa definir é comprar o crédito pré-pago para usar a API OpenAI. Recentemente, a OpenAI anunciou mudanças na forma como o faturamento deles funciona. Em vez de pagar no final do mês, precisamos adquirir crédito pré-pago para a chamada da API. Você pode visitar o Preços OpenAI página para estimar o crédito que você precisa. Você também pode verificar seus página do modelo para entender qual modelo você precisa.

Por último, você precisa instalar o pacote OpenAI Python em seu ambiente. Você pode fazer isso usando o código a seguir.

pip install openai

Em seguida, você precisa definir sua variável OpenAI Key Environment usando o código abaixo.

import os

os.environ['OPENAI_API_KEY'] = 'YOUR API KEY'

Com tudo definido, vamos começar a explorar a API dos modelos OpenAI com Python.

A estrela da API OpenAI é seu modelo Text Generations. Essa família de modelos de linguagem grande pode produzir saída de texto a partir da entrada de texto chamada prompt. Os prompts são basicamente instruções sobre o que esperamos do modelo, como análise de texto, geração de rascunhos de documentos e muito mais.

Vamos começar executando uma chamada simples da API Text Generations. Usaríamos o modelo GPT-3.5-Turbo da OpenAI como modelo base. Não é o modelo mais avançado, mas os mais baratos costumam ser suficientes para realizar tarefas relacionadas a texto.

from openai import OpenAI
client = OpenAI()

completion = client.chat.completions.create(
  model="gpt-3.5-turbo",
  messages=[
    {"role": "system", "content": "You are a helpful assistant."},
    {"role": "user", "content": "Generate me 3 Jargons that I can use for my Social Media content as a Data Scientist content creator"}
  ]
)

print(completion.choices[0].message.content)

1. “Liberando o poder da análise preditiva para impulsionar decisões baseadas em dados!”
2. “Mergulhar profundamente no oceano de dados para descobrir insights valiosos.”
3. “Transformando dados brutos em inteligência acionável por meio de algoritmos avançados.”

A chamada de API para o modelo de geração de texto usa o API Endpoint chat.completions para criar a resposta de texto do nosso prompt. 

Existem dois parâmetros obrigatórios para geração de texto: modelo e mensagens. 

Para o modelo, você pode verificar a lista de modelos que pode usar na página do modelo relacionado. 

Quanto às mensagens, passamos um dicionário com dois pares: o papel e o conteúdo. A chave de função especificou o remetente da função no modelo de conversa. Existem 3 funções diferentes: sistema, usuário e assistente.

Usando a função nas mensagens, podemos ajudar a definir o comportamento do modelo e um exemplo de como o modelo deve responder ao nosso prompt.

Vamos estender o exemplo de código anterior com o role assistant para fornecer orientação sobre nosso modelo. Além disso, exploraríamos alguns parâmetros do modelo de geração de texto para melhorar seu resultado.

completion = client.chat.completions.create(
    model="gpt-3.5-turbo",
    messages=[
        {"role": "system", "content": "You are a helpful assistant."},
        {"role": "user", "content": "Generate me 3 jargons that I can use for my Social Media content as a Data Scientist content creator."},
        {"role": "assistant", "content": "Sure, here are three jargons: Data Wrangling is the key, Predictive Analytics is the future, and Feature Engineering help your model."},
        {"role": "user", "content": "Great, can you also provide me with 3 content ideas based on these jargons?"}
    ],
    max_tokens=150,
    temperature=0.7,
    top_p=1,
    frequency_penalty=0
)

print(completion.choices[0].message.content)

Claro! Aqui estão três ideias de conteúdo baseadas nos jargões fornecidos:

1. “Liberando o poder da organização de dados: um guia passo a passo para cientistas de dados” – Crie uma postagem no blog ou um tutorial em vídeo apresentando as melhores práticas e ferramentas para organização de dados em um projeto de ciência de dados do mundo real.

2. “O Futuro da Análise Preditiva: Tendências e Inovações na Ciência de Dados” – Escreva um artigo de liderança inovadora discutindo tendências e tecnologias emergentes em análise preditiva e como elas estão moldando o futuro da ciência de dados.

3. “Dominando a engenharia de recursos: técnicas para aumentar o desempenho do modelo” – Desenvolva um infográfico ou uma série de mídia social destacando diferentes técnicas de engenharia de recursos e seu impacto na melhoria da precisão e eficiência dos modelos de aprendizado de máquina.

A saída resultante segue o exemplo que fornecemos ao modelo. Usar o assistente de função é útil se tivermos um determinado estilo ou resultado que queremos que o modelo siga.

Quanto aos parâmetros, aqui estão explicações simples de cada parâmetro que usamos:

• max_tokens: Este parâmetro define o número máximo de palavras que o modelo pode gerar.
• temperatura: este parâmetro controla a imprevisibilidade da saída do modelo. Uma temperatura mais alta resulta em resultados mais variados e imaginativos. O intervalo aceitável é de 0 a infinito, embora valores acima de 2 sejam incomuns.
• topo_p: também conhecido como amostragem nuclear, esse parâmetro ajuda a determinar o subconjunto da distribuição de probabilidade da qual o modelo extrai sua saída. Por exemplo, um valor top_p de 0.1 significa que o modelo considera apenas os 10% superiores da distribuição de probabilidade para amostragem. Seus valores podem variar de 0 a 1, com valores mais altos permitindo maior diversidade de saída.
• penalidade_frequência: penaliza tokens repetidos na saída do modelo. O valor da penalidade pode variar de -2 a 2, onde valores positivos desencorajam a repetição de tokens e valores negativos fazem o oposto, incentivando o uso repetido de palavras. Um valor 0 indica que nenhuma penalidade é aplicada por repetição.

Por último, você pode alterar a saída do modelo para o formato JSON com o código a seguir.

completion = client.chat.completions.create(
  model="gpt-3.5-turbo",
  response_format={ "type": "json_object" },
  messages=[
    {"role": "system", "content": "You are a helpful assistant designed to output JSON.."},
    {"role": "user", "content": "Generate me 3 Jargons that I can use for my Social Media content as a Data Scientist content creator"}
  ]
)

print(completion.choices[0].message.content)

{
“jargões”: [
“Aproveitando a análise preditiva para desbloquear insights valiosos”,
“Investigando as complexidades dos algoritmos avançados de aprendizado de máquina”,
“Aproveitando o poder do big data para impulsionar decisões baseadas em dados”
]
}

O resultado está no formato JSON e segue o prompt que inserimos no modelo.

Por completo Documentação da API de geração de texto, você pode conferi-los em sua página dedicada.

O modelo OpenAI é útil para casos de uso de geração de texto e também pode chamar a API para fins de geração de imagens. 

Utilizando o modelo DALL·E, podemos gerar uma imagem conforme solicitado. A maneira simples de fazer isso é usando o código a seguir.

from openai import OpenAI
from IPython.display import Image

client = OpenAI()

response = client.images.generate(
  model="dall-e-3",
  prompt="White Piano on the Beach",
  size="1792x1024",
  quality="hd",
  n=1,
)

image_url = response.data[0].url
Image(url=image_url)

Imagem gerada com DALL·E 3
 

Para os parâmetros, aqui estão as explicações:

• modelo: O modelo de geração de imagem a ser usado. Atualmente, a API suporta apenas os modelos DALL·E 3 e DALL·E 2. 
• pronto: Esta é a descrição textual com base na qual o modelo irá gerar uma imagem. 
• tamanho: Determina a resolução da imagem gerada. Existem três opções para o modelo DALL·E 3 (1024×1024, 1024×1792 ou 1792×1024).
• qualidade: Este parâmetro influencia a qualidade da imagem gerada. Se for necessário tempo computacional, “padrão” é mais rápido que “hd”.
• n: especifica o número de imagens a serem geradas com base no prompt. O DALL·E 3 só pode gerar uma imagem por vez. DALL·E 2 pode gerar até 10 por vez.

Também é possível gerar uma imagem variação a partir da imagem existente, embora só esteja disponível no modelo DALL·E 2. A API também aceita apenas imagens PNG quadradas abaixo de 4 MB.

from openai import OpenAI
from IPython.display import Image

client = OpenAI()

response = client.images.create_variation(
  image=open("white_piano_ori.png", "rb"),
  n=2,
  size="1024x1024"
)

image_url = response.data[0].url

Image(url=image_url)

A imagem pode não ser tão boa quanto a do DALL·E 3 gerações, pois é no modelo mais antigo.

OpenAI é uma empresa líder que fornece modelos que podem compreender a entrada de imagens. Este modelo é chamado de modelo Vision, às vezes chamado de GPT-4V. O modelo é capaz de responder perguntas de acordo com a imagem que fornecemos.

Vamos experimentar a API do modelo Vision. Neste exemplo, eu usaria a imagem do piano branco que geramos a partir do modelo DALL·E 3 e a armazenaria localmente. Além disso, eu criaria uma função que pegasse o caminho da imagem e retornasse o texto de descrição da imagem. Não se esqueça de alterar a variável api_key para sua chave API.

from openai import OpenAI
import base64
import requests
def provide_image_description(img_path):

    client = OpenAI()

    api_key = 'YOUR-API-KEY'
    # Function to encode the image
    def encode_image(image_path):
      with open(image_path, "rb") as image_file:
        return base64.b64encode(image_file.read()).decode('utf-8')
   
    # Path to your image
    image_path = img_path
   
    # Getting the base64 string
    base64_image = encode_image(image_path)
   
    headers = {
      "Content-Type": "application/json",
      "Authorization": f"Bearer {api_key}"
    }
   
    payload = {
      "model": "gpt-4-vision-preview",
      "messages": [
        {
          "role": "user",
          "content": [
            {
              "type": "text",
              "text": """Can you describe this image? """
            },
            {
              "type": "image_url",
              "image_url": {
                "url": f"data:image/jpeg;base64,{base64_image}"
              }
            }
          ]
        }
      ],
      "max_tokens": 300
    }
   
    response = requests.post("https://api.openai.com/v1/chat/completions", headers=headers, json=payload)

    return response.json()['choices'][0]['message']['content']

Esta imagem apresenta um piano de cauda colocado em um ambiente sereno de praia. O piano é branco, indicando um acabamento muitas vezes associado à elegância. O instrumento está situado bem na orla da costa, onde as ondas suaves acariciam levemente a areia, criando uma espuma que toca apenas a base do piano e o banco correspondente. A envolvência da praia implica uma sensação de tranquilidade e isolamento com céu azul claro, nuvens fofas ao longe e um mar calmo que se expande até ao horizonte. Espalhadas ao redor do piano na areia estão inúmeras conchas de vários tamanhos e formatos, destacando a beleza natural e a atmosfera serena do cenário. A justaposição de um instrumento de música clássica em um ambiente natural de praia cria uma composição surreal e visualmente poética.

Você pode ajustar os valores de texto no dicionário acima para corresponder aos requisitos do seu modelo Vision.

OpenAI também fornece um modelo para gerar áudio com base em seu modelo Text-to-Speech. É muito fácil de usar, embora o estilo de narração por voz seja limitado. Além disso, o modelo suporta vários idiomas, que você pode ver em seus página de suporte a idiomas.

Para gerar o áudio, você pode usar o código abaixo.

from openai import OpenAI
client = OpenAI()

speech_file_path = "speech.mp3"
response = client.audio.speech.create(
  model="tts-1",
  voice="alloy",
  input="I love data science and machine learning"
)

response.stream_to_file(speech_file_path)

Você deverá ver o arquivo de áudio em seu diretório. Tente jogar e veja se está de acordo com seu padrão. 

Atualmente, existem apenas alguns parâmetros que você pode usar para o modelo Text-to-Speech:

• model: O modelo Text-to-Speech a ser usado. Apenas dois modelos estão disponíveis (tts-1 ou tts-1-hd), onde o tts-1 otimiza a velocidade e o tts-1-hd para qualidade.
• voz: O estilo de voz a ser usado onde toda a voz é otimizada para inglês. A seleção é liga, eco, fábula, ônix, nova e brilho.
• response_format: O arquivo de formato de áudio. Atualmente, os formatos suportados são mp3, opus, aac, flac, wav e pcm.
• speed: A velocidade do áudio gerado. Você pode selecionar valores entre 0.25 e 4. 
• input: O texto para criar o áudio. Atualmente, o modelo suporta apenas até 4096 caracteres.

OpenAI fornece modelos para transcrever e traduzir dados de áudio. Usando o modelo de sussurros, podemos transcrever áudio do idioma suportado para arquivos de texto e traduzi-los para o inglês.

Vamos tentar uma transcrição simples do arquivo de áudio que geramos anteriormente.

from openai import OpenAI
client = OpenAI()

audio_file= open("speech.mp3", "rb")
transcription = client.audio.transcriptions.create(
  model="whisper-1",
  file=audio_file
)

print(transcription.text)

Adoro ciência de dados e aprendizado de máquina.

Também é possível realizar a tradução dos arquivos de áudio para o idioma inglês. O modelo ainda não está disponível para tradução para outro idioma.

from openai import OpenAI
client = OpenAI()

audio_file = open("speech.mp3", "rb")
translate = client.audio.translations.create(
  model="whisper-1",
  file=audio_file
)

Exploramos vários serviços de modelo que OpenAI fornece, desde modelos de geração de texto, geração de imagem, geração de áudio, visão e conversão de texto em fala. Cada modelo tem seu parâmetro de API e especificações que você precisa aprender antes de usá-los.
 
 

Cornélio Yudha Wijaya é gerente assistente de ciência de dados e redator de dados. Enquanto trabalha em tempo integral na Allianz Indonésia, ele adora compartilhar dicas sobre Python e dados nas redes sociais e na mídia escrita. Cornellius escreve sobre uma variedade de tópicos de IA e aprendizado de máquina.

• Conteúdo com tecnologia de SEO e distribuição de relações públicas. Seja amplificado hoje.
• PlatoData.Network Gerativa Vertical Ai. Capacite-se. Acesse aqui.
• PlatoAiStream. Inteligência Web3. Conhecimento Amplificado. Acesse aqui.
• PlatãoESG. Carbono Tecnologia Limpa, Energia, Ambiente, Solar, Gestão de resíduos. Acesse aqui.
• PlatoHealth. Inteligência em Biotecnologia e Ensaios Clínicos. Acesse aqui.
• Fonte: https://www.kdnuggets.com/exploring-the-openai-api-with-python?utm_source=rss&utm_medium=rss&utm_campaign=exploring-the-openai-api-with-python