# הקדמה

די ינאַגריישאַן פון אַרטיפיסיאַל ינטעלליגענסע (AI) אין ווייכווארג אַפּלאַקיישאַנז האט רעוואַלושאַנייזד די וועג מיר צוגאַנג פּראָבלעם סאַלווינג, באַשלוס-מאכן און אָטאַמיישאַן. אָבער, ווי אַי-געטריבן אַפּלאַקיישאַנז ווערן ינקריסינגלי קאָמפּליצירט, די נויט פֿאַר זיכער און סקאַלאַבלע אַרקאַטעקטשער איז געווארן אַ דרינגלעך דייַגע. אין דעם אַרטיקל, מיר וועלן ויספאָרשן די ינטערסעקשאַן פון אַי, ווייכווארג ינזשעניעריע און DevOps, מיט אַ ספּעציפיש טראָפּ אויף ניצן אָרקעסטראַטיאָן מכשירים ווי DSPy און LangChain צו ויסשטימען אַי אגענטן אין DevOps פּייפּליינז.

די טשאַלאַנדזשיז פון אַי-געטריבן ווייכווארג אַרקאַטעקטשער

אַי-געטריבן ווייכווארג אַפּלאַקיישאַנז האָבן יינציק טשאַלאַנדזשיז פֿאַר ווייכווארג ענדזשאַנירז און DevOps טימז. עטלעכע פון די הויפּט טשאַלאַנדזשיז אַרייַננעמען:

• ** סקאַלאַביליטי **: אַי מאָדעלס דאַרפן באַטייטיק קאַמפּיוטיישאַנאַל רעסורסן, וואָס קענען פירן צו סקאַלאַביליטי ישוז אין פּראָדוקציע ינווייראַנמאַנץ.
• ** זיכערהייט **: AI מאָדעלס קענען זיין שפּירעוודיק צו אַטאַקס, אַזאַ ווי דאַטן פאַרסאַמונג און מאָדעל ינווערזשאַן אַטאַקס.
• ** ינטעגראַטיאָן **: אַי מאָדעלס דאַרפֿן צו זיין ינאַגרייטיד מיט יגזיסטינג ווייכווארג סיסטעמען, וואָס קענען זיין אַ קאָמפּלעקס אַרבעט.
• ** מאָניטאָרינג און וישאַלט **: אַי מאָדעלס דאַרפן קעסיידערדיק מאָניטאָרינג און וישאַלט צו ענשור אַז זיי בלייבן פּינטלעך און פאַרלאָזלעך.

אָרקעסטראַטיאָן מכשירים: DSPy און LangChain

אָרטשעסטראַטיאָן מכשירים ווי DSPy און LangChain צושטעלן אַ לייזונג צו די טשאַלאַנדזשיז דורך געבן די ינטאַגריישאַן פון אַי אגענטן אין DevOps פּייפּליינז. די מכשירים צושטעלן אַ פריימווערק פֿאַר בנין, דיפּלויינג און אָנפירונג אַי מאָדעלס, ינשורינג זיכער און סקאַלאַבלע אַרקאַטעקטשער פֿאַר אַי-געטריבן אַפּלאַקיישאַנז.

דספּי

DSPy איז אַן אָפֿן-מקור אָרקעסטראַטיאָן געצייַג געבויט אויף שפּיץ פון פּיטהאָן. עס גיט אַ פּשוט און ינטואַטיוו אַפּי פֿאַר בנין, דיפּלויינג און אָנפירונג אַי מאָדעלס. DSPy שטיצט אַ ברייט קייט פון אַי פראַמעוואָרקס, אַרייַנגערעכנט TensorFlow, PyTorch און scikit-learn.

לאנגטשיין

LangChain איז אן אנדער אָפֿן-מקור אָרקעסטראַטיאָן געצייַג וואָס גיט אַ פריימווערק פֿאַר בנין, דיפּלויינג און אָנפירונג אַי מאָדעלס. LangChain איז געבויט אויף שפּיץ פון Rust און גיט אַ הויך-פאָרשטעלונג אַפּי פֿאַר ינטאַגרייטינג אַי אגענטן אין DevOps פּייפּליינז.

ימפּלעמענטינג זיכער און סקאַלאַבלע אַי-געטריבן ווייכווארג אַרקאַטעקטשער מיט DSPy

אין דעם אָפּטיילונג, מיר וועלן ויספאָרשן אַ פּשוט בייַשפּיל פון ימפּלאַמענינג זיכער און סקאַלאַבלע אַי-געטריבן ווייכווארג אַרקאַטעקטשער מיט DSPy.

ביישפּיל: בויען אַ פּשוט אַי מאָדעל מיט DSPy

לאָמיר באַטראַכטן אַ פּשוט בייַשפּיל פון בויען אַ מאַשין לערנען מאָדעל ניצן DSPy. מיר וועלן נוצן די scikit-לערן ביבליאָטעק צו בויען אַ לינעאַר ראַגרעשאַן מאָדעל.

אַרייַנפיר דספּי ווי דספּ
פֿון sklearn.linear_model אַרייַנפיר לינעאַר רעגרעססיאָן
פֿון סקלעאַרנ.דאַטאַסעטס אַרייַנפיר לאָוד_דיאַבעטעס

# לאָדן די דייאַבעטיקס דאַטאַבייס
דאַטאַסעט = load_diabetes()

# שפּאַלטן די דאַטאַסעט אין טריינינג און טעסטינג שטעלט
X_train, X_test, y_train, y_test = dsp.split_dataset(dataset.data, dataset.target, test_size=0.2)

# בויען אַ לינעאַר ראַגרעשאַן מאָדעל
מאָדעל = לינעאַר רעגרעססיאָן ()

# באַן די מאָדעל אויף די טריינינג דאַטן
model.fit (X_train, y_train)

# אָפּשאַצן די מאָדעל אויף די טעסטינג דאַטן
אַקיעראַסי = model.score(X_test, y_test)
print(f"מאָדעל אַקיעראַסי: {אַקיעראַסי:.2פ}")

דער קאָד בלאָק דעמאַנסטרייץ ווי צו בויען אַ פּשוט מאַשין לערנען מאָדעל ניצן DSPy. מיר לאָדן די צוקערקרענק דאַטאַבייס, שפּאַלטן עס אין טריינינג און טעסטינג שטעלט, בויען אַ לינעאַר ראַגרעשאַן מאָדעל, באַן עס אויף די טריינינג דאַטן און אָפּשאַצן די אַקיעראַסי פון די טעסטינג דאַטן.

ימפּלעמענטינג זיכער און סקאַלאַבלע אַי-געטריבן ווייכווארג אַרטשיטעקטורע מיט LangChain

אין דעם אָפּטיילונג, מיר וועלן ויספאָרשן אַ פּשוט בייַשפּיל פון ימפּלאַמענינג זיכער און סקאַלאַבלע אַי-געטריבן ווייכווארג אַרקאַטעקטשער מיט LangChain.

ביישפּיל: בויען אַ פּשוט אַי מאָדעל מיט לאַנגטשאַין

לאָמיר באַטראַכטן אַ פּשוט בייַשפּיל פון בויען אַ מאַשין לערנען מאָדעל ניצן LangChain. מיר וועלן נוצן די TensorFlow ביבליאָטעק צו בויען אַ נעוראַל נעץ מאָדעל.

נוצן לאַנגטשאַין ווי lc;
נוצן tensorflow::prelude::*;

// דעפינירן אַ פּשוט נעוראַל נעץ מאָדעל
fn מאָדעל (אַרייַנפיר: &טענסער) -> Tensor {
    לאָזן רעזולטאַט = אַרייַנשרייַב.מאַטמול (&טענסאָר :: נייַ (1, 1));
    רעזולטאַט
}

// שאַפֿן אַ LangChain אַגענט
לאָזן אַגענט = lc :: אַגענט :: נייַ (מאָדעל);

// דעפינירן אַ דאַטאַסעט
לאָזן דאַטאַסעט = lc::Dataset::new(vec![
    lc:: ביישפּיל::new(vec![1.0, 2.0], vec![3.0]),
    lc:: ביישפּיל::new(vec![4.0, 5.0], vec![6.0]),
]);

// באַן די מאָדעל אויף די דאַטאַסעט
אַגענט.טראַין(&דאַטאַסעט);

// אָפּשאַצן די מאָדעל אויף די דאַטאַסעט
לאָזן אַקיעראַסי = אַגענט.עוואַלואַטע (& דאַטאַסעט);
println!("מאָדעל אַקיעראַסי: {}", אַקיעראַסי);

דער קאָד בלאָק דעמאַנסטרייץ ווי צו בויען אַ פּשוט מאַשין לערנען מאָדעל ניצן LangChain. מיר דעפינירן אַ פּשוט נעוראַל נעץ מאָדעל, שאַפֿן אַ LangChain אַגענט, דעפינירן אַ דאַטאַסעט, באַן די מאָדעל אויף די דאַטאַסעט און אָפּשאַצן זייַן אַקיעראַסי אויף די דאַטאַסעט.

שפּיץ 5-10 מערסט געוויינט קאַמאַנדז / סניפּאַץ

דאָ זענען די שפּיץ 5-10 מערסט געוויינט קאַמאַנדז / סניפּאַץ פֿאַר DSPy און LangChain:

דספּי

• dsp.split_dataset (דאַטאַ, ציל, טעסט_סייז = 0.2): ספּליץ די דאַטאַסעט אין טריינינג און טעסטינג שטעלט.
• dsp.build_model(model_name, model_params): בויען אַ מאַשין לערנען מאָדעל ניצן די ספּעסיפיעד מאָדעל נאָמען און פּאַראַמעטערס.
• dsp.train_model(מאָדעל, דאַטן): טריינז די מאַשין לערנען מאָדעל אויף די ספּעסיפיעד דאַטן.
• dsp.evaluate_model(מאָדעל, דאַטן): עוואַלואַטעס די פאָרשטעלונג פון די מאַשין לערנען מאָדעל אויף די ספּעסיפיעד דאַטן.
• dsp.deploy_model(model, server_url): דיפּלוידז די מאַשין לערנען מאָדעל צו די ספּעסאַפייד סערווער URL.

לאנגטשיין

• lc::Agent::new(model): קריייץ אַ LangChain אַגענט ניצן די ספּעסיפיעד מאָדעל.
• lc::Dataset::new(examples): קריייץ אַ לאַנגטשאַין דאַטאַסעט ניצן די ספּעסיפיעד ביישפילן.
• lc::train(אַגענט, דאַטאַסעט): טריינז די LangChain אַגענט אויף די ספּעסיפיעד דאַטאַסעט.
• lc::evaluate(אַגענט, דאַטאַסעט): עוואַלואַטעס די פאָרשטעלונג פון די LangChain אַגענט אויף די ספּעסיפיעד דאַטאַסעט.
• lc::deploy(agent, server_url): דיפּלוידז די LangChain אַגענט צו די ספּעסאַפייד סערווער URL.

וויסואַליזאַטיאָן

דאָ איז אַ פּשוט וויזשוואַלאַזיישאַן פון די אַי-געטריבן ווייכווארג אַרקאַטעקטשער ניצן Chart.js:

const ctx = document.getElementById('myChart').getContext('2d');
קאָנסט טשאַרט = נייַ טשאַרט (קטקס, {
    טיפּ: 'באַר',
    דאַטן: {
        לאַבעלס: ['טריינינג צייט', 'ינפעראַנס צייט', 'מאָדעל אַקיעראַסי'],
        דאַטאַסעטס: [{
            פירמע: 'DSPy',
            דאַטן: [10, 5, 90],
            backgroundColor: 'rgba(255, 99, 132, 0.2)',
            borderColor: 'rgba(255, 99, 132, 1)',
            borderwidth: 1
        }, {
            פירמע: 'לאַנגטשאַין',
            דאַטן: [8, 6, 92],
            backgroundColor: 'rgba(54, 162, 235, 0.2)',
            borderColor: 'rgba(54, 162, 235, 1)',
            borderwidth: 1
        }]
    },
    אָפּציעס: {
        וואָג: {
            י: {
                beginAtZero: אמת
            }
        }
    }
});

דער קאָד בלאָק קריייץ אַ פּשוט באַר טשאַרט מיט Chart.js צו וויזשוואַלייז די פאָרשטעלונג פון DSPy און LangChain.

# מסקנא

אין דעם אַרטיקל, מיר ויספאָרשן די ינטערסעקשאַן פון אַי, ווייכווארג ינזשעניעריע און DevOps, מיט אַ ספּעציפיש טראָפּ אויף ניצן אָרקעסטראַטיאָן מכשירים ווי DSPy און LangChain צו ויסשטימען אַי אגענטן אין DevOps פּייפּליינז. מיר דעמאַנסטרייטיד ווי צו ינסטרומענט זיכער און סקאַלאַבלע אַי-געטריבן ווייכווארג אַרקאַטעקטשער ניצן DSPy און LangChain, און צוגעשטעלט אַ פּשוט ביישפּיל פון בויען אַ מאַשין לערנען מאָדעל ניצן יעדער געצייַג. מיר אויך צוגעשטעלט אַ שפּיץ 5-10 מערסט געוויינט קאַמאַנדז / סניפּאַץ פֿאַר יעדער געצייַג און אַ פּשוט וויזשוואַלאַזיישאַן פון די אַי-געטריבן ווייכווארג אַרקאַטעקטשער ניצן Chart.js.