Büyük Dil Modelleri Nedir?
Büyük Dil Modelleri (Large Language Models – LLM), milyarlarca parametre içeren ve büyük metin veri setleri üzerinde eğitilmiş yapay zeka sistemleridir. Bu modeller, insan benzeri metin üretebilme, dil çevirisi yapabilme, soru-cevap sistemleri oluşturabilme ve kod yazabilme yeteneklerine sahiptir.
Büyük Dil Modelleri Temel Özellikleri
- Büyük ölçekli parametreler: Milyarlarca hatta trilyonlarca parametre
- Transformer mimarisi: Dikkat mekanizması kullanan modern mimari
- Çok amaçlı kullanım: Metin üretme, analiz etme, çevirme
- Few-shot öğrenme: Az örnekle yeni görevleri öğrenebilme
- Sıfır-shot öğrenme: Hiç görmediği görevleri anlayabilme
Büyük Dil Modelleri Çalışma Mantığı
Transformer Mimarisi
LLM’ler temelinde Transformer mimarisini kullanır. Bu mimari, 2017 yılında Google tarafından geliştirilen “Attention is All You Need” makalesiyle tanıtılmıştır.
Attention Mekanizması
Attention mekanizması, modelin metindeki farklı kelimeler arasındaki ilişkileri anlamasını sağlar. Bu sayede model, uzun metinlerde bile bağlam bilgisini koruyabilir.
Eğitim Süreci
- Pre-training: Büyük metin korpusları üzerinde unsupervised öğrenme
- Fine-tuning: Spesifik görevler için supervised öğrenme
- RLHF (Reinforcement Learning from Human Feedback): İnsan geri bildirimlerinden öğrenme
Popüler Büyük Dil Modelleri
OpenAI GPT Serisi
- GPT-3.5: 175 milyar parametre
- GPT-4: Çok modlu yetenekler (metin + görsel)
- GPT-4 Turbo: Geliştirilmiş performans ve hız
Google Modelleri
- BERT: Bidirectional Encoder Representations
- T5: Text-to-Text Transfer Transformer
- PaLM: Pathways Language Model
- Gemini: Google’ın en yeni multimodal modeli
Meta Modelleri
- LLaMA: Large Language Model Meta AI
- LLaMA 2: Açık kaynak alternatif
Anthropic Claude
- Claude: Güvenlik odaklı asistan modeli
- Claude 2: Geliştirilmiş reasoning yetenekleri
Büyük Dil Modelleri ile İlk Adımlar
1. API Anahtarı Alma
İlk adım olarak kullanmak istediğiniz LLM servisinin API anahtarını almanız gerekir:
# OpenAI API anahtarı ayarlama
import os
os.environ["OPENAI_API_KEY"] = "your-api-key-here"
2. Gerekli Kütüphaneleri Yükleme
# OpenAI için
pip install openai
# Hugging Face için
pip install transformers torch
# LangChain için (LLM uygulamaları)
pip install langchain
3. İlk API Çağrısı
import openai
# OpenAI istemcisi oluşturma
client = openai.OpenAI()
# Basit bir sohbet tamamlama
response = client.chat.completions.create(
model="gpt-3.5-turbo",
messages=[
{"role": "user", "content": "Merhaba! LLM'ler hakkında kısa bilgi verir misin?"}
]
)
print(response.choices[0].message.content)
Büyük Dil Modelleri İçin Pratik Kod Örnekleri
Örnek 1: Metin Özetleme
def metin_ozetle(metin, api_key):
"""
Verilen metni özetleyen fonksiyon
"""
import openai
client = openai.OpenAI(api_key=api_key)
prompt = f"""
Aşağıdaki metni özetle. Özet kısa ve öz olsun:
{metin}
"""
response = client.chat.completions.create(
model="gpt-3.5-turbo",
messages=[{"role": "user", "content": prompt}],
max_tokens=150
)
return response.choices[0].message.content
# Kullanım örneği
metin = """
Yapay zeka, bilgisayar bilimlerinde makinelerin insan zekası gerektiren
görevleri yerine getirebilmesi için geliştirilmiş teknolojiler bütünüdür.
Bu alan, makine öğrenmesi, doğal dil işleme, bilgisayar görüşü gibi
alt dalları içerir.
"""
# ozet = metin_ozetle(metin, "your-api-key")
# print(ozet)
Örnek 2: Dil Çevirisi
def ceviri_yap(metin, kaynak_dil, hedef_dil, api_key):
"""
Metni belirtilen dilden başka dile çeviren fonksiyon
"""
import openai
client = openai.OpenAI(api_key=api_key)
prompt = f"""
Aşağıdaki metni {kaynak_dil} dilinden {hedef_dil} diline çevir:
{metin}
"""
response = client.chat.completions.create(
model="gpt-3.5-turbo",
messages=[{"role": "user", "content": prompt}]
)
return response.choices[0].message.content
# Kullanım örneği
# turkce_metin = "Merhaba dünya! Nasılsınız?"
# ingilizce_ceviri = ceviri_yap(turkce_metin, "Türkçe", "İngilizce", "your-api-key")
# print(ingilizce_ceviri)
Örnek 3: Kod Üretimi
def kod_uret(aciklama, programlama_dili, api_key):
"""
Verilen açıklamaya göre kod üreten fonksiyon
"""
import openai
client = openai.OpenAI(api_key=api_key)
prompt = f"""
{programlama_dili} dilinde aşağıdaki işlevi yerine getiren kod yaz:
{aciklama}
Kod açıklamalı ve test edilebilir olsun.
"""
response = client.chat.completions.create(
model="gpt-3.5-turbo",
messages=[{"role": "user", "content": prompt}]
)
return response.choices[0].message.content
# Kullanım örneği
# aciklama = "İki sayıyı toplayan ve sonucu döndüren fonksiyon"
# python_kodu = kod_uret(aciklama, "Python", "your-api-key")
# print(python_kodu)
Örnek 4: Soru-Cevap Sistemi
class SoruCevapSistemi:
def __init__(self, api_key):
import openai
self.client = openai.OpenAI(api_key=api_key)
self.sohbet_gecmisi = []
def soru_sor(self, soru):
# Soru geçmişe eklenir
self.sohbet_gecmisi.append({"role": "user", "content": soru})
# API çağrısı yapılır
response = self.client.chat.completions.create(
model="gpt-3.5-turbo",
messages=self.sohbet_gecmisi
)
cevap = response.choices[0].message.content
# Cevap geçmişe eklenir
self.sohbet_gecmisi.append({"role": "assistant", "content": cevap})
return cevap
def gecmisi_temizle(self):
self.sohbet_gecmisi = []
# Kullanım örneği
# qa_sistemi = SoruCevapSistemi("your-api-key")
# cevap1 = qa_sistemi.soru_sor("Python nedir?")
# cevap2 = qa_sistemi.soru_sor("Python'un avantajları neler?")
Örnek 5: Hugging Face Transformers ile Yerel Model
from transformers import pipeline, AutoTokenizer, AutoModelForCausalLM
def yerel_model_kullan():
"""
Hugging Face'den yerel model yükleyip kullanma
"""
# Türkçe destekli model yükleme
model_name = "microsoft/DialoGPT-medium"
# Pipeline oluşturma
chatbot = pipeline("conversational", model=model_name)
return chatbot
# Kullanım
# chatbot = yerel_model_kullan()
#
# from transformers import Conversation
# conversation = Conversation("Merhaba!")
# result = chatbot(conversation)
# print(result.generated_responses[-1])
Büyük Dil Modelleri En İyi Uygulamalar
1. Prompt Engineering (İstem Mühendisliği)
İyi bir prompt yazmanın altın kuralları:
# ❌ Kötü prompt
bad_prompt = "Kod yaz"
# ✅ İyi prompt
good_prompt = """
Python dilinde aşağıdaki gereksinimleri karşılayan kod yaz:
1. İki sayıyı parametre olarak alan
2. Bu sayıları toplayan
3. Sonucu return eden
4. Hata kontrolü yapan
5. Docstring içeren
Fonksiyon adı: toplama_yap
"""
2. Token Yönetimi
def token_sayisi_hesapla(metin):
"""
Yaklaşık token sayısını hesaplama
(1 token ≈ 4 karakter)
"""
return len(metin) // 4
def maliyeti_hesapla(input_tokens, output_tokens, model="gpt-3.5-turbo"):
"""
API çağrısının maliyetini hesaplama
"""
if model == "gpt-3.5-turbo":
input_cost = input_tokens * 0.0015 / 1000 # $0.0015 per 1K tokens
output_cost = output_tokens * 0.002 / 1000 # $0.002 per 1K tokens
return input_cost + output_cost
return 0
3. Hata Yönetimi
import time
import random
def api_cagrisi_yap(prompt, max_deneme=3):
"""
Hata durumunda yeniden deneme ile API çağrısı
"""
for deneme in range(max_deneme):
try:
response = client.chat.completions.create(
model="gpt-3.5-turbo",
messages=[{"role": "user", "content": prompt}]
)
return response.choices[0].message.content
except Exception as e:
print(f"Deneme {deneme + 1} başarısız: {e}")
if deneme < max_deneme - 1:
# Exponential backoff
time.sleep(2 ** deneme + random.uniform(0, 1))
else:
raise e
Büyük Dil Modelleri Yaygın Hatalar ve Çözümleri
1. Aşırı Uzun Prompt’lar
Problem: Token limitini aşan prompt’lar Çözüm: Prompt’u parçalara bölme
def uzun_metni_isle(uzun_metin, max_token=3000):
"""
Uzun metni parçalara bölerek işleme
"""
parcalar = []
kelimeler = uzun_metin.split()
mevcut_parca = []
mevcut_token = 0
for kelime in kelimeler:
kelime_token = len(kelime) // 4
if mevcut_token + kelime_token > max_token:
parcalar.append(" ".join(mevcut_parca))
mevcut_parca = [kelime]
mevcut_token = kelime_token
else:
mevcut_parca.append(kelime)
mevcut_token += kelime_token
if mevcut_parca:
parcalar.append(" ".join(mevcut_parca))
return parcalar
2. Tutarsız Çıktılar
Problem: Aynı prompt farklı sonuçlar veriyor Çözüm: Temperature ve seed parametrelerini kullanma
def tutarli_cevap_al(prompt, api_key):
"""
Daha tutarlı cevaplar için düşük temperature kullanma
"""
client = openai.OpenAI(api_key=api_key)
response = client.chat.completions.create(
model="gpt-3.5-turbo",
messages=[{"role": "user", "content": prompt}],
temperature=0.1, # Düşük temperature = daha tutarlı
seed=42 # Sabit seed = tekrarlanabilir sonuçlar
)
return response.choices[0].message.content
3. Hallucination (Yanılsama) Problemi
Problem: Model gerçek olmayan bilgiler üretiyor Çözüm: Doğrulama ve kaynak belirtme
def dogrulama_ile_cevap(soru, api_key):
"""
Cevabın doğruluğunu kontrol eden prompt
"""
prompt = f"""
Aşağıdaki soruyu cevapla, ancak emin olmadığın bilgiler için
"Bu konuda emin değilim" ifadesini kullan:
{soru}
Mümkünse kaynak belirt.
"""
# API çağrısı kodu buraya...
pass
Büyük Dil Modelleri için İleri Seviye Konular
1. Fine-tuning (İnce Ayar)
Kendi verilerinizle modeli özelleştirme:
# Fine-tuning için veri hazırlama
def veriyi_hazirla(ornekler):
"""
Fine-tuning için veri formatını hazırlama
"""
hazir_veri = []
for ornek in ornekler:
hazir_veri.append({
"messages": [
{"role": "user", "content": ornek["soru"]},
{"role": "assistant", "content": ornek["cevap"]}
]
})
return hazir_veri
# Örnek veri
ornekler = [
{
"soru": "Python'da liste nasıl oluşturulur?",
"cevap": "Python'da liste oluşturmak için köşeli parantez [] kullanılır. Örnek: my_list = [1, 2, 3]"
}
]
# hazir_veri = veriyi_hazirla(ornekler)
2. RAG (Retrieval-Augmented Generation)
Kendi belgelerinizle LLM’yi güçlendirme:
from langchain.document_loaders import TextLoader
from langchain.text_splitter import CharacterTextSplitter
from langchain.embeddings import OpenAIEmbeddings
from langchain.vectorstores import FAISS
def rag_sistemi_olustur(belgeler, api_key):
"""
RAG sistemi oluşturma
"""
# Belgeleri yükleme
documents = []
for belge in belgeler:
loader = TextLoader(belge)
documents.extend(loader.load())
# Metni parçalara bölme
text_splitter = CharacterTextSplitter(chunk_size=1000, chunk_overlap=0)
texts = text_splitter.split_documents(documents)
# Embeddings oluşturma
embeddings = OpenAIEmbeddings(openai_api_key=api_key)
# Vector store oluşturma
vectorstore = FAISS.from_documents(texts, embeddings)
return vectorstore
def rag_soru_sor(soru, vectorstore, api_key):
"""
RAG sistemi ile soru sorma
"""
# İlgili belgeleri bulma
docs = vectorstore.similarity_search(soru, k=3)
context = "\n".join([doc.page_content for doc in docs])
# Bağlamla beraber prompt oluşturma
prompt = f"""
Aşağıdaki bağlam bilgilerini kullanarak soruyu cevapla:
Bağlam:
{context}
Soru: {soru}
"""
# API çağrısı yapma (önceki örneklerdeki gibi)
# ...
3. Chain of Thought Prompting
Adım adım düşünme:
def chain_of_thought_prompt(problem):
"""
Adım adım çözüm için prompt
"""
prompt = f"""
Aşağıdaki problemi adım adım çöz:
{problem}
Çözüm adımları:
1. Problemı anla
2. Gerekli bilgileri belirle
3. Çözüm yolunu planla
4. Adım adım çöz
5. Sonucu kontrol et
"""
return prompt
# Örnek kullanım
# matematik_problem = "Bir dikdörtgenin uzunluğu 8 cm, genişliği 5 cm. Alanı kaç cm²?"
# cot_prompt = chain_of_thought_prompt(matematik_problem)
Büyük Dil Modelleri, modern yapay zeka uygulamalarının temel taşlarından biridir. Bu rehberde öğrendiğiniz temel bilgiler ve kod örnekleri ile kendi LLM uygulamalarınızı geliştirebilirsiniz.
Büyük Dil Modelleri Önemli Nokta Hatırlatmaları
- API anahtarlarınızı güvenli tutun
- Token kullanımınızı takip edin
- Prompt yazımına özen gösterin
- Hata yönetimini ihmal etmeyin
- Model çıktılarını doğrulayın
Öğrenmeye Devam Edin
- OpenAI Documentation
- Hugging Face Hub
- LangChain Documentation
- Papers with Code
- GitHub repositories
Bu rehber sizin LLM dünyasına ilk adımınız olsun. Pratik yaparak ve denemeler yaparak öğrenmeye devam edebilirsiniz.
