# הקדמה

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

אין דעם אַרטיקל, מיר וועלן ויספאָרשן די פּלאַן פּרינסאַפּאַלז און בעסטער פּראַקטיסיז פֿאַר קריייטינג מאַדזשאַלער, סקאַלאַבלע און עטישע ווייכווארג סיסטעמען וואָס ויסשטימען אַי אגענטן און מאַדזשאַלער וואָרקפלאָוו אַרקאַטעקטשער. מיר וועלן פאָקוס אויף קאַמביינינג די לעצטע אַדוואַנטידזשיז אין אַי (גרויס שפּראַך מאָדעלס (LLMs), ריטריוואַל-אַוגמענטעד גענעראַטיאָן (RAG)), ווייכווארג ינזשעניעריע (Python, Rust, Go) און אַרקאַטעקטשער צו שאַפֿן געזונט און מאַינטאַבאַל סיסטעמען.

מאָדולאַר וואָרקפלאָוו אַרטשיטעקטורע

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

דאָ איז אַ פּשוט בייַשפּיל פון אַ מאַדזשאַלער וואָרקפלאָוו אַרקאַטעקטשער אין פּיטהאָן:

# workflow.py
קלאַס וואָרקפלאָוו:
    דעף __יניט__ (זיך):
        self.modules = []

    def add_module (זיך, מאָדולע):
        self.modules.append(מאָדולע)

    דעפ לויפן (זיך):
        פֿאַר מאָדולע אין זיך.מאָדולעס:
            module.run()

# module1.py
קלאַס מאָדולע 1:
    דעפ לויפן (זיך):
        print ("מאָדול 1 איז פליסנדיק")

# module2.py
קלאַס מאָדולע 2:
    דעפ לויפן (זיך):
        print ("מאָדול 2 איז פליסנדיק")

# main.py
אויב __ נאָמען__ == "__ הויפּט __":
    וואָרקפלאָוו = וואָרקפלאָוו ()
    workflow.add_module(מאָדול 1())
    workflow.add_module(מאָדולע2())
    workflow.run()

אין דעם בייַשפּיל, מיר האָבן אַ 'וואָרקפלאָוו' קלאַס וואָס מאַנידזשיז אַ רשימה פון מאַדזשולז. יעדער מאָדולע איז פאַראַנטוואָרטלעך פֿאַר אַ ספּעציפיש אַרבעט, און זיי זענען מוסיף צו די וואָרקפלאָוו מיט די 'add_module' אופֿן. דער 'לויפן' אופֿן איז געניצט צו ויספירן יעדער מאָדולע אין די וואָרקפלאָוו.

אַי אַגענץ

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

עס זענען עטלעכע טייפּס פון אַי אגענטן, אַרייַנגערעכנט:

• ** הערשן-באזירט אגענטן **: די אגענטן נוצן פּרעדעפינעד כּללים צו מאַכן דיסיזשאַנז.
• ** מאשינען לערנען אגענטן **: די אגענטן נוצן מאַשין לערנען אַלגערידאַמז צו לערנען פון דאַטן און מאַכן דיסיזשאַנז.
• ** היבריד אגענטן **: די אגענטן פאַרבינדן הערשן-באזירט און מאַשין לערנען אַפּראָוטשיז צו מאַכן דיסיזשאַנז.

דאָ איז אַ ביישפּיל פון אַ פּשוט אַי אַגענט אין פּיטהאָן ניצן אַ מאַשין לערנען אַלגערידאַם:

# אַגענט.פּי
פֿון sclearn.ensemble אַרייַנפיר RandomForestClassifier
פֿון sclearn.model_selection אַרייַנפיר train_test_split
פֿון סקלעאַרנ.דאַטאַסעטס אַרייַנפיר לאָאַד_יריס

קלאַס אַגענט:
    דעף __יניט__ (זיך):
        self.model = RandomForestClassifier()

    דעפ באַן (זיך, X, י):
        X_train, X_test, y_train, y_test = train_test_split(X, y, test_size=0.2, random_state=42)
        self.model.fit(X_train, y_train)

    דעפ פאָרויסזאָגן (זיך, X):
        צוריקקומען self.model.predict(X)

# main.py
אויב __ נאָמען__ == "__ הויפּט __":
    יריס = load_iris()
    רענטגענ = יריס.דאַטאַ
    י = יריס. ציל
    אַגענט = אַגענט ()
    agent.train(X, y)
    פֿאָרויסזאָגן = אַגענט.פּרעדיקט (רענטגענ)
    דרוק (פאָרויסזאָגן)

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

קאַמביינינג אַי אַגענץ און מאָדולאַר וואָרקפלאָוו אַרקאַטעקטשער

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

דאָ איז אַ ביישפּיל פון אַ סיסטעם וואָס קאַמביינז אַי אגענטן און מאַדזשאַלער וואָרקפלאָוו אַרקאַטעקטשער:

# workflow.py
קלאַס וואָרקפלאָוו:
    דעף __יניט__ (זיך):
        self.modules = []
        self.agent = קיינער

    def add_module (זיך, מאָדולע):
        self.modules.append(מאָדולע)

    דעף אַדד_אַגענט (זיך, אַגענט):
        זיך.אַגענט = אַגענט

    דעפ לויפן (זיך):
        פֿאַר מאָדולע אין זיך.מאָדולעס:
            module.run()
        אויב זיך.אַגענט:
            self.agent.predict()

# module1.py
קלאַס מאָדולע 1:
    דעפ לויפן (זיך):
        print ("מאָדול 1 איז פליסנדיק")

# module2.py
קלאַס מאָדולע 2:
    דעפ לויפן (זיך):
        print ("מאָדול 2 איז פליסנדיק")

# אַגענט.פּי
פֿון sclearn.ensemble אַרייַנפיר RandomForestClassifier
פֿון sclearn.model_selection אַרייַנפיר train_test_split
פֿון סקלעאַרנ.דאַטאַסעטס אַרייַנפיר לאָאַד_יריס

קלאַס אַגענט:
    דעף __יניט__ (זיך):
        self.model = RandomForestClassifier()

דעפ באַן (זיך, X, י):
        X_train, X_test, y_train, y_test = train_test_split(X, y, test_size=0.2, random_state=42)
        self.model.fit(X_train, y_train)

    דעפ פאָרויסזאָגן (זיך, X):
        צוריקקומען self.model.predict(X)

# main.py
אויב __ נאָמען__ == "__ הויפּט __":
    וואָרקפלאָוו = וואָרקפלאָוו ()
    workflow.add_module(מאָדול 1())
    workflow.add_module(מאָדולע2())
    אַגענט = אַגענט ()
    agent.train(X, y)
    וואָרקפלאָוו.אַדד_אַגענט (אַגענט)
    workflow.run()

אין דעם בייַשפּיל, מיר האָבן אַ סיסטעם וואָס קאַמביינז אַי אגענטן און מאַדזשאַלער וואָרקפלאָוו אַרקאַטעקטשער. די סיסטעם האט צוויי מאַדזשולז און אַן אַי אַגענט וואָס ניצט אַ טראַפ וואַלד קלאַסאַפייער צו מאַכן פֿאָרויסזאָגן. דער אַגענט איז מוסיף צו די וואָרקפלאָוו מיט די 'add_agent' אופֿן, און עס מאכט פֿאָרויסזאָגן נאָך די מאַדזשולז האָבן לויפן.

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

דאָ זענען עטלעכע פון ​​די מערסט קאַמאַנדז און סניפּאַץ פֿאַר דיזיינינג סקאַלאַבלע און עטישע אַי-געטריבן ווייכווארג סיסטעמען מיט מאַדזשאַלער וואָרקפלאָוו אַרקאַטעקטשער און אַי אגענטן:

1. Python: 'ימפּאָרט פּאַנדאַס ווי פּד' (ימפּאָרטינג די פּאַנדאַס ביבליאָטעק)
2. Python: pd.read_csv('data.csv') (לייענען אַ קסוו טעקע אין אַ פּאַנדאַס דאַטאַפראַמע)
3. Python: agent.train(X, y) (טריינינג אַן אַי אַגענט אויף אַ דאַטאַסעט)
4. Python: agent.predict(X) (מאכן פֿאָרויסזאָגן ניצן אַן אַי אַגענט)
5. ** ראַסט **: לאָזן מוט אַגענט = אַגענט:: נייַ () (שאפן אַ נייַ אַי אַגענט אין רוסט)
6. ** ראַסט**: agent.train(X, y) (טריינינג אַן אַי אַגענט אויף אַ דאַטאַסעט אין רוסט)
7. Go: agent := NewAgent() (שאַפֿן אַ נייַע אַי אַגענט אין Go)
8. Go: agent.Train(X, y) (טריינינג אַן אַי אַגענט אויף אַ דאַטאַסעט אין גיין)
9. Chart.js: const טשאַרט = נייַ טשאַרט (קטקס, {טיפּ: 'באַר', דאַטן: { לאַבעלס: ['לאַבעל 1', 'לאַבעל 2'], דאַטאַסעץ: [{ פירמע: 'דאַטאַסעט 1', דאַטן: [10, 20] }] } ); (שאפן אַ באַר טשאַרט ניצן Chart.js
10. Chart.js: chart.data.datasets[0].data.push(30) (אַדינג אַ נייַ דאַטן פונט צו אַ טשאַרט ניצן Chart.js)

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

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

{
  "type": "באַר",
  "דאַטן": {
    "labels": ["לייבל 1", "לאַבעל 2"],
    "דאַטאַסעטס": [
      {
        "label": "דאַטאַסעט 1",
        "דאַטן": [10, 20]
      }
    ]
  }
}

דער טשאַרט האט צוויי לאַבעלס און איין דאַטאַסעט מיט צוויי דאַטן פונקטן. די טשאַרט קענען זיין קאַסטאַמייזד מיט פאַרשידן אָפּציעס און סעטטינגס.

# מסקנא

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

אין דעם אַרטיקל, מיר האָבן יקספּלאָרד די פּלאַן פּרינסאַפּאַלז און בעסטער פּראַקטיסיז פֿאַר קריייטינג מאַדזשאַלער, סקאַלאַבלע און עטישע ווייכווארג סיסטעמען וואָס ויסשטימען אַי אגענטן און מאַדזשאַלער וואָרקפלאָוו אַרקאַטעקטשער. מיר האָבן אויך צוגעשטעלט ביישפילן פון פּשוט אַי אגענטן און מאַדזשאַלער וואָרקפלאָוו אַרקאַטעקטשער אין Python, Rust און Go, ווי געזונט ווי אַ וויזשוואַלאַזיישאַן ביישפּיל ניצן Chart.js.

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