API modelu GPT

1. Podstawy modeli generowania tekstu

Model generowania tekstu OpenAI, zazwyczaj nazywany Generative Pre-trained Transformer (GPT), wykorzystuje mechanizm samo-uwagi w uczeniu głębokim do zrozumienia i przetwarzania języka naturalnego. Szkolenie modelu GPT składa się z dwóch etapów: wstępnego szkolenia i dostrojenia.

Wstępne szkolenie

Podczas etapu wstępnego szkolenia model przechodzi przez uczenie nienadzorowane przy użyciu dużego zbioru danych tekstowych. W tym procesie model jest szkolony poprzez przewidywanie następnego słowa. Na przykład, mając zdanie "Mam długopis", po zobaczeniu kilku pierwszych słów, próbuje przewidzieć słowo "długopis". Głównym celem wstępnego szkolenia jest umożliwienie modelowi zrozumienia struktury i semantyki języka.

Dostrojenie

Etap dostrojenia polega na uczeniu nadzorowanym w ramach konkretnych zadań. W tym etapie model jest dostosowywany do konkretnych zastosowań, takich jak systemy odpowiadania na pytania i streszczanie dokumentów. Dostrojenie polega na dalszym szkoleniu modelu przy użyciu oznakowanych zbiorów danych na podstawie wstępnie wytrenowanego modelu, umożliwiając mu lepsze dostosowanie do konkretnych zadań.

2. Scenariusze zastosowań

Model generowania tekstu OpenAI może być stosowany w szerokim zakresie scenariuszy. Oto kilka konkretnych zastosowań:

• Redagowanie Dokumentów: Pomoc użytkownikom w szybkim tworzeniu i edycji dokumentów.
• Pisanie Kodu Komputerowego: Generowanie fragmentów kodu w celu pomocy w programowaniu.
• Odpowiadanie na Pytania o Bazę Wiedzy: Udzielanie odpowiedzi na podstawie przechowywanej wiedzy.
• Analiza Tekstu: Wyodrębnianie informacji tekstowych, analiza sentymentu i inne.
• Zapewnianie Interfejsu Języka Naturalnego do Oprogramowania: Umożliwianie interakcji użytkowników z oprogramowaniem za pomocą języka naturalnego.
• Tutoring w Zakresie Różnych Przedmiotów: Udzielanie wsparcia edukacyjnego w różnych przedmiotach.
• Tłumaczenie Języka: Tłumaczenie tekstu między różnymi językami.
• Symulowanie Postaci w Grach: Generowanie dialogów i historii tła dla gier lub scenariuszy fabularnych.

3. Wprowadzenie do Modelu Dialogowego

Model dialogowy to specjalny rodzaj modelu generowania tekstu, który rozumie i generuje naturalne rozmowy poprzez wstępne szkolenie. Model ten może symulować rozmowę między użytkownikiem a asystentem wirtualnym, odpowiedni do aplikacji interaktywnych w czasie rzeczywistym.

Użycie modelu dialogowego zazwyczaj obejmuje wielokrotne interaktywne rozmowy. Na przykład, gdy użytkownik zada pytanie, model może generować odpowiednie odpowiedzi na podstawie wcześniejszych danych treningowych. Ponadto model dialogowy może zachować informacje kontekstowe, biorąc pod uwagę poprzednią zawartość rozmowy w celu generowania bardziej spójnych i naturalnych odpowiedzi.

Scenariusze zastosowań modelu dialogowego:

• Asystenci Obsługi Klienta: Automatyczne udzielanie odpowiedzi na często zadawane pytania użytkowników, udzielanie pomocy i porad.
• Chatboty: Prowadzenie naturalnych rozmów z użytkownikami.
• Asystenci Wirtualni: Wykonywanie poleceń głosowych użytkowników, takich jak planowanie spotkań, ustawianie przypomnień i inne.
• Gry Fabularne: Wzbogacanie doświadczenia z grami poprzez nadawanie postaciom gier unikalnych dialogów i osobowości.

4. Interfejs API Modelu Dialogowego

Interfejs API Modelu Dialogowego pozwala deweloperom na interakcję z modelem GPT za pomocą żądań HTTP. W tej sekcji zostanie przedstawione, jak korzystać z curla do konstruowania żądań i analizowania odpowiedzi zwracanych przez model.

Tworzenie Żądań

Przed rozpoczęciem musisz zarejestrować się i uzyskać klucz API od OpenAI, który musi być uwierzytelniony poprzez nagłówki HTTP podczas wysyłania żądań.

Oto przykład użycia curla do wysłania żądania do interfejsu API Modelu Dialogowego:

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": "Jesteś pomocnym asystentem."
      },
      {
        "role": "user",
        "content": "Który zespół wygrał World Series 2020?"
      }
    ]
  }'

Znaczenie Parametrów Modelu Dialogowego

Podczas korzystania z interfejsu API Modelu Dialogowego OpenAI główne parametry obejmują "model" i "messages", z każdym niosącym specyficzne znaczenie i wpływającym na wyniki produkowane.

Parametry Modelu

Parametr modelu służy do określenia wersji modelu, która ma zostać użyta. Na przykład, "model": "gpt-3.5-turbo" oznacza, że żądasz użycia modelu GPT-3.5-Turbo. Wybrana tutaj wersja modelu odpowie na wejście użytkownika zgodnie z jego zdolnościami, danymi treningowymi i cechami interfejsu.

Oto aktualnie obsługiwane modele:

Parametr Wiadomości

Parametr wiadomości to tablica, gdzie każdy element reprezentuje wiadomość w rozmowie. Każda wiadomość jest obiektem zawierającym dwie właściwości: role (rola nadawcy) oraz content (konkretna treść wiadomości).

• role: Określa rolę nadawcy wiadomości. Opcjonalne wartości to "system", "użytkownik" i "asystent".
• content: Konkretna treść wiadomości.

Typy i Funkcje roli

Wartość parametru role określa typ i funkcję wiadomości. API Dialogowe zmieni odpowiedź modelu w zależności od różnych ról.

Rola "system"

Wiadomości systemowe służą do globalnego określania zachowania modelu. Na przykład mogą jasno określać rolę, jaką pełni model (na przykład asystenta, tłumacza itp.), lub udzielać konkretnych instrukcji do przestrzegania podczas rozmowy. Wiadomości systemowe mają długoterminowy wpływ na zachowanie modelu w trakcie rozmowy, ale zazwyczaj są opcjonalne.

Na przykład, jeśli chcesz, aby model uczestniczył w rozmowie jako asystent ds. obsługi klienta, możesz określić w wiadomości systemowej:

{
  "role": "system",
  "content": "Jesteś asystentem ds. obsługi klienta."
}

Rola "użytkownik"

Wiadomości użytkownika reprezentują pytania wprowadzone przez użytkownika. Model reaguje na te wiadomości i udziela informacji, odpowiedzi lub innych form wyników. Te wiadomości stanowią istotną część interakcji z interfejsem API dialogowym i zazwyczaj odpowiadają rzeczywistym zapytaniom użytkownika w aplikacji.

Na przykład, w żądaniu użytkownika w przykładzie curl powyżej:

{
  "role": "user",
  "content": "Który zespół wygrał World Series 2020?"
}

Rola "asystent"

Wiadomości asystenta zazwyczaj odnoszą się do odpowiedzi generowanych przez model i mogą także być częścią historii rozmowy udostępnionej przez dewelopera, służące do symulowania formatu wiadomości zwracanych przez sztuczną inteligencję. W żądaniach interfejsu API, wiadomości roli asystenta zazwyczaj nie są podawane, chyba że konieczne jest wstępne ustawienie formatu, w jakim model odpowiada na pytania w historii rozmowy, w celu dostarczenia przykładów wyników modelu.

Parsowanie odpowiedzi

Odpowiedź modelu jest zwracana w formacie JSON. Oto przykład parsowania odpowiedzi:

{
  "choices": [
    {
      "finish_reason": "stop",
      "index": 0,
      "message": {
        "content": "Mistrzem World Series 2020 są Los Angeles Dodgers.",
        "role": "assistant"
      },
      "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
  }
}

W powyższej odpowiedzi, odpowiedź modelu można uzyskać z choices[0].message.content.

Jak zaimplementować funkcję pamięci w modelu dialogowym

Poniżej znajduje się przykład wykorzystania interfejsu OpenAI Chat Completions API do zaimplementowania funkcji pamięci modelu GPT, która demonstruje, jak zapisać historyczny kontekst rozmowy (czyli zawartość pamięci) w nowym żądaniu API, aby osiągnąć ciągły dialog.

import requests

api_url = "https://api.openai.com/v1/chat/completions"
api_key = "Twój klucz API OpenAI"

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

data = {
    "model": "gpt-3.5-turbo",  # Może zostać zastąpiony przez gpt-4 lub inne dostępne modele
    "messages": [
      {
        "role": "system",  # Komunikat systemowy, który ustala zachowanie modelu dialogowego
        "content": "Jesteś asystentem pomocy."
      },
      {
        "role": "user",  # Wiadomość od użytkownika, na którą model odpowie
        "content": "Czy możesz powiedzieć mi główne przyczyny zmian klimatu?"
      },
      {
        "role": "assistant",  # Odpowiedź modelu
        "content": "Główne przyczyny zmian klimatu to emisje gazów cieplarnianych, spalanie paliw kopalnych i wylesianie, itp."
      },
      {
        "role": "user",  # Nowe pytanie na podstawie odpowiedzi modelu
        "content": "Jak możemy zmniejszyć emisje gazów cieplarnianych?"
      }
    ]
}

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

if response.status_code == 200:
    reply_content = response.json()['choices'][0]['message']['content']
    print(f"Odpowiedź modelu => {reply_content}")
else:
    print(f"Błąd żądania: {response.status_code}")

W tym przykładzie symulujemy sytuację, w której użytkownik najpierw pyta o główne przyczyny zmian klimatu, a następnie zadaje inne pytanie w oparciu o wyjaśnienie modelu. W kolejnych żądaniach zachowujemy treść poprzedniej rozmowy, aby model mógł zapamiętać historię poprzedniej rozmowy i generować odpowiedź na jej podstawie. Metoda ta osiąga przekazywanie i pamięć stanu dialogu poprzez wykorzystanie wejścia i wyjścia poprzedniej rundy rozmowy jako historycznych wiadomości nowego żądania.

Wskazówka: Aby zaimplementować funkcję pamięci dialogu, ponieważ model ma limit maksymalnej liczby tokenów, nie jest wykonalne wprowadzenie wszystkich historycznych wiadomości rozmowy dla każdego żądania. Zazwyczaj związane wiadomości dotyczące bieżących pytań są wprowadzane jako historyczne wiadomości do modelu, a kolejne sekcje przedstawią, w jaki sposób funkcja osadzeń osiąga wyszukiwanie podobieństwa tekstu.

5. Schema JSON

Schema JSON to funkcja interfejsu API modelu dialogowego, która pozwala użytkownikom nakazać modelowi zawsze zwracać obiekt JSON, co jest odpowiednie dla scenariuszy wymagających otrzymywania odpowiedzi w formacie JSON.

Użycie schematu JSON

Aby korzystać ze schematu JSON, należy ustawić pole response_format na { "type": "json_object" } w ciele żądania HTTP i upewnić się, że komunikat systemowy wskazuje, że wynik modelu jest w formacie JSON. Poniżej znajduje się przykład żądania curl aktywujący schemat JSON:

curl https://api.openai.com/v1/chat/completions \
  -H "Content-Type: application/json" \
  -H "Authorization: Bearer $KLUCZ_API_OPENAI" \
  -d '{
    "model": "gpt-3.5-turbo-1106",
    "response_format": { "type": "json_object" },
    "messages": [
      {
        "role": "system",
        "content": "Jesteś pomocnym asystentem zaprojektowanym do wyprowadzania wyników w formacie JSON."
      },
      {
        "role": "user",
        "content": "Który zespół wygrał Serię Światową w 2020 roku?"
      }
    ]
  }'

Parsowanie Odpowiedzi JSON Schema

W trybie JSON Schema odpowiedź zawiera kompletny i idealnie sparsowany obiekt JSON. Ten tryb zapewnia, że wyjście modelu jest poprawnym obiektem JSON, który można bezpośrednio sparsować i użyć. Poniżej znajduje się przykład odpowiedzi, która mogłaby być zwrócona przy użyciu JSON Schema:

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

W Pythonie możesz użyć poniższego kodu do wyodrębnienia zawartości z odpowiedzi:

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)

Wyjście będzie:

{'winner': 'Los Angeles Dodgers'}

JSON Schema zapewnia niezawodną metodę zapewnienia poprawnego formatowania odpowiedzi dla określonych przypadków użycia. Dlatego zaleca się włączenie JSON Schema w scenariuszach, w których istnieją określone wymagania co do formatu odpowiedzi interfejsu API.