API Model GPT

1. Dasar-dasar Model Generasi Teks

Model generasi teks dari OpenAI, biasanya disebut sebagai Generative Pre-trained Transformer (GPT), mengandalkan mekanisme self-attention dalam deep learning untuk memahami dan memproses bahasa alami. Pelatihan model GPT terdiri dari dua tahap: pra-pelatihan dan penyetelan halus.

Pra-Pelatihan

Selama tahap pra-pelatihan, model menjalani pembelajaran tanpa pengawasan menggunakan dataset teks dalam skala besar. Dalam proses ini, model dilatih dengan memprediksi kata berikutnya. Misalnya, diberikan kalimat "Saya punya pena," setelah melihat beberapa kata pertama, model mencoba memprediksi kata "pena." Tujuan utama pra-pelatihan adalah memungkinkan model memahami struktur dan semantik bahasa.

Penyetelan Halus

Tahap penyetelan halus melibatkan pembelajaran terawasi pada tugas-tugas spesifik. Pada tahap ini, model disesuaikan untuk beradaptasi dengan aplikasi khusus seperti sistem tanya jawab dan ringkasan dokumen. Penyetelan halus melibatkan pelatihan lebih lanjut pada model dengan dataset yang telah di-annotasi berdasarkan model pra-pelatihan, memungkinkan model untuk lebih baik beradaptasi dengan tugas spesifik.

2. Skenario Aplikasi

Model generasi teks dari OpenAI dapat diterapkan pada berbagai skenario. Berikut adalah beberapa aplikasi spesifik:

• Pembuatan Dokumen: Membantu pengguna dalam dengan cepat membuat dan mengedit dokumen.
• Menulis Kode Komputer: Menghasilkan potongan kode untuk membantu dalam pemrograman.
• Menjawab Pertanyaan Tentang Basis Pengetahuan: Memberikan jawaban berdasarkan pengetahuan yang tersimpan.
• Analisis Teks: Mengekstrak informasi teks, menganalisis sentimen, dan lainnya.
• Memberikan Antarmuka Bahasa Alami untuk Perangkat Lunak: Memungkinkan pengguna berinteraksi dengan perangkat lunak menggunakan bahasa alami.
• Pembelajaran dalam Berbagai Mata Pelajaran: Memberikan bimbingan pengajaran di berbagai mata pelajaran.
• Penerjemahan Bahasa: Menerjemahkan teks antara berbagai bahasa.
• Simulasi Karakter untuk Permainan: Menghasilkan percakapan dan latar belakang cerita untuk permainan atau skenario peran.

3. Pengenalan Model Dialog

Model dialog merupakan jenis khusus dari model generasi teks yang memahami dan menghasilkan percakapan alami melalui pra-pelatihan. Model ini dapat mensimulasikan percakapan antara pengguna dan asisten virtual, cocok untuk aplikasi interaktif real-time.

Penggunaan model dialog biasanya melibatkan percakapan interaktif multi-putaran. Misalnya, ketika seorang pengguna bertanya, model dapat menghasilkan tanggapan yang sesuai berdasarkan data pelatihan sebelumnya. Selain itu, model dialog dapat mempertahankan informasi kontekstual, mempertimbangkan konten percakapan sebelumnya untuk menghasilkan tanggapan yang lebih koheren dan alami.

Skenario aplikasi model dialog:

• Asisten Layanan Pelanggan: Otomatis menjawab pertanyaan yang sering diajukan oleh pengguna, memberikan bantuan, dan saran.
• Chatbot: Terlibat dalam interaksi percakapan alami dengan pengguna.
• Asisten Virtual: Melaksanakan perintah suara pengguna, seperti jadwal rapat, mengatur pengingat, dan lainnya.
• Permainan Peran: Memperkaya pengalaman bermain dengan memberikan karakter permainan percakapan unik dan kepribadian.

4. API Model Dialog

API Model Dialog memungkinkan pengembang untuk berinteraksi dengan model GPT menggunakan permintaan HTTP. Bagian ini akan memperkenalkan cara menggunakan curl untuk membuat permintaan dan mem-parsing tanggapan yang dikembalikan oleh model.

Membangun Permintaan

Sebelum memulai, Anda perlu mendaftar dan memperoleh kunci API dari OpenAI, yang perlu diotentikasi melalui header HTTP saat mengirim permintaan.

Berikut ini adalah contoh penggunaan curl untuk mengirim permintaan ke API Model Dialog:

curl https://api.openai.com/v1/chat/completions \
  -H "Content-Type: application/json" \
  -H "Authorization: Bearer $OPENAI_API_KEY" \
  -d '{
    "model": "gpt-3.5-turbo",
    "messages": [
      {
        "role": "system",
        "content": "Anda adalah asisten yang membantu."
      },
      {
        "role": "user",
        "content": "Tim mana yang memenangkan Seri Dunia 2020?"
      }
    ]
  }'

Arti Parameter Model Dialog

Ketika menggunakan API Model Dialog dari OpenAI, parameter utama meliputi "model" dan "messages," masing-masing membawa makna spesifik dan mempengaruhi hasil yang dihasilkan.

Parameter Model

Parameter model digunakan untuk menentukan versi model yang akan digunakan. Misalnya, "model": "gpt-3.5-turbo" menunjukkan bahwa Anda meminta model GPT-3.5-Turbo. Versi model yang dipilih di sini akan merespons masukan pengguna berdasarkan kemampuannya, data pelatihan, dan fitur antarmuka.

Berikut adalah model-model yang saat ini didukung:

Parameter Pesan

Parameter pesan adalah sebuah larik, di mana setiap elemen mewakili pesan dalam percakapan. Setiap pesan adalah objek yang berisi dua properti: peran (peran pengirim) dan konten (konten spesifik dari pesan).

• role: Menentukan peran pengirim pesan. Nilai opsional meliputi "sistem", "pengguna", dan "asisten".
• content: Konten spesifik dari pesan.

Tipe dan Fungsi Peran

Nilai parameter peran mendefinisikan tipe dan fungsi pesan. API Dialog akan mengubah respon model berdasarkan peran yang berbeda.

Peran 'sistem'

Pesan sistem digunakan untuk secara global menunjukkan perilaku model. Misalnya, ini dapat secara eksplisit menentukan peran yang dimainkan oleh model (seperti asisten, penerjemah, dll.), atau memberikan instruksi khusus yang harus diikuti dalam percakapan. Pesan sistem memiliki dampak jangka panjang pada perilaku model sepanjang percakapan, tetapi biasanya bersifat opsional.

Misalnya, jika Anda ingin model berpartisipasi dalam percakapan sebagai asisten layanan pelanggan, Anda dapat menentukan dalam pesan sistem:

{
  "role": "system",
  "content": "Anda adalah asisten layanan pelanggan."
}

Peran 'pengguna'

Pesan pengguna mewakili pertanyaan yang dimasukkan oleh pengguna. Model merespons pesan-pesan ini dan memberikan informasi, jawaban, atau bentuk output lainnya. Pesan-pesan ini adalah bagian penting dari alur kerja API Dialog dan biasanya sesuai dengan pertanyaan pengguna aktual dalam aplikasi.

Misalnya, dalam permintaan pengguna pada contoh curl di atas:

{
  "role": "user",
  "content": "Tim mana yang memenangkan Seri Dunia 2020?"
}

Peran 'asisten'

Pesan asisten umumnya merujuk pada balasan yang dihasilkan oleh model dan juga dapat menjadi bagian dari pesan riwayat percakapan yang disediakan oleh pengembang, digunakan untuk mensimulasikan format pesan balik AI. Dalam permintaan API, pesan peran asisten biasanya tidak disediakan kecuali diperlukan untuk mengatur format di mana model menjawab pertanyaan dalam riwayat percakapan untuk memberikan contoh output untuk model.

Memproses Tanggapan

Tanggapan model dikembalikan dalam format JSON. Berikut adalah contoh memproses tanggapan:

{
  "choices": [
    {
      "finish_reason": "stop",
      "index": 0,
      "message": {
        "content": "Pemenang Seri Dunia 2020 adalah Los Angeles Dodgers.",
        "role": "asisten"
      },
      "logprobs": null
    }
  ],
  "created": 1677664795,
  "id": "chatcmpl-7QyqpwdfhqwajicIEznoc6Q47XAyW",
  "model": "gpt-3.5-turbo-0613",
  "object": "chat.completion",
  "usage": {
    "completion_tokens": 17,
    "prompt_tokens": 57,
    "total_tokens": 74
  }
}

Dalam tanggapan di atas, Anda dapat memperoleh jawaban model dari choices[0].message.content.

Cara Mengimplementasikan Fungsi Memori dalam Model Percakapan

Berikut adalah contoh penggunaan API Lengkap Obrolan OpenAI untuk mengimplementasikan fungsi memori model GPT, yang menunjukkan bagaimana menyimpan konteks percakapan historis (yaitu, konten memori) dalam permintaan API baru untuk mencapai percakapan berkelanjutan.

import requests

api_url = "https://api.openai.com/v1/chat/completions"
api_key = "Kunci API OpenAI Anda"

headers = {
    "Content-Type": "application/json",
    "Authorization": f"Bearer {api_key}"
}

data = {
    "model": "gpt-3.5-turbo",  # Dapat diganti dengan gpt-4 atau model lain yang tersedia
    "messages": [
      {
        "role": "system",  # Pesan sistem, digunakan untuk mengatur perilaku model percakapan
        "content": "Anda adalah asisten bantuan."
      },
      {
        "role": "user",  # Pesan pengguna, model akan merespons terhadap ini
        "content": "Bisakah kamu memberitahu saya alasan utama perubahan iklim?"
      },
      {
        "role": "assistant",  # Tanggapan model
        "content": "Alasan utama perubahan iklim termasuk emisi gas rumah kaca, pembakaran bahan bakar fosil, dan deforestasi, dll."
      },
      {
        "role": "user",  # Pertanyaan baru berdasarkan penjelasan model
        "content": "Bagaimana cara kita mengurangi emisi gas rumah kaca?"
      }
    ]
}

response = requests.post(api_url, headers=headers, json=data)

if response.status_code == 200:
    reply_content = response.json()['choices'][0]['message']['content']
    print(f"Tanggapan model => {reply_content}")
else:
    print(f"Error permintaan: {response.status_code}")

Pada contoh ini, kami mensimulasikan pengguna pertama-tama menanyakan tentang alasan utama perubahan iklim, dan kemudian mengajukan pertanyaan lain berdasarkan penjelasan model. Pada permintaan selanjutnya, kami menyimpan konten percakapan sebelumnya untuk memastikan bahwa model dapat mengingat sejarah percakapan sebelumnya dan menghasilkan respons berdasarkan hal itu. Metode ini mencapai transmisi dan memori keadaan percakapan dengan menggunakan masukan dan keluaran putaran percakapan sebelumnya sebagai pesan historis dari permintaan baru.

Tip: Untuk mengimplementasikan fungsi memori dari percakapan, karena model memiliki batas token maksimum, tidak memungkinkan untuk memasukkan semua pesan percakapan historis untuk setiap permintaan. Biasanya, pesan terkait yang terkait dengan pertanyaan saat ini dimasukkan sebagai pesan historis ke dalam model, dan bagian-bagian berikut akan mengenalkan bagaimana fitur Embeddings mencapai pencarian kesamaan teks.

5. Skema JSON

Skema JSON merupakan fitur dari API model percakapan yang memungkinkan pengguna untuk memberi instruksi kepada model untuk selalu mengembalikan objek JSON, cocok untuk skenario yang membutuhkan menerima respons dalam format JSON.

Menggunakan Skema JSON

Untuk menggunakan Skema JSON, Anda perlu mengatur bidang response_format menjadi { "type": "json_object" } dalam badan permintaan HTTP dan memastikan bahwa pesan sistem menunjukkan bahwa keluaran model berbentuk JSON. Berikut adalah contoh permintaan curl untuk mengaktifkan Skema JSON:

curl https://api.openai.com/v1/chat/completions \
  -H "Content-Type: application/json" \
  -H "Authorization: Bearer $OPENAI_API_KEY" \
  -d '{
    "model": "gpt-3.5-turbo-1106",
    "response_format": { "type": "json_object" },
    "messages": [
      {
        "role": "system",
        "content": "Anda adalah asisten bantuan yang dirancang untuk mengeluarkan JSON."
      },
      {
        "role": "user",
        "content": "Tim mana yang memenangkan Seri Dunia 2020?"
      }
    ]
  }'

Parsing JSON Schema Response

Pada mode Skema JSON, responsenya akan berisi objek JSON yang lengkap dan terurai dengan sempurna. Mode ini memastikan keluaran model adalah objek JSON yang valid yang dapat langsung diurai dan digunakan. Berikut adalah contoh respons yang dapat dikembalikan menggunakan Skema JSON:

{
  "choices": [
    {
      "finish_reason": "stop",
      "message": {
        "content": "{\"winner\": \"Los Angeles Dodgers\"}"
      }
    }
  ]
}

Di Python, Anda dapat menggunakan kode berikut untuk mengekstrak konten dari respons:

import json

response = {
  "choices": [
    {
      "finish_reason": "stop",
      "message": {
        "content": "{\"winner\": \"Los Angeles Dodgers\"}"
      }
    }
  ]
}

response_content = json.loads(response['choices'][0]['message']['content'])

print(response_content)

Hasilnya akan seperti ini:

{'winner': 'Los Angeles Dodgers'}

Skema JSON menyediakan metode yang dapat diandalkan untuk memastikan format respons yang benar untuk kasus penggunaan tertentu. Oleh karena itu, disarankan untuk mengaktifkan Skema JSON dalam skenario di mana terdapat persyaratan spesifik terkait format respons API.