Sarrera
Adimen Artifizialaren (AI) eta software ingeniaritzaren aurrerapen bizkorrek AI agenteak eta lan-fluxu modularra integratzen dituzten software-sistema konplexuak garatzea ekarri dute. Sistema hauek DevOps automatizazioari eta orkestrazioari heltzeko modua iraultzeko ahalmena dute. Hala ere, AI-a bultzatutako software sistema eskalagarriak eta etikoak diseinatzeak AI, software ingeniaritza eta arkitekturaren azken aurrerapenak sakon ulertzea eskatzen du.
Artikulu honetan, AI agenteak eta lan-fluxuen arkitektura modularra integratzen dituzten software-sistema modular, eskalagarriak eta etikoak sortzeko diseinu-printzipioak eta praktika onenak aztertuko ditugu. AI (Large Language Models (LLMs), Retrieval-Augmented Generation (RAG)), softwarearen ingeniaritza (Python, Rust, Go) eta arkitektura sistema sendoak eta mantendugarriak sortzeko azken aurrerapenak konbinatzera bideratuko gara.
Lan-fluxuaren arkitektura modularra
Lan-fluxuaren arkitektura modularra sistema konplexuak modulu txikiago eta independenteetan banatzen dituen diseinu-eredua da, erraz mantendu, eguneratu eta eskalatu daitezkeen. Modulu bakoitza zeregin edo funtzio zehatz baten arduraduna da, eta ondo definitutako interfazeen bidez komunikatzen dira elkarren artean.
Hona hemen Python-en lan-fluxu modular baten adibide sinple bat:
# workflow.py
klaseko lan-fluxua:
def __init__(norbera):
auto.moduluak = []
def add_module(norbera, modulua):
self.modules.append(modulua)
def run(self):
modulurako self.modules:
module.run()
# module1.py
klaseko 1 modulua:
def run(self):
print("1. modulua martxan dago")
# modulua2.py
klaseko 2 modulua:
def run(self):
print("2. modulua martxan dago")
# main.py
bada __izena__ == "__nagusia__":
lan-fluxua = Lan-fluxua()
workflow.add_module(Module1())
workflow.add_module(Module2())
workflow.run()
Adibide honetan, Workflow klase bat dugu, moduluen zerrenda kudeatzen duena. Modulu bakoitza zeregin zehatz baten arduraduna da, eta lan-fluxuan gehitzen dira add_module metodoa erabiliz. exekutatu metodoa lan-fluxuko modulu bakoitza exekutatzeko erabiltzen da.
AI agenteak
AI agenteak ikaskuntza automatikoko algoritmoak erabiltzen dituzten software osagaiak dira, sistema batean erabakiak hartzeko eta ekintzak egiteko. Zereginak automatizatzeko, erabiltzailearen esperientzia hobetzeko eta sistemaren errendimendua optimizatzeko erabil daitezke.
Hainbat AI agente mota daude, besteak beste:
- Arauetan oinarritutako agenteak: Erabakiak hartzeko aurrez zehaztutako arauak erabiltzen dituzte eragile hauek.
- Machine learning-eko agenteak: agente hauek ikaskuntza automatikoko algoritmoak erabiltzen dituzte datuetatik ikasteko eta erabakiak hartzeko.
- Agente hibridoak: agente hauek arauetan oinarritutako eta ikaskuntza automatikoaren ikuspegiak konbinatzen dituzte erabakiak hartzeko.
Hona hemen Python-en AI agente sinple baten adibide bat ikaskuntza automatikoko algoritmo bat erabiliz:
# agente.py
sklearn.ensemble import RandomForestClassifier-tik
sklearn.model_selection-tik inportatu train_test_split
sklearn.datasets-etik inportatu load_iris
klaseko agentea:
def __init__(norbera):
self.model = RandomForestClassifier ()
def train(norbera, X, y):
X_trena, X_test, y_trena, y_test = train_test_split (X, y, test_size=0.2, ausazko_egoera=42)
self.model.fit (X_trena, y_trena)
def predict(norberak, X):
itzuli self.model.predict(X)
# main.py
bada __izena__ == "__nagusia__":
iris = load_iris()
X = iris.datuak
y = iris.helburua
agente = Agente ()
agente.trena (X, y)
iragarpenak = agente.aurreikusi (X)
inprimatu (iragarpenak)
Adibide honetan, AI agente soil bat dugu, ausazko baso-sailkatzailea erabiltzen duena iragarpenak egiteko. Agentea irisaren datu-multzoan trebatzen da eta datu-multzo berean iragarpenak egiten ditu.
AI agenteak eta lan-fluxuen arkitektura modularra konbinatuz
AI eragileak eta lan-fluxuaren arkitektura modularra konbinatuz, AI bultzatutako erabakiak arkitektura modular eta eskalagarriarekin integratzen dituzten sistema konplexuak sortzeko aukera ematen digu.
Hona hemen AI agenteak eta lan-fluxuen arkitektura modularra konbinatzen dituen sistema baten adibidea:
# workflow.py
klaseko lan-fluxua:
def __init__(norbera):
auto.moduluak = []
self.agent = Bat ere ez
def add_module(norberak, modulua):
self.modules.append(modulua)
def add_agent(self, agent):
norbera.agente = agente
def run(self):
modulurako self.modules:
module.run()
auto.agentea bada:
auto.agente.aurreikusi()
# module1.py
klaseko 1 modulua:
def run(self):
print("1. modulua martxan dago")
# modulua2.py
klaseko 2 modulua:
def run(self):
print("2. modulua martxan dago")
# agente.py
sklearn.ensemble import RandomForestClassifier-tik
sklearn.model_selection-tik inportatu train_test_split
sklearn.datasets-etik inportatu load_iris
klaseko agentea:
def __init__(norbera):
self.model = RandomForestClassifier ()
def train(norbera, X, y):
X_trena, X_test, y_trena, y_test = train_test_split (X, y, test_size=0.2, ausazko_egoera=42)
self.model.fit (X_trena, y_trena)
def predict(norberak, X):
itzuli self.model.predict(X)
# main.py
bada __izena__ == "__nagusia__":
lan-fluxua = Lan-fluxua()
workflow.add_module(Module1())
workflow.add_module(Module2())
agente = Agente ()
agente.trena (X, y)
workflow.add_agent(agentea)
workflow.run()
Adibide honetan, AI eragileak eta lan-fluxuen arkitektura modularra konbinatzen dituen sistema dugu. Sistemak bi modulu eta AI agente bat ditu, ausazko baso sailkatzaile bat erabiltzen duena iragarpenak egiteko. Agentea lan-fluxuan gehitzen da add_agent metodoa erabiliz, eta iragarpenak egiten ditu moduluak exekutatu ondoren.
Gehien erabiltzen diren 5-10 komandoak/zatiak
Hona hemen gehien erabiltzen diren komando eta zati batzuk AI-n oinarritutako software-sistema eskalagarriak eta etikoak diseinatzeko, lan-fluxuen arkitektura modularra eta AI agenteekin:
- Python:
inportatu pandak pd gisa(panda liburutegia inportatzen) - Python:
pd.read_csv('data.csv')(CSV fitxategi bat pandas datu-marko batean irakurtzen) - Python:
agent.train(X, y)(AI agente bat datu multzo batean entrenatzen) - Python:
agent.predict(X)(iragarpenak egiten AI agente bat erabiliz) - Rust:
let mut agent = Agent::new()(AI agente berri bat sortu Rust-en) - Rust:
agent.train(X, y)(AI agente bat Rust-eko datu-multzo batean entrenatzen) - Go:
agent := NewAgent()(Go-n AI agente berri bat sortuz) - Go:
agent.Train(X, y)(AI-ko agente bat Go-n datu-multzo batean entrenatzen) - Chart.js:
const chart = new Chart(ctx, { type: 'bar', data: { labels: ['Label 1', 'Label 2'], datasets: [{ label: 'Dataset 1', data: [10, 20] }] } });(kart. barra bat sortuz) - Chart.js:
chart.data.datasets[0].data.push(30)(diagrama bati datu-puntu berri bat gehitzea Chart.js erabiliz)
Bistaratzea
Hona hemen Chart.js erabiliz barra-diagrama baten adibide bat:
{
"mota": "barra",
"datuak": {
"labels": ["Label 1", "Label 2"],
"datu multzoak": [
{
"label": "1. datu multzoa",
"datuak": [10, 20]
}
]
}
}
Diagrama honek bi etiketa eta datu multzo bat ditu bi datu-punturekin. Diagrama pertsonalizatu daiteke hainbat aukera eta ezarpen erabiliz.
Ondorioa
Lan-fluxuen arkitektura modulararekin eta AI agenteekin AI-n oinarritutako software sistema eskalagarriak eta etikoak diseinatzeak AI, software ingeniaritza eta arkitekturaren azken aurrerapenak sakon ulertzea eskatzen du. AI eragileak eta lan-fluxuaren arkitektura modularra konbinatuz, sistema konplexuak sor ditzakegu AI-k bultzatutako erabakiak hartzea arkitektura modular eta eskalagarriarekin integratzen dutenak.
Artikulu honetan, AI agenteak eta lan-fluxuen arkitektura modularra integratzen dituzten software-sistema modular, eskalagarriak eta etikoak sortzeko diseinu-printzipioak eta praktika onenak aztertu ditugu. Python, Rust eta Go-n AI agente sinpleen eta lan-fluxu modulararen arkitekturaren adibideak ere eman ditugu, baita Chart.js erabiliz bistaratzeko adibide bat ere.
Artikulu honetan azaltzen diren jarraibideei eta praktika onak jarraituz, garatzaileek AI-n oinarritutako software sistema sendoak eta mantendugarriak sor ditzakete, aplikazio eta industria modernoen beharrak asetzen dituztenak.