אוטומציה של חישוב הנדסי עם Python

רווחים:

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

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

למה חשבון קוד? עקיבות ושחזור

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

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

ניהול נפח: מקור השגיאה השכיח ביותר

בקוד ההנדסי, רוב השגיאות מגיעות מיחידות: N עם kN, m עם mm, Pa עם MPa, שניתן לבלבל בפקטור של 1000 או 1,000,000. יש שתי הגנות. הראשון הוא משמעת: בחירת מערכת יחידה אחת מההתחלה (למשל N, mm, MPa) והמרת כל התשומות אליה והוספת יחידות לשמות המשתנים (length_mm, force_N). השני הוא הכלי: ספרייה כמו pint נושאת את היחידות בתוך הקוד ותופסת את הפעולה הלא עקבית כשגיאה.

גישה

איך זה עובד

יתרון

משמעת שמות

כמו force_N, length_mm

פשוט, ללא תלות

מערכת יחידה אחת

הכל הומר ל-N-mm-MPa

פשטות, מהירות

ספריית ליטר

מעביר יחידה לפי משתנה

תופס אוטומטית חוסר עקביות

מבחן תוצאה ידוע

התייחסות עם טענה

תופס שגיאת נוסחה/יחידה

זהירות: ייתכן שהמרת יחידה חסרה או שגויה בקוד שנוצר בבינה מלאכותית והקוד עדיין "יעבוד". לדוגמה, אם הקוטר הוא מ"מ והשטח צפוי להיות מ"ר, התוצאה תסטה פי 1,000,000, אך התוכנית לא תיתן שגיאה. לפני הפעלת הקוד, ציין את היחידות של הכניסות והפלט; לאחר מכן ספק את התוצאה עם דוגמה ידועה.

שלב אחר שלב: קוד חשבון ניתן לאימות בינה מלאכותית

1. הבהרת הבעיה ומערכת היחידה. כניסות, יציאות, יחידות.
2. צור את הפונקציה. אחראי יחיד, פרשני, מאוחד.
3. הוסף בדיקת תוצאות ידועות. טען עם דוגמה להפניה.
4. נסה מארזי קצה. קלט אפס, שלילי, גדול מאוד/קטן.
5. תעשה בדיקת יחידה. האם יחידת התפוקה תואמת את הצפוי?
6. מסמך וגרסה. הנחות, מקור, תאריך; עקיבות עם git.

הנחיה המייצרת פונקציות ובדיקות

תפקיד: מפתח Python מנוסה בכתיבת חישובים הנדסיים. משימה: כתוב פונקציה המחשבת את מתח הכיפוף המקסימלי בקורת שלוחה בחתך מלבני. קלט: F (N), L (mm), b (mm), h (mm). פלט: sigma (MPa). מוסכמה: מערכת יחידה N-mm-MPa; הערה את היחידה של כל ערך. כלל: השתמש ב-I = b*h^3/12 וב-sigma = M*c/I; הערה את השלבים. כלל: הוסף מבחן עם תוצאה ידועה: sigma ~28.1 MPa עבור F=500,L=300,b=20,h=40; בדוק עם טענה (סובלנות קטנה).

שורת מצב Edge

הוסף בדיקות קצה לפונקציה שלמעלה:- אם b,h או L הם אפס או שלילי, תן ​​שגיאה משמעותית (העלה את ValueError).- הערה אם קיימת בעיית גלישה/דיוק עם כניסות גדולות/קטנות מאוד. הוסף גם 3 כניסות בדיקה שונות וכתוב את התוצאה הצפויה; להסביר את התוצאות בצורה שאוכל לאמת אותן באופן ידני.

הודעת אבטחה ליחידה (פינט).

בטוח ליחידה באותו חשבון עם ספריית 'פינט'. אפשר להגדיר תשומות ביחידות (למשל 500 * ureg.newton). המר את הפלט ל-MPa והדפיס אותו. הוסף דוגמה קטנה שמראה כיצד פיינט נכשל כאשר ניתן קלט עם היחידה הלא נכונה.

הנחיה לבדיקת קוד

ביקורת על קוד החישוב ההנדסי שלי למטה מנקודת מבט של סקירת קוד, אל תסכים איתי. בפרט: האם המרת היחידה נכונה, האם הנוסחה נכונה, האם נשקלו מקרי קצה (אפס, שליליים), האם הבדיקות באמת מאששות? עבור כל ממצא, כתוב כיצד לתקן אותו.[קוד]

הנחיה חלשה / הנחיה חזקה

הנחיה חלשה:

כתוב קוד Python לחישוב מתח.

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

הנחיה עוצמתית:

כתוב את פונקציית מתח הכיפוף בקורה שלוחה. קלט F(N), L(mm), b(mm),h(mm); פלט sigma (MPa). מערכת N-mm-MPa, ציין כל יחידה בהערה. הוסף בדיקה עם תוצאות ידועות (F=500, L=300, b=20, h=40 → ~28.1 MPa, טענה). תן שגיאה בקלט אפס/שלילי. פרש מקרי קצה.

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

שלושה מארזים קטנים (לפי מספרים)

מקרה 1 - שגיאת עוצמת קול שקטה. חישוב השטח המיוצר על ידי AI לוקח את הקוטר ב-mm ונותן mm² עם pi*d**2/4, אבל השורה הבאה מכניסה אותו לנוסחה שמצפה ל-m²; הקוד עובד ללא שגיאות ונותן את הלחץ נמוך פי 1,000,000. כאשר המהנדס מריץ את הבדיקה עם תוצאה ידועה (assert abs(sigma-28.1)<0.5), הבדיקה מתפוצצת והשגיאה נתפסת. אם לא הייתה בדיקה, התוצאה השגויה הייתה נכנסת לדוח בלי לשים לב. שיעור: קוד עובד ≠ קוד נכון.

מקרה 2 - התרסקות מצב קצה. בקוד שמתגלגל למשפחת חלקים, עובי h=0 מוזן בשורה אחת; כאשר I = b*h**3/12 = 0, sigma = M*c/I נותן חלוקה באפס שגיאה. הודות לפקד אם h<=0: העלאת ValueError שנוספה על ידי AI, הקוד נעצר עם הודעה משמעותית ואינו מייצר אינפ בשקט. שיעור: טפל בתיקי קצה לפני כן.

מקרה 3 - רווח חוזר. לקח למהנדס חצי יום לחשב ידנית את כוח המשאבה עבור 40 נקודות הפעלה שונות. כתוב ב-AI, הסקריפט קורא את ה-CSV, מחשב את ההספק עבור כל שורה, ומאמת נקודה ידועה באמצעות assert, מצמצם את העבודה ל-2 דקות וכתיבת התוצאות לקובץ שניתן לעקוב. כאשר ערך משתנה, הטבלה כולה מתעדכנת בכל שנייה. לקח: אוטומציה מאומתת היא גם מהירה וגם אמינה.

טעויות נפוצות

• כשל "עבד = נכון": לחשוב שקוד שעובד ללא שגיאות נכון.
• אי כתיבת מבחנים: הסתמכות על קוד ללא מבחן התייחסות עם תוצאה ידועה.
• עמימות יחידה: השארת יחידות קלט/פלט ללא פירוש, דילוג על המרה.
• התעלמות ממקרי קצה: שגיאה שקטה או קריסה בקלט אפס/שלילי.
• אי תיעוד המקור/הנחה: אי רישום המקור והנחת הנוסחה בה נעשה שימוש.
• לא ניהול גרסאות: השארת החשבון כקובץ חד פעמי מבלי להפוך אותו למעקב (git).

לסיכום

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

משימת יישום

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

רשימת בדיקה

• [ ] יחידות קלט ופלט מתועדות בבירור בקוד; נבחרה מערכת יחידה אחת.
• [ ] התווסף ועבר מבחן (טענה) עם תוצאה ידועה.
• [ ] נוסתה לפחות מקרה קצה אחד (אפס/שלילי); הקוד נתן שגיאה משמעותית.
• [ ] יחידת הפלט סופקה על ידי דוגמה ידנית (לא בהנחה ש"עבד = נכון").
• [ ] מקור הנוסחה, הנחות ותאריך מצוינים בקוד.
• [ ] החשבון נשמר למעקב/מעקב; האישור הסופי הושאר בידי המהנדס.