Mga nadagdag:
- Kakayahang i-automate ang pagkalkula ng engineering, pamamahala ng unit at pagproseso ng data gamit ang AI-powered Python code
- Kakayahang i-validate ang AI code gamit ang unit checking, kilalang resulta ng pagsubok, at edge cases
- Kakayahang magkaroon ng ugali ng paggawa ng mga nauulit, nasusubaybayan at kinokontrol na bersyon ng mga dokumento ng account
Sa mechanical engineering, ang parehong pagkalkula ay paulit-ulit na ginagawa: mga stress ng isang pamilya ng mga bahagi, pump power para sa isang hanay ng mga operating point, mga talahanayan ng ari-arian sa iba't ibang temperatura. Ang paggawa ng mga ito nang manu-mano ay parehong mabagal at madaling magkamali. Ang Python (isang madaling matutunang programming language na may mayayamang library para sa engineering) ay nag-automate ng mga pag-ulit na ito; Ginagawa nitong paulit-ulit, masusubaybayan at kontrolado ang bersyon. Ang artificial intelligence (AI) Python ay hindi kapani-paniwalang mabilis sa pagbuo ng code: pag-convert ng formula sa isang function, pagdaragdag ng pamamahala ng unit, pagbabasa ng data, pag-plot ng mga graph. Ngunit mayroong isang mapanganib na maling kuru-kuro dito: dahil lamang sa gumagana ang code nang walang mga error ay hindi nangangahulugan na ito ay kinakalkula nang tama. Maaaring tahimik na ibalik ng AI code ang mga maling resulta dahil sa maling conversion ng unit, maling formula, o sa mga edge na kaso, at patuloy na tatakbo ang program nang walang anumang mga error. Kaya naman ang bawat engineering code ay ginawa gamit ang AI; Ang mga input ng pagsubok na may mga kilalang resulta ay hindi mapagkakatiwalaan nang walang pag-verify sa pamamagitan ng pagsusuri ng unit (laki) at mga pagsubok sa edge case. Sa unit na ito, matututunan mo kung paano ligtas na i-set up ang Python account automation gamit ang AI.
Bakit Code Account? Traceability at Reproducibility
Ang manu-manong pagkalkula ay isang one-off; Kapag nagbago ang isang input, ginagawa ito mula sa simula at mawawala ang mga intermediate na hakbang. Ang pagkalkula na ginawa sa code ay parang isang dokumento: ang mga input, formula at output ay malinaw na nakasulat; magpalit ka ng input at makakuha ng bagong resulta sa loob ng ilang segundo; Gamit ang kontrol ng bersyon (tulad ng git), "kung ano ang nakalkula ko kung saan ang halaga sa anong petsa" ay maaaring masubaybayan. Ito ay napakahalaga sa mga tuntunin ng kontrol at pananagutan. Ngunit ang kapangyarihang ito ay nakasalalay sa kawastuhan ng code; Ang isang maling code ay gumagawa ng maling resulta, maaari ding muling gawin at mabilis.
Tip: Sumulat ng pagsubok para sa bawat compute function na may alam na totoong resulta sa tabi nito (igiit sa Python). Halimbawa, ang iyong stress function ay dapat magbigay ng 28.1 MPa sa isang kilalang sample. Ang pagsubok na ito ay agad na nagbabala sa iyo kung may masira ka kapag binago mo ang code sa hinaharap. Ang engineering code na hindi nasubok ay isang hindi na-verify na account.
Pamamahala ng Dami: Pinakakaraniwang Pinagmumulan ng Error
Sa engineering code, karamihan sa mga error ay nagmumula sa mga unit: N na may kN, m na may mm, Pa na may MPa, na maaaring malito sa pamamagitan ng isang kadahilanan na 1000 o 1,000,000. May dalawang depensa. Ang una ay disiplina: pagpili ng isang sistema ng yunit mula sa simula (hal. N, mm, MPa) at pag-convert ng lahat ng mga input dito at pagdaragdag ng mga yunit sa mga variable na pangalan (length_mm, force_N). Ang pangalawa ay ang tool: ang isang library tulad ng pint ay nagdadala ng mga yunit sa loob ng code at nakakakuha ng hindi pantay na operasyon bilang isang error.
Diskarte
Paano ito gumagana
Advantage
Pagpapangalan ng disiplina
tulad ng force_N, length_mm
Simple, walang dependencies
sistema ng isang yunit
Lahat ay na-convert sa N-mm-MPa
Ang pagiging simple, bilis
pint library
Inililipat ang unit ayon sa variable
Awtomatikong nakakakuha ng hindi pagkakapare-pareho
Kilalang resulta ng pagsusulit
sanggunian na may paninindigan
Nakakakuha ng error sa formula/unit
Babala: Maaaring nawawala o mali ang conversion ng unit sa code na binuo ng AI at "gumagana" pa rin ang code. Halimbawa, kung ang diameter ay mm at ang lugar ay inaasahang m², ang resulta ay lilihis ng 1,000,000 beses, ngunit ang programa ay hindi magbibigay ng error. Bago patakbuhin ang code, magkomento sa mga yunit ng mga input at output; pagkatapos ay ibigay ang resulta ng isang kilalang halimbawa.
Hakbang sa Hakbang: AI Verifiable Account Code
- Linawin ang problema at sistema ng yunit. Mga input, output, unit.
- Bumuo ng function. Nag-iisang responsable, nagpapakahulugan, nagkakaisa.
- Magdagdag ng mga kilalang resulta ng pagsubok. Igiit na may sanggunian na halimbawa.
- Subukan ang mga edge case. Zero, negatibo, napakalaki/maliit na input.
- Magsagawa ng unit check. Ang yunit ba ng output ay tumutugma sa inaasahan?
- Dokumento at bersyon. Mga pagpapalagay, pinagmulan, petsa; traceability sa git.
Prompt na bumubuo ng mga function at pagsubok
Tungkulin: Nakaranas ng Python developer sa pagsusulat ng mga kalkulasyon ng engineering. Gawain: Sumulat ng isang function na kinakalkula ang maximum na bending stress sa isang rectangular cross-section cantilever beam. Input: F (N), L (mm), b (mm), h (mm). Output: sigma (MPa).Convention: Unit system N-mm-MPa; puna ang unit ng bawat entry.Rule: gamitin ang I = b*h^3/12 at sigma = M*c/I; ikomento ang mga hakbang. Panuntunan: Magdagdag ng pagsusulit na may KILALAANG RESULTA: sigma ~28.1 MPa para sa F=500,L=300,b=20,h=40; Lagyan ng tsek na may paninindigan (maliit na pagpapaubaya).
Prompt ng katayuan sa gilid
Magdagdag ng mga tseke ng edge case sa function sa itaas:- Kung ang b, h o L ay zero o negatibo, magbigay ng malaking error (itaas ang ValueError).- Magkomento kung mayroong overflow/precision na problema sa napakalaki/maliit na input. Magdagdag din ng 3 iba pang mga input ng pagsubok at isulat ang inaasahang resulta; ipaliwanag ang mga resulta sa paraang ma-verify ko sila nang manu-mano.
Seguridad ng unit (pint) prompt
Unit-safe ang parehong account sa 'pint' library. Hayaang tukuyin ang mga input sa mga unit (hal. 500 * ureg.newton). I-convert ang output sa MPa at i-print ito. Magdagdag ng isang maliit na halimbawa na nagpapakita kung paano nabigo ang pint kapag binigyan ng input na may maling unit.
Prompt ng pagsuri ng code
Punahin ang aking engineering calculation code sa ibaba mula sa isang code review perspective, huwag sumang-ayon sa akin. Sa partikular: tama ba ang conversion ng unit, tama ba ang formula, isinaalang-alang ba ang mga edge case (zero, negatibo), tunay bang nagpapatunay ang mga pagsusuri? Para sa bawat paghahanap, isulat kung paano ito ayusin.[code]
Mahina Prompt / Malakas na Prompt
Mahinang prompt:
Sumulat ng Python code para sa pagkalkula ng stress.
Walang pagpipilian ng mga yunit, formula, kahulugan ng input at pagsubok; Bumubuo ang AI ng code na gumagana ngunit hindi na-verify at ang unit ay hindi alam.
Napakahusay na prompt:
Isulat ang function ng bending stress sa cantilever beam. Input F(N), L(mm), b(mm),h(mm); output sigma(MPa). N-mm-MPa system, tukuyin ang bawat unit sa komento. Magdagdag ng pagsubok na may mga kilalang resulta (F=500, L=300, b=20, h=40 → ~28.1 MPa, igiit). Magbigay ng error sa zero/negative na input. I-interpret ang mga edge case.
Ang pangalawang prompt ay nangangailangan ng sistema ng yunit, formula, mga input, pagsubok, at mga kaso sa gilid; Ginagawa nitong ma-verify ang code.
Tatlong Mini Case (Ayon sa Mga Numero)
Case 1 - Error sa tahimik na volume. Ang pagkalkula ng lugar na ginawa ng AI ay kumukuha ng diameter sa mm at nagbibigay ng mm² na may pi*d**2/4, ngunit inilalagay ito ng susunod na linya sa isang formula na inaasahang m²; Gumagana ang code nang walang mga error at nagbibigay ng stress ng 1,000,000 beses na mas mababa. Kapag pinatakbo ng inhinyero ang pagsubok na may alam na resulta (igiit ang abs(sigma-28.1)<0.5), sasabog ang pagsubok at nahuli ang error. Kung walang pagsubok, ang maling resulta ay maaaring pumasok sa ulat nang hindi napapansin. Aralin: working code ≠ tamang code.
Case 2 - Edge state crash. Sa code na naglo-loop para sa isang bahagi ng pamilya, ang kapal h=0 ay ipinasok sa isang linya; Kapag I = b*h**3/12 = 0, ang sigma = M*c/I ay nagbibigay ng dibisyon sa pamamagitan ng zero error. Salamat sa if h<=0: taasan ang ValueError control na idinagdag ng AI, humihinto ang code sa isang makabuluhang mensahe at hindi tahimik na gumagawa ng inf. Aralin: hawakan muna ang mga edge case.
Kaso 3 - Pagkakamit ng pag-uulit. Kinailangan ng isang inhinyero ng kalahating araw upang manu-manong kalkulahin ang pump power para sa 40 iba't ibang mga operating point. Nakasulat sa AI, binabasa ng script ang CSV, kinakalkula ang kapangyarihan para sa bawat linya, at bini-verify ang isang kilalang punto na may paggigiit, binabawasan ang trabaho sa ~2 minuto at isinusulat ang mga resulta sa isang nasusubaybayang file. Kapag nagbago ang isang entry, ina-update ang buong talahanayan bawat segundo. Lesson: Ang na-verify na automation ay parehong mabilis at maaasahan.
Mga karaniwang pagkakamali
- "Worked = correct" fallacy: Tama ang pag-iisip na ang code na gumagana nang walang error.
- Hindi sumusulat ng mga pagsubok: Umaasa sa code nang walang reference na pagsubok na may alam na resulta.
- Kalabuan ng unit: Pag-iiwan sa mga unit ng input/output na hindi nabibigyang kahulugan, nilaktawan ang conversion.
- Hindi pinapansin ang mga edge case: Tahimik na error o pag-crash sa zero/negative na input.
- Hindi pagdodokumento ng source/assumption: Hindi pagsusulat ng source at assumption ng formula na ginamit.
- Hindi nagber-bersyon: Ang pag-iwan sa account bilang isang beses na file nang hindi ginagawa itong ma-trace (git).
Sa buod
- Ginagawa ng Python na paulit-ulit, masusubaybayan, at kontrolado ang bersyon ng engineering computation.
- Ang AI ay napakabilis sa pagbuo ng code; Ngunit ang katotohanan na ang code ay gumagana nang walang mga error ay hindi nangangahulugan na ito ay kinakalkula nang tama.
- Ang bawat code ay dapat ma-validate sa pamamagitan ng alam na resulta ng pagsubok, pagsusuri ng unit, at mga edge case.
- Ang mga error sa unit ay ang pinaka-madalas at pinaka-mapanlalang pinagmumulan ng error; Ipagtanggol sa pamamagitan ng solong sistema ng yunit, katawagan o pint.
- Ang napatunayang automation ay nakakatipid ng oras at nagbibigay ng kumpiyansa; Mapanganib ang hindi na-verify na code.
Gawain ng aplikasyon
Pumili ng umuulit na pagkalkula ng engineering (gaya ng stress, pump power, heat load). Sumulat ng isang Python function sa AI na gumagawa ng pagkalkula na ito; Ikomento ang unit ng bawat input at output at magdagdag ng assert test na may alam na resulta. Patakbuhin ang pagsubok at tingnan kung pumasa ito. Pagkatapos ay gumawa ng dalawa pang pag-verify: subukan ang isang edge case (zero o negatibong input) upang suriin kung ang code ay nagbabalik ng isang malaking error, at manu-manong ibigay ang unit ng output sa isang halimbawa. Kung maaari, magkaroon din ng unit-safe na bersyon na ginawa sa pint. Panghuli, idagdag ang mga pagpapalagay ng kalkulasyon, pinagmulan ng formula, at petsa sa code bilang isang maikling pamagat at isulat kung bakit nangangailangan pa rin ng pag-apruba ng engineer ang code na ito.
checklist
- [ ] Ang mga input at output unit ay malinaw na nakadokumento sa code; isang sistema ng yunit ang napili.
- [ ] Isang pagsubok (assert) na may alam na resulta ang idinagdag at naipasa.
- [ ] Kahit isang edge case (zero/negatibo) ang sinubukan; Ang code ay nagbigay ng isang makabuluhang error.
- [ ] Ang yunit ng output ay ibinigay ng isang manu-manong halimbawa (hindi ipinapalagay na "nagtrabaho = tama").
- [ ] Pinagmulan ng formula, mga pagpapalagay at petsa na nakasaad sa code.
- [ ] Pinananatiling nasusubaybayan/nasusubaybayan ang account; ang huling pag-apruba ay naiwan sa inhinyero.