Didelio masto LLM vamzdynų suderinimas su DSPy ir LangChain, kad būtų patobulinti „DevOps“

Didelio masto LLM vamzdynų surengimas naudojant DSPy ir LangChain, kad būtų patobulinti „DevOps“

Įvadas

Didžiųjų kalbų modelių (LLM) atsiradimas sukėlė revoliuciją natūralios kalbos apdorojimo (NLP) ir dirbtinio intelekto (AI) srityse. Tačiau didėjant LLM pagrįstų sistemų sudėtingumui ir mastui, didėja tvirtų ir efektyvių orkestravimo ir automatizavimo įrankių poreikis. Šiame straipsnyje mes pasinersime į DSPy ir LangChain pasaulį – dvi galingas sistemas, kurios leidžia kurti atsparias ir keičiamo dydžio programinės įrangos sistemas AI amžiuje.

** Didelio masto LLM vamzdynų iššūkis**

Didelio masto LLM vamzdynai apima kelis komponentus, įskaitant išankstinį duomenų apdorojimą, modelio mokymą ir išvadas. Šie vamzdynai gali būti sudėtingi, su daugybe skirtingų komponentų priklausomybių ir sąveikų. Didėjant šių vamzdynų mastui, didėja klaidų, vėlavimų ir išteklių kliūčių rizika.

Įveskite DSPy ir LangChain

DSPy ir LangChain yra dvi sistemos, kuriomis siekiama supaprastinti didelio masto LLM vamzdynų orkestravimą ir automatizavimą. DSPy yra Python pagrindu sukurta sistema, kuri suteikia paprastą ir efektyvų būdą kurti ir valdyti sudėtingus duomenų vamzdynus, o „LangChain“ yra sistema, leidžianti kurti keičiamo dydžio ir atsparias AI sistemas.

DSPy: Python pagrindu sukurta duomenų perdavimo linijų sistema

DSPy yra Python pagrindu sukurta sistema, kuri suteikia paprastą ir efektyvų būdą kurti ir valdyti sudėtingus duomenų vamzdynus. Naudodami DSPy, kūrėjai gali sukurti duomenų srautus, kurie yra keičiamo dydžio, atsparūs ir lengvai prižiūrimi.

Čia yra paprasto duomenų vamzdyno, sukurto naudojant DSPy, pavyzdys:

importuoti dspy kaip dsp


duomenų_šaltinis = dsp.Source(
    name="mano_duomenų_šaltinis",
    type="csv",
    path="/path/to/data.csv"
)

# Apibrėžkite duomenų tvarkytoją
duomenų_procesorius = dsp.Procesorius(
    name="mano_duomenų_procesorius",
    type="pandos",
    func=lambda x: x.dropna()
)

# Apibrėžkite duomenų kaupiklį
data_sink = dsp.Sink(
    name="my_data_sink",
    type="csv",
    path="/path/to/output.csv"
)

# Sukurkite duomenų vamzdyną
vamzdynas = dsp.Pipeline(
    name="mano_vamzdis",
    šaltiniai=[duomenų_šaltinis],
    procesoriai = [duomenų_procesorius],
    sinks=[duomenų_sink]
)

# Paleiskite dujotiekį
pipeline.run()

Šiame pavyzdyje apibrėžiame duomenų šaltinį, duomenų procesorių ir duomenų kaupiklį, o tada sukuriame duomenų vamzdyną, jungiantį šiuos komponentus. Tada dujotiekis paleidžiamas naudojant „run()“ metodą.

LangChain: keičiamo dydžio ir atsparių AI sistemų sistema

„LangChain“ yra sistema, leidžianti kurti keičiamo dydžio ir atsparias AI sistemas. Naudodami „LangChain“, kūrėjai gali sukurti dirbtinio intelekto sistemas, kurias lengva prižiūrėti, jas galima keisti ir kurios atsparios gedimams.

Štai paprastos AI sistemos, sukurtos naudojant „LangChain“, pavyzdys:

importuoti langchain kaip lc

# Apibrėžkite modelį
modelis = lc.Model(
    vardas = "mano_modelis",
    type="transformatorius",
    kelias="/kelias/į/modelis"
)

# Apibrėžkite raginimą
prompt = lc.Prompt(
    name="my_prompt",
    text="Tai yra raginimo pavyzdys"
)

# Sukurkite AI sistemą
ai_system = lc.AISystem(
    name="mano_ai_sistema",
    modelis = modelis,
    raginimas = raginimas
)

# Paleiskite AI sistemą
ai_system.run()

Šiame pavyzdyje apibrėžiame modelį, raginimą ir tada sukuriame AI sistemą, jungiančią šiuos komponentus. Tada AI sistema paleidžiama naudojant „run()“ metodą.

Didelio masto LLM vamzdynų orkestravimas naudojant DSPy ir LangChain

Norėdami organizuoti didelio masto LLM vamzdynus su DSPy ir LangChain, galime naudoti šį metodą:

Apibrėžkite duomenų konvejerį naudodami DSPy, jungiantį kelis duomenų šaltinius, procesorius ir kriaukles.
Apibrėžkite AI sistemą naudodami „LangChain“, jungiančią kelis modelius, raginimus ir išvestis.
Naudokite DSPy duomenų konvejeriui valdyti, o LangChain AI sistemai valdyti.
Norėdami suplanuoti duomenų srauto ir AI sistemos vykdymą, naudokite planavimo priemonę, pvz., „Apache Airflow“ arba „Kubernetes“.

Štai paprasto orkestravimo scenarijaus, kuris naudoja DSPy ir LangChain, pavyzdys:

importuoti dspy kaip dsp
importuoti langchain kaip lc
importuoti apache_airflow kaip af

# Apibrėžkite duomenų vamzdyną
data_pipeline = dsp.Pipeline(
    name="my_data_pipeline",
    šaltiniai=[dsp.Šaltinis(vardas="mano_duomenų_šaltinis", tipas="csv", kelias="/kelis/į/duomenys.csv")],
    procesoriai=[dsp.Procesorius(vardas="mano_duomenų_procesorius", tipas="pandas", func=lambda x: x.dropna())],
    sinks=[dsp.Sink(vardas="mano_duomenų_sink", tipas="csv", path="/path/to/output.csv")]
)

# Apibrėžkite AI sistemą
ai_system = lc.AISystem(
    name="mano_ai_sistema",
    model=lc.Model(vardas = "mano_modelis", tipas = "transformatorius", kelias = "/kelis/į/modelį"),
    prompt=lc.Prompt(vardas="my_prompt", text="Tai raginimo pavyzdys")
)

# Suplanuokite duomenų vamzdyno ir AI sistemos vykdymą
af.schedule_task(
    task_id="mano_užduotis",
    dag_id="mano_dag",
    vamzdynas=data_pipeline,
    system=ai_system
)

Šiame pavyzdyje apibrėžiame duomenų vamzdyną ir AI sistemą naudodami DSPy ir LangChain, o tada suplanuojame šių komponentų vykdymą naudodami Apache Airflow.

5–10 dažniausiai naudojamų komandų / fragmentų

Čia yra 5–10 dažniausiai naudojamų DSPy ir LangChain komandų / fragmentų:

`dsp.Pipeline(name = "mano_vamzdis", šaltiniai = [šaltinis], procesoriai = [procesorius], sinks = [sink])
„lc.Model“
`lc.Prompt(name="my_prompt", text="Tai yra raginimo pavyzdys")'
`dsp.Source(vardas = "mano_duomenų_šaltinis", tipas = "csv", kelias =="/path/to/data.csv")'
`dsp.Processor(name="mano_duomenų_procesorius", tipas="pandas", func=lambda x: x.dropna())
`dsp.Sink(name="mano_duomenų_sink", tipas="csv", path="/path/to/output.csv")'
`lc.AISystem(name = "mano_ai_sistema", modelis = modelis, prompt = prompt)
`af.schedule_task(task_id="mano_užduotis", dag_id="mano_dag", pipeline=pipeline, system=sistema)
„dsp.run_pipeline(pipeline)“.
„lc.run_system(system)“.

Vizualizacija

Štai DSPy ir LangChain sistemų vizualizacija naudojant Chart.js:

{
  "tipas": "juosta",
  "duomenys": {
    "labels": ["DSPy", "LangChain"],
    "duomenų rinkiniai": [
      {
        "label": "Savybės",
        "duomenys": [10, 15],
        "backgroundColor": [
          "rgba(255, 99, 132, 0,2)",
          "rgba(54, 162, 235, 0,2)"
        ],
        "borderColor": [
          "rgba(255, 99, 132, 1)",
          "rgba(54, 162, 235, 1)"
        ],
        "borderWidth": 1
      }
    ]
  },
  "parinktys": {}
}

Ši vizualizacija parodo DSPy ir LangChain funkcijų skaičių.

Išvada

Apibendrinant galima pasakyti, kad DSPy ir LangChain yra dvi galingos sistemos, leidžiančios dirbtinio intelekto amžiuje sukurti atsparias ir keičiamo dydžio programinės įrangos sistemas. Naudodami šias sistemas, kūrėjai gali sukurti didelio masto LLM vamzdynus, kuriuos lengva prižiūrėti, keisti ir atsparus gedimams. Naudodami orkestravimo ir automatizavimo įrankius, tokius kaip „Apache Airflow“ ir „Kubernetes“, kūrėjai gali suplanuoti šių vamzdynų ir sistemų vykdymą, kad būtų lengviau valdyti sudėtingas AI sistemas.

Ateities darbas

Būsimas darbas apima:

Daugiau DSPy ir LangChain funkcijų kūrimas.
DSPy ir LangChain našumo ir mastelio gerinimas.
Sukurti daugiau orkestravimo ir automatizavimo įrankių, skirtų DSPy ir LangChain.
Daugiau vizualizacijų ir prietaisų skydelių, skirtų DSPy ir LangChain, kūrimas.

Nuorodos

DSPy dokumentacija: https://dspy.readthedocs.io/en/latest/
LangChain dokumentacija: https://langchain.readthedocs.io/en/latest/
„Apache Airflow“ dokumentacija: https://airflow.apache.org/docs/apache-airflow/stable/index.html
Kubernetes dokumentacija: https://kubernetes.io/docs/home/

Didelio masto LLM vamzdynų suderinimas su DSPy ir LangChain, kad būtų patobulinti „DevOps“

Have Questions?