Tinker Eğitimi: Thinking Machines Lab ile LLM İnce Ayarı

Büyük dil modellerini ince ayarlamak genellikle dağıtık GPU altyapısıyla uğraşmayı, küme hatalarını yönetmeyi ve karmaşık eğitim betiklerini hata ayıklamayı gerektirir. Tinker, tam da bunu çözmek için var.

Mira Murati’nin Thinking Machines Lab’i tarafından 1 Ekim 2025’te yayınlanan Tinker, altyapı karmaşıklığının tamamını üstlenen ve size algoritmalarınız ile verileriniz üzerinde tam kontrol veren bir eğitim API’sidir. Dört temel fonksiyonla basit Python betikleri yazmanızı sağlar ve Tinker, Llama 70B veya Qwen 235B gibi çok sayıda açık kaynaklı model için bunları dağıtık GPU’larda çalıştırır.

Platform, maliyetleri düşürmek için Low-Rank Adaptation (LoRA) ince ayarını kullanır ve gözetimli öğrenmeden pekiştirmeli öğrenmeye kadar her şeyi destekler. Princeton, Stanford ve Berkeley’deki araştırma ekipleri bunu hâlihazırda çalışmalarında kullanıyor.

Bu eğitimde Tinker’ın kurulumunu, API’sinin mantığını ve Qwen3-8B taban modelini kullanarak eksiksiz bir finansal Soru-Cevap modelinin nasıl ince ayarlanacağını adım adım göstereceğim. Uygulamalı pratikle ince ayar hakkında daha fazla öğrenmek isterseniz, Llama 3 ile İnce Ayar kursuna göz atmanızı öneririm.

Tinker nedir?

Thinking Machines Lab, Tinker’ı, altyapı uzmanı olmadan modellerin nasıl öğrendiğini özelleştirmek isteyenler için geliştirdi.

Tinker’ı kimler kullanır?

Platform üç grubu hedefler: 

• Yeni eğitim yöntemlerini keşfeden araştırmacılar
• Özel davranış gerektiren yapay zekâ ürünleri geliştiren geliştiriciler
• Kurumsal kaynaklar olmadan üretim kalitesinde sonuçlar isteyen yapıcılar. 

Her grubun ortak bir ihtiyacı var: Modellerinin ne yapmasını istediklerini biliyorlar, ancak standart ince ayar arayüzleri onlara yeterli kontrolü sağlamıyor.

Örneğin, akademik ekipler bunu yeni algoritmaları test etmek için kullanabilir. Bir kimya laboratuvarı, tipik talimat-ayar kalıplarına uymayan alan spesifik akıl yürütme örüntüleri üzerinde model eğitmek isteyebilir. Finansal danışman botu geliştiren bir girişim, modelin belirli çıktı formatlarını ve akıl yürütme zincirlerini takip etmesini sağlayabilir. 

Bu kullanım örneklerinin ortak noktası, yalnızca veri kümelerini değiştirmek değil, bizzat eğitim sürecini değiştirmeleri gerektiğidir.

Tinker’ı farklı kılan nedir?

Çoğu platform iki şeyden birini optimize eder: kullanım kolaylığı veya esneklik. Tinker’ın yaklaşımı, bu ikisinin çatışmak zorunda olmadığıdır. Platform, dört temel işlem aracılığıyla eğitime düşük seviyede erişim sağlar; geri kalan her şeyi otomatik olarak halleder:

• Eğitim döngüsü kontrolü: Kendi kayıp fonksiyonlarınızı, gradyan biriktirme stratejilerinizi veya örnekleme desenlerinizi yazın.
• Model güncellemeleri: Optimizasyon sırasında ağırlıkların tam olarak nasıl değişeceğini belirtin.
• Değerlendirme: Eğitimin herhangi bir noktasında çıktı üretin veya olasılıkları hesaplayın.
• Durum yönetimi: Kalıcı olacak unsurlar üzerinde tam kontrolle eğitimi kaydedin ve devam ettirin.

Tinker bu yetenekleri, uygulamalı bölümde öğreneceğiniz dört API ilkel fonksiyonu aracılığıyla sunar.

Bu, çoğu eğitim karmaşıklığının algoritmaların kendisinden değil, altyapıdan gelmesi sayesinde mümkün olur. Özel bir eğitim döngüsünü dizüstü bilgisayarınızda çalıştırmak basittir. Aynısını 100 GPU’da, hata kurtarma ve kaynak zamanlamasıyla çalıştırmak zordur. Tinker ikinci kısmı üstlenir; siz de ilki üzerinde odaklanabilirsiniz.

Tinker nerede konumlanır

Yapay zekâ araç ekosistemi kabaca üç katmana ayrılır: ham GPU sağlayan bulut bilişim sağlayıcıları, önceden tanımlı iş akışlarını çalıştıran yönetimli platformlar ve sıfırdan eğitim sistemleri kurmanıza yardımcı olan çerçeveler. Tinker, yönetimli platformlar ile çerçeveler arasında yer alır. Hugging Face AutoTrain gibi platformlardan daha fazla kontrol, Google Cloud Platform (GCP) üzerinde özel bir küme kurmaya kıyasla daha az altyapı işi elde edersiniz.

Tinker Fiyatlandırma ve krediler

Tinker, model boyutuna ve işlem türüne göre değişen, şeffaf token başı fiyatlandırma kullanır. Qwen3-8B’yi eğitmek, milyon token başına 0,40 $’dır. Güzel haber: yeni kullanıcılar bekleme listesinden onaylandıklarında 150 $ kredi alır; bu da bu eğitimdeki gibi birkaç deneysellik içeren eğitim çalışmasını fazlasıyla karşılar.

Kaynak: Thinking Machines Lab

Tinker Örneği: Qwen3-8B’nin Finansal S&C için İnce Ayarı

Bu bölümde, Tinker’ın API’sini kullanarak eksiksiz bir ince ayar iş akışının nasıl kurulacağını göstereceğim. Qwen3-8B’yi LoRA ile finansal soru-cevap verileri üzerinde ince ayarlayacağız; bunu yaparken dört temel API ilkelini öğrenecek ve üretim en iyi uygulamalarını göreceksiniz.

Modelin daha ayrıntılı bir genel görünümü için, Qwen3’ü anlatan bu makaleye mutlaka göz atın.

Önemli not: Tinker şu anda bekleme listesi tabanlı erişimle betadadır. Erişiminiz varsa, adımları izleyip kodu çalıştırabilirsiniz. Bekleme listesindeyseniz de, Tinker ile ince ayar sürecinin ne kadar kolay olduğunu anlamak için okumaya devam edebilirsiniz. Erişim aldığınızda hemen başlamaya hazır olacaksınız.

Eğitim sonuçları ve kontrol noktası seçimi

Önce eğitim sonuçlarına bakalım. Ne olduğunu anlamak, kendi ince ayar işlerinizde bu desenleri fark etmenize yardımcı olur.

Qwen3-8B’yi, LoRA (rank 32) kullanarak, zincirleme düşünme finansal akıl yürütme veri kümesi olan FinCoT üzerinde ince ayarladık. 10.000 token’dan uzun olmayan dizileri filtreledikten sonra elimizde 7.244 eğitim örneği ve doğrulama için 500 örnek kaldı. 

Eğitim, dört epoch boyunca 904 yineleme sürdü ve yaklaşık üç saatte tamamlandı; bu sırada Tinker tüm dağıtık GPU koordinasyonunu üstlendi. 

Bir epoch, tüm eğitim veri kümesinden bir kez tamamen geçmek demektir. Her epoch’ta 226 batch olduğundan (7.244 örnek, batch boyutu 32), dört epoch toplamda 904 yineleme etti.

Eğitim sonuçlarını analiz etme

Aşağıdaki grafik üç metriği takip eder: eğitim kaybı (mavi), doğrulama kaybı (kırmızı) ve öğrenme oranı (yeşil).

Erken eğitim (0-400 yineleme) sağlıklı görünüyor: eğitim ve doğrulama kayıpları birlikte hızla düşerek 1,4’ün üzerinden 0,8’in altına iniyor ve aralarında yaklaşık 0,1 fark kalıyor. 

Bu dönem, modelin veride genellenebilir örüntüleri etkili şekilde öğrendiğini gösterir. Öğrenme oranı (yeşil çizgi) ilk 200 yineleme boyunca ısınma sayesinde yumuşak biçimde artarak eğitimi dengeler. 

Yaklaşık 400-600 yinelemeleri arasında tablo değişir. Eğitim kaybı düşmeye devam ederken, doğrulama kaybı 0,75-0,8 bandında yatay seyreder ve model aşırı uyum göstermeye başladıkça fark 0,13’e açılır. 600-900 yinelemeleri arasında ayrışma belirginleşir: eğitim kaybı 0,39’a düşerken doğrulama kaybı 0,8’e çıkar; bu da modelin akıl yürütme örüntülerini öğrenmekten örnekleri ezberlemeye kaydığını gösterir. 

Bu desen, akıl yürütme modellerini ince ayarlarken yaygındır. Akıl yürütme yeteneklerinin eğitim sırasında nasıl geliştiği ilginizi çekiyorsa, benzer dinamikleri inceleyen DeepSeek R1’in ince ayarı üzerine bu eğitime bakabilirsiniz.

checkpoint-400’de kaydedilen model en iyi genellemeyi sunar: eğitim kaybı 0,68, doğrulama kaybı 0,73 ve aradaki fark yalnızca 0,05’tir. Son kontrol noktasından daha yüksek bir eğitim kaybına sahip olmasına rağmen yeni soruları daha iyi ele alır. En düşük eğitim kaybı nadiren en iyi modeli üretir; bu nedenle doğrulama metrikleri önemlidir.

Bunu daha sonra, checkpoint-400’deki modeli bir LLM hakemi kullanarak temel modelle karşılaştırarak doğrulayacağız. Şimdilik bu ince ayar iş akışını adım adım kurmaya geçelim.

Adım 1: Tinker’ı kurun ve ortamınızı hazırlayın

Not: Aşağıdaki adımlar yaklaşık 300 satırlık bir betiği parçalara ayırır. Açıklamalar kod parçalarına serpiştirildiğinden, tam resmi görmek için tam betiği yeni bir sekmede açmanızı öneririz.

Python 3.11 veya daha yenisi ile stabil bir internet bağlantısına ihtiyacınız olacak. Tinker GPU eğitimini kendi sunucularında yürüttüğünden, güçlü bir bilgisayardan ziyade iyi bir bağlantı daha önemlidir.

Önce Tinker konsoluna giriş yapıp bir API anahtarı oluşturun. Bu anahtarı proje dizininizdeki bir .env dosyasında saklayın:

TINKER_API_KEY=your_key_hereAltyapı:

Kurulumu tamamladığınızda Tinker konsolu, eğitim çalıştırmalarını izlemek ve kontrol noktalarını yönetmek için merkezi üssünüz olur.

Tinker konsolu, tüm eğitim çalışmalarınızı temel ayrıntılarla takip eder: benzersiz çalıştırma kimlikleri, taban model, LoRA rütbesi ve son istek zamanları. Bu arayüzden birden fazla deneyi arayabilir, filtreleyebilir ve yönetebilirsiniz.

Gerekli paketleri kurun. Tinker, otomatik kurulmayan eş bağımlılıklara sahiptir; bu yüzden bunları açıkça belirtin:

pip install tinker transformers torch datasets python-dotenv numpyAltyapı:

transformers ve torch paketleri, Tinker’ın dahili olarak kullandığı tokenizasyon ve tensör işlemlerini sağlar. datasets kütüphanesi ise Hugging Face’ten eğitim verisinin yüklenmesini üstlenir.

Şimdi içe aktarmalarınızı ve bir yeniden deneme yardımcı fonksiyonunu ayarlayın. Uzak sunucularda eğitim yaparken, genellikle gerçekte bir sorun olmasa bile geçici bağlantı hataları görebilirsiniz. Eğitim işiniz Tinker altyapısında sorunsuz devam eder. Bu yeniden deneme sarmalayıcısı geçici hataları otomatik olarak ele alır:

import time
import numpy as np
from dotenv import load_dotenv
from datasets import load_dataset
import tinker
from tinker import types

def with_retry(future, max_attempts=3, delay=5):
    """Simple retry logic for API futures"""
    for attempt in range(max_attempts):
        try:
            return future.result()
        except Exception as e:
            if attempt == max_attempts - 1:
                raise
            time.sleep(delay)Altyapı:

Bu fonksiyon, Tinker’ın API’sinden gelen bir future nesnesini (henüz tamamlanmamış bir işlemi temsil eder) alır ve sonucu en fazla üç kez elde etmeye çalışır; denemeler arasında beş saniye bekler. Çoğu geçici hata bu aralıkta çözülür.

Adım 2: ServiceClient’i başlatın ve veri kümesini yükleyin

ServiceClient, Tinker’a giriş kapınızdır. Uygun modelleri bulur ve kimlik doğrulamayı gerçekleştirir:

load_dotenv()
service_client = tinker.ServiceClient()Altyapı:

Bunu ilk kurulumdan sonra çok kullanmayacaksınız. Esas olarak belirli modeller için eğitim ve örnekleme istemcileri oluşturmak için vardır.

Şimdi FinCoT veri kümesini yükleme zamanı.  Finansal soruların adım adım akıl yürütme zincirleri ve nihai yanıtlarla eşleştirilmiş hâlini içerir. Basit S&C veri kümelerinden farklı olarak FinCoT, modelin yanıt vermeden önce gerekçesini göstermesini öğretir; bu, kullanıcıların önerilerin arkasındaki mantığı anlamasının önemli olduğu finansal danışmanlık uygulamaları için kritik bir beceridir.

dataset = load_dataset("TheFinAI/FinCoT")Altyapı:

Veri kümesi, tam akıl yürütme zincirleri içeren bir SFT (gözetimli ince ayar) bölümü ve pekiştirmeli öğrenme için bir RL bölümü içerir. Modelin farklı örneklere genellemesini sağlamak için eğitimi SFT bölümünde yapın ve doğrulama için RL bölümünden örnekleyin.

train_data_raw = dataset["SFT"]  # 7,686 examples with reasoning chains
val_data_raw = dataset["RL"].shuffle(seed=42).select(range(500))  # 500 validation examples

print(f"Loaded {len(train_data_raw)} training examples")
print(f"Loaded {len(val_data_raw)} validation examples")Altyapı:

Adım 3: LoRA eğitim istemcinizi oluşturun

Şimdi Qwen3-8B için bir LoRA eğitim istemcisi oluşturun:

training_client = service_client.create_lora_training_client(
    base_model="Qwen/Qwen3-8B",
    rank=32
)Altyapı:

Burada olanları parçalara ayıralım:

• Qwen/Qwen3-8B: 8 milyar parametreli bir modeldir; gerçek görevler için yeterince güçlü, eğitim için ise hâlâ verimlidir. Öğrenmek için iyi bir tatlı noktadır. Mevcut tüm modelleri Tinker’ın model listesinde görebilirsiniz.
• LoRA (Low-Rank Adaptation): Tüm 8 milyar parametreyi güncellemek yerine LoRA, taban modelin davranışını değiştiren küçük “adaptör” katmanlarını eğitir. Bunu, tüm kamerayı yeniden inşa etmek yerine kameraya özel lensler eklemek gibi düşünebilirsiniz. Taban model Tinker’ın sunucularında donuk kalır; yalnızca bu küçük adaptörleri eğitirsiniz.
• rank=32: LoRA adaptörlerinizin kaç eğitilebilir parametre içereceğini kontrol eder. Rank 32, 5.000-10.000 örnekli veri kümeleri için iyi çalışır. Daha büyük veri kümeleri, daha fazla uyarlama kapasitesi için rank=64 veya rank=128 gerektirebilir.

LoRA’nın matematiksel olarak nasıl çalıştığı ve rank parametrelerinin nasıl ayarlanacağı hakkında daha derine inmek için Tinker’ın LoRA özetini veya Low-Rank Adaptation’ı ustalıkla kullanma üzerine DataCamp’in kapsamlı rehberini inceleyin.

Dil modelleri doğrudan kelimelerle çalışmaz; “token” adı verilen metin parçalarıyla çalışır. Bir tokenizer metni bu parçalara ayırır. Örneğin, “financial” tek bir token olabilirken “understanding” “under” ve “standing” olarak bölünebilir. 

Tokenizer, metni modelin işleyebileceği sayılara (token kimliklerine) dönüştürür. Tokenizer’ı eğitim istemcisinden alarak Qwen3-8B’nin beklediği tam olarak aynı tokenizasyonu kullandığınızdan emin olursunuz.

tokenizer = training_client.get_tokenizer()Altyapı:

Adım 4: Veriyi Tinker formatına dönüştürün

Tinker, eğitim verinizi types.Datum adlı bir formatta ister. Bu format, model girdisini kayıp fonksiyonu yapılandırmasından ayırır ve hangi token’ların eğitime katkıda bulunacağını hassas biçimde kontrol etmenizi sağlar.

Dil modellerini ince ayarlarken, genellikle modelin iyi yanıtlar üretmeyi öğrenmesini, soruları ezberlememesini istersiniz. Bunu, girdinin farklı kısımlarına farklı ağırlıklar atayarak yaparsınız:

• İstem (soru) token’ları: Ağırlık = 0,0 (bunlardan öğrenme)
• Tamamlama (yanıt) token’ları: Ağırlık = 1,0 (bunlardan öğren)

Veri dönüşüm fonksiyonunu adım adım oluşturalım. Fonksiyon imzasıyla başlayın:

def prepare_datum(example, max_length=10000):Altyapı:

Qwen3’ün sohbet şablonuyla konuşmayı biçimlendirin

Farklı modeller, çok turlu konuşmalar için farklı biçimler bekler. Qwen3, mesaj sınırlarını işaretlemek için <|im_start|> ve <|im_end|> gibi özel token’lar kullanır. Her mesajı “gözlem” (rol başlıkları) ve “eylem” (asıl içerik) parçalarına ayırın:

   # Qwen3 chat format - split into observation and action parts
    user_ob = "<|im_start|>user\n"
    user_ac = f"{example['Question']}<|im_end|>"
    
    assistant_ob = "\n<|im_start|>assistant\n"
    # Include both reasoning process AND final answer
    assistant_ac = f"{example['Reasoning_process']}\n\nFinal Answer: {example['Final_response']}<|im_end|>"Altyapı:

FinCoT veri kümesi yapılandırılmış akıl yürütme sunar; bu yüzden Reasoning_process ve Final_response alanlarını birleştiriyoruz. Bu, modelin yanıtlamadan önce gerekçesini göstermesini öğretir.

Her parçayı ayrı ayrı token’laştırın 

Ağırlıkların nerede uygulanacağını takip edebilmek için her mesaj parçasının ayrı ayrı token’laştırılması gerekir.

   # Tokenize each part separately to track weight boundaries
    user_ob_tokens = tokenizer.encode(user_ob, add_special_tokens=False)
    user_ac_tokens = tokenizer.encode(user_ac, add_special_tokens=False)
    assistant_ob_tokens = tokenizer.encode(assistant_ob, add_special_tokens=False)
    assistant_ac_tokens = tokenizer.encode(assistant_ac, add_special_tokens=False)
    
    # Combine all tokens
    all_tokens = user_ob_tokens + user_ac_tokens + assistant_ob_tokens + assistant_ac_tokensAltyapı:

Fazla uzun dizileri filtreleyin

Bazı FinCoT örnekleri, Qwen3-8B’nin konforlu bağlam penceresini aşan son derece ayrıntılı akıl yürütme zincirleri içerir. Model teknik olarak 32.768 token’ı desteklese de, çok uzun diziler eğitimde istikrarsızlığa neden olabilir:

   # Check if sequence exceeds max length
    if len(all_tokens) > max_length:
        return None  # Skip this exampleAltyapı:

10.000 token’ın üzerindeki örnekleri filtrelemek, verinin yalnızca %5-6’sını kaldırırken eğitim güvenilirliğini belirgin şekilde artırır.

Modelin neyden öğreneceğini kontrol etmek için ağırlık atayın

Sorunun (model soruları tahmin etmeyi öğrenmesin diye) ağırlıklarını 0,0’a ve yanıtın (iyi yanıtlar üretmeyi öğrensin diye) ağırlıklarını 1,0’a ayarlayın:

   # Weights: only train on assistant's answer (action part)
    weights = np.array(
        [0.0] * len(user_ob_tokens) +
        [0.0] * len(user_ac_tokens) +
        [0.0] * len(assistant_ob_tokens) +
        [1.0] * len(assistant_ac_tokens)
    )Altyapı:

Sonraki-token tahmini için token’ları ve ağırlıkları kaydırın

Dil modelleri, bir dizideki bir sonraki token’ı tahmin eder. Model 0-9 token’larını gördüğünde, 10. token’ı tahmin etmelidir. Bu nedenle hedefleriniz her zaman girdinin bir pozisyon ileri kaydırılmış hâlidir:

   # CRITICAL: Shift tokens AND weights for next-token prediction
    input_tokens_model = all_tokens[:-1]
    target_tokens = all_tokens[1:]
    weights_shifted = weights[1:]Altyapı:

Önemle vurgulamak gerekir ki ağırlıkları token’larla birlikte kaydırmalısınız. Ağırlıkları kaydırmazsanız, kayıp hesaplaması hizasız olur: model ilk yanıt token’ını tahmin etmek için eğitilirken, o konumdaki ağırlık istemden gelen 0,0 olarak kalır. Bu hizalama hatası, modelin doğru şekilde öğrenmesini engelleyebilir.

Biçimlendirilmiş veriyi döndürün

Son olarak, prepare_datum() fonksiyonu işlenmeye hazır biçimlendirilmiş veriyi döndürür.

   return types.Datum(
        model_input=types.ModelInput.from_ints(tokens=input_tokens_model),
        loss_fn_inputs=dict(weights=weights_shifted, target_tokens=target_tokens),
    )Altyapı:

Tanımlanan fonksiyonu ham eğitim ve doğrulama alt kümelerine uygulayarak artık tüm veri kümesini işleyebiliriz:

# Process and filter training data
training_data_raw = [prepare_datum(example) for example in train_data_raw]
training_data = [d for d in training_data_raw if d is not None]
skipped = len(train_data_raw) - len(training_data)

print(f"Processed {len(training_data)} examples (skipped {skipped} too-long sequences)")
# Output: Processed 7,244 examples (skipped 442 too-long sequences)

# Process validation data
val_data_raw_processed = [prepare_datum(example) for example in val_data_raw]
val_data = [d for d in val_data_raw_processed if d is not None]

print(f"Validation set: {len(val_data)} examples")Altyapı:

Adım 5: Eğitim döngüsüyle modeli eğitin

Eğitim döngüsü, Tinker’ın iki temel API ilkelini kullanır: forward_backward ve optim_step. Aşırı uyumu erkenden yakalamak için doğrulama takibiyle adım adım oluşturalım.

Bir doğrulama kaybı fonksiyonu tanımlayın

Önce bir doğrulama kaybı fonksiyonu tanımlayın. Eğitim kaybından farklı olarak doğrulama kaybı, modelinizin görülmemiş veriye ne kadar iyi genellediğini söyler. Aşırı uyumu tespit etmek için kritik önemdedir.

def compute_validation_loss(val_data, batch_size=100):
    """Compute loss on validation set (forward only, no backward)"""
    batch_indices = np.random.choice(
        len(val_data), size=min(batch_size, len(val_data)), replace=False
    )
    batch = [val_data[i] for i in batch_indices]
    
    # Forward pass only (no backward!)
    fwd_future = training_client.forward(batch, loss_fn="cross_entropy")
    fwd_result = with_retry(fwd_future)
    
    # Calculate per-token loss
    loss_sum = fwd_result.metrics["loss:sum"]
    total_completion_tokens = sum(
        np.sum(np.array(val_data[i].loss_fn_inputs["weights"].data) > 0)
        for i in batch_indices
    )
    return loss_sum / total_completion_tokens if total_completion_tokens > 0 else 0Altyapı:

forward() yöntemi, gradyan hesaplamadan kaybı hesaplar; bu da performansı ölçmek istediğiniz, fakat ağırlıkları güncellemediğiniz değerlendirme için verimlidir. Doğrulama kaybını hesaplamak, (sadece ileri geçiş olduğu için, gradyan yok) asgari ek yük getirir; ancak, eğitim ve doğrulama kaybı arasındaki fark 0,2’yi aştığında modelinizin öğrenmek yerine ezberlediğine dair erken uyarı sağlar.

Eğitim parametrelerini yapılandırın

Epoch sayısını ve öğrenme oranını tanımlamamız gerekir. LoRA, tam ince ayara kıyasla önemli ölçüde daha yüksek öğrenme oranları gerektirir; tipik olarak 10-20 kat daha büyüktür.

# Training configuration
n_samples = len(training_data)  # 7,244
n_epochs = 4  # More epochs for smaller dataset
batch_size = 32

# Calculate optimal LR for Qwen3-8B with LoRA
# Formula: base_lr * lora_multiplier * (2000 / hidden_size) ** exponent
# For Qwen: base=5e-5, multiplier=10, hidden_size=4096, exponent=0.0775
learning_rate = 5e-5 * 10.0 * (2000 / 4096) ** 0.0775  # ≈ 4.7e-4Altyapı:

Formül, model boyutunu (Qwen3-8B’nin gizli boyutu 4.096’dır) hesaba katar ve model ailesine göre değişen, ampirik olarak belirlenmiş üsleri kullanır; bu, Tinker cookbook’ta belgelenmiştir. Qwen modelleri için üs 0,0775 iken Llama modelleri 0,781 kullanır. Bizim durumumuzda bu, yaklaşık 4,7e-4 civarında bir öğrenme oranı üretir ve gradyan patlamaları olmadan kararlı yakınsamayı sağlar.

Öğrenme oranı ısınmasını ayarlayın

Eğitimin başında tam öğrenme oranıyla başlamak, model göreve uyum sağlamadan önce gradyan patlamalarına neden olabilir. Isınma, ilk 200 yineleme boyunca öğrenme oranını sıfıra yakın bir değerden hedef değere kademeli olarak yükseltir. Bunu daha önceki eğitim görselleştirmesinde açıkça görebilirsiniz; öğrenme oranı (yeşil çizgi) ilk 200 yineleme boyunca yumuşak biçimde artar.

# Warmup configuration
warmup_steps = 200

# Calculate iterations from epochs
num_iterations = n_epochs * (n_samples // batch_size)  # 4 * 226 = 904
checkpoint_interval = 200
validation_interval = 50Altyapı:

Eğitim döngüsünü başlatın

Kayıpları takip edecek listeleri başlattıktan sonra eğitim döngüsünü başlatabiliriz:

losses = []
per_token_losses = []
val_losses = []

for iteration in range(num_iterations):
    # Sample random batch
    batch_indices = np.random.choice(len(training_data), size=batch_size, replace=False)
    batch = [training_data[i] for i in batch_indices]
    
    # Apply learning rate warmup
    if iteration < warmup_steps:
        current_lr = learning_rate * (iteration + 1) / warmup_steps
    else:
        current_lr = learning_rateAltyapı:

Isınma mantığı, ilk 200 yineleme boyunca öğrenme oranını kademeli olarak artırarak erken dönemdeki dengesizliği önler.

Tinker’ın temel eğitim ilkel fonksiyonlarını çağırın

Her yinelemede Tinker’ın temel ilkel fonksiyonları şu şekilde çağrılır:

   # API Primitive 1: forward_backward - compute gradients
    fwdbwd_future = training_client.forward_backward(batch, loss_fn="cross_entropy")

    # API Primitive 2: optim_step - update parameters
    optim_future = training_client.optim_step(types.AdamParams(learning_rate=current_lr))

    # Wait for results with retry logic
    fwdbwd_result = with_retry(fwdbwd_future)
    optim_result = with_retry(optim_future)Altyapı:

forward_backward, modelin tahminlerinin ne kadar hatalı olduğunu ve her parametrenin hangi yönde ayarlanması gerektiğini bulup gradyanları hesaplar. Gerçek bir sonraki token’ların olasılık dağılımıyla modelin tahmin ettiği dağılımın ne kadar uyumlu olduğunu ölçen çapraz entropi kaybını kullanır. optim_step ise Adam optimizasyoncusunu kullanarak bu gradyanlara göre model parametrelerini gerçekten günceller.

Her iki yöntemin de anında “future” nesneleri döndürdüğüne dikkat edin. Bu, Tinker’ın aynı anda birden çok işlemi yürütmesine olanak tanır ve işleri hızlandırır. with_retry(future) çağrısı, belirli işlemin tamamlanmasını bekler.

Kayıp metriklerini takip edin ve görüntüleyin

Toplam ve token başına kaybı hesaplayıp ilgili listelere ekliyoruz:

   # Track loss
    loss_sum = fwdbwd_result.metrics["loss:sum"]
    total_completion_tokens = sum(
        np.sum(np.array(training_data[i].loss_fn_inputs["weights"].data) > 0)
        for i in batch_indices
    )
    per_token_loss = loss_sum / total_completion_tokens

    losses.append(loss_sum)
    per_token_losses.append(per_token_loss)

    if iteration % 10 == 0:
        warmup_indicator = "🔥" if iteration < warmup_steps else ""
        print(f"{warmup_indicator} Iteration {iteration} | Train: {per_token_loss:.4f} | LR: {current_lr:.6f}")Altyapı:

Token başına kayıp, kaybı yanıt token sayısına göre normalize eder; bu da farklı batch boyutları arasında yorumlamayı kolaylaştırır. İyi bir eğitim genellikle token başına kaybı yaklaşık 1,2-1,5 seviyesinde başlatır ve checkpoint-400’e gelindiğinde 0,8’in altına indirir. Kayıp 2,0’ın üzerinde başlarsa ya da 50 yineleme sonra düşmüyorsa, veri hazırlığınızı ve öğrenme oranınızı kontrol edin.

Periyodik doğrulama kontrolleri ve kontrol noktaları ekleyin

Ağırlıkları her 200 yinelemede bir kaydetmek, karşılaştırabileceğiniz anlık görüntüler oluşturur. Daha önce gördüğünüz gibi, checkpoint-400 daha yüksek eğitim kaybına rağmen son kontrol noktasından daha iyi geneller. Her zaman birden fazla kontrol noktası kaydedin ve bunları ayrılmış veride değerlendirin. Betiğiniz tamamlandıktan sonra kontrol noktaları Tinker’ın sunucularında kalıcıdır.

   # Compute validation loss periodically
    if iteration % validation_interval == 0:
        val_loss = compute_validation_loss(val_data)
        val_losses.append((iteration, val_loss))
        gap = val_loss - per_token_loss
        print(f"  📊 Iteration {iteration} | Train: {per_token_loss:.4f} | Val: {val_loss:.4f} | Gap: {gap:+.4f}")

    # Checkpoint every 200 iterations
    if iteration > 0 and iteration % checkpoint_interval == 0:
        training_client.save_weights_for_sampler(name=f"fincot-checkpoint-{iteration}")Altyapı:

Tinker, kontrol noktalarını iki kategoriye ayırır: eğitimi kesintiye uğrarsa devam etmek için tam-durum kontrol noktaları ve çıkarım için hafif kontrol noktaları (örnekleyici ağırlıkları). checkpoint-400’ün her iki formatta da göründüğüne dikkat edin; bu, hem eğitime devam etmeyi hem de modeli dağıtmayı kolaylaştırır.

Eğitim çalışmanız kesilirse, kaydedilmiş herhangi bir kontrol noktasından tam-durum ağırlıklarını kullanarak devam edebilir ve baştan başlamadan eğitimi sürdürebilirsiniz.

Bu yöntemler için eksiksiz API başvurusu için Tinker’ın eğitim ve örnekleme dokümantasyonuna bakın.

Adım 6: İnce ayarlı modelinizi kaydedin

Eğitim tamamlandıktan sonra, son model ağırlıklarını kaydedin:

sampling_client = training_client.save_weights_and_get_sampling_client(
    name="financial-qa-qwen3-8b-lora"
)Altyapı:

Ağırlıklar bilgisayarınızda değil, Tinker’ın sunucularında saklanır. LoRA adaptörleri genellikle yalnızca onlarca megabayt gerektirir. İsterseniz modeli kendi altyapıları dışında dağıtmak için Tinker, bunları harici çıkarım sağlayıcılarıyla kullanmak üzere dışa aktarabilir.

Adım 7: Modeli örnek sorularla test edin

Son olarak, sample API ilkelini kullanarak ince ayarlı modelinizi test edin. Önce örnekleme parametrelerini yapılandırın:

sampling_params = types.SamplingParams(
    max_tokens=200,
    temperature=0.7,
    top_p=0.9,
    stop_sequences=["<|im_end|>"]
)Altyapı:

Bu parametreleri açıklayalım:

• max_tokens: Üretilen yanıtın azami uzunluğu (200 token yaklaşık 150 kelimedir).

• temperature: Üretimde rastgeleliği kontrol eder. Düşük değerler (0,1-0,5) çıktıyı daha odaklı ve deterministik yapar; yüksek değerler (0,7-1,0) daha fazla yaratıcılığa izin verir. 0,7 değeri, tutarlılık ve çeşitlilik arasında denge kurar.

• top_p (çekirdek örnekleme): Birlikte kümülatif olasılığı bu değeri aşan en küçük token kümesini dikkate alır. 0,9, “olasılık kütlesinin %90’ını birlikte oluşturan token’ları dikkate al” anlamına gelir. Bu, modelin çok düşük olasılıklı token’ları seçmesini engeller.

• stop_sequences: Modelin bu diziye ulaştığında üretimi durdurmasını söyler. <|im_end|> dizi sonu işaretleyicisidir.

Test soruları için yanıtlar üretin:

questions = [
    "What are the main risks associated with investing in stocks?",
    "How does diversification help reduce portfolio risk?"
]

for question in questions:
    model_input = types.ModelInput.from_ints(tokenizer.encode(question))

    response = with_retry(
        sampling_client.sample(
            prompt=model_input,
            num_samples=1,
            sampling_params=sampling_params
        )
    )

    answer = tokenizer.decode(response.sequences[0].tokens)
    print(f"Q: {question}")
    print(f"A: {answer}\n")Altyapı:

İnce ayarlı modelden iki örnek çıktı (gösterim için kısaltılmıştır):

Q: What are the main risks associated with investing in stocks?
A: Investing in stocks carries several key risks. Market risk represents the potential for stock prices to decline due to economic downturns or market volatility. Company-specific risk arises from poor management decisions, competitive pressures, or operational failures that affect individual stocks. Liquidity risk occurs when you cannot sell shares quickly without significantly impacting the price. Additionally, investors face inflation risk, where returns may not keep pace with rising prices...

Q: How does diversification help reduce portfolio risk?
A: Diversification reduces portfolio risk by spreading investments across different asset classes, sectors, and geographic regions. When you hold multiple uncorrelated assets, losses in one investment can be offset by gains in others. For example, if technology stocks decline but healthcare stocks rise, a diversified portfolio experiences less volatility than one concentrated in technology alone. The key principle is that different assets respond differently to market conditions...Altyapı:

Yanıt nesnesi, her istem için birden fazla örnek talep edebileceğiniz için bir sequences listesi içerir. Token’lara sequences[0].tokens üzerinden erişin ve aynı tokenizer’ı kullanarak tekrar metne dönüştürün.

Artık dört temel API ilkelini başarıyla göstermiş oldunuz:

1. forward_backward: Eğitim verinizden gradyanları hesaplayın

2. optim_step: Adam optimizasyoncusu ile model parametrelerini güncelleyin

3. save_weights_and_get_sampling_client: İnce ayarlı modelinizi kalıcı hâle getirin

4. sample: İnce ayarlı modelden tahminler üretin

Aynı iş akışı kalıbı daha gelişmiş eğitim paradigmalarına da genişler. Pekiştirmeli öğrenme veya tercih optimizasyonu için aynı ilkel fonksiyonları kullanır, ancak farklı kayıp fonksiyonları ve veri formatlarıyla çalışırsınız. Modelleri insan tercihleriyle hizalamak ilginizi çekiyorsa, aynı temele dayanan tercih ince ayarı tekniklerine göz atın. Gelişmiş senaryolar için Tinker cookbook örnekler sunar.

Peki ince ayarın performansı gerçekten iyileştirip iyileştirmediğini nasıl anlarsınız? Öznel izlenimlere güvenmek yerine, titiz değerlendirmeye ihtiyacınız var. Sonraki bölümde, ince ayarlı modelin temel Qwen3-8B’ye karşı 10 farklı finansal soruda karşılaştırıldığı bir LLM-hakem değerlendirmesinin sonuçlarını göreceksiniz.

LLM hakemi ile ince ayarlı modelin değerlendirilmesi

Performansı nesnel olarak ölçmek için LLM-hakem yaklaşımını kullandık: GPT-4o, 10 farklı finansal soru üzerinde checkpoint-400’ü temel Qwen3-8B’ye karşı değerlendirdi; her yanıtı doğruluk, açıklık, bütünlük ve finansal terminoloji açısından puanladı.

İnce ayarlı model 10 üzerinden 8,5 puan alırken, temel model 6,5 aldı; 10 karşılaştırmanın tamamını kazandı. Kararlar nedenini ortaya koyuyor: İnce ayarlı model, güvenli ve yapılandırılmış akıl yürütmeyle eksiksiz açıklamalar sunarken; temel model “bence”, “belki” gibi ifadelerle çekingen kalıp düşüncelerini yarım bırakıyor.

Bu, checkpoint-400’ün gerçek dünyadaki üstün performansını doğrular. 900. yinelemede daha düşük eğitim kaybı bize akıl yürütme değil ezber sunacaktı.

Benzer değerlendirmeleri kendi modellerinizde çalıştırmak için karşılaştırma betiğine ve ayrıntılı sonuçlara göz atın.

Sonuç

Tinker’ın, kontrolden ödün vermeden ince ayarı nasıl basitleştirdiğini gördünüz. forward_backward, optim_step, save_weights_and_get_sampling_client ve sample adlı dört temel API ilkel fonksiyonu, Tinker dağıtık altyapıyı yönetirken, özelleştirilmiş eğitim iş akışları için yapı taşlarını sunar.

Oluşturduğumuz finansal S&C modeli, en iyi üretim uygulamalarını sergiler: doğrulama takibi, aşırı uyumu erkenden yakaladı; genellemeye odaklanan checkpoint-400, son modelden daha iyi performans gösterdi; LLM-hakem değerlendirmesi ise temel modele göre 2 puanlık iyileşmeyi doğruladı. Bu kalıplar, 8B ya da 70B parametreli modelleri ince ayarlarken de geçerlidir.

Platform beta olup bekleme listesiyle erişilir; ancak öğrendiğiniz kavramlar erişim aldığınızda doğrudan uygulanır. Bu eğitim için yaptığım çalışmalar (başarısız ve deneysellik içerenler de dahil) 150 başlangıç kredisini kullandı; yani başlangıç kredileriyle bu eğitimi 6 kez ve ek deneylerle çalıştırabilirsiniz; bu da kendi ince ayar projelerinizde öğrenmek ve yinelemek için fazlasıyla alan sağlar.

Sırada ne var? Alanınıza özgü verilerle ince ayar deneyin, farklı LoRA rank’ları ve öğrenme oranlarıyla denemeler yapın veya insan geri bildiriminden pekiştirmeli öğrenme gibi gelişmiş eğitim paradigmalarını keşfedin. Bu senaryolar için Tinker cookbook örnekler sunar. Kendi kullanım senaryonuzu şimdiden düşünmeye başlayın—modelinizin hangi davranışı öğrenmesini istiyorsunuz?

Üretim için en yeni yapay zekâ modellerini eğitme ve ince ayarlama konusunda daha geniş bir beceri seti geliştirmek istiyorsanız, Geliştiriciler için Associate AI Mühendisi kariyer yoluna mutlaka göz atın.