OpenAI O1 API Eğitimi: OpenAI'nin API'sine Nasıl Bağlanılır

OpenAI kısa süre önce uzun zamandır beklenen ve “doktora seviyesinde akıl yürütme” yapabilen modelini yayınladı; çoğumuzun düşündüğü gibi GPT-5 değil—OpenAI o1 modeli.

OpenAI o1’in çalışma şekli, hesaplama kaynaklarının tahsisinde, özellikle eğitim ve çıkarım (inference) aşamalarına daha fazla vurgu yapan önemli bir paradigma değişikliğine işaret ediyor. Bu yaklaşım, modeli karmaşık akıl yürütme görevlerinde olağanüstü iyi hale getiriyor; ancak kardeşleri GPT-4o ve GPT-4o mini ile karşılaştırıldığında oldukça yavaş.

Bununla birlikte GPT-4o ve GPT-4o mini hızlı yanıt, görsel işleme veya fonksiyon çağrısı gerektiren uygulamalar için tercih edilen seçenekler olmaya devam ediyor. Ancak projeniz gelişmiş akıl yürütme yetenekleri talep ediyor ve biraz daha uzun yanıt sürelerini tolere edebiliyorsa, o1 modeli doğru tercih olacaktır.

Ben OpenAI'nin API'si üzerinden o1'i keşfetme fırsatı buldum ve bu blogda adım adım bunu nasıl yapacağınızı anlatacağım. API'ye nasıl bağlanacağınızı, maliyetleri nasıl yöneteceğinizi göstereceğim ve sonunda masrafları azaltmanıza ve daha iyi yanıtlar almanıza yardımcı olacak birkaç istem (prompt) ipucunu paylaşacağım.

Daha giriş seviyesinde bir makale arıyorsanız, şu OpenAI o1 Rehberi yazısına göz atın.

Not: Bu eğitimi yazdığımız sırada o1 modelleri hâlâ beta aşamasındadır. Ancak API'ye bağlanma süreci aynı kalmaktadır.

OpenAI O1 API Gereksinimleri ve Oran Sınırları

Şu anda bilmeniz gereken ilk şeylerden biri, o1 modellerine API aracılığıyla erişmek için şimdilik Seviye 5 (Tier 5) kullanım düzeyine ihtiyaç duyduğunuzdur.

Kullanım seviyenizi kontrol etmek için hesap sayfanıza OpenAI geliştirici platformunda gidin ve Organization altında Limits bölümüne bakın.

Her kullanım seviyesi belirli oran sınırlarıyla gelir. Bu makalenin yazıldığı tarihte, Seviye 5 oran sınırları şunlardır:

O1 modelleri çıkarım aşamasında kayda değer süreler alır; bu da GPT-4o modellere kıyasla daha düşük RPM limitlerini açıklar. Toplu işlem (batching) şu anda o1 modellerinde desteklenmediğinden, aynı anda birden fazla isteği gruplayamazsınız.

O1 modeli hâlâ yeni, dolayısıyla bu gereksinimler ve oran sınırları önümüzdeki haftalarda değişebilir. Örneğin, OpenAI başlangıçta haftalık limitleri o1-preview için 30 mesaj ve o1-mini için 50 olarak duyurdu. Ancak sadece birkaç gün sonra, limitleri o1-preview için haftada 50 sorgu, o1-mini için günde 50 sorgu olarak güncellediler.

OpenAI O1 Akıl Yürütme Belirteçleri

Uygulamalı kısma birazdan geçeceğiz; ancak ondan önce, API üzerinden o1 kullanımı için temel bir kavramı netleştirelim: akıl yürütme belirteçleri (reasoning tokens). Bu kavramı anlamak, aylık OpenAI faturanızı anlamanız için kritik önemdedir.

Eğer o1-preview’i ChatGPT arayüzü üzerinden kullandıysanız, bir cevap üretmeden önce “sesli düşünme” şeklinde akıl yürüttüğünü görmüşsünüzdür.

o1 modelini API üzerinden kullandığımızda da aynı düşünme sürecinden geçer. Tek fark, ChatGPT arayüzündeki gibi akıl yürütmenin görünür olmaması ve yalnızca nihai cevabı görmemizdir.

Bununla birlikte akıl yürütme yine de belirteçlere dönüştürülür (bu nedenle “reasoning tokens” adı) ve tahmin edeceğiniz üzere ücretlendirilir. Akıl yürütme belirteçleri, girdi belirteçlerinden dört kat daha pahalı olan çıktı belirteçleri olarak faturalandırılır.

Birazdan belirteç sayısını nasıl kontrol edeceğimizi ve maliyetleri nasıl yöneteceğimizi öğreneceğiz; fakat şimdilik o1 modellerini kullanmak için OpenAI’nın API’sine bağlanmaya odaklanalım.

OpenAI O1 API: OpenAI’nın API’sine Nasıl Bağlanılır

Bu bölümde, API üzerinden o1-preview modeline bağlanmanıza yardımcı olacak bir dizi adımı özetleyeceğiz. Ardından o1-mini modeline nasıl bağlanacağınızı da ele alacağız.

Adım 1: API kimlik bilgilerini alın

Aktif bir hesabınız varsa, gizli API anahtarınızı OpenAI’nın API anahtarı sayfasından alabilirsiniz.

Bir organizasyonun parçasıysanız, maliyetleri daha etkili yönetmek için kuruluş kimliğine ve proje kimliğine de ihtiyacınız olabilir. Bu konuda ekibinizle konuştuğunuzdan emin olun.

API'lere yeni olun ya da deneyimli bir geliştirici, her durumda API en iyi uygulamalarını takip etmek iyi bir fikirdir.

Adım 2: openai kütüphanesini içe aktarın

OpenAI, API'siyle etkileşimi Python kütüphanesi openai üzerinden kolaylaştırır. Aşağıdaki komutla kurabilirsiniz:

pip install openai

Kurulumdan sonra, openai kütüphanesinden OpenAI sınıfını içe aktarırız:

from openai import OpenAI

Adım 3: Bir istemci nesnesini başlatın

OpenAI’nın API’siyle etkileşim kurmak için gizli API anahtarımızı kullanarak bir istemci başlatırız:

client = OpenAI(api_key=’your-api-key’)

Bir organizasyonun parçasıysanız, kuruluş kimliğine ve proje kimliğine de ihtiyacınız olabilir; bu durumda adım sizde şöyle görünebilir:

client = OpenAI(
    organization=’your-organization-id’,
    project=’your-project-id’,
    api_key=’your-api-key’
)

Adım 4: Bir API çağrısı yapın

Bu makalenin yazıldığı tarihte mevcut tek o1 modelleri o-1 preview ve o1-mini’dir. Her ikisine de chat.completions uç noktası üzerinden erişilir. Aşağıdaki kodda şunlara dikkat edin:

• Uç noktayı client.chat.completions.create() ile çağırıyoruz.
• model parametresi için ”o1-preview” dizesini belirtiyoruz.
• İstemi ”content” anahtarına değer olarak geçiyoruz.
• Nihai cevaba response.choices[0].message.content üzerinden erişiyoruz.

response = client.chat.completions.create(
    model="o1-preview",
    messages=[
        {
            "role": "user",
            "content": "Write a Python script that takes a matrix represented as a string with format '[1,2],[3,4],[5,6]' and prints the transpose in the same format."
        }
    ]
)
print(response.choices[0].message.content)

```python
import ast

# Read the input string
s = input()

# Add outer brackets to make it a valid list representation
input_str = '[' + s + ']'

# Safely evaluate the string to a list of lists
matrix = ast.literal_eval(input_str)

# Transpose the matrix
transposed = list(map(list, zip(*matrix)))

# Convert the transposed matrix back to the required string format
transposed_str = ','.join('[' + ','.join(map(str, row)) + ']' for row in transposed)

# Print the result
print(transposed_str)
```

Akıl Yürütme Belirteçlerinin Sayısı Nasıl Bulunur

Daha önce belirttiğimiz gibi, arka plandaki akıl yürütme de ücretlendirilen belirteçlere dahildir. Yukarıda çalıştırdığımız kod için kullanılan tüm belirteçlerin dökümü şöyledir:

print(response.usage)

CompletionUsage(completion_tokens=1279, prompt_tokens=43, total_tokens=1322, completion_tokens_details={'reasoning_tokens': 1024})

Çıktıyı incelediğimizde akıl yürütme belirteçlerinin sayısının 1024 olduğunu görüyoruz: completion_tokens_details={'reasoning_tokens': 1024}.

Model 1279 belirteç kullanarak bir tamamlamayı (completion_tokens=1279) üretti; bunun 1024'ü görünmez akıl yürütme belirteçleriydi—yaklaşık %80!

Yeni o1 modelleriyle birlikte maliyetleri yönetmek biraz daha karmaşık hale geliyor; bunu daha ayrıntılı konuşalım.

OpenAI O1 Modellerinde Maliyeti Nasıl Kontrol Ederiz

Önceki modellerde tamamlanma belirteçlerinin sayısını kontrol etmek için max_tokens parametresini kullanıyorduk. İşler oldukça basitti: Üretilen belirteç sayısı ile görünen belirteç sayısı her zaman aynıydı.

O1 modellerinde ise, görünür çıktı belirteçleri ve görünmez akıl yürütme belirteçleri dahil olmak üzere tüm tamamlanma belirteçleri için üst sınır koyan bir parametreye ihtiyaç duyuyoruz. Bu nedenle OpenAI, max_tokens parametresini kullanım dışı bırakıp o1 modelleriyle uyumsuz hale getirirken max_completion_tokens parametresini ekledi.

Önceki örneğimizle max_completion_tokens'ı deneyelim. Bunu 300 olarak ayarlayıp ne elde edeceğimize bakalım. Bu yeni parametreyi kullanmak için, openai kütüphanesinin eski sürümlerini kullanıyorsanız güncelleme yapmanız gerekebilir.

response_with_limit = client.chat.completions.create(
    model="o1-preview",
    messages=[
        {
            "role": "user",
            "content": "Write a Python script that takes a matrix represented as a string with format '[1,2],[3,4],[5,6]' and prints the transpose in the same format."
        }
    ],
    max_completion_tokens=300
)
print(response_with_limit.choices[0].message.content)

‎ ‎ ‎ ‎ 

Dikkat ederseniz hiçbir çıktı almadık. Peki yine de ödeme yapıyor muyuz? Cevap evet.

print(response_with_limit.usage)

CompletionUsage(completion_tokens=300, prompt_tokens=43, total_tokens=343, completion_tokens_details=CompletionTokensDetails(reasoning_tokens=300))

o1 modeli nihai cevaba ulaşmadan önce belirteç sınırına ulaşırsa, akıl yürütme sürecini durdurur ve herhangi bir çıktı döndürmez. Bu nedenle, max_completion_tokens değerini çıktıyı garanti edecek bir seviyeye ayarlamak önemlidir—aksi halde hem akıl yürütme hem de girdi belirteçleri için faturalandırılır, karşılığında hiçbir şey alamayız.

Tam değer, kullanım senaryonuza göre deneme gerektirecektir; ancak OpenAI, toplam tamamlanma belirteci sayısı için en az 25.000 belirteç ayırmanızı önerir. 

Kesilmiş (truncated) çıktıdan (veya hiç çıkmamasından) kaçınmak için, kullanım senaryonuz çok sayıda belirteç içeriyorsa bağlam penceresine de dikkat etmeniz gerekir. o1-preview ve o-1 mini modellerinin bağlam penceresi 128.000 belirteçtir. Ancak, çıktı belirteçlerinin (görünür ve görünmez) o1-preview için 32.768 ve o1-mini için 65.536 ile sınırlandığını unutmayın.

Kaynak: OpenAI

OpenAI O1-Mini API: OpenAI’nın API’sine Nasıl Bağlanılır

Büyük o1 modeli ileri düzey akıl yürütmede güçlüdür; ancak oldukça da yavaştır. Uygulamalarınız için daha hızlı yanıt sürelerine ihtiyaç duyuyor ve akıl yürütme performansında küçük bir tavize razıysanız, o1-mini modeli daha iyi bir seçenek olabilir.

API üzerinden o1-mini modeline bağlanmak için o1-preview modeli için ele aldığımız adımların tamamını uygulayın—yalnızca model parametresinde ”o1-mini” dizesini kullanmanız gerekir.

Belirteç kullanımını karşılaştırabilmek için son örneğimizdeki istemin aynısını kullanacağız:

response_mini = client.chat.completions.create(
    model="o1-mini",
    messages=[
        {
            "role": "user",
            "content": "Write a Python script that takes a matrix represented as a string with format '[1,2],[3,4],[5,6]' and prints the transpose in the same format."
        }
    ]
)
print(response_mini.choices[0].message.content)

Certainly! Below is a Python script that takes a matrix represented as a string in the format `'[1,2],[3,4],[5,6]'`, computes its transpose, and prints the transposed matrix in the same string format.

```python
def parse_matrix(matrix_str):
    """
    Parses a matrix string like '[1,2],[3,4],[5,6]' into a list of lists.
    """
    # Split the string by '],[' to separate the rows
    rows = matrix_str.strip().split('],[')
    
    # Clean the first and last elements by removing any leading '[' or trailing ']'
    rows[0] = rows[0].lstrip('[')
    rows[-1] = rows[-1].rstrip(']')
    
    # Convert each row into a list of integers
    matrix = []
    for row in rows:
        # Split each row by ',' and convert each element to integer
        matrix.append([int(num) for num in row.split(',')])
    
    return matrix

def transpose_matrix(matrix):
    """
    Transposes a given matrix (list of lists).
    """
    # Use zip with unpacking to transpose the matrix
    transposed = list(zip(*matrix))
    # Convert each tuple in the transposed matrix back to a list
    transposed = [list(row) for row in transposed]
    return transposed

def matrix_to_string(matrix):
    """
    Converts a list of lists into a string format like '[1,3,5],[2,4,6]'.
    """
    # Convert each row to a string
    row_strings = []
    for row in matrix:
        # Convert each number to string and join with commas
        row_str = ','.join(str(num) for num in row)
        # Enclose the row in brackets
        row_strings.append(f'[{row_str}]')
    
    # Join all rows with commas
    return ','.join(row_strings)

def main():
    # Example input
    input_str = '[1,2],[3,4],[5,6]'
    
    # Parse the input string into a matrix
    matrix = parse_matrix(input_str)
    
    # Compute the transpose of the matrix
    transposed = transpose_matrix(matrix)
    
    # Convert the transposed matrix back to string format
    output_str = matrix_to_string(transposed)
    
    # Print the result
    print(output_str)

if __name__ == "__main__":
    main()
```

### How It Works:

1. **Parsing the Input String:**
    - The `parse_matrix` function takes the input string and splits it into individual rows by looking for the pattern `"],["`.
    - It cleans the first and last rows by removing any leading `[` or trailing `]`.
    - Each row string is then split by `,` to extract individual numbers, which are converted to integers and stored in a nested list.

2. **Transposing the Matrix:**
    - The `transpose_matrix` function uses the `zip` function along with unpacking (`*`) to transpose the matrix. This effectively switches rows with columns.
    - Since `zip` returns tuples, each transposed row is converted back into a list.

3. **Converting Back to String:**
    - The `matrix_to_string` function takes the transposed matrix and converts each row back into a string in the desired format.
    - It joins the elements of each row with commas and encloses them in brackets.
    - Finally, all row strings are joined together with commas to form the final output string.

4. **Main Execution:**
    - The `main` function demonstrates the usage with an example input. You can modify `input_str` to test with different matrices.
    - It prints the transposed matrix in the specified string format.

### Example:

Given the input string:
```
'[1,2],[3,4],[5,6]'
```
The script will output:
```
[1,3,5],[2,4,6]
```

### Handling User Input:

If you'd like the script to accept user input instead of having a hardcoded string, you can modify the `main` function as follows:

```python
def main():
    # Take user input
    input_str = input("Enter the matrix string (e.g., '[1,2],[3,4],[5,6]'): ").strip()
    
    # Parse the input string into a matrix
    matrix = parse_matrix(input_str)
    
    # Compute the transpose of the matrix
    transposed = transpose_matrix(matrix)
    
    # Convert the transposed matrix back to string format
    output_str = matrix_to_string(transposed)
    
    # Print the result
    print(output_str)
```

With this modification, when you run the script, it will prompt you to enter the matrix string:

```
Enter the matrix string (e.g., '[1,2],[3,4],[5,6]'): [1,2],[3,4],[5,6]
[1,3,5],[2,4,6]
```

### Notes:

- **Error Handling:** The current script assumes that the input string is well-formatted. For production code, you might want to add error handling to manage malformed inputs.
- **Non-integer Elements:** If your matrix contains non-integer elements (e.g., floats or strings), you'll need to adjust the parsing logic accordingly.

### Running the Script:

1. **Save the Script:** Save the above code to a file, say `transpose_matrix.py`.
2. **Run the Script:** Open a terminal or command prompt, navigate to the directory containing the script, and execute:

   ```bash
   python transpose_matrix.py
   ```

3. **Provide Input:** If you've modified it to accept user input, enter the matrix string when prompted.

This script provides a straightforward way to transpose a matrix represented as a string and can be easily adapted or extended based on specific requirements.

Görünen çıktı o1-preview’in çıktısıyla karşılaştırıldığında çok daha detaylı—kullanımı karşılaştıralım:

print(response_mini.usage) # o1-mini
print(response.usage) # o1-preview

CompletionUsage(completion_tokens=1511, prompt_tokens=43, total_tokens=1554, completion_tokens_details=CompletionTokensDetails(reasoning_tokens=256))
CompletionUsage(completion_tokens=1279, prompt_tokens=43, total_tokens=1322, completion_tokens_details={'reasoning_tokens': 1024})

o1-mini modeli, o1 modeline kıyasla dört kat daha az akıl yürütüyor (256 vs. 1024 akıl yürütme belirteci). Ancak cevabının uzun olması nedeniyle toplam tamamlanma belirteci sayısı aslında daha büyük. o1-mini, o1-preview’den belirgin şekilde daha ucuz olsa da, bu yine de ideal değil.

Bunu hafifletmenin bir yolu prompt engineering olabilir—modele açıklamalardan ve girişlerden kaçınmasını, çıktısını yalnızca cevabla sınırlamasını söyleyeceğiz.

response_mini_2 = client.chat.completions.create(
    model="o1-mini",
    messages=[
        {
            "role": "user",
            "content": "Write a Python script that takes a matrix represented as a string with format '[1,2],[3,4],[5,6]' and prints the transpose in the same format. Limit yourself to the answer and don't add explanations or introductions."
        }
    ]
)
print(response_mini_2.choices[0].message.content)

```python
import ast

def parse_matrix(matrix_str):
    rows = matrix_str.split('],[')
    rows[0] = rows[0].lstrip('[')
    rows[-1] = rows[-1].rstrip(']')
    matrix = [ast.literal_eval(f'[{row}]') for row in rows]
    return matrix

def transpose(matrix):
    return list(zip(*matrix))

def format_matrix(transposed):
    return ','.join([f'[{",".join(map(str, row))}]' for row in transposed])

input_str = '[1,2],[3,4],[5,6]'
matrix = parse_matrix(input_str)
transposed = transpose(matrix)
output_str = format_matrix(transposed)
print(output_str)
```

Çok daha iyi! Toplam tamamlanma belirteci sayısı yaklaşık üçte birine indi:

print(response_mini_2.usage)

CompletionUsage(completion_tokens=487, prompt_tokens=55, total_tokens=542, completion_tokens_details=CompletionTokensDetails(reasoning_tokens=320))

API Beta Kısıtlamaları

Bu eğitimi yazdığımız sırada o1 modelleri hâlâ beta aşamasındadır. OpenAI önümüzdeki haftalarda ek özellikler ve daha elverişli oran sınırları planlarını duyurmuş olsa da, beta o1 modellerini kullanırken karşılaşacağınız kısıtlamalar şunlardır:

• Modaliteler: Yalnızca metin desteklenir; görseller işlenemez.
• Mesaj türleri: Yalnızca kullanıcı ve asistan mesajlarına izin verilir; sistem mesajları kabul edilmez.
• Akış (streaming): Bu özellik mevcut değildir.
• Araçlar: Fonksiyon çağrısı, araçlar ve yanıt biçimi parametreleri dahil değildir.
• Logprobs: Bu parametre desteklenmez.
• Diğer ayarlar: temperature, top_p ve n değerleri 1 olarak sabittir; presence_penalty ve frequency_penalty ise 0 olarak ayarlanmıştır.
• Assistants ve batch: Bu modeller Assistants API veya Batch API ile kullanılamaz.

OpenAI O1 API: Fiyatlandırma

Şu anda, ileri düzey akıl yürütme alanında OpenAI’nın pek bir rakibi yok gibi görünüyor. Bu nedenle fiyatlar bir miktar yüksek sayılabilir ve görüldüğü üzere GPT-4o modellere kıyasla belirgin derecede daha pahalıdır:

O1 Modelleriyle En İyi İstem Uygulamaları

o1 modelleri, alışık olduğumuz GPT-4o veya Claude 3.5 Sonnet gibi modellerden oldukça farklıdır. o1 modelleri zaten zincirleme düşünme (chain-of-thought) akıl yürütmesi gerçekleştirdiğinden, en iyi düz metin ve doğrudan istemlerle çalışır. Few-shot kullanmak veya modele “adım adım düşünmesini” istemek performansını hatta düşürebilir.

İşte OpenAI geliştiricilerinin önerdiği en iyi istem uygulamalarından bazıları:

• İstemleri öz ve net tutun: Modeller, süslü açıklamalara gerek kalmadan kısa ve doğrudan talimatlarla başarılı olur.
• Chain-of-thought istemlerden kaçının: Bu modeller akıl yürütmeyi dahili olarak yürütür; bu yüzden “adım adım düşün” ya da “akıl yürütmeni açıkla” demeye gerek yoktur.
• Ayrıştırıcılar (delimiter) kullanın: Girdi bölümlerini netçe tanımlamak için üç tırnak, XML etiketleri veya bölüm başlıkları gibi ayrıştırıcılar ekleyin.
• geri getirmeyle artırılmış üretimde (RAG) ek bağlamı sınırlayın: Bağlam veya belge eklerken, modelin yanıtını karmaşıklaştırmamak için yalnızca en alakalı bilgileri dahil edin.

Sonuç

Bu blog boyunca, OpenAI’nın API’si üzerinden o1 modellerine bağlanmaya dair adım adım bir rehber paylaştım.

Projeniz gelişmiş akıl yürütme yetenekleri gerektiriyor ve biraz daha uzun yanıt sürelerini tolere edebiliyorsa, o1 modelleri mükemmel seçeneklerdir.

Hızlı yanıt, görsel işleme veya fonksiyon çağrısı gerektiren uygulamalar için GPT-4o ve GPT-4o mini tercih edilen seçenekler olmaya devam eder.

Öğrenmeye devam etmek için şu kaynakları öneririm:

• OpenAI API ile Çalışmak
• OpenAI Temelleri
• OpenAI API ile Yapay Zekâ Sistemleri Geliştirme
• OpenAI o1 Rehberi: Nasıl Çalışır, Kullanım Alanları, API ve Daha Fazlası