אוקי...זה הולך להיות מצחיק...

מישהו יכול לשלוח כמה לינקים לגבי אכיטקטורה של AI ?

איך מתחילים ואיך כדאי לתכנן?

תודה !

אינטלגנציה מלאכותית זה תחום מאוד רחב שמתחיל משיטות חיפוש בעץ מהלכים, ומתפתח לנושאים כמו סיווג (classification).

אלגוריתם פופולרי למציאת מהלך אופטימלי בתנאים פשוטים יחסית הוא A star.

רוב האלגוריתמים המתקדמים (שנוגעים לזיהוי דיבור/עצמים בתמונה/מוסיקה) הם בעצם שייכים למשפחה של אלגוריתמי סיווג, שרובם מורכבים למדי (רשתות נוירונים זה אחד היותר פשוטים).

תודה רבה בומרנג

יש לי שאלת המשך אליך, בומרנג

ה-AI שאנחנו מעוניינים בו (אני ושלוגי) צריך לקבל מספר מסויים של פרמטרים, ועל פיהם להחליט מה לעשות

תוכל לכוון אותנו באופן יותר ספציפי על אלגוריתם?

אם נבנה את זה בצורה לא חכמה האלגוריתם ייראה כך: "אם .... אז .... אחרת אם .... אז...."

אני מקווה שאתה מבין את הכוונה

אנחנו מנסים למצוא תשתית שתהיה מודולרית (שניתן להוסיף/לשנות תנאים בלי שינוי של הקוד)

תודה רבה על העזרה!

יש לי שאלת המשך אליך, בומרנג

ה-AI שאנחנו מעוניינים בו (אני ושלוגי) צריך לקבל מספר מסויים של פרמטרים, ועל פיהם להחליט מה לעשות

תוכל לכוון אותנו באופן יותר ספציפי על אלגוריתם?

אם נבנה את זה בצורה לא חכמה האלגוריתם ייראה כך: "אם .... אז .... אחרת אם .... אז...."

אני מקווה שאתה מבין את הכוונה

אנחנו מנסים למצוא תשתית שתהיה מודולרית (שניתן להוסיף/לשנות תנאים בלי שינוי של הקוד)

תודה רבה על העזרה!

יש מה שבומרנג אמר שנקרא רשתות נירונים. זה מין מיני-מודל של תאים המוח, הם יכולים לקבל בתיואריה אין סוף ערכים ולהוציא אין סוף ערכים, בפרקטיקה מספר הנירונים מוקבל בכמות הזכרון. דוגא לרשת כזאת תיהיה שימוש במקרה הבאה:

דמיין ריבוע של 8*8 ריבועים קטנים כאשר כל ריבוע קטן יכול להיות באחד משתי המצבים דלוק/כבוי. על ידי הדלקה של ריבועיים מסויימים ניתן להציג ספרות שונות מ 0 עד 9. המטרה זה לבנות רשת שיהיוו לה 64 כניסות והיא תוכל לומר האם הספרה היא נניח הספרה 4 (כלומר יציאה אחת).

רשתות נירונים היא תורה דיי מסובכת וזה יותר משחק על מזל, כי צריך פשוט לשבת למצוא מספר אופטימלי של פעילות הסינפס, מספר אופטימלי של שכבות וכודמה.

אני לא ממש בקיא בנושא, רק קראתי על זה קצת וניסיתי לממש אחת משלי, ככה שאם תרצה הרחבה תחכה למישהוא אם יותר מידע או תחפש בגוגל Artificial neural networks.

אבל שוב זה תלוי עד כמה הפונקציה שלך מסובכת, מה כמות הפרמטרית שהיא מקבלת, אולי בכלל הפתרון הכי טוב יהיה IF-ELSE, וזה בכלל לא נקרא "צורה לא חכמה" (לדעתי לפחות) ואם זה אמור להיות סטטי לחלוטין ("עבור A B C הוצא D עבור A C B הוצא E") אז אני לא רואה בעיה ב IF-ELSE.

בהצלחה.

יש לי שאלת המשך אליך, בומרנג

ה-AI שאנחנו מעוניינים בו (אני ושלוגי) צריך לקבל מספר מסויים של פרמטרים, ועל פיהם להחליט מה לעשות

תוכל לכוון אותנו באופן יותר ספציפי על אלגוריתם?

אם נבנה את זה בצורה לא חכמה האלגוריתם ייראה כך: "אם .... אז .... אחרת אם .... אז...."

אני מקווה שאתה מבין את הכוונה

אנחנו מנסים למצוא תשתית שתהיה מודולרית (שניתן להוסיף/לשנות תנאים בלי שינוי של הקוד)

תודה רבה על העזרה!

איך אתה מודד עד כמה התוצאה היתה נכונה? האם זה משהו שניתן לחשב בצורה אובייקטיבית או שזה "ציון" שאתה (כבן-אדם) צריך לתת?

אם זה משהו שניתן לחשב בצורה אובייקטיבית אז החיים שלך הרבה יותר קלים, כי הבעיה הופכת לבעיית חיפוש.

אם זה משהו שאתה לתת לו ציון, או שהציון לא ניתן לחישוב בצורה אובייקטיבית אז אתה באמת נכנס לתחום של למידה ממוחשבת, שאחת הגישות הפשוטות (יחסית) אליה זו רשת נוירונים (יש גם גישות הרבה יותר מורכבות).

AI כמו שאמרו פה מתייחס בדרך כלל למערכות לומדות, כאלו שאתה לא מכניס בהן את הלוגיקה ישירות אלא או שיש להן שלב לימוד נפרד שבו הן דוגמות סט קבוע מראש של בעיות - תשובות וכך מתאימות את הפרמטרים שלהן או שתוך כדי עבודה רציפה הן מקבלות פידבק על רמת ההצלחה שלהן ומתקנות את הפרמטרים בהתאם.

אם הצורך שלכם הוא רק "תשתית מודולרית (שניתן להוסיף/לשנות תנאים בלי שינוי של הקוד)" בשביל זה לא צריך AI. את החלק המודולרי בתוכנה אפשר לבנות בשפת סקריפטינג שהמערכת שלכם תקרא ותריץ, אפשר לכתוב את התנאים כקבצי XML, או לבנות DSL שיתאים למערכת. התנאים המודולריים ישמרו במערכת הקבצים או בבסיס הנתונים וכך יהיה ניתן לשנות אותם בלי לקמפל מחדש את כל המערכת.

יכול להיות באמת ש-etal צודק וזה בסופו של דבר לא יהיה נטו AI

התנאים שלנו באמת קבועים מראש

אבל שוב זה תלוי עד כמה הפונקציה שלך מסובכת, מה כמות הפרמטרית שהיא מקבלת, אולי בכלל הפתרון הכי טוב יהיה IF-ELSE, וזה בכלל לא נקרא "צורה לא חכמה" (לדעתי לפחות) ואם זה אמור להיות סטטי לחלוטין ("עבור A B C הוצא D עבור A C B הוצא E") אז אני לא רואה בעיה ב IF-ELSE.

אני עדיין לא מסכים עם זה, כי כשיש לך 10 פרמטרים בצורה: "אם A = ערך וגם B = ערך, אז אם C = ערך אז *תוצאה*, אחרת אם F = ערך וגם A = ערך"

וכמובן זה נמשך עוד ועוד ברמה שאי אפשר לנהל ב-IF ELSE (אפשר אולי אחרי עשרות אלף שורות קוד, אבל להכניס שינויים זה די בלתי אפשרי)

אז אני אנסח מחדש את השאלה: אחד מכם יכול להציע דרך שבה יישמרו התנאים של האלגוריתם?

אני לא חושב ש-XML הוא פתרון מספק כי זה אמור להיות בנוי בצורה שאנחנו בודקים את פרמטר A, ולפי הערך בודקים את שאר הפרמטרים.

במערכת עם 3 פרמטרים יש 27 אפשרויות, ואנחנו לא רוצים לכתוב 27 פתרונות בקובץ XML כי יש לנו כמה עשרות פרמטרים.

אני בטוח שאחד מכם מכיר דרך יותר הגיונית לנהל את זה

תודה רבה לכל מי שהגיב ויגיב

אני עדיין לא מסכים עם זה, כי כשיש לך 10 פרמטרים בצורה: "אם A = ערך וגם B = ערך, אז אם C = ערך אז *תוצאה*, אחרת אם F = ערך וגם A = ערך"

וכמובן זה נמשך עוד ועוד ברמה שאי אפשר לנהל ב-IF ELSE (אפשר אולי אחרי עשרות אלף שורות קוד, אבל להכניס שינויים זה די בלתי אפשרי)

לא אמרתי שזה פשוט למנהל 1000 אפשרויות, פשוט זה לא המקרה שבו פונים לדברים כמו רשתות נירוניום או אלגוריתמים גינטיים.

שוב עקב חוסר הידע שלי אני יכול להמליץ על משהוא לא ממש טוב אבל אני אנסה:

אתה יכול לנסות להתשמש באוטומט סופי דטרמיניסטי (בחיים לא חשבתי שהשטות הזאתי תייהיה כו שימושית!) ואני דיי בטוח שיש דרך ליישם את זה לא דווקא אם IF-ELSE, אבל לא אוכל לעזור פה כי שוב לא התנסיתי.

אתה יכול אומנם לבדוק את האתר הזה:

http://www.ai-junkie.com/architecture/state_driven/tut_state1.html

או פה שגם יש קישורים לרתות נירונים אם תצרטף והמלצות לספרים (לתיכנות משחק אומנם)

http://www.ai-junkie.com/

ברור שאם שמים 1000 תנאי IF אחד אחרי השני באותו קובץ אז אי אפשר להבין מזה כלום ובטח שלא לתחזק את זה.

יש מערכות שנועדו בדיוק בשביל לאפשר ניהול של הרבה חוקים וכללים עם היררכיה, הרשאות וכל מה שצריך, זה בדרך כלל נופל תחת ההגדרה של rule engines. אם לא רוצים לקחת את זה כל כך רחוק עדיין יש דרכים לתכנן את זה שזה לא יראה כמו סתם אוסף אקראי של פקודות IF.

כאמור זה לא קשור בכלל לתחום של AI או מערכות לומדות.

אם הצורך שלכם הוא רק "תשתית מודולרית (שניתן להוסיף/לשנות תנאים בלי שינוי של הקוד)" בשביל זה לא צריך AI. את החלק המודולרי בתוכנה אפשר לבנות בשפת סקריפטינג שהמערכת שלכם תקרא ותריץ, אפשר לכתוב את התנאים כקבצי XML, או לבנות DSL שיתאים למערכת. התנאים המודולריים ישמרו במערכת הקבצים או בבסיס הנתונים וכך יהיה ניתן לשנות אותם בלי לקמפל מחדש את כל המערכת.

זה בתנאי שהדומיין מספיק ספציפי. אם נסחפים, אפשר להגיע בקלות ל-inner platform effect:

http://en.wikipedia.org/wiki/Inner-Platform_Effect

תוכלו לפרט עוד על האלגוריתם שאתם רוצים לממש? איזו בעיה הוא פותר?

אם אתם סתם מחפשים דרך נוחה לסדר תנאים ופעולות, אתם יכולים להחזיק רשימה של של אובייקטים שכל אחד מכיל את התנאים לבדיקה, הפעולה שצריכה להתבצע, ועדיפות, ואז לרוץ על הרשימה כשהיא מסודרת לפי עדיפות ולמצוא את האובייקט שעליו מתקיימים כל התנאים, ולבצע את הפעולה שנמצאת עליו.

(ואגב, אפשר לנצל את זה לרמה מסויימת של "למידה" אם כתגובה לפעולה שמבצעים מקבלים ציון, ולפי זה מעלים או מורידים את העדיפות)

קודם כל, שוב תודה לכולם על הלינקים וההצעות

אני אנסה לענות לכולם:

etal - נבדוק את ההצעה שלך של rule engines, יכול להיות שזה מה שאנחנו מחפשים. ושוב אני חוזר, אכן נוצר אצלנו הבלבול שמדובר על AI כי המערכת תחליף בנאדם, אבל גם התפקיד של הבנאדם היה לחשוב כמו מחשב, כלומר הכל ידוע מראש ואין הרבה "חשיבה", אז אפשר להגיד שזה לא AI.

נשמח לעוד רעיונות אם יש לתכנון מערכת כזאת.

Boomerang - הבעיה שלנו היא במשפט שלך שאומר "כל אחד מכיל את התנאים לבדיקה, הפעולה שצריכה להתבצע". כלומר, אנחנו מחפשים פתרון למעבר בין "כל התנאים" לבין "הפעולה שצריכה להתבצע" - על ידי בדיקה של כל פרמטר נתון ומתן פתרון (לא שקלול של כל פרמטר ואז על סמך ציון סופי מחליטים על פתרון)

Component - אני לא יכול לפרט יותר מדי על המטרה הסופית, אך זה לא אמור לשנות, אני שוב אתן דוגמא לאלגוריתם:

בהנחה שיש לנו שני פרמטרים לבדיקה, A ו-B, ולכל אחד מהם יכולים להיות שני ערכים, X ו-Y, אז זה משהו כזה:

אם A = X

אז אם B = X

אז תבצע פעולה א'

אחרת תבצע פעולה ב'

אחרת אם B = X

אז תבצע פעולה ג'

אחרת תבצע פעולה ד'

כמובן שבמקרה הזה IF-ELSE מתאים בכיף, אבל לנו יש לצורך העניין 20 פרמטרים ולכל אחד מהם בממוצע 5 ערכים.

ואז IF-ELSE לא מתאים, ואנחנו מחפשים משהו שכן יתאים.

שוב תודה!

נראה לי שלא כ"כ הבנת אותי. מה שהצעתי הוא למעשה rule-base.

אם לקחת את הדוגמא שלך, אז הוא יהיה בנוי ככה.

תנאים:

c1: A==X

c2: B==x

חוקים:

r1:

condition: c1 & c2

priority: 1

action: פעולה א'

r2:

condition: c1 & !c2

priority: 2

action: פעולה ב'

r3:

condition: !c1 & c2

priority: 3

action: פעולה ג'

וכך הלאה.

במקרה הפשוט הזה התנאים שלך היו זרים לגמרי, ולכן אין משמעות לעדיפויות.

בעיקרון אין מניעה שיהיו חפיפות בין התנאים, ואז אתה עובר על החוקים לפי העדיפויות ומבצע את הפעולה הראשונה שהתנאים מקיימים את החוק שלה.

ככה למשל מנוהלת מערכת החוקים ברוב ה- firewalls (אם לא בכולם).

אוקיי, הבנתי...

העניין הוא שיש לנו הרבה פרמטרים לבדיקה, שלכל אחד מהם יכולים להיות כמה ערכים, וככה אנחנו מגיעים למצב של אלפי חוקים, אם לא עשרות אלפים.

אני מניח (מקווה מאוד) שיש דרך יותר חכמה להימנע מזה, אולי משהו בסגנון טבלה רק מימדית של הפרמטרים והערכים, וכל תא בטבלה מוביל לבדיקה של פרמטר אחר או תוצאה סופית.

יש רעיון?