Po co stosować Fine-Tuning?

Gdy odpowiedzi modelu nie spełniają naszych oczekiwań, fine-tuning umożliwia lepsze dostosowanie modelu do pożądanych rezultatów. Dzięki temu można osiągnąć:

• Wyższą jakość wyników w specyficznych zadaniach.
• Oszczędność tokenów, poprzez krótsze prompty.
• Zmniejszenie opóźnienia żądań.

Kiedy stosować Fine-Tuning?

Fine-tuning ma sens, gdy łatwiej jest nam pokazać modelowi, co ma robić, niż to opisywać. Warto także pamiętać, że będzie on najbardziej efektywny, gdy potrzeby użytkowników są dobrze zdefiniowane i można je sformułować na podstawie powtarzalnych wzorców. Przykłady zastosowań obejmują: Przykłady zastosowań:

• Ustawienie stylu odpowiedzi lub tonu.
• Zwiększyć pewność zwrócenia pożądanego wyniku.
• Zarządzanie przypadkami brzegowymi w konkretny sposób.
• Kategoryzowanie danych.

Jak przygotować dane do Fine-Tuningu?

Aby wyszkolić model OpenAI, musimy przygotować plik w formacie JsonL zawierający dane, na których model będzie douczany. JsonL to w zasadzie plik Json, ale z tą różnicą, że każdy obiekt zapisany jest w jednej linii. Przykład struktury:

{"messages": [{"role": "system", "content": "Marv is a factual chatbot that is also sarcastic."}, {"role": "user", "content": "What's the capital of France?"}, {"role": "assistant", "content": "Paris, as if everyone doesn't know that already."}]}

W pliku tym znajdują się struktury wiadomości systemowej, użytkownika i odpowiedzi asystenta. Dzięki wielu takim liniom model uczy się, jak odpowiadać na podobne pytania.

Zastosowanie fine-tuningu w praktyce

Weźmy przykład aplikacji, której celem jest pobranie od użytkownika słów w bezokoliczniku i użycie ich do budowania zdań poprawnych gramatycznie. Na przykład, mając słowa „mama”, „ja”, „wczoraj”, „być” i „las”, model generuje zdanie: „Mamo, byłem wczoraj w lesie.” W takim przypadku fine-tuning jest niezwykle pomocny, gdyż łatwiej jest pokazać modelowi, w jaki sposób ma formułować zdania, niż wyjaśniać koncepcję przy każdym zapytaniu.

Dane do nauki modelu można przygotować w formacie:

Mama, ja, chcieć, ciastko; Mamo chcę dostać ciastko.
Ja, być, wczoraj, zewnątrz; Byłem wczoraj na zewnątrz.

Przygotowanie pliku JsonL

Korzystając z tej struktury, przygotowałem skrypt do przetworzenia danych:

import json
import sys

if len(sys.argv) != 2:
    print("Using: python convert.py <input_file_name>")
    sys.exit(1)

input_file = sys.argv[1]

try:
    with open(input_file, "r", encoding="utf-8") as f:
        data = f.read()
except FileNotFoundError:
    print(f"File {input_file} does not exists.")
    sys.exit(1)

lines = data.strip().split("\\n")

output = []

def process_line(line):
    input_part, output_part = line.split("; ")
    return {
        "messages": [
            {"role": "system", "content": "Popraw gramatykę zdania."},
            {"role": "user", "content": input_part.strip()},
            {"role": "assistant", "content": output_part.strip()}
        ]
    }

for line in lines:
    output.append(process_line(line))

output_file = "fine_tuning_grammar.jsonl"
with open(output_file, "w", encoding="utf-8") as f:
    for item in output:
        f.write(json.dumps(item, ensure_ascii=False) + "\\n")

print(f"Data was write to the {output_file}")

I po przekonwertowaniu pliku głównego dostałem następujący rezultat:

{"messages": [{"role": "system", "content": "Popraw gramatykę zdania."}, {"role": "user", "content": "Mama, ja, chcieć, ciastko"}, {"role": "assistant", "content": "Mamo chcę dostać cistko."}]}
{"messages": [{"role": "system", "content": "Popraw gramatykę zdania."}, {"role": "user", "content": "Ja, być, wczoraj, zewnątrz"}, {"role": "assistant", "content": "Byłem wczoraj na zewnątrz."}]}

Przygotowałem ponad 50 takich przykładów. Większa ilość danych może poprawić skuteczność modelu. Jeżeli nie mamy danych uczących, możemy użyć dowolnych modeli LLM do ich stworzenia.

Jak przeprowadzić Fine-Tuning?

Mając przygotowany plik, potrzebujemy zalogować się na nasze konto OpenAI na platformie, a następnie przejść na Dashboards: PLATFORM

Po lewej stronie będzie zakładka “Fine-tuning”.

Następnie tworzymy nowy “fine-tuned model” i wybieramy model który chcemy douczyć.

W moim przypadku padło na gpt-4-mini ze względu na niski koszt nauki. Z racji tego, że informacje o dostępnych modelach jak i kosztach mogą się zmieniać w przyszłości to szczegółowe informacje można znaleźć tutaj: PRICING

Dla moich potrzeb resztę konfiguracji zostawiam domyślnie.

W tym momencie plik JsonL, który chcę wykorzystać do douczenia modelu przechodzi przez etap walidacji jego danych. Między innymi czy struktura jest poprawna oraz czy nie ma w nim danych łamiących regulamin. Następnym etapem jest etap fine-tuningu, który może potrwać od kilku do kilkudziesięciu minut w zależności od ilości danych .

Po tym czasie nasz model będzie w pełni nauczony i będziemy mogli go wykorzystać.

Dodatkową informacją jest zamieszczony dla wytrenowanego modelu wykres:

Przedstawia on proces nauki modelu. Widać na nim jak model na początku popełniał błędy i z upływem czasu zielona linia jest wypłaszczona. Co oznacza, że model prawidłowo przetwarzał dane testowe.

Jak wywołać fine-tuned model przez API?

Po prawidłowym przejściu etapu fine-tuningu możemy użyć modelu. Skopiuj wartość „Output model” i użyj jej w polu „model” podczas wysyłania zapytania do API.

Przykład wykorzystania API:

Jak widać prompt użytkownika zaczynam od polecenia systemowego, użytego na etapie przygotowywania pliku JsonL. Jest on niezbędny, żeby model wiedział, że teraz ma zwrócić odpowiedz w konkretny sposób, który go nauczyliśmy.