Python’da AI ve LLM Mühendisleri için Tasarım Kalıpları: Pratik Bir Kılavuz

AI mühendisleri olarak, temiz, verimli ve bakımı kolay kod oluşturmak kritiktir, özellikle karmaşık sistemler inşa ederken.

Tasarım kalıpları yazılım tasarımındaki ortak sorunlara yeniden kullanılabilir çözümlerdir. AI ve büyük dil modeli (LLM) mühendisleri için tasarım kalıpları, güçlü, ölçeklenebilir ve bakımı kolay sistemler oluşturmak için yardımcı olur. Bu makale, AI ve LLM’de kullanılan Python tasarım kalıplarına odaklanıyor. Her kalıbı pratik AI kullanım örnekleriyle ve Python kodu örnekleriyle açıklayacağım.

AI ve makine öğrenimi bağlamında özellikle faydalı olan bazı ana tasarım kalıplarını keşidelim.

AI Mühendisleri için Tasarım Kalıplarının Önemi

AI sistemleri genellikle şunları içerir:

1. Karmaşık nesne oluşturma (örneğin, model yükleme, veri ön işleme.pipeline’ları).
2. Bileşenler arasındaki etkileşimleri yönetme (örneğin, model çıkarımı, gerçek zamanlı güncellemeler).
3. Değişen gereksinimlere göre ölçeklenebilirlik, bakım ve esneklik sağlama.

Tasarım kalıpları bu zorlukları ele alır ve net bir yapı sağlar, böylece acele çözümler azaltılır. Üç ana kategoriye ayrılırlar:

• Oluşturucu Kalıplar: Nesne oluşturmaya odaklanırlar. (Singleton, Factory, Builder)
• Yapısal Kalıplar: Nesneler arasındaki ilişkileri organize ederler. (Adapter, Decorator)
• Davranışsal Kalıplar: Nesneler arasındaki iletişimi yönetirler. (Strategy, Observer)

1. Singleton Kalıbı

Singleton Kalıbı, bir sınıfın yalnızca bir örneğinin olmasını sağlar ve bu örneğe küresel erişim sağlar. AI iş akışlarında paylaşılan kaynakları (örneğin, yapılandırma ayarları, günlük sistemleri veya model örnekleri) tutarlı bir şekilde yönetmek için özellikle değerlidir.

Ne Zaman Kullanılır

• Global yapılandırmaları yönetme (örneğin, model hiperparametreleri).
• Çoklu iş parçacıkları veya süreçler arasında kaynakları paylaşma (örneğin, GPU belleği).
• Tek bir çıkarım motoru veya veritabanı bağlantısına tutarlı erişim sağlamak.

Uygulama

AI modeli için yapılandırmaları yönetmek amacıyla Python’da Singleton kalıbını nasıl uygulayacağımızı görelim:

[kod dili=”PYTHON”]
class ModelConfig:
“””AI modeli için global yapılandırmaları yöneten Singleton sınıfı.”””
_instance = None # Singleton örneğini depolamak için sınıf değişkeni

def __new__(cls, *args, **kwargs):
if not cls._instance:
# Örnek yoksa yeni bir tane oluştur
cls._instance = super().__new__(cls)
cls._instance.ayarlar = {} # Yapılandırma sözlüğünü başlat
return cls._instance

def set(self, key, value):
“””Bir yapılandırma anahtar-değer çifti ayarla.”””
self.ayarlar[key] = value

def get(self, key):
“””Bir yapılandırma değerini anahtar tarafından al.”””
return self.ayarlar.get(key)

# Kullanım Örneği
config1 = ModelConfig()
config1.set(“model_name”, “GPT-4”)
config1.set(“batch_size”, 32)

# Aynı örneğe erişim
config2 = ModelConfig()
print(config2.get(“model_name”)) # Çıktı: GPT-4
print(config2.get(“batch_size”)) # Çıktı: 32
print(config1 is config2) # Çıktı: True (her iki örnek aynıdır)
[/kod]

Açıklama

1. __new__ Yöntemi: Bu, yalnızca bir sınıf örneğinin oluşturulmasını sağlar. Bir örnek zaten varsa, mevcut olanı döndürür.
2. Paylaşılan Durum: Hem config1 hem de config2 aynı örneğe işaret eder, böylece tüm yapılandırmalar küresel olarak erişilebilir ve tutarlıdır.
3. AI Kullanım Örneği: Bu kalıbı, global ayarları yönetmek için kullanın, Örneğin, veri seti yolları, günlük ayarları veya ortam değişkenleri.

2. Fabrika Kalıbı

Fabrika Kalıbı, nesne oluşturmayı alt sınıflara veya özel fabrika yöntemlerine devredebilme sağlar. AI sistemlerinde, bu kalıp, farklı model türleri, veri yükleyicileri veya iş akışları oluşturmak için idealdir.

Ne Zaman Kullanılır

• Kullanıcı girişi veya görev gereksinimlerine bağlı olarak modelleri dinamik olarak oluşturma.
• Karmaşık nesne oluşturma mantığını yönetme (örneğin, çok adımlı ön işleme pipeline’ları).
• Nesne oluşturmayı sistemın geri kalanından ayırarak esnekliği artırma.

Uygulama

Farklı AI görevleri için modeller oluşturmak amacıyla Fabrika kalıbını nasıl uygulayacağımızı görelim:

[kod dili=”PYTHON”]
class BaseModel:
“””AI modelleri için soyut temel sınıf.”””
def predict(self, data):
raise NotImplementedError(“Alt sınıflar predict yöntemini uygulamalıdır”)

class TextClassificationModel(BaseModel):
def predict(self, data):
return f”Metni sınıflandırma: {data}”

class SummarizationModel(BaseModel):
def predict(self, data):
return f”Metni özetleme: {data}”

class TranslationModel(BaseModel):
def predict(self, data):
return f”Metni çevirme: {data}”

class ModelFactory:
“””AI modellerini dinamik olarak oluşturan fabrika sınıfı.”””
@staticmethod
def create_model(task_type):
“””Görev türüne göre model oluşturma.”””
task_mapping = {
“classification”: TextClassificationModel,
“summarization”: SummarizationModel,
“translation”: TranslationModel,
}
model_class = task_mapping.get(task_type)
if not model_class:
raise ValueError(f”Bilinen görev türü değil: {task_type}”)
return model_class()

# Kullanım Örneği
task = “classification”
model = ModelFactory.create_model(task)
print(model.predict(“AI dünyasını değiştirecek!”))
# Çıktı: Metni sınıflandırma: AI dünyasını değiştirecek!
[/kod]

Açıklama

1. Soyut Temel Sınıf: BaseModel sınıfı, tüm alt sınıfların uygulaması gereken predict arayüzünü tanımlar.
2. Fabrika Mantığı: ModelFactory sınıfı, görev türüne bağlı olarak dinamik olarak model oluşturur.
3. Genişletilebilirlik: Yeni model türleri eklemek kolaydır; yalnızca yeni bir alt sınıf uygulamak ve fabrikanın task_mapping‘ine eklemek gerekir.

AI Kullanım Örneği

Bir sistem tasarlıyorsanız ve görev türüne bağlı olarak (örneğin, BERT, GPT veya T5 gibi) farklı modelleri seçmek istiyorsanız, Fabrika kalıbı bu işlemi kolaylaştırır.

3. Builder Kalıbı

Builder Kalıbı, karmaşık bir nesnenin oluşturulmasını onun temsiliğinden ayırır. AI sistemlerinde, bu kalıp, çok adımlı işlemler veya yapılandırmalar gerektiren nesneleri oluşturmak için yararlıdır.

Ne Zaman Kullanılır

• Çok adımlı pipeline’lar oluşturma (örneğin, veri ön işleme).
• Deney veya model eğitimi için yapılandırmaları yönetme.
• Birçok parametreye sahip nesneleri, okunabilirlik ve bakım için oluşturma.

Uygulama

Veri ön işleme pipeline’larını oluşturmak amacıyla Builder kalıbını nasıl uygulayacağımızı görelim:

[kod dili=”PYTHON”]
class DataPipeline:
“””Veri ön işleme pipeline’larını oluşturan Builder sınıfı.”””
def __init__(self):
self.adımlar = []

def add_step(self, step_function):
“””Pipeline’a bir ön işleme adımı ekle.”””
self.adımlar.append(step_function)
return self # Zincirleme yöntemi ermögür

def run(self, data):
“””Pipeline’daki tüm adımları çalıştır.”””
for step in self.adımlar:
data = step(data)
return data

# Kullanım Örneği
pipeline = DataPipeline()
pipeline.add_step(lambda x: x.strip()) # Adım 1: Boşlukları kaldır
pipeline.add_step(lambda x: x.lower()) # Adım 2: Küçük harfe çevir
pipeline.add_step(lambda x: x.replace(“.”, “”)) # Adım 3: Noktalama işareti kaldır

processed_data = pipeline.run(” Merhaba Dünya. “)
print(processed_data) # Çıktı: merhaba dünya
[/kod]

Açıklama

1. Zincirleme Yöntemi: add_step yöntemi, pipeline tanımlama söz dizimini kolaylaştırır.
2. Adım Adım İşleme: Pipeline, veriyi her adımda işler.
3. AI Kullanım Örneği: Builder kalıbını, karmaşık veri ön işleme pipeline’ları veya model eğitimi ayarları oluşturmak için kullanın.

4. Strategy Kalıbı

Strategy Kalıbı, değiştirilebilir algoritmalar ailesini tanımlar, her birini kapsüller ve davranışın çalışma zamanında değişmesine izin verir. AI sistemlerinde, bu kalıp, aynı işlem (örneğin, çıkarım veya veri işleme) için farklı yaklaşımlar gerektiğinde özellikle kullanışlıdır.

Ne Zaman Kullanılır

• Çıkarım stratejileri arasında geçiş yapma (örneğin, toplu işleme karşı akışkan işleme).
• Farklı veri işleme tekniklerini dinamik olarak uygulama.
• Kaynak yönetimi stratejilerini mevcut altyapıya göre seçme.

Uygulama

AI modeli için iki farklı çıkarım stratejisi uygulamak amacıyla Strategy kalıbını nasıl uygulayacağımızı görelim:

[kod dili=”PYTHON”]
class InferenceStrategy:
“””Çıkarım stratejileri için soyut temel sınıf.”””
def infer(self, model, data):
raise NotImplementedError(“Alt sınıflar infer yöntemini uygulamalıdır”)

class BatchInference(InferenceStrategy):
“””Toplu çıkarım için strateji.”””
def infer(self, model, data):
print(“Toplu çıkarım yapıyor…”)
return [model.predict(item) for item in data]

class StreamInference(InferenceStrategy):
“””Akışkan çıkarım için strateji.”””
def infer(self, model, data):
print(“Akışkan çıkarım yapıyor…”)
results = []
for item in data:
results.append(model.predict(item))
return results

class InferenceContext:
“””Çıkarım stratejilerini dinamik olarak değiştirmeye izin veren bağlam sınıfı.”””
def __init__(self, strategy: InferenceStrategy):
self.strategy = strategy

def set_strategy(self, strategy: InferenceStrategy):
“””Çıkarım stratejisini dinamik olarak değiştir.”””
self.strategy = strategy

def infer(self, model, data):
“””Seçilen stratejiyle çıkarım yaptır.”””
return self.strategy.infer(model, data)

# Mock Model Sınıfı
class MockModel:
def predict(self, input_data):
return f”Öngörü: {input_data}”

# Kullanım Örneği
model = MockModel()
data = [“örnek1”, “örnek2”, “örnek3”]

context = InferenceContext(BatchInference())
print(context.infer(model, data))
# Çıktı:
# Toplu çıkarım yapıyor…
# [‘Öngörü: örnek1’, ‘Öngörü: örnek2’, ‘Öngörü: örnek3’]

# Akışkan çıkarıma geçiş
context.set_strategy(StreamInference())
print(context.infer(model, data))
# Çıktı:
# Akışkan çıkarım yapıyor…
# [‘Öngörü: örnek1’, ‘Öngörü: örnek2’, ‘Öngörü: örnek3’]
[/kod]

Açıklama

1. Soyut Strateji Sınıfı: InferenceStrategy sınıfı, tüm alt sınıfların uygulaması gereken infer arayüzünü tanımlar.
2. Somut Stratejiler: Her strateji (BatchInference, StreamInference) spesifik bir yaklaşımı uygular.
3. Dinamik Değişim: InferenceContext sınıfı, çalışma zamanında strateji değişmesine olanak sağlar.

Ne Zaman Kullanılır

• Toplu çıkarım ile akışkan çıkarım arasında geçiş yapma.
• Veri işleme tekniklerini dinamik olarak değiştirme.

5. Observer Kalıbı

Observer Kalıbı, nesneler arasında bir-çok ilişki kurar. Bir nesne (konu) değiştiğinde, tüm bağımlı nesneleri (gözlemciler) otomatik olarak bilgilendirir. AI sistemlerinde, bu kalıp, gerçek zamanlı izleme, olay işleme veya veri senkronizasyonu için özellikle yararlıdır.

Ne Zaman Kullanılır

• Eğitim sırasında doğruluk veya kayıp gibi metriklere izleme yapma.
• Çoklu iş parçacıkları veya süreçler arasında gerçek zamanlı güncellemeler.
• Karmaşık iş akışlarındaki bağımlılıkları yönetme.

Uygulama

AI modelinin performansını gerçek zamanlı izlemek amacıyla Observer kalıbını nasıl uygulayacağımızı görelim:

[kod dili=”PYTHON”]
class Subject:
“””Gözlemlenen konular için temel sınıf.”””
def __init__(self):
self._gözlemciler = []

def attach(self, observer):
“””Bir gözlemci ekleyin.”””
self._gözlemciler.append(observer)

def detach(self, observer):
“””Bir gözlemci çıkarın.”””
self._gözlemciler.remove(observer)

def notify(self, data):
“””Tüm gözlemcilere durum değişikliğini bildirin.”””
for observer in self._gözlemciler:
observer.update(data)

class ModelMonitor(Subject):
“””Model performansını izleyen konu.”””
def update_metrics(self, metric_name, value):
“””Performans metriğini güncelleyin ve gözlemcileri bilgilendirin.”””
print(f”{metric_name} güncellendi: {value}”)
self.notify({metric_name: value})

class Observer:
“””Gözlemciler için soyut temel sınıf.”””
def update(self, data):
raise NotImplementedError(“Alt sınıflar update yöntemini uygulamalıdır”)

class LoggerObserver(Observer):
“””Günlük gözlemcisi.”””
def update(self, data):
print(f”Metrik güncellemesi günlüğe kaydedildi: {data}”)

class AlertObserver(Observer):
“””Uyarı gözlemcisi.”””
def __init__(self, threshold):
self.threshold = threshold

def update(self, data):
for metric, value in data.items():
if value > self.threshold:
print(f”UYARI: {metric} eşiği aştı: {value}”)

# Kullanım Örneği
monitor = ModelMonitor()
logger = LoggerObserver()
alert = AlertObserver(threshold=90)

monitor.attach(logger)
monitor.attach(alert)

# Metrik güncellemesi simülasyonu
monitor.update_metrics(“doğruluk”, 85) # Günlüğe kaydedilir
monitor.update_metrics(“doğruluk”, 95) # Günlüğe kaydedilir ve uyarı tetiklenir
[/kod]

Açıklama

1. Konu: ModelMonitor sınıfı, performans metriğini izler ve gözlemcileri bilgilendirir.
2. Gözlemciler: Her gözlemci (LoggerObserver, AlertObserver) spesifik bir eylem gerçekleştirir.
3. Loose Coupling: Gözlemciler ve konular gevşek bir şekilde bağlanır, sistemi modüler ve genişletilebilir kılar.

AI Kullanım Örneği

AI modelinin eğitim sürecinde, doğruluk veya kayıp gibi metriklere gerçek zamanlı izleme yapabilirsiniz. Observer kalıbı, bu süreci kolaylaştırır.

AI Mühendisleri için Tasarım Kalıplarının Farklılıkları

Tasarım kalıpları, AI mühendisliği bağlamında benzersiz özellikler taşır. AI sistemlerinin getirdiği zorluklar, hedefler ve iş akışları, kalıpların geleneksel kullanımlarının ötesine geçerek uyarlanmasını gerektirir.

1. Nesne Oluşturma: Statik karşı Dinamik İhtiyaçlar

• Geleneksel Mühendislik: Nesne oluşturma kalıpları genellikle statik yapılandırmalar, veritabanı bağlantıları veya kullanıcı oturumlarını yönetmek için kullanılır.
• AI Mühendisliği: Nesne oluşturma, dinamik iş akışları içerir:
  • Kullanıcı girişine veya sistem gereksinimlerine bağlı olarak modelleri oluşturma.
  • Farklı görevler için farklı model yapılandırmalarını yükleme.
  • Veri işleme pipeline’ları oluşturma.

2. Performans Kısıtlamaları

• Geleneksel Mühendislik: Tasarım kalıpları genellikle gecikme ve işleme hızını optimize etmek için kullanılır.
• AI Mühendisliği: Performans gereksinimleri, model çıkarımı gecikmesi, GPU/TPU kullanımı ve bellek optimizasyonunu içerir. Kalıplar:
  • Aradaki sonuçları önbelleğe alma (Decorator veya Proxy kalıpları).
  • Algoritmaları dinamik olarak değiştirme (Strategy kalıbı) için sistem yükü veya gerçek zamanlı kısıtlamalarına bağlı olarak.

3. Veri Merkezli Doğa

• Geleneksel Mühendislik: Kalıplar genellikle sabit girdi-çıktı yapılarına odaklanır.
• AI Mühendisliği: Kalıplar, veri değişkenliği ve ölçeği ile başa çıkmalıdır:
  • Gerçek zamanlı veri akışları.
  • Çoklu modlu veri (metin, resim, video).
  • Büyük ölçekli veri kümeleri.

4. Deneysellik karşı Kararlılık

• Geleneksel Mühendislik: Kalıplar, kararlı ve öngörülebilir sistemler oluşturmak için kullanılır.
• AI Mühendisliği: AI iş akışları thường deneyseldir ve:
  • Model mimarilerini veya veri ön işleme tekniklerini iteratif olarak güncelleme.
  • Sistem bileşenlerini dinamik olarak güncelleme.
  • Mevcut pipeline’lara yeni bileşenler ekleme.