Modele de proiectare în Python pentru ingineri AI și LLM: Un ghid practic

Ca ingineri AI, crearea unui cod curat, eficient și întreținut este critic, în special atunci când se construiesc sisteme complexe.

Modelele de proiectare sunt soluții reutilizabile pentru probleme comune în proiectarea software. Pentru inginerii AI și LLM, modelele de proiectare ajută la crearea unor sisteme robuste, scalabile și întreținute, care pot gestiona fluxuri de lucru complexe în mod eficient. Acest articol explorează modelele de proiectare în Python, cu accent pe relevanța lor în sistemele AI și LLM. Voi explica fiecare model cu exemple practice de utilizare în AI și cod Python.

Să explorăm câteva dintre modelele de proiectare cheie care sunt deoseit de utile în contextele AI și de învățare automată, împreună cu exemplele lor în Python.

De ce modelele de proiectare sunt importante pentru inginerii AI

Sistemele AI implică adesea:

1. Crearea de obiecte complexe (de exemplu, încărcarea modelelor, pipeline-urile de prelucrare a datelor).
2. Managementul interacțiunilor dintre componente (de exemplu, inferența modelului, actualizările în timp real).
3. Manipularea scalabilității, întreținerii și flexibilității pentru cerințe în schimbare.

Modelele de proiectare abordează aceste provocări, oferind o structură clară și reducând soluțiile ad-hoc. Ele se împart în trei categorii principale:

• Modele creionale: Se concentrează pe crearea de obiecte. (Singleton, Factory, Builder)
• Modele structurale: Organizează relațiile dintre obiecte. (Adapter, Decorator)
• Modele comportamentale: Gestionează comunicarea dintre obiecte. (Strategy, Observer)

1. Modelul Singleton

Modelul Singleton asigură că o clasă are doar o instanță și oferă un punct de acces global la acea instanță. Acest lucru este deoseit de valoros în fluxurile de lucru AI, unde resursele partajate, cum ar fi setările de configurare, sistemele de logging sau instanțele modelului, trebuie gestionate în mod coerent și fără redundanță.

Când să se utilizeze

• Managementul configurațiilor globale (de exemplu, hiperparametrii modelului).
• Partajarea resurselor între mai multe fire sau procese (de exemplu, memoria GPU).
• Asigurarea accesului coerent la un singur motor de inferență sau conexiune la bază de date.

Implementare

Iată cum se implementează modelul Singleton în Python pentru a gestiona configurațiile pentru un model AI:

class ConfigModel:
"""
Clasă Singleton pentru gestionarea configurațiilor globale ale modelului.
"""
_instanță = None # Variabilă de clasă pentru a stoca instanța Singleton

def __new__(cls, *args, **kwargs):
if not cls._instanță:
# Creează o nouă instanță dacă nu există una
cls._instanță = super().__new__(cls)
cls._instanță.setări = {} # Inițializează dicționarul de configurare
return cls._instanță

def set(self, cheie, valoare):
"""
Setează o pereche cheie-valoare de configurare.
"""
self.setări[cheie] = valoare

def get(self, cheie):
"""
Obține o valoare de configurare după cheie.
"""
return self.setări.get(cheie)

# Exemplu de utilizare
config1 = ConfigModel()
config1.set("nume_model", "GPT-4")
config1.set("dimensiune_lot", 32)

# Accesarea aceleiași instanțe
config2 = ConfigModel()
print(config2.get("nume_model")) # Output: GPT-4
print(config2.get("dimensiune_lot")) # Output: 32
print(config1 este config2) # Output: True (ambele sunt aceeași instanță)

Explicație

1. Metoda __new__: Asigură că se creează doar o singură instanță a clasei. Dacă o instanță există deja, returnează acea instanță.
2. Stare partajată: Atât config1, cât și config2 se referă la aceeași instanță, făcând toate configurațiile accesibile global și coerente.
3. Caz de utilizare în AI: Utilizați acest model pentru a gestiona setări globale, cum ar fi căile către seturile de date, configurațiile de logging sau variabilele de mediu.

2. Modelul Factory

Modelul Factory oferă o modalitate de a delega crearea de obiecte către subclase sau metode de fabrică dedicate. În sistemele AI, acest model este ideal pentru crearea dinamică a diferitelor tipuri de modele, încărcătoare de date sau pipeline-uri în funcție de context.

Când să se utilizeze

• Crearea dinamică a modelelor în funcție de intrarea utilizatorului sau de cerințele sarcinii.
• Managementul logicii complexe de creare a obiectelor (de exemplu, pipeline-uri de prelucrare a datelor cu mai multe etape).
• Decuplarea instanțierii obiectului de restul sistemului pentru a îmbunătăți flexibilitatea.

Implementare

Să construim o fabrică pentru crearea de modele pentru diferite sarcini AI, cum ar fi clasificarea textului, rezumarea și traducerea:

class ModelDeBază:
"""
Clasă de bază abstractă pentru modelele AI.
"""
def predict(self, date):
raise NotImplementedError("Subclasele trebuie să implementeze metoda `predict`")

class ModelClasificareText(ModelDeBază):
def predict(self, date):
return f"Clasificarea textului: {date}"

class ModelRezumare(ModelDeBază):
def predict(self, date):
return f"Rezumarea textului: {date}"

class ModelTraducere(ModelDeBază):
def predict(self, date):
return f"Traducerea textului: {date}"

class FabricăModel:
"""
Clasă de fabrică pentru a crea modele AI dinamic.
"""
@staticmethod
def create_model(tip_sarcină):
"""
Metodă de fabrică pentru a crea modele în funcție de tipul sarcinii.
"""
mapping_sarcină = {
"clasificare": ModelClasificareText,
"rezumare": ModelRezumare,
"traducere": ModelTraducere,
}
clasă_model = mapping_sarcină.get(tip_sarcină)
if not clasă_model:
raise ValueError(f"Tip de sarcină necunoscut: {tip_sarcină}")
return clasă_model()

# Exemplu de utilizare
sarcină = "clasificare"
model = FabricăModel.create_model(sarcină)
print(model.predict("AI va transforma lumea!"))
# Output: Clasificarea textului: AI va transforma lumea!

Explicație

1. Clasă de bază abstractă: Clasa ModelDeBază definește interfața (predict) pe care toate subclasele trebuie să o implementeze, asigurând coerență.
2. Logica fabricii: Clasa FabricăModel selectează dinamic clasa potrivită în funcție de tipul sarcinii și creează o instanță.
3. Extensibilitate: Adăugarea unui nou tip de model este ușoară – doar implementați o nouă subclasă și actualizați mapping_sarcină al fabricii.

Caz de utilizare în AI

Imaginați-vă că proiectați un sistem care selectează un LLM diferit (de exemplu, BERT, GPT sau T5) în funcție de sarcină. Modelul Factory face ca extinderea sistemului cu noi modele să fie ușoară, fără a modifica codul existent.

3. Modelul Builder

Modelul Builder separă construirea unui obiect complex de reprezentarea sa. Este util atunci când un obiect necesită mai multe etape pentru inițializare sau configurare.

Când să se utilizeze

• Construirea de pipeline-uri cu mai multe etape (de exemplu, prelucrarea datelor).
• Managementul configurațiilor pentru experimente sau antrenarea modelului.
• Crearea de obiecte care necesită mulți parametri, asigurând citibilitate și întreținere.

Implementare

Iată cum se utilizează modelul Builder pentru a crea o pipeline de prelucrare a datelor:

class PipelineDate:
"""
Clasă Builder pentru a construi o pipeline de prelucrare a datelor.
"""
def __init__(self):
self.etape = []

def adaugă_etapă(self, funcție_etapă):
"""
Adaugă o etapă de prelucrare la pipeline.
"""
self.etape.append(funcție_etapă)
return self # Returnează self pentru a permite lanțuirea metodelor

def rulează(self, date):
"""
Execută toate etapele din pipeline.
"""
for etapă in self.etape:
date = etapă(date)
return date

# Exemplu de utilizare
pipeline = PipelineDate()
pipeline.adaugă_etapă(lambda x: x.strip()) # Etapa 1: șterge spațiile albe
pipeline.adaugă_etapă(lambda x: x.lower()) # Etapa 2: convertire în minuscule
pipeline.adaugă_etapă(lambda x: x.replace(".", "")) # Etapa 3: șterge punctele

date_prelucrate = pipeline.rulează(" Salut Lume. ")
print(date_prelucrate) # Output: salut lume

Explicație

1. Metode lanțuite: Metoda adaugă_etapă permite lanțuirea pentru o sintaxă compactă și intuitivă la definirea pipeline-urilor.
2. Execuție etapă cu etapă: Pipeline-ul prelucrează datele prin executarea fiecărei etape în secvență.
3. Caz de utilizare în AI: Utilizați modelul Builder pentru a crea pipeline-uri complexe de prelucrare a datelor sau pentru a configura antrenarea modelului.

4. Modelul Strategy

Modelul Strategy definește o familie de algoritmi interschimbabili, encapsulând fiecare și permițând schimbarea comportamentului la rulare. Acesta este deoseit de util în sistemele AI, unde același proces (de exemplu, inferența sau prelucrarea datelor) poate necesita abordări diferite în funcție de context.

Când să se utilizeze

• Comutarea între diferite strategii de inferență (de exemplu, prelucrarea în loturi vs. streaming).
• Aplicarea diferitelor tehnici de prelucrare a datelor dinamic.
• Alegerea strategiilor de gestionare a resurselor în funcție de infrastructura disponibilă.

Implementare

Să utilizăm modelul Strategy pentru a implementa două strategii de inferență diferite pentru un model AI: inferența în loturi și inferența în flux:

<p>class StrategieInferență:
&quot;&quot;&quot;
Clasă de bază abstractă pentru strategiile de inferență.
&quot;&quot;&quot;
def infer(self, model, date):
raise NotImplementedError(&quot;Subclasele trebuie să implementeze metoda `infer`&quot;)</p>

<p>class InferențăÎnLoturi(StrategieInferență):
&quot;&quot;&quot;
Strategie pentru inferența în loturi.
&quot;&quot;&quot;
def infer(self, model, date):
print(&quot;Se efectuează inferența în loturi...&quot;)
return [model.predict(item) for item in date]</p>

<p>class InferențăÎnFlux(StrategieInferență):
&quot;&quot;&quot;
Strategie pentru inferența în flux.
&quot;&quot;&quot;
def infer(self, model, date):
print(&quot;Se efectuează inferența în flux...&quot;)
rezultate = []
for item in date:
rezultate.append(model.predict(item))
return rezultate</p>

<p>class ContextInferență:
&quot;&quot;&quot;
Clasă de context pentru a comuta între strategiile de inferență dinamic.
&quot;&quot;&quot;
def __init__(self, strategie: StrategieInferență):
self.strategie = strategie</p>

<p>def setează_strategie(self, strategie: StrategieInferență):
&quot;&quot;&quot;
Schimbă strategia de inferență dinamic.
&quot;&quot;&quot;
self.strategie = strategie</p>

<p>def infer(self, model, date):
&quot;&quot;&quot;
Delegează inferența către strategia selectată.
&quot;&quot;&quot;
return self.strategie.infer(model, date)</p>

<p># Clasă model mock
class ModelMock:
def predict(self, input_date):
return f&quot;Predicted: {input_date}&quot;</p>

<p># Exemplu de utilizare
model = ModelMock()
date = [&quot;sample1&quot;, &quot;sample2&quot;, &quot;sample3&quot;]</p>

<p>context = ContextInferență(InferențăÎnLoturi())
print(context.infer(model, date))
# Output:
# Se efectuează inferența în loturi...
# [&#039;Predicted: sample1&#039;, &#039;Predicted: sample2&#039;, &#039;Predicted: sample3&#039;]</p>

<p># Comută la inferența în flux
context.setează_strategie(InferențăÎnFlux())
print(context.infer(model, date))
# Output:
# Se efectuează inferența în flux...
# [&#039;Predicted: sample1&#039;, &#039;Predicted: sample2&#039;, &#039;Predicted: sample3&#039;]</p>

Explicație

1. Clasă de strategie abstractă: Clasa StrategieInferență definește interfața pe care toate strategiile trebuie să o implementeze.
2. Strategii concrete: Fiecare strategie (de exemplu, InferențăÎnLoturi, InferențăÎnFlux) implementează logica specifică acelei abordări.
3. Comutare dinamică: Clasa ContextInferență permite comutarea strategiilor la rulare, oferind flexibilitate pentru diferite cazuri de utilizare.

Când să se utilizeze

• Comutați între inferența în loturi pentru prelucrarea offline și inferența în flux pentru aplicații în timp real.
• Ajustați dinamic tehnici de prelucrare a datelor sau de augmentare a datelor în funcție de sarcină sau de formatul de intrare.

5. Modelul Observer

Modelul Observer stabilește o relație de la unu la mulți între obiecte. Atunci când un obiect (subiectul) își schimbă starea, toți dependenții săi (observatorii) sunt notificați automat. Acesta este deoseit de util în sistemele AI pentru monitorizarea în timp real, gestionarea evenimentelor sau sincronizarea datelor.

Când să se utilizeze

• Monitorizarea metricilor precum acuratețea sau pierderea în timpul antrenării modelului.
• Actualizări în timp real pentru tablouri de bord sau jurnale.
• Managementul dependențelor între componente în fluxuri de lucru complexe.

Implementare

Să utilizăm modelul Observer pentru a monitoriza performanța unui model AI în timp real:

class Subiect:
"""
Clasă de bază pentru subiecții care sunt observați.
"""
def __init__(self):
self._observatori = []

def atașează(self, observator):
"""
Atașează un observator la subiect.
"""
self._observatori.append(observator)

def detașează(self, observator):
"""
Detașează un observator de la subiect.
"""
self._observatori.remove(observator)

def notifică(self, date):
"""
Notifică toți observatorii despre o schimbare de stare.
"""
for observator in self._observatori:
observator.actualizează(date)

class MonitorModel(Subiect):
"""
Subiect care monitorizează metricile de performanță ale modelului.
"""
def actualizează_metrici(self, nume_metrică, valoare):
"""
Simulează actualizarea unei metrici de performanță și notifică observatorii.
"""
print(f"Actualizat {nume_metrică}: {valoare}")
self.notifică({nume_metrică: valoare})

class Observator:
"""
Clasă de bază pentru observatori.
"""
def actualizează(self, date):
raise NotImplementedError("Subclasele trebuie să implementeze metoda `actualizează`")

class ObservatorJurnal(Observator):
"""
Observator care înregistrează metrici.
"""
def actualizează(self, date):
print(f"Înregistrare metrică: {date}")

class ObservatorAlertă(Observator):
"""
Observator care ridică alerte atunci când sunt depășite praguri.
"""
def __init__(self, prag):
self.prag = prag

def actualizează(self, date):
for metrică, valoare in date.items():
if valoare > self.prag:
print(f"ALERTĂ: {metrică} a depășit pragul cu valoarea {valoare}")

# Exemplu de utilizare
monitor = MonitorModel()
jurnal = ObservatorJurnal()
alertă = ObservatorAlertă(prag=90)

monitor.atașează(jurnal)
monitor.atașează(alertă)

# Simulează actualizări de metrici
monitor.actualizează_metrici("acuratețe", 85) # Înregistrează metrica
monitor.actualizează_metrici("acuratețe", 95) # Înregistrează și declanșează alertă

1. Subiect: Gestionează o listă de observatori și îi notifică atunci când starea sa se schimbă. În acest exemplu, clasa MonitorModel urmărește metrici.
2. Observatori: Efectuează acțiuni specifice atunci când sunt notificați. De exemplu, ObservatorJurnal înregistrează metrici, în timp ce ObservatorAlertă ridică alerte atunci când un prag este depășit.
3. Proiectare decuplată: Observatorii și subiecții sunt slab cuplați, făcând sistemul modular și extensibil.

Cum diferă modelele de proiectare pentru inginerii AI față de inginerii tradiționali

Modelele de proiectare, deși universal aplicabile, capătă caracteristici unice atunci când sunt implementate în ingineria AI, comparativ cu ingineria software tradițională. Diferența constă în provocările, obiectivele și fluxurile de lucru inerente sistemelor AI, care adesea necesită adaptarea sau extinderea modelelor dincolo de utilizările lor convenționale.

1. Crearea de obiecte: Nevoi statice vs. dinamice

• Inginerie tradițională: Modelele de creare a obiectelor, cum ar fi Factory sau Singleton, sunt adesea utilizate pentru a gestiona configurări, conexiuni la baze de date sau stări de sesiune ale utilizatorului. Acestea sunt, de obicei, statice și bine definite în timpul proiectării sistemului.
• Inginerie AI: Crearea de obiecte implică adesea fluxuri de lucru dinamice, cum ar fi:
  • Crearea de modele dinamic, pe baza intrării utilizatorului sau a cerințelor sistemului.
  • Încărcarea diferitelor configurări ale modelului pentru sarcini precum traducere, rezumare sau clasificare.
  • Instantierea mai multor pipeline-uri de prelucrare a datelor, care variază în funcție de caracteristicile setului de date (de exemplu, date tabulare vs. text nestructurat).

Exemplu: În AI, un model Factory ar putea genera dinamic un model de învățare profundă pe baza tipului de sarcină și a constrângerilor hardware, în timp ce în sistemele tradiționale, ar genera pur și simplu un component al interfeței cu utilizatorul.

2. Constrângeri de performanță

• Inginerie tradițională: Modelele de proiectare sunt, de obicei, optimizate pentru latență și debit în aplicații precum servere web, interogări de baze de date sau renderizarea interfeței cu utilizatorul.
• Inginerie AI: Cerințele de performanță în AI se extind la latența inferenței modelului, utilizarea GPU/TPU și optimizarea memoriei. Modelele trebuie să se adapteze la:
  • Memorarea rezultatelor intermediare pentru a reduce calculele redundante (modele Decorator sau Proxy).
  • Comutarea algoritmilor dinamic (model Strategy) pentru a echilibra latența și acuratețea în funcție de încărcarea sistemului sau de constrângerile în timp real.

3. Natură axată pe date

• Inginerie tradițională: Modelele de proiectare operează adesea pe structuri de intrare-ieșire fixe (de exemplu, formulare, răspunsuri API).
• Inginerie AI: Modelele trebuie să gestioneze variabilitatea datelor atât în structură, cât și în scară, inclusiv:
  • Fluxuri de date pentru sisteme în timp real.
  • Date multimodale (de exemplu, text, imagini, videoclipuri) care necesită pipeline-uri de prelucrare cu pași flexibili.
  • Seturi de date de mare scară care necesită pipeline-uri eficiente de prelucrare și augmentare a datelor, adesea utilizând modele precum Builder sau Pipeline.

4. Experimentare vs. Stabilitate

• Inginerie tradițională: Accentul este pe construirea de sisteme stabile și previzibile, unde modelele asigură performanță și fiabilitate constantă.
• Inginerie AI: Fluxurile de lucru AI sunt adesea experimentale și implică:
  • Iterarea pe diferite arhitecturi de modele sau tehnici de prelucrare a datelor.
  • Actualizarea dinamică a componentelor sistemului (de exemplu, reantrenarea modelelor, schimbarea algoritmilor).
  • Extinderea fluxurilor de lucru existente fără a rupe pipeline-urile de producție, adesea utilizând modele extensibile precum Decorator sau Factory.

Exemplu: O fabrică în AI nu numai că instantiază un model, dar poate și atașa greutăți preîncărcate, configura optimizatori și conecta callback-uri de antrenare – toate în mod dinamic.