แแแขแแ แ: แกแแ แแแ แแฃแแแแแฉแแแแแ, InterSystems-แแก แแแแกแฃแแขแแแขแ แแแแแแแ แ
แ แแแแฃแ แแ แแจแ AI/ML แแแแแแแแแแ แแแ แแแ
แแแแแฌแงแแ InterSystems-แจแ แแแแแชแแแแ แแแชแแแแ แแแแก แแ แแฅแขแแแแก แแแแแชแแแแแแแแแ แแแแแแแแแแแ:
- แฉแแขแแแ แแฃแแ แแงแแแแแแแก แแแ แขแแแ แแแแแแจแแ แแแฃแแแ แแแแแแ แกแแ แแแแแแแแแชแแ แกแแกแขแแแแกแแแ. แแแฎแแแแ แแฅแชแแแแแก แ แแกแขแ แฃแฅแขแฃแ แแแแชแแ แกแแชแแแ แฅแกแแแจแ (แแแแแแแแแ, แแฅแชแแแแแก โแแ แขแงแแแโ แฎแแแแก แแแชแแแแ, แแฎแแ แแแแแงแแแแแฃแแ แแฅแแแแ โแกแแแแแแข-แขแแฅแขแแแแกโ แแแขแ แแชแ). แ แ แแแแ แแแแ แกแแ แแแแแแแแแชแแ แซแ แแแแแก? แ แ แฎแแแแ แกแแ แแแแแแแแแชแแ แซแ แแแจแ แแแแแชแแแแแแก แฌแแ แแแแแแกแ แแ แแแแแฎแแแแแกแแแ (แจแแกแฃแแ แแแแแชแแแแแแก แแแชแฃแแแแ แแแแแแ แแ 25000-แฏแแ )? แ แ แแแแ แแแแ แ แแแแแแแแแชแแแแแก แจแแแฃแจแแแแแแก (แกแแ แแแแแแแแแชแแ แฌแแกแแแแก แคแแแขแ แแชแแแก แแฆแฃแ แแแแก แแแแกแฏแแ แจแแแชแแ แแแแก แแฃแชแแแแแแแแ แแแแ แ แแแแแแแแแกแ แแ โแแแแแแแแแแกโ แแแแกแฏแแ แแแแ แแแก แแแแ)?
- แแ แกแแแแแก แแฆแญแฃแ แแแแแแแก แแแแแแแแแขแแแจแ แแแคแแฅแขแแแแก แแแแแแแแ แแแแก แแแแแแแแแก แแแแแขแแ แแแแแก แกแแกแขแแแ. แแแแแขแแ แแแแแก แกแแกแขแแแแก แฃแแ แแแแแแแ แแ แแชแแกแแก แแแแขแ แแแแก แแแขแแแแขแฃแ แ แกแแกแขแแแ, แ แแแแแแช แงแแแแ แฌแแแจแ แแแแแกแชแแแแ แแแแกแแแแ แขแแฅแแแแแแแฃแ แ แแ แแชแแกแแก แแแ แแแแขแ แก. แ แ แแแแ แแฌแแแ แแแแแขแแ แแแแแก แกแแกแขแแแแก, แ แแแแแแช แแแ แ แแฃแจแแแแแ โแฎแแแแ แแแแฃแจแแแแโ (แจแแฃแซแแแ แแฃ แแ แ แแแก แฌแแแแแ แแ แแแแแฎแแ แชแแแแแก แแแแแแแแแก แแแแแขแแ แแแแ)? แ แ แแแฎแแแแ, แแฃ แ แแแแแแแแ แแกแแฃแแ แกแแแขแแก แแฎแแแ แแแแแ แแแแแฉแแแแแ แจแแงแแแแแก แแแแแชแแแแแจแ แกแแแกแแ แแแแก แฌแแแแแฎแแแแแ, แ แแแแแแแช แแฎแแแฎแแ แแแแแแขแ แแ แแชแแกแแก แแแแขแ แแแแก แกแแกแขแแแแก (แแฃแชแแแแแแแแ แแ แ แแแแแ แฎแแแก แจแแฉแแ แแแก แแแแแขแแ แแแแแก แกแแกแขแแแ, แ แแ แจแแแขแแแแก แแฎแแแ แกแแแกแแ แแแแก แแแแแชแแแแแ แแแแแแแจแ )?
- แจแแแฅแแแ AI/ML แแแฅแแแแแแแแแก แแแแ แแแ (แ แแแแแแแแแชแแ, แแแแแขแแ แแแแ, แแ แแแแแแแ แแแ), แ แแแแแแแช แแ แแแแแแแแก แแฃแจแแแแแก แจแแแแแแแก แแงแแแแแแ. แ แแแแแแ แแแแแแแแฃแ แ แกแแแแแ แกแแญแแ แ แงแแแแแแแแฃแ แแ แแ แแแแแแแฅแกแแก แแฃแจแแแแแก แแแแแขแแชแแแกแแแแก แจแแงแแแแแก แแแแแชแแแแแแก แชแแแแแแแแกแแแ? แ แ แแ แแก แแแแแแ โแจแแแแแแแโ, แ แแแแกแแช แแแก แแฎแแ แก แฃแญแแ แก แแแแแฏแแแแขแแก แแแแแฌแงแแแขแแแแแแก แแแฆแแแแก แแแแแแแฅแกแ (แแแกแจแ แแฎแแแ แแแแฎแแแ แ แแแคแแ แแแชแแแก แแแฉแแแแก แกแแฎแจแแ แ แแฎแแแ แจแแงแแแแแก แแแแแชแแแแแแก แแแฉแแแแก แกแแฎแจแแ แแกแแแ แจแแแแ แแแแ)?
- แแแแงแแคแแแ แแแ แ แแฃ แแ แ แฉแแแแก แแแแแแแแแจแ AI/ML แแแแแแแแ แแแแแ แจแแฅแแแแกแ แแ แแแแแขแแชแแแก แกแแกแฌแ แแคแแ (แชแแแแแแแ แกแแขแฃแแชแแแกแแแ)?
- แ แแแแแแแ แฃแญแแ แก แแฎแแ แก AI/ML แแแแแฌแงแแแขแแแแแแแ, แ แแแแแแกแแช แฉแแแ แแแงแแแแแ แ แแแแฃแ แแ แแจแ แแแแแแกแแก แแแ แแแแจแ?
- แจแแฃแซแแแ แแฃ แแ แ AI/ML แแแแแฌแงแแแขแแแแแแแก, แ แแแแแแกแแช แฉแแแ แแแงแแแแแ แแแแแฃแแแแแแแแ (แแแแแแแแแ แแแแก แแแ แแจแ) แแแแแขแแ แแแก แแแแแชแแแแ แแ แแแแแแกแแก แแแ แแแแก แแ แแฅแขแแแแก แชแแแแแแแแแแแ?
แฉแแแแ แกแขแแขแแ แแ แแก InterSystems IRIS แแแแขแคแแ แแแก แจแแกแแซแแแแแแแแแแก แกแแคแฃแซแแแแแแ แแแแแฎแแแแ AI/ML แแแฅแแแแแแแแแก แแแแแแแแแแก แฃแแแแแ แกแแแฃแ แ แแฎแแ แแแญแแ แแก แแแแแกแแแ แแกแแ, AI/ML แแแแแฌแงแแแขแแแแแแแแก แแฌแงแแแ (แแแขแแแ แแชแแ) แแ AI/ML แแแแแฌแงแแแขแแแแแแแแก แขแ แแแแแแ (แขแแกแขแแ แแแ) แแแขแแแกแแฃแ แแ. แแแแแชแแแแ แแแแแแแแ. แแ แกแขแแขแแแจแ แฉแแแ แแแแแแฎแแแแแ แแแแ แแก แแแแแแแก, AI/ML แแแแแฌแงแแแขแแแแแแแแก แจแแแแฎแแแแแก แจแแกแฌแแแแแก แแ แแแแชแแแขแฃแแแฃแ แแกแแแฅแขแแแก, แ แแกแแช แฉแแแ แแฃแฌแแแแแ แ แแแแฃแ แแ แแจแ AI/ML แแแแขแคแแ แแแก.
แ แ แแแชแแ แแแแแแแแฎแแแแแแแ: แ แแแแฃแ แแ แแจแ แแแแแแแชแแแแ
แแแกแแแแแแ
แกแฃแ แแแ 1 แ แแแแฃแ แแ แแจแ แแแแแชแแแแแแก แฌแแแงแแแแ แแแแฎแแแ แแแแแแ
แแแแ, แฉแแแแก แแแ แแแแแจแ แแแแแงแแแแแ แแ แแแแแแแก แจแแแแแแแแก แแแฎแกแแแแแแก แแแแจแแแแแแแแแ แคแ แแแแแแขแแแ:
โ... แแแแแชแแแแ แแแแแแแแแก แแแขแแแ แแ แแแแก แแแกแขแ แฃแแแแขแแแแก แแแแฃแแแ แแแแก แขแแแแแแชแแแแ แแ, แแแแแ แแ แแก, แแแแขแแแแแ แแแจแ แแแแแแแแแแแก แแฎแแ แแแญแแ แ, แแซแแแแ แกแแแแ แแแฃแ แแแกแฃแฎแก แแแแ แแก แแแแฎแแแแแแ แแคแแฅแขแฃแ แ แแแแแฌแงแแแขแแแแแแแแก แฃแคแ แ แกแแแแกแฃแฎแ, แ แแชแแแแแแฃแ แ, แแแแแแแฃแ แ แจแแแแแแแแแแก แจแแกแแฎแแ. แแแแแแแก แแแแแชแแแแแ แแแแแกแชแแแก แแแคแแ แแแชแแแก แฃแคแ แ แกแฌแ แแคแแ, แแแแ แ แขแ แแแแชแแฃแแ แแแแแขแแก แแแแแชแแแแแ. แแแแก แแแแขแแแ แแแแแแแแแแ แแแแแแแแแก แกแฌแ แแคแแ แแแแแงแแแแแแก แจแแกแแซแแแแแแแ, แ แแแแ แแชแแ, แแแแแแแแแ, AI/ML-แแ แแแคแฃแซแแแแฃแแ แ แแแแแแแแแชแแแแ, แแแแแฃแ แแแขแฃแแ แฃแแแ แแขแแกแแแแแแก แจแแฅแแแ แแแแฎแแแ แแแแแแ แแแแงแแคแแแแแแก แแแแ แแแก แแแแ. แกแแกแฌแ แแคแแก แ แแแแ แแกแแแ แแแแแแแแก แแฎแแแแก DevOps แแแ แแแแแแแก แงแแแแ แ แแแแ - แแแแแแแชแแแแแก แจแแแฃแจแแแแแแกแ แแ แแแแแ แแแแก แฃแคแ แ แแคแแฅแขแฃแ แก แฎแแแก. โฆ แ แแแแก แแแฎแแ IT แแ แแคแแกแแแแแแแ แแแแฌแแแ แแแคแแ แแแชแแ แแแแแแแ แแ แแแแแแแชแแแแจแ แแแแแชแแแแ แแแแแแแแแก แแแแแงแแแแแแก แจแแกแแฎแแ. แ แแกแแแแแแแขแแแ แซแแ แแแแแแ แแแกแแแแแแแก แฅแแแงแแแแจแ แแงแแแแ แแแแแแแแแฃแแ (41% แแแ แแแแจแ แแ 37% แฉแ แแแแแแ แแแแ แแแแจแ) แแ แแแแฅแแแก แแแแแแ แแ แแงแ แแแแแฌแแแแแฃแแ แแชแแ แ, แกแแจแฃแแแ แแ แแแ แแแแแแแแแแก แจแแ แแก. ...
... แฎแแแแแแฃแ แ แแแขแแแแฅแขแ แแ แแ แแก แแแแแขแแแ. แแแแแแ XNUMX แแ แแชแแแขแ, แแแแช แฃแแแ แแงแแแแแก แแแแแชแแแแ แแแแแแแก แแแแฃแจแแแแแแก แแ แแแฃแฅแขแแฃแแแแแก AI/ML แแแแแแแชแแแแจแ, แแแแกแขแฃแ แแแก, แ แแ AI/ML-แแก แแแแแงแแแแแ แงแแแแแแ แแแ แแ แแแก แแแแแแฎแแแก แแแแแแแ แฌแแแก (แกแฎแแ แแแแแแแชแแแแแแ แจแแแแ แแแแ).
- แ แแกแแแแแแแขแแ แฃแแ แแแแแกแแแแก แแแ แแ, แแแแแชแแแแ แแแแแแแแแก แแแแแงแแแแแ AI/ML แกแชแแแแ แแแจแ แงแแแแแแ แแแ แแ แแแก แแแแแแฎแแแก แแแแแแแ แฌแแแก.
- AI/ML-แจแ แแแแแแแชแแแแ แแแแแ แแแแ แแ แ แแฎแแแแ แจแแแแ แแแแ แแฎแแแ แขแแแแก แกแชแแแแ แแแแก แแแแ, แแ แแแแ แขแ แแแแชแแฃแแ แกแชแแแแ แแแแก แแแแ, แ แแแแแแจแแช แ แแแแฃแ แแ แแจแ แแแแแชแแแแแ แกแฃแ แฃแคแ แ แแแขแแ แแแแแแงแแแแแ.
- AI/ML-แแก แแแ แแ, แจแแแแแแญแแแแแ แแแแฃแแแแแแแก แแแแ IoT แแแแแชแแแแ แแแแกแแแแแแแแก แแแแฎแแแ แแแแแแจแ - แแแ 48%, แแแแช แฃแแแ แแแขแแแ แแ แแแฃแแแ IoT แแแแแชแแแแแ แแแแแแก, แ แแ แแ แแแแแชแแแแแแ แกแชแแแแ แแก แแแแฎแแ แชแแแแแแ แฃแแฎแแแแก แแแแแแแแจแ แแแแจแแแแแแแแ แแ แแแก แแแแแแฎแแแก. ..."
แแ แกแแแแแแ แกแแแแขแแ แแกแ แแแแแแแแฎแแแแแ แแ แแแแแ, แ แแ แแแแฅแแแฃแ แ แกแฌแแแแแกแ แแ แฎแแแแแแฃแ แ แแแขแแแแฅแขแแก แกแชแแแแ แแแแก, แ แแแแ แช แแแแแชแแแแ แแแแแแแแแก แแแฎแแแ แแแแก แแแแแ แแแแ แแฆแฅแแ แฃแแแ โแแแแจแแโ. แแแแ แแ แแ แแแแแแแ แแแแจแแแแแแแแแ แแแแแแ แแแแแ แ แแแแฃแ แแ แแจแ AI/ML-แแก แแฆแฅแแ DevOps-แแก แแแแแแแแ: แแฅ แฃแแแ แจแแแแแซแแแ แแแแแฌแงแแ แกแแฃแแแ แ แฏแแ แแแแแ แแแแแแแแขแฃแ แ แแฃแแขแฃแ แแก แขแ แแแกแคแแ แแแชแแแแ โแแ แแฏแแ แแแ AI/ML แกแ แฃแแแ แฎแแแแแกแแฌแแแแแ แแแแแชแแแแ แแแแ แแแแโ.
แ แแแแฃแ แแ แแจแ AI/ML แแแแขแคแแ แแแก แแแแชแแคแชแแ
แ แแแแฃแ แแ แแจแ AI/ML แแแแแแแชแแแก แแ แ-แแ แแ แขแแแแฃแ แ แกแคแแ แแ แแ แแชแแกแแก แแแแขแ แแแ แฌแแ แแแแแแจแ. แแแกแ แแแแแแแแแก แแแแแงแแแแแแ แแ แฌแแแ แแแ แแแแก แแแแแแแแกแฌแแแแแแ, แฉแแแ แฉแแแแแแงแแแแแแแ แ แแแแฃแ แแ แแจแ AI/ML แแแแขแคแแ แแแก แแแแชแแคแชแแแก.
แฎแแแแแแฃแ แ แแแขแแแแฅแขแแกแ แแ แแแแฅแแแแแแชแแแแแแแแก แแแแแงแแแแแแก แแ แแชแแกแแก แแแแขแ แแแจแ แแฅแแก แแแแแ แ แแแ แแแฎแแกแแแแแแแแแ:
- แขแแฅแแแแแแแฃแ แ แแ แแชแแกแแก แแแแแแแ แแแแแก แจแแกแแฎแแ แแแแแชแแแแแ แแแแฆแแแ แแแขแแแกแแฃแ แแ: แแแฆแแแ แกแแฎแจแแ แแ แแ แแแ แแแแขแ แแแแก แคแแ แแ แแแแแแแแแแกแแแแก (แแ แแชแแกแแก แแแแขแ แแแแก แกแแกแขแแแแแแ แฌแแแจแ แแแแแชแแแฃแแ แแแแแแแกแแแแ แแแ แแแแขแ แแก แแแแจแแแแแแแ).
- แแแแแชแแแแแ แแแคแแฅแขแแแแก แแแแแขแแคแแแแชแแแก แจแแกแแฎแแ, แ แแ แแฆแแ แแคแแ แ แแแฅแแแ แแแแ แแแแแแแแ แแแแก แจแแกแแฎแแ, แแแ แแฅแแ, แแฌแแ แแ แแ แแ แแ แแแฃแแแ แฃแแ, แฎแแกแแแแแแแ แแแคแแฅแขแแแแก แแ แแกแแแแแ แแกแ แขแแแแแแ แแ แแ แแจแ แแแแ แแแแแแแแแชแแแ (แฎแจแแ แแ แฌแแ แแแแแแแแแแ แฅแแฆแแแแแก แฉแแแแฌแแ แแแแ).
- แแ แแฅแขแแแฃแแ แแแแแกแแแ แแกแแ, แแฎแแแแ แฌแงแแ แแก แแแแแชแแแแแแก "แ แแแแแแแขแฃแ แแแแก แคแแแฏแแ แ" แฎแแแแแกแแฌแแแแแแ แขแ แแแแแแแกแ แแ แแแแแแแแแก แแแแแงแแแแแแกแแแแก, แ แแแแแแช แแกแแฎแแแก แขแแฅแแแแแแแฃแ แ แแ แแชแแกแแก แแแแแแแแแก แแแแแแ แฃแ แแแชแฃแ แแแแก แแแขแแ แแแแแ, แ แแแแแแช แแแแแ แแแแ แแ แแชแแกแแก แแแ แแแแขแ แแแแก แแแแ แฌแแแแแฎแฃแแ แแแแจแแแแแแแแแแ.
แแก แแแฎแแกแแแแแแแแแ แแแแแซแฃแแแแก, แขแแฅแแแแแแแฃแ แ แแ แแชแแกแแแแ แแแขแแแกแแฃแ แ โแคแแ แแแแแแแแแแ แจแแงแแแแแก แกแแแแแแแกโ แ แแแแฃแ แแ แแจแ แแแฆแแแแกแ แแ แซแแ แแแแแ แแแแฃแจแแแแแแก แแแ แแ, แจแแแแกแ แฃแแแ (แแแ แแแแแฃแ แแ) AI / แจแแแแแแแแก แแแแแงแแแแแ, แขแ แแแแแแ แแ แฎแแ แแกแฎแแก แแแแขแ แแแ. ML แแแแแแแแ - แแกแแแ แ แแแแฃแ แแ แแจแ. "แฉแแ แฉแ", แ แแแแแกแแช แฉแแแแ แแแแแแแแ "แฎแแแแแแ" แจแแกแแแแแแกแแแแก แแแชแฃแ แแแแก แคแแแฏแแ แแจแ แแฃแแแแแแ แแชแแแแแ - แแ แแแกแแแ แแ แแแ แแชแแแแแ แฌแแ แกแฃแแจแ แแ แ-แแ แ "แฉแแ แฉแแแ" แแแแแแแแแฃแแ AI/ML แแแแแแแแแก แแฃแจแแแแแก แจแแแแแแแแก แฎแแ แแกแฎแแช. . แแฃ AI/ML แแแแแแแแแก แแฃแจแแแแแก แจแแแแแแแแก แฎแแ แแกแฎแ แแแฃแแ แแกแแแแ (แแแแแแแแแ: โแแแแแแจแแก แแแ แแแกโ แแแแกแแคแแแแชแแแก แจแแชแแแแแก แแแแจแแแแแแแ แแแกแชแแ แฉแแแแก แแแแ แแแแกแแแฆแแ แฃแ แกแแแฆแแ แแแก), แแแแแแแแแก แแแแแขแแแแแ แขแ แแแแแแ แแแขแแแแขแฃแ แแ แฃแแแ แแแแฌแงแแก. แฃแคแ แ แแฅแขแฃแแแฃแ แ โแฉแแ แฉแโ - แแ แแแแแแแแแก แแแแแขแแแแแ แขแ แแแแแแแก แแแฌแงแแแแก แแแแแแขแแก แแ แฉแแแแ แฃแแแ แแแแแแแแแกแฌแแแแก, แแฃ แ แแแแ แฎแแแแ แแแแแ แขแ แแแแแแแก แฎแแแแ แซแแแแแแ แแ แแแแแแแแแก แแแแแแแแ แ แแแ แกแแแก แแฃแจแแแแแก แฎแแ แแกแฎแแก แแแฃแแ แแกแแแแก แแแแแแแแ (แ แแแแแ แแแแแแแแแก แแแแแแแแแแแ แแแ แกแแแแแก แแแแแงแแแแแ แแ แซแแแแแแ แแแแแแแแแก แแแแแแแแแแก แแแ แแแแจแ แแ แกแแแแ แแ แฉแแแแงแแแแแแแแ แแแแ โแแฎแแแ แแแแแแแแแฃแแโ แแแ แกแแแแ).
InterSystems IRIS-แก แแฅแแก แซแแ แแแแแ แแแแขแคแแ แแแก แจแแกแแซแแแแแแแแแ, แ แแแ แฉแแ แแแก AI/ML แแแแแฌแงแแแขแแแแแแแ แแ แแชแแกแแก แ แแแแฃแ แแ แแจแ แแแแขแ แแแแกแแแแก. แแก แจแแกแแซแแแแแแแแแ แจแแแซแแแแ แแแแงแแก แกแแ แซแแ แแแแ แฏแแฃแคแแ:
- แแฎแแแ แแ แแแแแขแแ แแแฃแแ แแ แกแแแฃแแ AI/ML แแแฅแแแแแแแแแก แฃแฌแงแแแขแ แแแแแ แแแ (แฃแฌแงแแแขแ แแแแแแแแแ/แแแฌแแแแแ, CD) แแ แแแฃแฅแขแแฃแ แแแแแฌแงแแแขแแจแ, แ แแแแแแช แแฃแจแแแแก แ แแแแฃแ แแ แแจแ InterSystems IRIS แแแแขแคแแ แแแแ
- แฃแฌแงแแแขแ แแแขแแแ แแชแแ (CI) แจแแแแแแแแแ แขแแฅแแแแแแแฃแ แ แแ แแชแแกแแก แแแแแชแแแแ แแแแแแแแแก แแ แ แแ แแแฃแฅแขแฃแ แแแแแฌแงแแแขแแจแ, แแแแแชแแแแ แ แแแแแ AI/ML แแแฅแแแแแแแแแก แแแแแงแแแแแแก/แขแ แแแแแแแก/แฎแแ แแกแฎแแก แแแแขแ แแแแกแแแแก แแ แแแแแชแแแแ/แแแแแก/แแแแขแ แแแแก แแแฅแแแแแแแแแก แแแชแแแ แแแแแแแขแแแฃแ แ แแแแแแแ แแแแก แแแ แแแแจแ, แแ แแแกแขแ แแ แแแฃแแ แ แแแแฃแ แแ แแจแ. แแแแขแคแแ แแ InterSystems IRIS
- AI/ML แแแฅแแแแแแแแแก แฃแฌแงแแแขแ (แแแแ) แกแฌแแแแแแ (แแแแ แซแแแแแฃแแ แกแฌแแแแแแ, CT), แจแแกแ แฃแแแแฃแแ แแแแแแแขแแแฃแ แ แแแแแแแ แแแแก แแแ แแแแจแ แแแแแชแแแแ, แแแแแกแ แแ แแแแขแ แแแแก แแแฅแแแแแแแแแก แแแแแงแแแแแแ (โแแแฆแแแฃแแ แแแแแฌแงแแแขแแแแแแแโ), แ แแแแแแแช แแแแแชแแแฃแแแ InterSystems IRIS แแแแขแคแแ แแแ.
แแแแขแคแแ แแแก แจแแกแแซแแแแแแแแแแก แแแแกแแคแแแแชแแ แแแแฅแแแฃแ แกแฌแแแแแกแแแ แแ แฎแแแแแแฃแ แแแขแแแแฅแขแแแ แแแแแแจแแ แแแแ แแฃแกแขแแ แแ แฏแแฃแคแแแแ แจแแแแฎแแแแแแ แแ แแ แแก. แแแแแงแแแแแ แแแแแแแแแแแฃแ แ
โ... DevOps แแแแชแแคแชแแ, แ แแแแแแช แแแแฃแแแ แฃแแแ แแ แแฆแแแแจแ, แแแแชแแแก แคแแ แแแแแกแจแขแแแแแแ แกแแแแคแแ แแแชแแ แกแแกแขแแแแแแก แแแแแแแแ แแแแก แแ แคแฃแแฅแชแแแแแ แแแแก. แแ แแแแชแแคแชแแแก แแแแฎแแ แชแแแแแแแก แฃแแแ แแขแแกแแแแแแ แแแแแแแแ แแแแก แชแแแแแแแก แฎแแแแ แซแแแแแแแก แจแแแชแแ แแแ, แแแแแแแแ แแแแแ แฃแคแ แ แกแฌแ แแคแ แแแแแแแแแ แแ แแแแแจแแแแแก แแแแแแแแแก แแแฅแแแแแแ. แแ แฃแแแ แแขแแกแแแแแแก แแแกแแฆแฌแแแแ, DevOps แแแแชแแแก แแแแแแฃแ แแ แ แแ แแฅแขแแแแก แแแแฎแแ แชแแแแแแแก:
- แฃแฌแงแแแขแ แแแขแแแ แแชแแ (CI)
- แฃแฌแงแแแขแ แแแฌแแแแแ (CD)
แแก แแ แแฅแขแแแ แแกแแแ แแ แชแแแแแแ AI/ML แแแแขแคแแ แแแแแ, แ แแแ แฃแแ แฃแแแแแงแแก แแ แแแฃแฅแขแแฃแแ AI/ML แแแแแฌแงแแแขแแแแแแแแก แกแแแแแแ แแ แแคแแฅแขแฃแ แ แจแแแ แแแ.
AI/ML แแแแขแคแแ แแแแ แแแแกแฎแแแแแแแ แกแฎแแ แกแแแแคแแ แแแชแแ แกแแกแขแแแแแแกแแแ แจแแแแแแ แแกแแแฅแขแแแแ:
- แแฃแแแแก แแแแแแขแแแชแแแแ: AI/ML แแแแแฌแงแแแขแแก แจแแฅแแแแกแแก, แแฃแแแ แฉแแแฃแแแแ แแ แแแแชแแแก แแแแแชแแแแ แแแชแแแแ แแแก แแ โแแแแแแแแฃแ โ แแฅแกแแแ แขแแแก แแแแแชแแแแ แแแแแแแก แกแคแแ แแจแ, แ แแแแแแแช แแขแแ แแแแ แแแแแชแแแแ แแแแแแแก, แแแแแแ แแแแ แแ แแแแฌแแแแแ แแแแแแแแก. แแฃแแแแก แแก แฌแแแ แแแ แจแแแซแแแแ แแ แแงแแแแ แแ แแคแแกแแแแแแ แแ แแแฃแฅแขแแฃแแ แแแแแก แจแแแฅแแแแแแแ.
- แแแแแแแแ แแแ: AI/ML แซแ แแแแแ แแฅแกแแแ แแแแแขแฃแแ แฎแแกแแแแแกแแ. แแ แแแแแแแก แงแแแแแแ แแคแแฅแขแฃแ แ แแแแแญแ แแก แแแแแแ, แแฃแชแแแแแแแแ แจแแงแแแแแก แชแแแแแแแแก, แแแแแ แแแแแแแก, แแแแแแแ แแแแก แแแแแแแแแกแ แแ แแแแแแแก แแแ แแแแขแ แแแแก แกแฎแแแแแกแฎแแ แแแแแแแแชแแแแแก แแแแแ. แแกแแแ แซแแแแแก แกแแ แแฃแแ แแแแแแแ แแแแก แแแแจแ, แ แแ แแแซแแแแแ โแ แ แแฃแจแแแแแ/แแ แแฃแจแแแแแโ, แแแแแแแแแแก แแแแแแแ แแแแแแแแก แฃแแ แฃแแแแแงแแคแ, แแแแแแแ แแแแแ แแแแฎแแ แชแแแแแแแกแแแแก แแแแแแแแ แแแฃแแ แแแแแแแแแแก แแแแแแแแแแแ.
- แขแแกแขแแ แแแ: AI/ML แซแ แแแแแแก แขแแกแขแแ แแแ แแแแแฎแแแก แขแแกแขแแแแก แฃแคแ แ แคแแ แแ แกแแแฅแขแ แก, แแแแ แ แกแฎแแ แแแแแแแแ แแแแก. แกแขแแแแแ แขแฃแแ แแ แแแฃแแแกแ แแ แแแขแแแ แแชแแแก แขแแกแขแแแแก แแแ แแ, แแแฌแแแแแ แแแแแชแแแแ แแแแแแแแ แแ แแแแแแแก แแแแแงแแแแแแก แจแแแแแแแแก แฎแแ แแกแฎแ แกแแกแฌแแแแ แแ แกแแแแแขแ แแแ แแแแฃแจแแแแ.
- แแแแแ แแแ: AI/ML แแแแแฌแงแแแขแแแแแแแแก แแแแแ แแแ แแ แจแแแแแคแแ แแแแแ แแฎแแแแ แแ แแแแแแแ แแแแแ แกแแ แแแกแแแแ, แ แแแแแแแช แแงแแแแแแ แแ แแฎแแ แแแฌแแ แแแแ แแแแแแก. AI/ML แแแแแฌแงแแแขแแแแแแแ แแแแแฃแแแ แแ แแแแแกแแคแแฎแฃแ แแแแ แแแแกแแแแแแแแก แแ แแแแแ, แ แแแแแแแช แแกแ แฃแแแแแ แแแขแแแแขแฃแ แ แแแแแแแก แขแ แแแแแแก แแ แแแแแแแชแแแแก. แแกแแแ แแแแกแแแแแแแแก แแแแแแแแแ แแฃแแแกแฎแแแแก แแ แ แขแ แแแแแแฃแ แ แฅแแแแแแแแแก แแแขแแแแขแแแแชแแแก, แ แแแแแแแช แขแ แแแแชแแฃแแแ แฎแแแแ แแกแ แฃแแแแแ แแแแแชแแแแ แแแชแแแแ แแแก, แ แแแ แจแแซแแแ แแแแแแแแแก แแแแแแแแแ แแ แขแแกแขแแ แแแ.
- แแ แแแฃแฅแขแแฃแแแแ: AI/ML แซแ แแแแแก แจแแแซแแแแ แแ แฐแฅแแแแแก แแ แแแฃแฅแขแแฃแแแแ แแ แ แแฎแแแแ แแ แแแคแแฅแขแฃแ แ แแ แแแ แแแแ แแแแก แแแแ, แแ แแแแ แจแแงแแแแแก แแแแแชแแแแแแก แแฃแแแแแแ แชแแแแแแแแ แฎแแกแแแแแก แแแแ. แกแฎแแ แกแแขแงแแแแแ แ แแ แแแฅแแแ, AI/ML แแแฅแแแแแแแแแก แแแฅแแแแแแ แจแแแซแแแแ แจแแแชแแ แแแก แแแแแแแแแก แฃแคแ แ แคแแ แแ แกแแแฅแขแ แแก แแแแ, แแแแ แ แฉแแแฃแแแแ แแแ แแแแแแแแแแก แจแแกแ แฃแแแแ. แ แแช แแฌแแแแก แฉแแแแ AI/ML แซแ แแแแแแก แแฃแจแแแแแก (แแแแแแ) แแแแแขแแ แแแแแก แแฃแชแแแแแแแแแก, แแแ แแแแ แแแคแ แแฎแแแแแแแแก แแแแแแแแแก แแ แจแแแแแแแแก แฃแแ แงแแคแแก, แแฃ แจแแกแ แฃแแแแแก แแแแแแแขแแ แแแ แแ แแแแแงแแคแแแแแแ แแแแแแแแก.
AI/ML แแแแขแคแแ แแแแ แกแฎแแ แกแแแแคแแ แแแชแแ แกแแกแขแแแแแแก แแกแแแแกแแ แแแแ, แ แแ แแ แแแ แกแแญแแ แแแแก แแแแแก แฃแฌแงแแแข แแแขแแแ แแชแแแก แแแ แกแแแก แแแแขแ แแแแแ, แแ แแแฃแแแก แขแแกแขแแ แแแแกแแแ, แแแขแแแ แแชแแแก แขแแกแขแแ แแแแกแแแ แแ แฃแฌแงแแแขแ แแแแแแแแ แแแแก แแแแแแแแแแกแแแ. แแฃแแชแ, AI/ML-แแก แจแแแแฎแแแแแจแ, แแ แกแแแแแก แ แแแแแแแแ แแแแจแแแแแแแแแ แแแแกแฎแแแแแแ:
- CI (แฃแฌแงแแแขแ แแแขแแแ แแชแแ) แแฆแแ แจแแแแแคแแ แแแแแ แแฎแแแแ แแแแแแแแแฃแแ แแแแแแแแแขแแแแก แแแแแก แขแแกแขแแ แแแแแ แแ แแแแแกแขแฃแ แแแแ - แแก แแกแแแ แแแแชแแแก แแแแแชแแแแแแก แแ AI/ML แแแแแแแแแก แขแแกแขแแ แแแแกแ แแ แแแแแกแขแฃแ แแแแก.
- CD (แแฃแแแแแ แแแฌแแแแแ/แแแแแแแแแ, แฃแฌแงแแแขแ แแแแแแแแแ) แแ แจแแแแแคแแ แแแแแ แแแแแขแแแแก แแ แกแแ แแแกแแแแก แแแฌแแ แแแ แแ แแแแแจแแแแแ, แแ แแแแ แแฃแแแกแฎแแแแก แแแแขแคแแ แแแก AI/ML แแแแแฌแงแแแขแแแแแแแแก แจแแแแแแแแแแแแก, แขแ แแแแแแแกแ แแ แแแแแงแแแแแแกแแแแก.
- CT (Continuous Training, แฃแฌแงแแแขแ แขแ แแแแแแ) แแ แแก แแฎแแแ แแแแแแแขแ [แแแแฎ. แกแขแแขแแแก แแแขแแ แ: แแฎแแแ แแแแแแแขแ DevOps-แแก แขแ แแแแชแแฃแ แแแแชแแคแชแแแกแแแ แแแแแ แแแแแจแ, แ แแแแแจแแช CT แแ แแก, แ แแแแ แช แฌแแกแ, แฃแฌแงแแแขแ แขแแกแขแแ แแแ], แแแแแแงแแแแแ AI/ML แแแแขแคแแ แแแแแกแแแแก, แ แแแแแแช แแแกแฃแฎแแกแแแแแแแแ AI-แแก แขแ แแแแแแแกแ แแ แแแแแงแแแแแแก แแแฅแแแแแแแแแก แแแขแแแแแแฃแ แแแ แแแแแ. /ML แแแแแแแแ. ..."
แจแแแแแซแแแ แแแแแแชแฎแแแแ, แ แแ แ แแแแฃแ แแ แแจแ แแแแแชแแแแแแ แแแแฃแจแแแ แแแแฅแแแฃแ แ แกแฌแแแแ แแ แฎแแแแแแฃแ แ แแแขแแแแฅแขแ แแแแแฎแแแก แแแกแขแ แฃแแแแขแแแแกแ แแ แแแแแแขแแแชแแแแแก แฃแคแ แ แคแแ แแ แแแแแแแฅแขแก (แแแแแก แจแแแฃแจแแแแแแแแ แแแแแแแขแแแฃแ แ แแแแแแแ แแแแก แแแ แแแแก แแ แแแกแขแ แแ แแแแแแ), แฃแคแ แ แแญแแแ แ แแแขแแแ แแชแแแก แงแแแแ แคแฃแแฅแชแแฃแ แแ แกแแแแแแ แแ แกแคแแ แแก แจแแ แแก, แแแแแแแแแก แแ แแแแแแแแแก แฃแคแ แ แแคแแฅแขแฃแ แแ แแแแแแแชแแแก. แแแแฅแแแแก แ แแกแฃแ แกแแแ.
แ แแแแฃแ แแ แแจแ แกแชแแแแ แ: แแแแแแก แขแฃแแแแแแแก แแแคแแฅแขแแแแก แแแแแแแแ แแแแก แแฆแแแ แแแ
แแแแแแ แซแแ แแ แแชแแกแแก แแแแขแ แแแแก แแ แแแแแก แแแแแแแแแก แแแแแงแแแแแ, แแแแแฎแแแแ แแแแแ แแขแฃแแ แแ แแแแแแ (แฉแแแ แฃแแแ แแฆแแแแจแแแ แแแแแแแแแ): แฉแแแ แฃแแแ แแฃแแ แฃแแแแแงแแ แ แแแแฃแ แแ แแจแ แขแฃแแแแแแแก แแแคแแฅแขแแแแก แแแแแแแแ แแแแก แแแแแขแแ แแแแ, แแ แแชแแกแแก แแแ แแแแขแ แแก แแแแจแแแแแแแแแแก แแแแแแแก แกแแคแฃแซแแแแแ. แแ แกแแ แแแแแขแ แแแ แกแแแแแแก แแแแแ แแจแแแ แแแแแแแแแแแ แแแคแแฅแขแแแแก แจแแกแแฎแแ.
แกแฃแ แแแ 2 แแ แแแแแแแก แคแแ แแฃแแแ แแแ แแแคแแฅแขแแแแก แแแแแแแแ แแแแก แแแแแขแแ แแแแแกแแแแก
แแ แแฅแขแแแแจแ แแ แแแแ แแแกแแฃแแ แแแแชแแแแแแก แฃแแ แแแแแกแแแแก แแแแแกแแแฃแ แแแ แแก แแ แแก, แ แแ แแแแแชแแแแ แแแฆแแแแก (APCS) แ แแแฃแแแ แฃแแแแ แแ แแคแแฅแขแฃแ แแแ แฃแแแ แแแแแฎแแแแแแแแก แกแฎแแแแแกแฎแแ แขแแแแก แแแคแแฅแขแแแแก แแแแแแแฃแ แ แแ แแ แแ แแแฃแแแ แฃแแ แฌแแ แแแจแแแแก (แแ แ แแแแกแขแ แแชแแแก) แคแแแแ. แกแฎแแ แกแแขแงแแแแแ แ แแ แแแฅแแแ: แแ แแชแแกแแก แแแแขแ แแแแก แกแแกแขแแแแก แแแแแชแแแแแ แแแแแก แฌแแแจแ แแ แแฎแแ, แกแฌแแ แ แแ แแฃแกแขแ, แฎแแแ แแแคแแฅแขแแแแก แจแแกแแฎแแ แจแแแแจแแแแแ แแแแแแแแ แฅแแแแฃแ แ แคแแแฅแ แแ, แกแแแแช แแแแแแแแฃแแแ แแแ แแฆแ แกแแฎแแแแกแแแจแ แแ แกแแแฃแ แแแแแ แ แแแฃแแจแ (แแแแแแแแแ: โ12.01 โ แแแแแแแ แกแแคแแ แจแ. แแ-3 แกแแแแกแ แแก แแฎแ แแแแโ).
แแแ แแแแ, แฉแแแ แจแแแแแซแแแ แแแแแแแขแแ แแ แแแแแแแก แคแแ แแฃแแแ แแแ แจแแแแแแ แแแแจแแแแแแแแแ แจแแแฆแฃแแแแ: แฉแแแ แแแแฅแแก แแแแแ แแขแฃแแ แขแแแแก แแแคแแฅแขแแก แแฎแแแแ แแ แแ โแแขแแแแขแแ แแแโ (แแแฃ แแแแแ แแขแฃแแ แขแแแแก แแแคแแฅแขแแก แแแแแแแแ แฌแแ แแแแแแแแแแ แแ แแชแแกแแก แแแแขแ แแแแก แแแแแชแแแแแแ. แกแแกแขแแแ แแแแแ แแขแฃแ แแแ แแฆแแ - แแ แแ แแแแแ แแขแฃแแ แขแแแแก แแแคแแฅแขแแก แแแขแ แแแแแแแแแแ แแ แแแแฅแแก). แแก แจแแแฆแฃแแแ แแแจแแแแ แแแแแแแงแแแก แแแแกแแแฃแ แ แแแแฅแแแแแแชแแแแแแแแก แคแแ แแแแแก แแแ แแ (แแแแแแฎแแแแแแแแแแ แกแฌแแแแแแ), แ แแกแแแแกแแช แแแแ แ โแขแแแโ แฃแแแ แแงแแก.
แกแฃแ แแแ 3 แแแคแแฅแขแแแแก แแแแแแแแ แแแแก แแแแแขแแ แแแแแก แแแแชแแแแก แแแ แแแแแ
แจแแแแแซแแแ แ แแแแ แแ โแแแแแแ แแแแแโ แฉแแแแก แฎแแแ แแ แกแแแฃแแ แแ แแแแแ แแ โแขแแแโ? แฒแแแฎ แฉแแแ แจแแแแแซแแแ. แขแฃแแแแก แแแแแแแแแแแ แแแแแแแ แแแแ แฎแแกแแแแแแแ แ แแแแกแขแ แแ แแแฃแ แแแคแแฅแขแแแแแ แแกแแแแกแแแแก แฎแแ แแกแฎแแ. แ แแแแแแแแ แแแ แแแแแแแแแก แแแแแงแแแแแแก แแแ แแจแแช แแ, แแแแฃแแแฃแ แ แแฆแฅแแแก แแแแแแ, แแ แแชแแกแแก แแแแขแ แแแแก แกแแกแขแแแแแแ แแแแแแแแ แ แแแแแชแแแแ แแแแจแแแแแแแแแแก แแแแแแแแแก แแแแแแ แแแแแ, แฃแแแ แจแแแแซแแแแ แแแแ แ แ แแแแก แกแฌแแแแ:
แกแฃแ แแแ 4 แขแฃแแแแก แแแแแแแ แแแแแก แแแแแแแแ แแแชแแแฃแแ แขแแแแก แแแคแแฅแขแแก โแแแจแแแกโ แคแแแแ
แแแแ แแ แแแแฃแแแฃแ แ แแฆแฅแแ (แงแแแแ แจแแแแฎแแแแแจแ, แแฎแแ) แแ แแ แแก "แขแแแแแแก" แงแแแแแแ แจแแกแแคแแ แแกแ แแแแแ แแขแแ แ แฉแแแแก แกแฌแ แแคแแ แชแแแแแแแ แกแชแแแแ แจแ. แฉแแแ แจแแแแคแแกแแแ แแ แกแแแฃแแ แขแฃแแแแก แแแแแแแ แแแแแก แแกแแแแกแแแแก แแแฎแกแแแแแฃแ แแแคแแฅแขแแแแแ แกแขแแขแแกแขแแแฃแ แ แขแแกแขแแก แแแแแงแแแแแแ.
แกแฃแ แแแ 5 แกแขแแขแแกแขแแแฃแ แ แขแแกแขแแก แแแแแงแแแแแ แจแแแแแแแแ แแแแแชแแแแแแ แแแคแแฅแขแแก โแแขแแแแขแแกโ แคแแแแ
แกแขแแขแแกแขแแแฃแ แ แขแแกแขแ แแแแกแแแฆแแ แแแก แแแแแแแแแก, แ แแ แฉแแแแฌแแ แแแ แขแแฅแแแแแแแฃแ แ แแ แแชแแกแแก แแแ แแแแขแ แแแแก แแแแจแแแแแแแแแแ แแ แแชแแกแแก แแแแขแ แแแแก แกแแกแขแแแแแแ แแแฆแแแฃแ โแแแแแแแก แแแแแขแจแโ แแกแแแแกแแ แแแ แแแแฃแแ แขแแแแก แแแคแแฅแขแแก โแขแแแแกโ แฉแแแแฌแแ แแแแแ. แแแแแแแแแก แแแแจแแแแแแแ (แกแขแแขแแกแขแแแฃแ แ แแกแแแแกแแแแก แแแแแฅแกแ), แ แแแแแแช แแแแแแแแแแแ แกแขแแขแแกแขแแแฃแ แ แขแแกแขแแก แแแแแงแแแแแแก แจแแแแแแ, แแแ แแแแฅแแแแแ 0 แแ 1 แแแแจแแแแแแแแ, แ แแช แฎแแแแ แแแแฅแแแฃแ แ แกแฌแแแแแแแก โแแขแแแแขแโ แแกแแแแกแแแแแ แจแแแแฌแแแแฃแ แแแแแขแจแ แแแแแแฃแ แแแแแ แแขแฃแ แฉแแแแฌแแ แจแ. แแแฃ, แขแฃแแแแก แแแแแแแ แแแแแก แฉแแแแฌแแ แแแแก แแฎแแแ แแแฆแแแฃแแ แแแแแขแแก แกแขแแขแแกแขแแแฃแ แ แขแแกแขแแ แแแแฃแจแแแแแแก แจแแแแแ, แฉแแแ แแแแฅแแก แจแแกแแซแแแแแแแ (แ) แแแแแแแขแแ แแก แแแแแขแ AI/ML แแแแแแแก แขแ แแแแแแแแแก แกแแกแฌแแแแ แแแแแแแฅแขแจแ แแ (แ) แแแแแแฎแแ แชแแแแแ แฎแแ แแกแฎแแก แแแแขแ แแแ. แแแแแแแก แแแแแแแแ แ แแแ แกแแ แแ แแแแแขแจแ แแแแแงแแแแแแกแแก.
แกแฃแ แแแ 6 แแแแฅแแแฃแ แ แกแฌแแแแแแแก แแแแแแแก แแแแแงแแแแแ แจแแแแกแฃแ แแแแแชแแแแแแ แแแคแแฅแขแแก โแแขแแแแขแแกโ แคแแแแ
แแ แ-แแ แ แฉแแแแก แฌแแแ
แกแฃแ แแแ 7 AI/ML แแแแแแแแแแแก แ แแแแขแแแแชแแ InterSystems IRIS-แจแ
แแฃ แกแแญแแ แแ แแ แแแแแ แ โแแแแ แ แแแ แโ InterSystems IRIS-แจแ แแแแแแฃแ แ แแแแแแแแแแแก แแ แแก แแแฆแแแฃแแ แแแแแแแแแแก แฎแแ แแกแฎแแ, แแฅแแแแแ แกแแแแแกแฃแแขแแชแแ แแ แแชแแกแ, แ แแแ แจแแแกแ แฃแแแก แแแแแแแแแก แขแ แแแแแแ แแ แแแแแงแแแแแ แแแแขแ แแแแก แแแแแชแแแแ แแแแแแ แฆแ แฃแแแแแแแ แกแแ แแแกแแแแก แแแแแงแแแแแแ (แแแแแแแแแ, Microsoft Azure, Amazon แแแ แกแแ แแแกแแแ, Google Cloud Platform แแ แ.แจ.):
แกแฃแ แแแ 8 แแแแ แ แแแกแแแ แแแ Microsoft Azure-แแแ, แแ แแแกแขแ แแ แแแฃแแ InterSystems IRIS-แแก แแแแ
แฉแแแแ แกแชแแแแ แแก แแ แแขแแขแแแ InterSystems IRIS-แจแ แจแแฅแแแแแแ, แ แแแแ แช แแแแแขแแ แแแคแฃแซแแแแฃแแ แแแแแแขแแแฃแ แ แแ แแชแแกแแแแก แกแแกแขแแแ, แ แแแแแแช แฃแ แแแแ แแฅแแแแแแก แแฆแญแฃแ แแแแแแแก แแแแแฅแขแแแ (แขแฃแแแ), แแแแแแแขแแแฃแ แ แแแแแแแ แแแแก แแแ แแแแกแแแ (Python, R แแ Julia) แแ แฃแแ แฃแแแแแงแแคแก แงแแแแ แฉแแ แแฃแแ AI/แแแแแแแแแแฃแแแแแก แกแฌแแแแแก. ML แแแฅแแแแแแแแ - แ แแแแฃแ แแ แแจแ แแแแแชแแแแ แแแแแแแแแ.
แกแฃแ แแแ 9 แ แแแแฃแ แแ แแจแ AI/ML แแแแแฌแงแแแขแแก แซแแ แแแแแ แคแฃแแฅแชแแแแแแแแ InterSystems IRIS-แจแ
แฉแแแแ แแ แแขแแขแแแแก แแ แแฅแขแแแฃแแ แจแแแแแ:
- แแแแแแแก แแแแ แแฆแแแ แแแฃแแ แแแแฃแจแแก แแแคแแฅแขแ (12 แแแแแแ แ):
- แแแแแแแก แแแแ แแฆแแแ แแแฃแแ แแแแแแแแ แแแแแ แแแคแแฅแขแ, แ แแแแแแช แแ แแงแ แจแแขแแแแแ แแแแฃแจแจแ (11 แกแแฅแขแแแแแ แ, แแแแแ แแแคแแฅแขแ แกแแ แแแแแขแ แฏแแฃแคแแ แแแแแแแแแแ แแฎแแแแ แแ แ แแฆแแก แจแแแแแ, 13 แกแแฅแขแแแแแ แก):
แ แแแแฃแ แ แแแแแชแแแแแแก แกแแแฃแแแชแแแ, แ แแแแแแช แจแแแชแแแก แแ แแ แแ แแแแแ แแแคแแฅแขแแก แ แแแแแแแแ แแแแแแแก, แแฉแแแแ, แ แแ InterSystems IRIS แแแแขแคแแ แแแแ แแแแแ แแแแ แฉแแแแ แแแแแฌแงแแแขแ แกแแจแฃแแแแแแก แแแแซแแแแก แแแแแกแแแฆแแ แแ แแ แขแแแแก แแแคแแฅแขแแแแก แแแแแแแแ แแแ แกแแ แแแแแขแ แฏแแฃแคแแก แแแแ แแแ แแแแแแแแแแแแ แ แแแแแแแแ แแฆแแ แแแ แ.
InterSystems IRIS - แฃแแแแแ แกแแแฃแ แ แ แแแแฃแ แแ แแจแ AI/ML แแแแแแแแแแ แแแแขแคแแ แแ
InterSystems IRIS แแแแขแคแแ แแ แแแแ แขแแแแแก แแแแแชแแแแ แ แแแแฃแ แแ แแจแ แแแแแฌแงแแแขแแแแแแแแก แจแแแฃแจแแแแแแก, แแแแแ แแแแก แแ แคแฃแแฅแชแแแแแ แแแแก. InterSystems IRIS-แก แจแแฃแซแแแ แแ แแแ แแฃแแแ แแแแแฎแแ แชแแแแแก แขแ แแแแแฅแชแแฃแแ แแ แแแแแแขแแแฃแ แ แแแแแชแแแแ แแแแฃแจแแแแแ; แแแแแชแแแแ แกแแแฅแ แแแแแแแฃแแ แฎแแแแแแก แแฎแแ แแแญแแ แ แแ แแแแแ แแแแแแแก แแแฎแแแแแ (แแแ แจแแ แแก แ แแแแชแแฃแ แ, แแแ แแ แฅแแฃแแ, แแแแแฅแขแ แแ แแแแฃแแแแขแ); แแแแฅแแแแแก แ แแแแ แช แแแแขแคแแ แแ แแแแแชแแแแ แฌแงแแ แแแแแก แคแแ แแ แกแแแฅแขแ แแกแ แแ แแแแแแแแฃแแแฃแ แ แแแแแแแชแแแแแก แแแขแแแ แแ แแแแกแแแแก; แฃแแ แฃแแแแแงแแก แแแคแแ แแแแแฃแแ แ แแแแฃแ แแ แแจแ แแแแแแขแแแ แกแขแ แฃแฅแขแฃแ แแ แแแฃแ แแ แแ แแกแขแ แฃแฅแขแฃแ แแ แแแฃแ แแแแแชแแแแแแ. InterSystems IRIS แแกแแแ แฃแแ แฃแแแแแงแแคแก แแแ แ แแแแแแขแแแฃแ แ แฎแแแกแแฌแงแแแแแก แแแแแงแแแแแแก แแแฅแแแแแแแแก แแ แแซแแแแ แฆแ แฃแแแแจแ แแ แแแแแแแแ แแ แกแแ แแแ แแแแ แฐแแกแขแแแแแก แแแฅแแแ แแแแแแแแชแแแก.
InterSystems IRIS แแแแขแคแแ แแแแ แแแแแฃแแ แแแแแแแชแแแแ แแแแแแแแแฃแแแ แกแฎแแแแแกแฎแแ แแแแฃแกแขแ แแแจแ, แ แแช แแฎแแแ แแแ แแแแแแแแแแก แแแแชแแแแแแ แแ แแแแจแแแแแแแแแ แแแแแแแแแฃแ แ แกแแ แแแแแแ แกแขแ แแขแแแแฃแแ แแ แแแแ แแขแแฃแแ แแแ แกแแแฅแขแแแแแแ, แแแแแ แแแ แแแคแแ แแแ แแแฃแแ แแแแแฌแงแแแขแแแแแแแแก แแแฆแแแ แแ แฎแแแแก แฃแคแกแแ แฃแแ แแแแแแแแแก, แแแแแแแกแ แแ แแแฅแแแแแแแก แจแแ แแก.
แกแฃแ แแแ 10 InterSystems IRIS แแ แฅแแขแแฅแขแฃแ แ แ แแแแฃแ แแ แแจแ AI/ML แแแแขแแฅแกแขแจแ
แฌแแแ แแแแแ แแแแก แแกแแแแกแแ, แฅแแแแแ แแแชแแแฃแแ แแแแแ แแแ แแแ แแแแแแแก แแฎแแ โแแแแ แแแแแขแแ แกแแกแขแแแแกโ (CD/CI/CT) แแแแขแคแแ แแแก แกแแแฃแจแแ แแแแแแแขแแแก แจแแ แแก แแแคแแ แแแชแแแก แแแแแแแก แแแแแ แแแแกแแแ. แแแแฃแแแแแแชแแ แแฌแงแแแ แแแแ แแแแฅแแแแแฃแ แ CD-แแ แแ แแ แซแแแแแแ แแแแ แแแแฅแแแแแแ CI แแ CT.
แกแฃแ แแแ 11 แแแคแแ แแแชแแแก แแแแแแแแแก แแแแแ แแแ InterSystems IRIS แแแแขแคแแ แแแก AI/ML แแแแแแแขแแแก แจแแ แแก
CD แแแฅแแแแแแแก แแ แกแ InterSystems IRIS-แจแ: แแแแขแคแแ แแแก แแแแฎแแแ แแแแแแ (AI/ML แแแแแฌแงแแแขแแแแแแแแก แแแแแแแแแ แแแ) แแแแแขแแ แแแแ แแ แกแแแฃแ แแ/แแ แฅแแแแแ แแฎแแ AI/ML-แแก แแแแแแแแ แแแแก AI/ML แแแฅแแแแแแแแแกแแแแก แกแแแชแแแแแแแแฃแแ แแแแแก แ แแแแฅแขแแ แแก แแแแแงแแแแแแ: Jupyter (แกแ แฃแแ แกแแฎแแแ: Jupyter Notebook; แแแแแแ, แแ แ แแแแฅแขแแ แจแ แจแแฅแแแแ แแแแฃแแแแขแแแก แแแแฏแแ แฃแฌแแแแแแ). Jupyter-แจแ, แแแแแแแแแ แก แแฅแแก แจแแกแแซแแแแแแแ แแแฌแแ แแก, แแแแแ แแแก แแ แแแแแแแแฌแแแก แแแแแ แแขแฃแแ AI/ML แแแแแแแแ แแแแก แจแแกแ แฃแแแแ (แแ แแคแแแแก แแแแแงแแแแแแ), แกแแแแ แแก แแแแแแแกแแแแ (โแแแแแแแแแแโ) InterSystems IRIS-แจแ. แแแแแแแ, แ แแ แแ แแแแ แจแแฅแแแแแ แแฎแแแ แแแแแแแแ แแแ แแแแฆแแแก แแฎแแแแ แซแแ แแแแ แแแแแ แแแแก (แ แแแแแ, แแแ แซแแ, แแฃแแแขแแ แ แแ แแฃแจแแแแก แ แแแแฃแ แแ แแจแ แแแแแชแแแแ แแแแแแแแแแ) - แแก แแ แแก แฌแแกแ แแแจแ, แ แแแแแ แแฃแแแขแแ แจแ แแแแแแแแ แแแแก แแแแแแ แ แจแแแแแแ. แแ แแก แชแแแแแฃแแ AI/ML แแแฅแแแแแแแก แคแฃแแแแแแแขแฃแ แ แคแฃแแฅแชแแแแแ แแแแก แแแแแกแขแฃแ แแแ (โแแแแฉแแแแแแก แแแกแแแแแแแ แจแแแแแก แแแแแชแแแแ แแแแฃแจแแโ). แแแแแแแแฃแ แแ, แแแฅแแแแแแ, แ แแแแแแช แฃแแแ แแแแแแแกแแแฃแแแ แแแแขแคแแ แแแจแ (แแฎ. แจแแแแแแ แแแแ แ แแแฅแแแแแแแแ) Jupyter-แจแ แแแแแ แแแแแแ, แจแแแซแแแแ แแแแแฎแแแแก โแแแแ แฃแแแแโ โแฌแแแแกแฌแแ แแแแขแคแแ แแแแโ (แคแแแแแแแ แแแแแชแแแแแแก แแแแฎแแ, แแแแแชแแแแแแ แแฃแจแแแแ xDBC-แแก แแแจแแแแแแ แชแฎแ แแแแแแก แแแชแแแแ, แแแ แแแแแ แ แฃแ แแแแ แแฅแแแแแแ แแแแแแแแแแแ - แแแแแชแแแแ แแ แแแแแแแแแแแแแแแแแแ แแแกแแแแแ InterSystems IRIS โ แแ แ.แจ.).
CD-แแก แแแแแ แแแแก แแแแจแแแแแแแแแ แแกแแแฅแขแ InterSystems IRIS-แจแ: แแ แแฎแ แแแ แแแขแแแ แแชแแ แแแแฎแแ แชแแแแแ แแแแขแคแแ แแแกแ แแ Jupyter-แก แจแแ แแก, แ แแช แกแแจแฃแแแแแแก แแซแแแแก Python-แจแ, R-แกแ แแ Julia-แก แแแแขแแแขแก แแแแแแขแแแแก แแแแขแคแแ แแแแ (แแ, แจแแแแแแแจแ, แแแแฃแจแแแแแก แแแแขแคแแ แแแแ) (แกแแแแแ แแ แแก แแ แแแ แแแแ แแแ. แแแแแ แจแแกแแแแแแก แฌแแแงแแแ แฆแแ แแแแแจแ). แฌแงแแ แแก แแแแแแแขแแแฃแ แ แแแแแแแ แแแแก แแแ แแแ). แแแ แแแแ, AI/ML แแแแขแแแขแแก แแแแแแแแแ แแแก แแฅแแ แจแแกแแซแแแแแแแ แแแแแฎแแ แชแแแแแ แแ แแแแขแแแขแแก โแฃแฌแงแแแขแ แแแแแแแแแโ แแแแขแคแแ แแแแ, แแแฃแจแแแ แแแ แแแชแแแ Jupyter แ แแแแฅแขแแ แจแ, แแแชแแแ แแแแแแแแแแแแแแ, แ แแแแแแแช แฎแแแแแกแแฌแแแแแแ Python, R, Julia-แจแ แแ แแแแแฎแแ แชแแแแแ แซแแ แแแแแ แแแแแ แแแ (แกแแญแแ แแแแแก แจแแแแฎแแแแแจแ). แแแแขแคแแ แแแก แแแ แแ.
แแแแแ แแแแแแแแแ CI แแแแ แ แแแฅแแแแแแแ InterSystems IRIS-แจแ. แแแแแ แแแ แแแแฉแแแแแแก "แ แแแแฃแ แแ แแจแ แ แแแแขแแแแขแแ แแก" แแแแ แ แแ แแชแแกแก (แแแแแชแแแแ แกแขแ แฃแฅแขแฃแ แแแแก, แแแแแแก แแ แแชแแกแแแแก แแ แแแแแก แคแ แแแแแแขแแแแก แแแแแแแฅแกแ, แ แแแแแแช แแแ แแแแ แแแฌแงแแแแแแ แแแแแแแขแแแฃแ แ แแแแแแ แแ ObjectScript - InterSystems IRIS-แแก แแแแแแแแ แแแแก แแจแแแแแฃแ แแแแแ). แแ แแแแ แ แแ แแชแแกแแก แแแแชแแแแ แจแแแแแ แฉแฃแแแก AI/ML แแแฅแแแแแแแแแก แคแฃแแฅแชแแแแแ แแแแกแแแแก แกแแญแแ แ แแแแแชแแแแ แ แแแแแ (แแแคแฃแซแแแแฃแแ แแแแแชแแแแ แแแแแแแแแ, แ แแแแแแแช แแแแแแชแแแ แแแแขแคแแ แแแก แ แแแแฃแ แแ แแจแ), แแแแฆแแก แแแแแฌแงแแแขแแแแแแแ แแแแแชแฎแแแแก แแแแแแแแแแ แแแแกแ แแ AI/ แแกแแ แขแแแแแขแแก แจแแกแแฎแแ. ML แแแฅแแแแแแแแ (แแกแแแ แแกแแแ แแ แแก โแแแแแแแขแแแฃแ แ แแแแแ แแแแแแโ, โแแแแแแแแโ โโแแ แ.แจ. โ แจแแแซแแแแ แแแแกแฎแแแแแแฃแแแ แแฌแแแแก แแแแฎแแ แชแแแแแแแก แกแแแชแแคแแแแแแ แแ แขแแ แแแแแแแแแฃแ แ แแ แแคแแ แแแชแแแแแแแ แแแแแแแแแแ แ), แแแแแแฎแแแแก แแแแแชแแแแ แกแขแ แฃแฅแขแฃแ แแแก แฎแแแแแแฃแ แ แแแขแแแแฅแขแแก/ แแฃแจแแแแแก แจแแแแแแแแก แแแกแแแแแแแแแแแแ. ML แแแฅแแแแแแแแ (แแฃแแแแ, แชแฎแ แแแแแ, แแแแแชแแแแ แแ แแแแแแแแแแแแแแแแแแ แแแกแแแแแ แแ แ.แจ.) แแ แ.แจ. โ แแแฎแกแแแแแแแแกแแแแก, แแแคแแแแกแแแแก แแ แ.แจ.).
InterSystems IRIS-แจแ CI แแแแฎแแ แชแแแแแแแก แแแแจแแแแแแแแแ แแกแแแฅแขแ: แแ แแฎแ แแแ แแแขแแแ แแชแแ แแแแฎแแ แชแแแแแ แแแแขแคแแ แแแกแ แแ แแแแแแแขแแแฃแ แ แแแแแแแ แแแแก แแแ แแแแก แจแแ แแก, แ แแช แกแแจแฃแแแแแแก แแแซแแแแ แจแแแกแ แฃแแแ แแแแขแคแแ แแแจแ แแแแแแแกแแแฃแแ แจแแแแแ แกแ Python-แจแ, R-แจแ แแ Julia-แจแ แแแ แจแแกแแแแแแก แแแ แแแแจแ แแ แแแแฆแแ แฃแแแ แจแแกแ แฃแแแแแก แจแแแแแแแ. แแก แแแขแแแ แแชแแ แแแแฎแแ แชแแแแแแฃแแแ แ แแแแ แช โแขแแ แแแแแแแก แ แแแแแจแโ (แแแฃ, AI/ML แแแแขแแแขแ แฉแแแแงแแแแแแแฃแแแ แ แแแแ แช ObjectScript แแแแ, แ แแแแแแช แ แแแแแก แแแ แแแแจแ) แแ โแแแแแแก แแ แแชแแกแแก แ แแแแแจแโ (แแแฃ AI/ML แแแแขแแแขแ แฉแแแแงแแแแแแแฃแแแ แ แแแแ แช แแแแแแก แแ แแชแแกแ. แแ แแคแแแฃแแ แ แแแแฅแขแแ แแก แแแแแงแแแแแแ, แแ แแแแฏแแ Jupyter-แแก แแแแแงแแแแแแ, แแ IDE-แแก แแแแแงแแแแแแ - IRIS Studio, Eclipse, Visual Studio Code). Jupyter-แจแ แ แแแแฅแขแแ แแแแกแแแแก แแแแแแก แแ แแชแแกแแแแก แฎแแแแแกแแฌแแแแแแแ แแแกแแฎแแแ IRIS-แก แจแแ แแก CI แแแแแแ แแ Jupyter-แก แจแแ แแก CD แแแแแแ. แแแแแแแขแแแฃแ แ แแแแแแแ แแแแก แแแ แแแแกแแแ แแแขแแแ แแชแแแก แฃแคแ แ แแแขแแแฃแ แ แแแแแฎแแแแ แแแชแแแฃแแแ แฅแแแแแ. แแ แแขแแแแ, แฉแแแแ แแแ แแ, แแ แกแแแแแก แงแแแแ แกแแคแฃแซแแแแ แแแแก แฃแแ แฃแแแแแกแแงแแคแแ, แ แแ แแแแขแคแแ แแแก แฐแฅแแแแแก แงแแแแ แกแแญแแ แ แแแกแขแ แฃแแแแขแ AI/ML-แแก แแแแแแแแ แแแแแ โแฃแฌแงแแแขแ แแแขแแแ แแชแแแกโ แแแแกแแฎแแ แชแแแแแแแแ (แแแแแแแแ แแแแก โแฃแฌแงแแแขแ แแแแแแแแแแแแโ) แ แแแแฃแ แแ แแจแ AI/ML แแแแแฌแงแแแขแแแแแแแจแ.
แแ แแแแแแ แ แแแแ แ แแแฅแแแแแแ: CT. แแแแก แแแ แแจแ แแ แแแ แกแแแแแก AI/ML แแแแขแคแแ แแ (แแฃแแชแ โแ แแแแฃแ แ แแ แโ แแแแฎแแ แชแแแแแแแ CD/CI-แแก แกแแจแฃแแแแแแ). CT-แแก แแ แกแ แแ แแก แแแแขแคแแ แแแก แแฃแจแแแแ แแแแฅแแแแแแชแแแแแแแแก แแ แฎแแแแแแฃแ แ แแแขแแแแฅแขแแก โแแ แขแแคแแฅแขแแแแแโ แฃแจแฃแแแแ แแแแแแแขแแแฃแ แ แแแแแแแ แแแแก แแแ แแแแก แกแแแฃแจแแ แกแแกแแแแจแ: แแแแแแแแ, แแแแแฌแแแแแแก แชแฎแ แแแแแ, แแแขแ แแชแแก แแแฅแขแแ แแแ, แแแ แแฃแแ แฅแกแแแแแแก แคแแแแแ แแ แ.แจ. แแก "แแแแฃแจแแแแ แ", แฃแแแขแแก แจแแแแฎแแแแแจแ, แแแแชแแแก แแฆแแแจแแฃแแ แแ แขแแคแแฅแขแแแแก แจแแฅแแแแก แแแ แแแแจแ (แแแแแแแแแ, แแแแแแแแแก แจแแแแฎแแแแแจแ, "แจแแฅแแแ" แแแแชแแแก แแแแแแแก แกแแแชแแคแแแแชแแแก แแแงแแแแแแก แแ แแแกแ แแแ แแแแขแ แแแแก แแแแจแแแแแแแแแแก แจแแแแแแ แจแแ แฉแแแแก - แแแแแแแก แแแ แแ แฌแแแแแฃแแ โแกแฌแแแแแแโ), แแแแ แแแแแงแแแแแ (แแแแแแแแแกแแแแก: แแแแ แแแฎแแแ แแแแ แกแแแแแแ แชแแแแแแแแก โแแแแแแฃแ แโ แแแแจแแแแแแแแแแก แแแแแแแแ - แแ แแแแแแแแ, แแแขแแแแ แแแก แฌแแแ แแแ, แแแแแแแแก แแแแแแแแ แแ แ.แจ.) แแ แฃแแแ แแแฃแแฏแแแแกแแแ. แจแแฅแแแแแ แแ แแแแแงแแแแแฃแแ แแ แขแแคแแฅแขแแแ (แแแแแแแแแ, แแแแแแแก แจแแงแแแแแก แชแแแแแแแแก แแแแ แแแแก แฎแแแแฎแแแ แแแแกแแแฆแแ แ แแแแแชแฎแแแแก แจแแแแแแแแ แแแงแ แแแแแแ - แแ แแแแแแแ แแแแก แกแแแฃแกแขแแก แแแกแแฃแแฏแแแแกแแแแแ, แ แแแแ แช แแแ แแแแขแ). CT-แแก แ แแแแก แแแแแแแจแ แแแแแแ แแ แแแกแ โแแแกแขแ แแฅแชแแโ CD แแ CI-แแก แ แแแแแแแแแ: CT แแแแแฎแแ แชแแแแแแก แงแแแแ แแ แขแแคแแฅแขแก, แคแแแฃแกแแ แแแฃแแ แแฅแแแแ AI/ML แแแแแฌแงแแแขแแก แแแแแแแแแ แแ แแแแแแแขแแแฃแ แกแแแชแแคแแแแแ, แกแแแชแแคแแแฃแ แ แแแ แแแแก แจแแกแแซแแแแแแแแแแก แคแแ แแแแแจแ. แแแกแฃแฎแแกแแแแแแแแ โแจแแงแแแแแก แแแฌแแแแแแแโ แแ โแแแแแแแแแแ แจแแแแแแแแก แแแฌแแแแแแแโ แแฅแแแแ CD แแ CI-แแก แแแกแฃแฎแแกแแแแแแแแ.
CTโแแก แแแแแ แแแแก แแแแจแแแแแแแแแ แแกแแแฅแขแ แแแแแ แแขแฃแแแ InterSystems IRISโแจแ: แแแแแแแขแแแฃแ แ แแแแแแแ แแแแก แแแ แแแแกแแแ แแแขแแแ แแชแแแก แแแแแงแแแแแแ, แ แแแแแแช แฃแแแ แแฆแแแแจแแแ, แแแแขแคแแ แแแก แแฅแแก แฃแแแ แ แแแแแฆแแก แกแฌแแ แแ แแก แแ แขแแคแแฅแขแแแ แกแแแฃแจแแ แกแแกแแแแแแแ, แ แแแแแแแช แแแแแแแแ แแแแก แแแก แแแแขแ แแแแก แฅแแแจ แแแแแแแขแแแฃแ แ แแแ แแแแจแ แแ (แ แแช แแแแแแ แแ) แแแแแฎแแแแ. แแกแแแ แแแแขแคแแ แแแก แแแแแชแแแแ แแแแแฅแขแแแแ. แแแแแแแแแ, แแแแแฌแแแแแแก แชแฎแ แแแ, แ แแแแแแช แแฎแแแฎแแ แจแแแฅแแแ แแแแแแแก แกแแแฃแจแแ แกแแกแแแแ, แจแแแซแแแแ (แแแแแแแก แกแแกแแแก แจแแฉแแ แแแแก แแแ แแจแ) แแแแแแแแแก แแแแขแคแแ แแแแ, แแแแแแแแแ, แแแแแแแฃแ แ (แแ แแแแแแแแแแแแแแแแแแ InterSystems IRIS แแแแแชแแแแ แแแกแแแแก) แกแแฎแแ - แแ แแแแแงแแแแแฃแแ แแฅแแแก. แกแฎแแ AI/ML- แแแฅแแแแแแจแ (แแแแฎแแ แชแแแแแแฃแแ แกแฎแแ แแแ แแแแก แแแแแ - แแแแแแแแแ, R-แจแ) - แแ แแแ แขแฃแแแฃแ แชแฎแ แแแจแ แแแแแแแแแแแกแแแแก. แแแแแ แแ แแ แแแแแแแแ: แแแแแแแก แแฃแจแแแแแก โแแแ แแแแฃแ แ แ แแแแแแกโ แแแ แแแแแฃแ แแ (แแแแแแแก แกแแแฃแจแแ แกแแกแแแแ), โแแแขแ-MLโ แฎแแ แชแแแแแแแ แแแก แจแแงแแแแแก แแแแแชแแแแแแ: แแแขแแแแแฃแ แ แจแแงแแแแแก แชแแแแแแแแก แแแขแแแแขแฃแ แ แจแแ แฉแแแ แแ แแแ แแแแขแ แแก แแแแจแแแแแแแแแ. แแ "แ แแแฃแแแ แฃแ" แขแ แแแแแแแแ แแ แแแ, แแ แแแฃแฅแขแแฃแแ แแแแแแ แ แแแแฃแ แแ แแจแ แแกแแแ แแฆแแแก "แฌแแแแแแแแแแก แแแขแแแแแแชแแแกแแแแก" แแแกแ แกแแแชแแคแแแแชแแแก - แ แแแแแจแแช แแชแแแแแ แจแแงแแแแแก แชแแแแแแแแก แแแแ แแแ, แแชแแแแแ แแแ แแแแขแ แแก แแแแจแแแแแแแแแ (แแฆแแ แฎแแแแ แขแ แแแแแแแก แจแแแแแแ. แแแแแแจแ, แแแแ แแ แแแ แฏแแจแแก แจแแแแแแ แกแแแฃแแแ แ แแแแแก โแแแขแแ แแแขแแฃแแโ แแแ แกแแแ, แ แแแแ แแชแแ H2O แกแขแแแ), แ แแแแแแช แกแแจแฃแแแแแแก แแซแแแแก แกแแแ แแ AI/ML แแแแแฌแงแแแขแแก แแแแแฃแแแแแแแแ แแแฃแแแแแแแแก แจแแงแแแแแก แแแแแชแแแแแแกแ แแ แแแแแแแ แแแฃแแ แคแแแแแแแแแแก แแฃแแแแแจแ แแแฃแแแแแแ แชแแแแแแแแแก. .
แแแแแ แฃแคแ แ แแแขแแแฃแ แแ แแแแแชแแแ InterSystems IRIS-แแก แแแแขแคแแ แแแก AI/ML แคแฃแแฅแชแแแแแแฃแ แแแแก, แ แแแแฃแ แ แแ แแขแแขแแแแก แแแแแแแแแ.
แฅแแแแแ แแแชแแแฃแ แแแแแ แแแแแ, แกแแแแแแก แแแ แชแฎแแแ แแฎแแ แแก แแ แแก แแแแแแก แแ แแชแแกแแก แแแฌแแแ, แ แแแแแแช แแฎแแ แชแแแแแแก แกแแ แแแขแแแแก แจแแกแ แฃแแแแแก Python-แจแ แแ R-แจแ. แชแแแขแ แแแฃแ แแแฌแแแจแ แแ แแก แแ แกแแ แแแขแแแแก แแแแแแ แแ แจแแกแ แฃแแแแแก แแแแฃแแแฃแ แ แแฃแ แแแแ, แจแแกแแแแแแกแแ, Python-แจแ แแ R.-แจแ แแแฃแงแแแแแแแแ แแแ แฃแแแ แแแแแแกแแแฃแแแ แจแแแแแ แกแแก แแแแแแแแแแ แแแ แแ แแแแ แ แแแแแ, แแแแแขแแแแแ แจแแกแแกแ แฃแแแแแแ แจแแกแแแแแแก แแแ แแแแจแ. แแแแแก แแแ แฏแแแแ แแ แแก แแแแฃแแแแแแชแแ, แ แแแแแแช แแคแฃแซแแแแ แกแแ แแแขแแก แจแแกแ แฃแแแแแก แจแแแแแแแก. แแแแ แแแแฃแแแแแแชแแ แแแแแแแ IRIS Analytics-แแ (แแแแแชแแแแแ แแฆแแแฃแแ แแงแ Python-แแแ InterSystems IRIS แแแแแชแแแแ แแแแขแคแแ แแแแ แแ แแแฉแแแแแแ แแงแ แแแคแแแ แแแแขแคแแ แแแก แแแแแงแแแแแแ), แแแแแจแ แแแแแแแ แแแ แแแแแ R แกแแแฃแจแแ แกแแกแแแแ แแ แแฅแแแแ แแแแแแแแแแ แแ แแคแแแฃแ แคแแแแแแจแ. . แแแแจแแแแแแแแแ แแกแแแฅแขแ: แแ แแขแแขแแแจแ แฌแแ แแแแแแแแแ แคแ แแแแแแขแ แแแกแฃแฎแแกแแแแแแแแ แแแแแแแก แขแ แแแแแแแ (แแฆแญแฃแ แแแแแแแก แแแแแแแ แแแแแแแก แแแแกแแคแแแแชแแ) แแฆแญแฃแ แแแแแแแก แกแแแฃแแแขแแ แแก แแ แแชแแกแแแแ แ แแแแฃแ แแ แแจแ แแแฆแแแฃแ แแแแแชแแแแแแ, แแแแแแแก แแแแแงแแแแแแกแแก แแแคแแฅแกแแ แแแฃแแ แแแแกแแคแแแแชแแแก แฎแแ แแกแฎแแก แแแแแขแแ แแแแแก แแ แแชแแกแแก แแ แซแแแแแแ. แแแแฎแแแฃแแ แแฅแแแแ AI/ML แแแแแฌแงแแแขแแก แแแแแ แแแ แฃแ แแแแ แแฅแแแแแแแก แแ แแชแแกแแแแก (โแแแแแขแแแโ) แกแแฎแแ.
แกแฃแ แแแ 12 แฃแ แแแแ แแฅแแแแแแ แแแแแแแแ, R แแ แฏแฃแแแแกแแแ InterSystems IRIS-แจแ
แแแแขแคแแ แแแก แแ แแชแแกแแแ (แแกแแแ แแกแแแ แแ แแก โแแแแแแก แแ แแชแแกแแแโ, โแแแแแแขแแแฃแ แ แแ แแชแแกแแแโ, โแแแแกแแแแแแแโ แแ แ.แจ. - แแแแขแแฅแกแขแแแแ แแแแแแแแแแ แ), แฃแแแ แแแแแก แงแแแแแกแ, แ แแแแฅแขแแ แแแแ แแแแแ แแแแขแคแแ แแแก แแ แแคแแแฃแ แแแแแแก แแ แแชแแกแแแแก แ แแแแฅแขแแ แจแ แแ แแกแแ แจแแแแฎแแแแแจแ. แแกแ, แ แแ แแแกแ แแแแ-แกแฅแแแ แแ แจแแกแแแแแแกแ AI/ML แแแฅแแแแแแ (แแ แแแ แแแแก แแแแ) แแ แแแ แแฃแแแ แแฅแแแแแ. แ แแแแกแแช แฉแแแ แแแแแแแ, แ แแ โแแแฆแแแฃแแแ AI/ML แแแฅแแแแแแโ, แแแแแแแแ แแแแแ แแแฃแแแกแฎแแแแ แฐแแแ แแแแแแก (แแ แแ แแ แแชแแกแแก แคแแ แแแแแจแ): แแแแขแแแขแ แแแแแแแขแแแฃแ แ แแแแแแแ แแแแก แแแ แแแแก แแแแแจแ แแ แแก SQL-แแก แจแแแแแ แกแแก แแแแแแแแ แ (แแแ แจแแ แแก แแแคแแ แแแแแแแ).
แกแฃแ แแแ 13 แแแแฃแแแฃแ แ แแแ แแแ AI/ML แแแแแฌแงแแแขแแแแแแแแก แจแแแแแแแแแแแแกแแแแก InterSystems IRIS-แจแ
แ แแแแ แช แฃแแแ แแฆแแแแจแแแ, แแแแขแคแแ แแแจแ แฃแแแ แแแแแ แแแแ AI/ML แแแฅแแแแแแแแแก แกแแฌแงแแกแ แแแแแแแแ แแแ แแ (แแแแแแ แ แจแแแแฎแแแแแจแ) แแแแแขแแชแแ แแแฎแแแแ/แจแแแซแแแแ แแแแฎแแ แชแแแแแแก แแแแขแคแแ แแแก แแแ แแ Jupyter-แแก แ แแแแฅแขแแ แจแ. แฅแแแแแ แแแชแแแฃแ แแแแแ แแแแจแ แฉแแแ แแฎแแแแแ แแ แกแแแฃแแ แแแแขแคแแ แแแก แแ แแชแแกแแก แแแแแขแแชแแแก แแแแแแแแก (แแแแแ แ แแแแ แช แแแแแ แแแชแแแฃแ แแแแแ แแแแจแ) - แแกแ แแแแแแงแฃแ แแแ แคแ แแแแแแขแ, แ แแแแแแช แแแกแฃแฎแแกแแแแแแแแ แแแแแแแก แแแแแแแแแแแ แแฃแแแขแแ แจแ. แแแแแแแก แแแแขแแแขแ แฎแแแแแกแแฌแแแแแแ แ แแแแฅแขแแ แแแแกแแแแก, แแแแแ แแแแกแแแแก แแ แแ แแคแแแฃแแ แแแแแกแแกแแแแแแ แแแ แแแแแ Jupyter-แจแ. แชแแแแแแแแแ (แกแแญแแ แแแแแก แจแแแแฎแแแแแจแ) แจแแแซแแแแ แแแแฎแแ แชแแแแแแก แแแแขแคแแ แแแก แแ แแชแแกแจแ แแงแแกแแแ แ แกแแแฅแ แแแแแแชแแแก แแแแ, แแแกแ แแ แแแฃแฅแขแแฃแแ แแแ แกแแแก แฉแแแแแแ. แแฎแแแ แจแแแแแ แกแแก แแแแขแคแแ แแแแ แแแแแขแแแ แจแแกแแซแแแแแแแ แแแแแแแแฃแ แแ (แแฎแแแ แแแแขแคแแ แแแก แแ แแชแแกแ แแแขแแแแขแฃแ แแ แแแแแ แแ แแแฃแแแ).
แกแฃแ แแแ 14 Jupyter Notebook-แแก แแแแแงแแแแแแ AI/ML แซแ แแแแก แ แแแแฅแขแแ แแแแกแแแแก InterSystems IRIS แแแแขแคแแ แแแแ
แแแแขแคแแ แแแก แแ แแชแแกแแก แแแแแขแแชแแ แจแแแซแแแแ แแแแฎแแ แชแแแแแแก แแ แ แแฎแแแแ แแ แแคแแแฃแแ แแ แแแแขแแแแก แคแแ แแแขแจแ - แแ แแแแ "แขแแขแแแฃแ แ" IDE (แแแขแแแ แแ แแแฃแแ แแแแแแแแ แแแแก แแแ แแแ) แคแแ แแแขแจแ. แแก IDE แแ แแก IRIS Studio (แแจแแแแแฃแ แ IRIS แกแขแฃแแแ), Visual Studio Code (InterSystems IRIS แแแคแแ แแแแแ VSCode-แกแแแแก) แแ Eclipse (Atelier แแแแฃแแ). แแแแแแ แ แจแแแแฎแแแแแจแ, แจแแกแแซแแแแแแแ แแแแแแแแแ แฃแแแ แแฃแแแแ แแแแแแงแแแแก แกแแแแแ IDE แแ แแแ แแฃแแแ. แฅแแแแแ แแแชแแแฃแ แแแแแ แแแแแ แแแฉแแแแแแแ แแแแแ แแ แแชแแกแแก แ แแแแฅแขแแ แแแแก แแแแแแแแ IRIS studio-แจแ, Visual Studio Code-แจแ แแ Eclipse-แจแ. แแแกแแแฃแขแฃแ แแ แงแแแแ แแแแขแแแขแ แฎแแแแแกแแฌแแแแแแ แ แแแแฅแขแแ แแแแกแแแแก: Python/R/Julia/SQL, ObjectScript แแ แแแแแแก แแ แแชแแกแ.
แแแแแ แแแ 15 InterSystems IRIS แแแแแแก แแ แแชแแกแแก แแแแแแแแ แแแ แกแฎแแแแแกแฎแแ IDE-แแแจแ
แแแแกแแแฃแแ แแแฃแแ แแฆแแแจแแแแก แฆแแ แกแแ InterSystems IRIS แแแแแแก แแ แแชแแกแแแแก แแฆแฌแแ แแกแ แแ แจแแกแ แฃแแแแแก แแแกแขแ แฃแแแแขแแแ แแแแแแก แแ แแชแแกแแก แแแแแ (BPL). BPL แจแแกแแซแแแแแแก แฎแแแก "แแแ แแแขแแแ แแชแแแก แแแแแแแแแขแแแแก" (แแฅแขแแแแแแแแก) แแแแแงแแแแแแก แแแแแแก แแ แแชแแกแแแจแ - แ แแช, แคแแฅแขแแแ แแแแ, แงแแแแ แกแแคแฃแซแแแแก แแซแแแแ แแแแก แแฅแแ, แ แแ "แฃแฌแงแแแขแ แแแขแแแ แแชแแ" แแแแแ แแแแแ InterSystems IRIS-แจแ. แแแ แแแแแแก แแ แแชแแกแแก แแแแแแแแแขแแแ (แแฅแขแแแแแแแ แแ แแแ แจแแ แแก แแแแจแแ แแแ) แแ แแก แซแแแแ แ แแแแฉแฅแแ แแแแแ AI/ML แแแแแฌแงแแแขแแก แแฌแงแแแแกแแแแก. แแ แแ แ แแฎแแแแ แจแแแ แแแแแ: แแแ แจแแ แแก แแฅแขแแแแแแแแกแ แแ แแแแจแแ แแแแก แฌแงแแแแแแ AI/ML แแแแกแฎแแแแแแฃแ แแแแแแแแ แแแแกแ แแ แแแฅแแแแแแแแแแ แแแแแแจแแ แแแแ, แฌแแ แแแแฅแแแแแ โแแแขแแแแแแฃแ แ แแแ แแแแก แคแแแโ, แ แแแแแกแแช แจแแฃแซแแแ แแแแแฌแงแแแขแแแแแแแแก แแแฆแแแ แกแแขแฃแแชแแแก แแแฎแแแแแ, แ แแแแฃแ แแ แแจแ.
แกแฃแ แแแ 16 แแแ แแแแแแก แแ แแชแแกแแก แแแแแแแแแขแแแ แฃแฌแงแแแขแ แแแขแแแ แแชแแแกแแแแก (CI) InterSystems IRIS แแแแขแคแแ แแแแ
แแแแแขแฃแ แ แกแแกแขแแแแแแก แแแแชแแคแชแแแก (แแกแแแ แชแแแแแแแ แ แแแแ แช "แแ แแแแแแแแแขแฃแ แ แกแแกแขแแแแแ") แแฅแแก แซแแแแ แ แแแแแชแแ แ แแแแขแแแแชแแแจแ แแ InterSystems IRIS แแแแขแคแแ แแ แแ แแแแฃแแแ แแฎแแ แก แฃแญแแ แก แแแก "แแ แแแฃแฅแขแ-แแ แแชแแกแแก" แแแแกแขแ แฃแฅแชแแแก แแแจแแแแแแ. แแแ แแ แแแแแแฃแแ แแ แแชแแกแแก โแฉแแงแ แแกโ แจแแฃแแฆแฃแแแแ แจแแกแแซแแแแแแแแแแกแ แแแแแแแ แแแแแฌแงแแแขแแกแแแแก แแฃแชแแแแแแแ แคแฃแแฅแชแแแแแ แแแแ, แแแแขแคแแ แแแก แแ แแชแแกแแแแก แกแแกแขแแแแก แแแแแญแแแ โแแแแแขแแกโ แแแแกแแแแ แกแแจแฃแแแแแแก แแแซแแแแ แจแแฅแแแแ แแคแแฅแขแฃแ แ แแแแแฌแงแแแขแแแแแแแ แฃแแแแฃแ แแกแแ แแ แแกแขแแแแแฃแ แ แแแแขแแ แแแฃแแ แคแแแแแแแแแแกแแแแก (แฅแชแแแ แกแแชแแแแฃแ แ/ แแแแกแแกแขแแแแแ, แแแฌแแแแแ แแ แแแแแแ แแแแแแ แขแแฅแแแแแแแฃแ แ แแ แแชแแกแแแ แแ แ.แจ.).
แกแฃแ แแแ 16 AI/ML แแแแแฌแงแแแขแแก แแแฅแแแแแแ, แ แแแแ แช แแแแแขแแ แแแคแฃแซแแแแฃแแ แแแแแแก แแ แแชแแกแแก แกแแกแขแแแ InterSystems IRIS-แจแ
แฉแแแ แแแแ แซแแแแแ InterSystems IRIS-แแก แแแแแฎแแแแแก แแกแขแแ แแแ แแแแขแคแแ แแแก แแแแแงแแแแแแแ แแแแแงแแแแแแก แจแแกแแฎแแ แ แแแแฃแ แแ แแจแ แแ แแแแแแแแแก แแแแแ แแแแกแแก แแแแแกแแญแ แแแแ (แกแแแแแแ แแแขแแแฃแ แ แจแแกแแแแแ AI/ML แแแแขแคแแ แแแก แ แแแแแแแแ แกแแฃแแแแแกแ แแ แแฅแขแแแแก แจแแกแแฎแแ InterSystems IRIS-แแ แจแแแแซแแแแ แแฎแแแแ แแ แแจแ. แฉแแแแ แฌแแแ
แฌแแแ แแแแแ แแแแก แฅแฃแกแแแแแ แชแฎแแแ, แฅแแแแแ แแแชแแแฃแแแ แแแแแขแฃแ แ แกแแกแขแแแแก แฃแคแ แ แแแขแแแฃแ แ แแแแแ แแแ. แแแแแ แแแแแ แแแฉแแแแแแแ แแ แแ แแ แแแแแ แแ แแขแแขแแแ, แแแฎแแแ แแแแแขแฃแ แ แแ แแชแแกแ แฉแแแก, แแแ แจแแ แแก แฃแ แแแแ แแแแแแ แกแฅแแแแขแฃแ แแ แแ แแก แแแฎแแขแฃแแ: GENERATOR - แแแฃแจแแแแแก แแแแแชแแแแ แจแแฅแแแแก แแฆแญแฃแ แแแแแแแก แกแแแกแแ แแแแ, BUFFER - แแแ แแแแก แแแแแชแแแแ แ แแแแแก, ANALYZER - แแกแ แฃแแแแก แแแแฅแแแแแแชแแแแแแแแก, MONITOR - แแแแแขแ แแแแแก แแแแฅแแแแแแชแแแแแแแแก แฎแแ แแกแฎแ แแ แฌแแ แฃแแแแแก แกแแแแแแก แแแแแแแก แแแแแแแแแแแแก แแฃแชแแแแแแแแแก แจแแกแแฎแแ.
แกแฃแ แแแ 17 AI/ML แแแแแฌแงแแแขแแก แจแแแแแแแแแแแ แแแแแขแแ แแแคแฃแซแแแแฃแแ แแแแแแก แแ แแชแแกแแก แกแแกแขแแแแก แกแแฎแแ InterSystems IRIS-แจแ
แฅแแแแแ แแแชแแแฃแแ แแแแแ แแแ แแกแแฎแแแก แกแฎแแ แ แแแแขแฃแแ แแ แแขแแขแแแแก แแแขแแแแแแฃแ แคแฃแแฅแชแแแแแ แแแแก (แขแแฅแกแขแแแแก แแแแชแแฃแ แ แจแแฆแแแแแก แแแแชแแแแ) แแแ แแแแฃแแ แแ แแแก แแแแแแแแแแแจแ. แแแแ แแแฌแแแจแ แแ แแก แแแแแแแก แขแ แแแแแแแก แฎแแ แแกแฎแแก แแแแแแแขแแ แแก แแแแแฃแชแแ (แฎแแ แแกแฎแ แแแ แแแแ), แฅแแแแ แแแฌแแแจแ แแ แแก แแแแแแแก แแแแแงแแแแแแก แฎแแ แแกแฎแแก แแแแแแแขแแ แแก แแแแแแแแ แแ แแแแแแแ แแแแแ แแแ แฏแแจแแก แคแแฅแขแแแ (แฌแแแแแ แแแแแแ). แ แแแแ แช แฎแแแแแ, แแแแแกแแแแแแ แแกแฌแแแแ แแแแแ แแคแแฅแขแฃแ แแ แแ แแแขแแแแแแฃแ แแ แแ แแแฅแแแแแแก แแแชแแแฃแ แฎแแ แแกแฎแแก แแแแแแ (แฎแแ แแกแฎแแก แฅแฃแแแก แแแแจแแแแแแแแแ แแ แฉแแแแแแก 80%-แแ แฅแแแแแ).
แกแฃแ แแแ 18 แฃแฌแงแแแขแ (แแแแ) แกแฌแแแแแแ (CT) InterSystems IRIS แแแแขแคแแ แแแแ
แฉแแแ แแกแแแ แแฆแแแแจแแแ "auto-ML" แแแ แ, แแแแ แแ แฅแแแแแ แแแชแแแฃแแ แแแแแ แแแ แแแแฉแแแแแแก แแ แคแฃแแฅแชแแแก แแแแแงแแแแแแก แแแขแแแฃแ แแ แกแฎแแ แแ แแขแแขแแแแก แแแแแแแแแก แแแแแงแแแแแแ. แแแแแแก แแ แแชแแกแแก แคแ แแแแแแขแแก แแ แแคแแแฃแแ แแแแแ แแแ แแแแฉแแแแแแก แแฅแขแแแแแแก, แ แแแแแแช แแฌแแแแก แแแแแแแ แแแแก H2O แกแขแแแจแ, แแฉแแแแแแก แแ แแแแแแแ แแแแก แจแแแแแแแก (แจแแแแแ แแแแแแแก แแจแแแ แ แแแแแแแ แแแ โแแแแแแแแแก แจแแฅแแแแโ แแแแแแแแแ, แจแแแแ แแแแแ แแแแแ แแแแก แแแฎแแแแแ. ROC แแ แฃแแแแ, แแกแแแ โแงแแแแแแ แแแแแแแแแแ แชแแแแแแแแกโ แแแขแแแแขแฃแ แ แแแแแขแแคแแแแชแแ, แ แแแแแแแช แฎแแแแแกแแฌแแแแแแ แแ แแแแแแแฃแ แแแแแชแแแแ แแแแ แแแจแ). แแฅ แแแแจแแแแแแแแแ แแฃแแฅแขแแ แแ แแแกแ แแ แกแแแฅแกแแแ แขแ แ แแกแฃแ แกแแแแก แแแแแแแ, แ แแแแแแช แแแแฆแฌแแแ โแแแขแ-MLโ-แแก แกแแจแฃแแแแแแ: แ แแกแแช แฉแแแแ แแแแขแคแแ แแแก แแ แแชแแกแ แแแฎแแแแ แฌแฃแแจแ แแแแแแแก (แแแขแแแแแฃแ แ แแแแแแแก แแแแแ แแ แกแฌแแแแแแ) แจแแแซแแแแ แแฅแกแแแ แขแก แแ แแ แแแแ แแแแ แแ แ แแแแแแ แแแกแญแแ แแแก.
แกแฃแ แแแ 19 โauto-MLโ-แแก แแแขแแแ แแชแแ AI/ML แแแแแฌแงแแแขแแจแ InterSystems IRIS แแแแขแคแแ แแแแ
แฅแแแแแ แแแงแแแแแแ แแแแแ แแแ แแแแแ แชแแแแ แแแ แก, แแแแ แแ แแก แแแ แแ แแแแ แแกแขแแ แแแก แแแกแแกแ แฃแแแแแแ แ แแแแฃแ แแ แแจแ แแแแแแ แแแฃแแ แแ แแแแแแแแแก แแแแกแแแแก แจแแกแแฎแแ: แจแแแแฎแกแแแแแ, แ แแ InterSystems IRIS แแแแขแคแแ แแแก แงแแแแ แจแแกแแซแแแแแแแแ, แแแกแ แแแแขแ แแแแก แฅแแแจ แแงแแคแ แกแแกแฌแแแแ แแแแแแแแแ. แแ แแ แแก แกแแแแแแแแฃแแ. แแแแขแคแแ แแแก แจแแฃแซแแแ แแแ แแแแ แแแแฆแแก แแแแแแแก แแแ แแ แฌแแแแแฃแแ PMML แกแแแชแแคแแแแชแแ, แแแฌแแ แแแแแ แแแกแขแ แฃแแแแขแแ, แ แแแแแแช แแ แแ แแก แแแแขแคแแ แแแก แแแแขแ แแแแก แฅแแแจ - แแ แแแแแแงแแแแก แแก แแแแแแ แ แแแแฃแ แแ แแจแ แแแกแ แแแแแ แขแแก แแแแแแขแแแแ.
แกแฃแ แแแ 20 โauto-MLโ-แแก แแแขแแแ แแชแแ AI/ML แแแแแฌแงแแแขแแจแ InterSystems IRIS แแแแขแคแแ แแแแ
แแแแแ แฉแแแแแแแแแแ InterSystems IRIS-แแก แแแแแขแแแแแ แแแแขแคแแ แแแก แฃแแแ แแขแแกแแแแแ (แกแแชแฎแแแแกแแแแก, แแ แแชแแกแแก แแแแขแ แแแแแ แแแแแแจแแ แแแแ), แ แแแแแแกแแช แแแแ แแแแจแแแแแแแ แแฅแแก แฎแแแแแแฃแ แ แแแขแแแแฅแขแแก แแแขแแแแขแแแแชแแแกแ แแ แ แแแแฃแ แแ แแจแ แแแแฅแแแแแแชแแแแแแแแจแ:
- แจแแแฃแจแแแแแฃแแ แแแขแแแ แแชแแแก แแแกแขแ แฃแแแแขแแแ แแแแแชแแแแ แแแแแกแแแแ แฌแงแแ แแกแแแ แแ แแแแฎแแแ แแแแแแแ (แแ แแชแแกแแก แแแแขแ แแแแก แกแแกแขแแแ/SCADA, แแฆแญแฃแ แแแแแแ, MRO, ERP แแ แ.แจ.)
- แฉแแแแแขแแแแแฃแแ
แแ แแแแ แแแแแแแก DBMS แแแแแกแแแแ แ แแแชแฃแแแแแก แขแแฅแแแแแแแฃแ แ แแ แแชแแกแแก แแแแแชแแแแแแก แแแฆแแแ แฎแแ แแกแฎแแก แขแ แแแแแฅแชแแ แแ แแแแแแขแแแฃแ แ แแแแฃแจแแแแแแกแแแแก (แฐแแแ แแแฃแแ แขแ แแแแแฅแชแแ/แแแแแแขแแแฃแ แ แแแแฃแจแแแแแ, HTAP) - แแแแแแแแ แแแแก แแแกแขแ แฃแแแแขแแแ AI/ML แซแ แแแแแแก แฃแฌแงแแแขแ แแแแแแแแแแกแแแแก แ แแแแฃแ แแ แแจแ Python, R, Julia-แแ แแแคแฃแซแแแแฃแแ แแแแแฌแงแแแขแแแแแแแแกแแแแก
- แแแแแขแแ แแแฃแแ แแแแแแก แแ แแชแแกแแแ แ แแแแฃแ แแ แแจแ AI/ML แแแแแฌแงแแแขแแก แซแ แแแแแแก แฃแฌแงแแแขแ แแแขแแแ แแชแแแกแ แแ (แแแแ) แกแฌแแแแแกแแแแก
- แฉแแจแแแแแฃแแ แแแแแแก แแแแแแ แแแก แแแกแขแ แฃแแแแขแแแ แแ แแชแแกแแก แแแแแชแแแแแแกแ แแ AI/ML แแแแแฌแงแแแขแแก แจแแแแแแแแก แแแแฃแแแแแแชแแแกแแแแก
API แแแแแฏแแแแขแ AI/ML แแแแแฌแงแแแขแแก แจแแแแแแแแก แแแฌแแแแแแกแแแแก แแ แแชแแกแแแแก แแแแขแ แแแแก แกแแกแขแแแแแแ/SCADA, แกแแแแคแแ แแแชแแ แแ แแแแแแขแแแฃแ แ แกแแกแขแแแแแแกแแแแก, แกแแแแแแแแแก แแแแแแแแแกแแแแก แแ แ.แจ.
AI/ML แแแแแฌแงแแแขแแแแแแแ InterSystems IRIS แแแแขแคแแ แแแแ แแแแแแแ แฏแแแแ แแ แกแแแฃแ IT แแแคแ แแกแขแ แฃแฅแขแฃแ แแจแ. InterSystems IRIS แแแแขแคแแ แแ แฃแแ แฃแแแแแงแแคแก AI/ML แแแแแฌแงแแแขแแแแแแแแก แแแฆแแ แกแแแแแแแแแแก แจแแชแแแแแแแกแแแแ แแ แแแขแแกแขแ แแคแแแแกแแแแ แขแแแแ แแแขแฃแแ แแแแคแแแฃแ แแชแแแแแก แแฎแแ แแแญแแ แแ แแ แแแฅแแแแ แแแแแแแแแแ แแแ แขแฃแแแฃแ แแแ แแแแจแ, แคแแแแแฃแ แกแแ แแแ แแแแ, แแแ แซแ แแ แกแแฏแแ แ แฆแ แฃแแแแแจแ แแ Docker แแแแขแแแแแ แแแจแ.
แแแ แแแแ, InterSystems IRIS แแ แแก แฃแแแแแ แกแแแฃแ แ แ แแแแฃแ แแ แแจแ AI/ML แแแแแแแแแแ แแแแขแคแแ แแ. แฉแแแแ แแแแขแคแแ แแแก แฃแแแแแ แกแแแฃแ แแแ แแ แแฅแขแแแแจแ แแแกแขแฃแ แแแแ แแแแฎแแ แชแแแแแแฃแแ แแแแแแแแแแแก แกแแ แแฃแแแก แแ แคแแฅแขแ แจแแแฆแฃแแแแแแก แแ แแ แกแแแแแแ, InterSystems IRIS-แแก แฃแแแ แแ แแแแแแแจแแ แแก (แ แแแแฃแ แแ แแจแ) แกแชแแแแ แแก แแแแฃแจแแแแแ แกแฎแแแแแกแฎแแ แแแแฃแกแขแ แแแแแแแ แแ แแแแกแแแฃแแ แแแฃแแ แแแแแขแแ แแแ. แแแแแกแแแแ แ แแแแขแคแแ แแแก แคแฃแแฅแชแแแแ แแ แแแฅแแแแแแแแ แแแแฎแแแ แแแแแแ แแแแแ แแขแฃแ แกแแญแแ แแแแแแแ.
แกแฃแ แแแ 21 InterSystems IRIS - แฃแแแแแ แกแแแฃแ แ แ แแแแฃแ แแ แแจแ AI/ML แแแแแแแแแแ แแแแขแคแแ แแ
แฃแคแ แ แแ แกแแแแแ แแแขแแ แแฅแชแแแกแแแแก แฉแแแแก แแแแแฎแแแแแแแแ, แ แแแแแแแช แแแแแขแแ แแกแแแฃแแแ แแ แแแ แแฅ แฌแแ แแแแแแแแแ แแแกแแแแแแ, แแแ แฉแแแ แแ แจแแแแแคแแ แแแแ แแแกแ แฌแแแแแฎแแแ แแ แแแแแแ แซแแ แแแแแแแ โแแแแ แ แแแแแจแโ. แแแฎแแ แฃแแ แแแฅแแแแแ แแแแแฎแแแ แแ แ แแแแฃแ แแ แแจแ AI/ML แกแชแแแแ แแแแก แคแแ แแฃแแแ แแแแจแ แแฅแแแแ แแแแแแแแแก แกแแแชแแคแแแแกแแแ แแแแแแจแแ แแแแ, แจแแแแกแ แฃแแแ แแ แแแแแแแ แแ แแขแแขแแแแ แแแ InterSystems IRIS แแแแขแคแแ แแแแ, แฉแแแแแแงแแแแแแ แแ แแ แแฅแขแแแแจแ แแแแแแฎแแ แชแแแแแ แกแแแแแ แ แฃแแ แฎแแแแแแฃแ แ แแแขแแแแฅแขแแกแ แแ แแแแฅแแแฃแ แ แกแฌแแแแแแแก แแแแแ แแแแกแแแแก. แแฅแแแแ แฌแแ แแแแแแกแ แแ แแแ แแแแก แแ แแชแแกแแแจแ. แฉแแแแ AI/ML แแฅแกแแแ แขแแ แแฃแแแ แกแแแแแขแแฅแขแ แแแคแแกแขแ โ
แฌแงแแ แ: www.habr.com