ഈ ലേഖനം InterSystems IRIS ഡാറ്റാ പ്ലാറ്റ്‌ഫോമിനായുള്ള ഒരു ഓപ്പൺ സോഴ്‌സ് കമ്മ്യൂണിറ്റി പ്രോജക്റ്റായ പൈത്തൺ ഗേറ്റ്‌വേയെക്കുറിച്ചാണ്. പൈത്തണിൽ സൃഷ്‌ടിച്ച ഏതൊരു മെഷീൻ ലേണിംഗ് അൽഗോരിതം (പല ഡാറ്റാ സയന്റിസ്റ്റുകളുടെയും പ്രധാന അന്തരീക്ഷം) ക്രമീകരിക്കാൻ ഈ പ്രോജക്റ്റ് നിങ്ങളെ അനുവദിക്കുന്നു, ഇന്റർസിസ്റ്റംസ് ഐആർഐഎസ് പ്ലാറ്റ്‌ഫോമിൽ അഡാപ്റ്റീവ്, റോബോട്ടിക് അനലിറ്റിക്കൽ AI/ML സൊല്യൂഷനുകൾ വേഗത്തിൽ സൃഷ്‌ടിക്കാൻ നിരവധി റെഡിമെയ്ഡ് ലൈബ്രറികൾ ഉപയോഗിക്കുക. ഈ ലേഖനത്തിൽ, ഇന്റർസിസ്റ്റംസ് IRIS-ന് എങ്ങനെ പൈത്തണിലെ പ്രക്രിയകൾ ക്രമീകരിക്കാമെന്നും രണ്ട്-വഴി ഡാറ്റ കാര്യക്ഷമമായി ആശയവിനിമയം നടത്താമെന്നും ബുദ്ധിപരമായ ബിസിനസ്സ് പ്രക്രിയകൾ സൃഷ്ടിക്കാമെന്നും ഞാൻ കാണിക്കും.

പദ്ധതി

ആമുഖം.
ഉപകരണങ്ങൾ.
ഇൻസ്റ്റാളേഷൻ
API.
പരസ്പര പ്രവർത്തനക്ഷമത.
ജൂപ്പിറ്റർ നോട്ട്ബുക്ക്.
നിഗമനങ്ങൾ.
ലിങ്കുകൾ.
MLToolkit.

ആമുഖം

ഡെവലപ്പർ ഉൽപ്പാദനക്ഷമതയും കോഡ് റീഡബിലിറ്റിയും മെച്ചപ്പെടുത്താൻ ലക്ഷ്യമിട്ടുള്ള ഒരു ഉയർന്ന തലത്തിലുള്ള, പൊതു-ഉദ്ദേശ്യ പ്രോഗ്രാമിംഗ് ഭാഷയാണ് പൈത്തൺ. ഈ ലേഖന പരമ്പരയിൽ, ഇന്റർസിസ്റ്റംസ് ഐആർഐഎസ് പ്ലാറ്റ്‌ഫോമിൽ പൈത്തൺ ഉപയോഗിക്കുന്നതിനുള്ള സാധ്യതകളെക്കുറിച്ച് ഞാൻ ചർച്ചചെയ്യും, ഈ ലേഖനത്തിന്റെ പ്രധാന ലക്ഷ്യം മെഷീൻ ലേണിംഗ് മോഡലുകൾ സൃഷ്ടിക്കുന്നതിനും പ്രവർത്തിപ്പിക്കുന്നതിനുമുള്ള ഒരു ഭാഷയായി പൈത്തണിന്റെ ഉപയോഗമാണ്.

മെഷീൻ ലേണിംഗ് (ML) എന്നത് കൃത്രിമബുദ്ധി രീതികളുടെ ഒരു വിഭാഗമാണ്, ഇതിന്റെ സ്വഭാവ സവിശേഷത ഒരു പ്രശ്നത്തിന്റെ നേരിട്ടുള്ള പരിഹാരമല്ല, മറിച്ച് സമാനമായ നിരവധി പ്രശ്നങ്ങൾ പരിഹരിക്കുന്ന പ്രക്രിയയിൽ പഠിക്കുക എന്നതാണ്.

മെഷീൻ ലേണിംഗ് അൽഗോരിതങ്ങളും മോഡലുകളും കൂടുതൽ സാധാരണമായിക്കൊണ്ടിരിക്കുകയാണ്. ഇതിന് നിരവധി കാരണങ്ങളുണ്ട്, പക്ഷേ ഇതെല്ലാം പ്രവേശനക്ഷമത, ലാളിത്യം, പ്രായോഗിക ഫലങ്ങൾ കൈവരിക്കൽ എന്നിവയിലേക്ക് വരുന്നു. ക്ലസ്റ്ററിംഗ് അല്ലെങ്കിൽ ന്യൂറൽ നെറ്റ്‌വർക്ക് മോഡലിംഗ് ഒരു പുതിയ സാങ്കേതികവിദ്യയാണോ?

തീർച്ചയായും അല്ല, എന്നാൽ ഇക്കാലത്ത് ഒരൊറ്റ മോഡൽ പ്രവർത്തിപ്പിക്കുന്നതിന് നൂറുകണക്കിന് ആയിരക്കണക്കിന് വരികൾ കോഡ് എഴുതേണ്ട ആവശ്യമില്ല, കൂടാതെ മോഡലുകൾ സൃഷ്ടിക്കുന്നതിനും ഉപയോഗിക്കുന്നതിനുമുള്ള ചെലവ് കുറഞ്ഞുവരികയാണ്.

ടൂളുകൾ വികസിച്ചുകൊണ്ടിരിക്കുന്നു - ഞങ്ങൾക്ക് പൂർണ്ണമായി GUI-കേന്ദ്രീകൃത AI/ML ടൂളുകൾ ഇല്ലെങ്കിലും, BI (കോഡ് എഴുതുന്നത് മുതൽ ചട്ടക്കൂടുകളും GUI-കേന്ദ്രീകൃതമായ കോൺഫിഗറബിൾ സൊല്യൂഷനുകളും ഉപയോഗിക്കുന്നത് വരെ) പോലെയുള്ള മറ്റ് നിരവധി വിവര സംവിധാനങ്ങളിൽ നാം കണ്ട പുരോഗതിയാണ്. AI/ML സൃഷ്ടിക്കുന്നതിനുള്ള ടൂളുകളിലും നിരീക്ഷിക്കപ്പെടുന്നു. കോഡ് എഴുതുന്ന ഘട്ടം ഞങ്ങൾ ഇതിനകം കടന്നുപോയിട്ടുണ്ട്, ഇന്ന് മോഡലുകൾ നിർമ്മിക്കുന്നതിനും പരിശീലിപ്പിക്കുന്നതിനും ഞങ്ങൾ ചട്ടക്കൂടുകൾ ഉപയോഗിക്കുന്നു.

അന്തിമ ഉപയോക്താക്കൾക്ക് അവരുടെ നിർദ്ദിഷ്ട ഡാറ്റയിൽ മോഡൽ പരിശീലിപ്പിക്കുന്നത് പൂർത്തിയാക്കേണ്ട പ്രീ-ട്രെയിൻഡ് മോഡൽ വിതരണം ചെയ്യാനുള്ള കഴിവ് പോലെയുള്ള മറ്റ് മെച്ചപ്പെടുത്തലുകൾ, മെഷീൻ ലേണിംഗ് ആരംഭിക്കുന്നത് എളുപ്പമാക്കുന്നു. ഈ മുന്നേറ്റങ്ങൾ പ്രൊഫഷണലുകൾക്കും പൊതുവെ കമ്പനികൾക്കും മെഷീൻ ലേണിംഗ് വളരെ എളുപ്പമാക്കുന്നു.

മറുവശത്ത്, ഞങ്ങൾ കൂടുതൽ കൂടുതൽ ഡാറ്റ ശേഖരിക്കുന്നു. InterSystems IRIS പോലെയുള്ള ഒരു ഏകീകൃത ഡാറ്റ പ്ലാറ്റ്‌ഫോം ഉപയോഗിച്ച്, ഈ വിവരങ്ങളെല്ലാം ഉടനടി തയ്യാറാക്കുകയും മെഷീൻ ലേണിംഗ് മോഡലുകളിലേക്ക് ഇൻപുട്ടായി ഉപയോഗിക്കുകയും ചെയ്യാം.

ക്ലൗഡിലേക്കുള്ള നീക്കത്തോടെ, AI/ML പ്രോജക്ടുകൾ സമാരംഭിക്കുന്നത് എന്നത്തേക്കാളും എളുപ്പമായിക്കൊണ്ടിരിക്കുകയാണ്. നമുക്ക് ആവശ്യമുള്ള വിഭവങ്ങൾ മാത്രമേ ഉപയോഗിക്കാനാകൂ. മാത്രമല്ല, ക്ലൗഡ് പ്ലാറ്റ്‌ഫോമുകൾ വാഗ്ദാനം ചെയ്യുന്ന സമാന്തരവൽക്കരണത്തിന് നന്ദി, ചിലവഴിച്ച സമയം ലാഭിക്കാം.

എന്നാൽ ഫലങ്ങളുടെ കാര്യമോ? ഇവിടെയാണ് കാര്യങ്ങൾ കൂടുതൽ സങ്കീർണ്ണമാകുന്നത്. നിർമ്മാണ മോഡലുകൾക്കായി നിരവധി ഉപകരണങ്ങൾ ഉണ്ട്, അത് ഞാൻ അടുത്തതായി ചർച്ച ചെയ്യും. ഒരു നല്ല മോഡൽ നിർമ്മിക്കുന്നത് എളുപ്പമല്ല, എന്നാൽ അടുത്തത് എന്താണ്? ഒരു ബിസിനസ് മോഡൽ ഉപയോഗിച്ച് ലാഭം ഉണ്ടാക്കുന്നതും നിസ്സാരമല്ലാത്ത ഒരു ജോലിയാണ്. വിശകലനപരവും ഇടപാടുപരവുമായ ജോലിഭാരങ്ങളും ഡാറ്റ മോഡലുകളും വേർതിരിക്കുന്നതാണ് പ്രശ്നത്തിന്റെ അടിസ്ഥാനം. ഞങ്ങൾ ഒരു മോഡൽ പരിശീലിപ്പിക്കുമ്പോൾ, ഞങ്ങൾ സാധാരണയായി അത് ചരിത്രപരമായ ഡാറ്റയിലാണ് ചെയ്യുന്നത്. എന്നാൽ നിർമ്മിച്ച മോഡലിനുള്ള സ്ഥലം ഇടപാട് ഡാറ്റ പ്രോസസ്സിംഗിലാണ്. ഞങ്ങൾ ദിവസത്തിൽ ഒരിക്കൽ പ്രവർത്തിപ്പിച്ചാൽ ഏറ്റവും മികച്ച വഞ്ചനാപരമായ ഇടപാട് കണ്ടെത്തൽ മോഡൽ എന്താണ് പ്രയോജനം? തട്ടിപ്പുകാർ പണവുമായി പോയിട്ട് ഏറെ നാളായി. ചരിത്രപരമായ ഡാറ്റയിൽ ഞങ്ങൾ മോഡലിനെ പരിശീലിപ്പിക്കേണ്ടതുണ്ട്, എന്നാൽ പുതിയ ഇൻകമിംഗ് ഡാറ്റയിൽ ഞങ്ങൾ അത് തത്സമയം പ്രയോഗിക്കേണ്ടതുണ്ട്, അതുവഴി ഞങ്ങളുടെ ബിസിനസ്സ് പ്രക്രിയകൾക്ക് മോഡൽ നടത്തിയ പ്രവചനങ്ങളിൽ പ്രവർത്തിക്കാനാകും.

ML ടൂൾകിറ്റ് എന്നത് അത് ചെയ്യാൻ ലക്ഷ്യമിടുന്ന ഒരു കൂട്ടം ടൂളുകളാണ്: മോഡലുകളെ ഏകീകരിക്കുക, ഒരു ഇടപാട് അന്തരീക്ഷം, അങ്ങനെ നിർമ്മിച്ച മോഡലുകൾ നിങ്ങളുടെ ബിസിനസ്സ് പ്രക്രിയകളിൽ നേരിട്ട് ഉപയോഗിക്കാൻ കഴിയും. ML ടൂൾകിറ്റിന്റെ ഭാഗമാണ് പൈത്തൺ ഗേറ്റ്‌വേ, പൈത്തൺ ഭാഷയുമായി സംയോജനം നൽകുന്നു (ML ടൂൾകിറ്റിന്റെ ഭാഗമായ R ഗേറ്റ്‌വേ, R ഭാഷയുമായി സംയോജനം നൽകുന്നത് പോലെ).

ടൂൾകിറ്റ്

ഞങ്ങൾ തുടരുന്നതിന് മുമ്പ്, ഞങ്ങൾ പിന്നീട് ഉപയോഗിക്കുന്ന കുറച്ച് പൈത്തൺ ടൂളുകളും ലൈബ്രറികളും വിവരിക്കാൻ ഞാൻ ആഗ്രഹിക്കുന്നു.

സാങ്കേതികവിദ്യയുടെ

പൈത്തൺ ഒരു വ്യാഖ്യാന, ഉയർന്ന തലത്തിലുള്ള, പൊതു-ഉദ്ദേശ്യ പ്രോഗ്രാമിംഗ് ഭാഷയാണ്. ഗണിതശാസ്ത്രം, ML, AI ലൈബ്രറികളുടെ വലിയ ലൈബ്രറിയാണ് ഭാഷയുടെ പ്രധാന നേട്ടം. ഒബ്‌ജക്റ്റ് സ്‌ക്രിപ്റ്റ് പോലെ, ഇത് ഒരു ഒബ്‌ജക്റ്റ് ഓറിയന്റഡ് ഭാഷയാണ്, എന്നാൽ എല്ലാം സ്റ്റാറ്റിക്കലിക്ക് പകരം ചലനാത്മകമായി നിർവചിച്ചിരിക്കുന്നു. കൂടാതെ എല്ലാം ഒരു വസ്തുവാണ്. പിന്നീടുള്ള ലേഖനങ്ങൾ ഭാഷയുമായി കടന്നുപോകുന്ന പരിചയം അനുമാനിക്കുന്നു. നിങ്ങൾക്ക് പഠനം ആരംഭിക്കണമെങ്കിൽ, ആരംഭിക്കാൻ ഞാൻ ശുപാർശ ചെയ്യുന്നു പ്രമാണീകരണം.
ഞങ്ങളുടെ തുടർന്നുള്ള വ്യായാമങ്ങൾക്കായി, സജ്ജമാക്കുക പൈത്തൺ 3.6.7 64 ബിറ്റ്.
IDE: ഞാൻ ഉപയോഗിക്കുന്നു PyCharm, എന്നാൽ പൊതുവേ അവർ много. നിങ്ങൾ Atelier ഉപയോഗിക്കുകയാണെങ്കിൽ, പൈത്തൺ ഡെവലപ്പർമാർക്കായി ഒരു എക്ലിപ്സ് പ്ലഗിൻ ഉണ്ട്. നിങ്ങൾ വിഎസ് കോഡ് ഉപയോഗിക്കുന്നുണ്ടെങ്കിൽ, പൈത്തണിന് ഒരു എക്സ്റ്റൻഷൻ ഉണ്ട്.
നോട്ട്ബുക്ക്: ഒരു IDE-ക്ക് പകരം, നിങ്ങൾക്ക് ഓൺലൈൻ നോട്ട്ബുക്കുകളിൽ നിങ്ങളുടെ സ്ക്രിപ്റ്റുകൾ എഴുതാനും പങ്കിടാനും കഴിയും. അവയിൽ ഏറ്റവും പ്രചാരമുള്ളത് വ്യാഴം.

ലൈബ്രറികൾ

മെഷീൻ ലേണിംഗ് ലൈബ്രറികളുടെ ഒരു (സമഗ്രമല്ലാത്ത) ലിസ്റ്റ് ഇതാ:

നംപി - കൃത്യമായ കണക്കുകൂട്ടലുകൾക്കുള്ള അടിസ്ഥാന പാക്കേജ്.
പാണ്ഡകൾ — ഉയർന്ന പ്രവർത്തനക്ഷമതയുള്ള ഡാറ്റാ ഘടനകളും ഡാറ്റ വിശകലന ടൂളുകളും.
മാറ്റ്‌പ്ലോട്ട്ലിബ് - ഗ്രാഫുകളുടെ സൃഷ്ടി.
കടൽ - matplotlib അടിസ്ഥാനമാക്കിയുള്ള ഡാറ്റ ദൃശ്യവൽക്കരണം.
Sklearn - മെഷീൻ ലേണിംഗ് രീതികൾ.
XGBoost - ഗ്രേഡിയന്റ് ബൂസ്റ്റിംഗ് മെത്തഡോളജിയുടെ ചട്ടക്കൂടിനുള്ളിൽ മെഷീൻ ലേണിംഗ് അൽഗോരിതങ്ങൾ.
ജെൻസിം - എൻ.എൽ.പി.
കേരസ് - ന്യൂറൽ നെറ്റ്‌വർക്കുകൾ.
ടെൻസർഫ്ലോ - മെഷീൻ ലേണിംഗ് മോഡലുകൾ സൃഷ്ടിക്കുന്നതിനുള്ള ഒരു പ്ലാറ്റ്ഫോം.
പൈടോർച്ച് പൈത്തണിൽ ശ്രദ്ധ കേന്ദ്രീകരിച്ച് മെഷീൻ ലേണിംഗ് മോഡലുകൾ സൃഷ്ടിക്കുന്നതിനുള്ള ഒരു പ്ലാറ്റ്ഫോമാണ്.
ന്യോക - വിവിധ മോഡലുകളിൽ നിന്നുള്ള പിഎംഎംഎൽ.

AI/ML സാങ്കേതികവിദ്യകൾ ബിസിനസിനെ കൂടുതൽ കാര്യക്ഷമവും അനുയോജ്യവുമാക്കുന്നു. മാത്രമല്ല, ഇന്ന് ഈ സാങ്കേതികവിദ്യകൾ വികസിപ്പിക്കാനും നടപ്പിലാക്കാനും എളുപ്പമായിക്കൊണ്ടിരിക്കുകയാണ്. AI/ML സാങ്കേതികവിദ്യകളെക്കുറിച്ചും അവ നിങ്ങളുടെ സ്ഥാപനത്തിന്റെ വളർച്ചയെ എങ്ങനെ സഹായിക്കുമെന്നും പഠിക്കാൻ ആരംഭിക്കുക.

ഇൻസ്റ്റലേഷൻ

പൈത്തൺ ഗേറ്റ്‌വേ ഇൻസ്റ്റാൾ ചെയ്യാനും ഉപയോഗിക്കാനും നിരവധി മാർഗങ്ങളുണ്ട്:

OS
- വിൻഡോസ്
- ലിനക്സ്
- മാക്
ഡോക്കർ
- DockerHub-ൽ നിന്നുള്ള ഒരു ചിത്രം ഉപയോഗിക്കുക
- നിങ്ങളുടെ സ്വന്തം രൂപം സൃഷ്ടിക്കുക

ഇൻസ്റ്റാളേഷൻ രീതി പരിഗണിക്കാതെ തന്നെ, നിങ്ങൾക്ക് സോഴ്സ് കോഡ് ആവശ്യമാണ്. കോഡ് ഡൗൺലോഡ് ചെയ്യാനുള്ള ഒരേയൊരു സ്ഥലം റിലീസ് പേജ്. ഇതിൽ പരീക്ഷിച്ച സ്ഥിരതയുള്ള റിലീസുകൾ അടങ്ങിയിരിക്കുന്നു, ഏറ്റവും പുതിയത് എടുക്കുക. ഇപ്പോൾ അത് 0.8 ആണ്, എന്നാൽ കാലക്രമേണ പുതിയവ ഉണ്ടാകും. റിപ്പോസിറ്ററി ക്ലോൺ ചെയ്യരുത്/ഡൗൺലോഡ് ചെയ്യരുത്, ഏറ്റവും പുതിയ റിലീസ് ഡൗൺലോഡ് ചെയ്യുക.

OS

നിങ്ങൾ ഒരു ഓപ്പറേറ്റിംഗ് സിസ്റ്റത്തിൽ പൈത്തൺ ഗേറ്റ്‌വേ ഇൻസ്റ്റാൾ ചെയ്യുകയാണെങ്കിൽ, ആദ്യം (ഓപ്പറേറ്റിംഗ് സിസ്റ്റം പരിഗണിക്കാതെ) നിങ്ങൾ പൈത്തൺ ഇൻസ്റ്റാൾ ചെയ്യേണ്ടതുണ്ട്. ഇതിനായി:

പൈത്തൺ 3.6.7 64 ബിറ്റ് ഇൻസ്റ്റാൾ ചെയ്യുക. സ്ഥിരസ്ഥിതി ഡയറക്ടറിയിൽ പൈത്തൺ ഇൻസ്റ്റാൾ ചെയ്യാൻ ശുപാർശ ചെയ്യുന്നു.
മൊഡ്യൂൾ ഇൻസ്റ്റാൾ ചെയ്യുക dill: pip install dill.
ObjectScript കോഡ് ഡൗൺലോഡ് ചെയ്യുക (അതായത്. do $system.OBJ.ImportDir("C:InterSystemsReposPythoniscpy", "*.cls", "c",,1)) ഉൽപ്പന്നങ്ങളുള്ള ഏതെങ്കിലും പ്രദേശത്തേക്ക്. ഉൽപന്നങ്ങളെ പിന്തുണയ്ക്കാൻ നിലവിലുള്ള ഒരു ഏരിയ നിങ്ങൾക്ക് താൽപ്പര്യമുണ്ടെങ്കിൽ, പ്രവർത്തിപ്പിക്കുക: write ##class(%EnsembleMgr).EnableNamespace($Namespace, 1).
സ്ഥലം കോൾഔട്ട് DLL/SO/DYLIB ഫോൾഡറിലേക്ക് bin നിങ്ങളുടെ InterSystems IRIS ഉദാഹരണം. മടങ്ങിയ പാതയിൽ ലൈബ്രറി ഫയൽ ഉണ്ടായിരിക്കണം write ##class(isc.py.Callout).GetLib().

വിൻഡോസ്

പരിസ്ഥിതി വേരിയബിൾ ഉറപ്പാക്കുക PYTHONHOME പൈത്തൺ 3.6.7 ലേക്ക് പോയിന്റ് ചെയ്യുന്നു.
സിസ്റ്റം എൻവയോൺമെന്റ് വേരിയബിൾ ആണെന്ന് ഉറപ്പാക്കുക PATH ഒരു വേരിയബിൾ അടങ്ങിയിരിക്കുന്നു PYTHONHOME (അല്ലെങ്കിൽ അത് ചൂണ്ടിക്കാണിക്കുന്ന ഡയറക്ടറി).

ലിനക്സ് (ഡെബിയൻ/ഉബുണ്ടു)

പരിസ്ഥിതി വേരിയബിൾ ആണോ എന്ന് പരിശോധിക്കുക PATH അടങ്ങിയിരിക്കുന്നു /usr/lib и /usr/lib/x86_64-linux-gnu. ഫയൽ ഉപയോഗിക്കുക /etc/environment പരിസ്ഥിതി വേരിയബിളുകൾ സജ്ജമാക്കാൻ.
പിശകുകളുടെ കാര്യത്തിൽ undefined symbol: _Py_TrueStruct ക്രമീകരണം സജ്ജമാക്കുക PythonLib. കൂടാതെ ഇൻ Readme ഒരു ട്രബിൾഷൂട്ടിംഗ് വിഭാഗമുണ്ട്.

മാക്

നിലവിൽ പൈത്തൺ 3.6.7 മാത്രമാണ് പിന്തുണയ്ക്കുന്നത് Python.org. വേരിയബിൾ പരിശോധിക്കുക PATH.

നിങ്ങൾ പരിസ്ഥിതി വേരിയബിളുകൾ മാറ്റിയിട്ടുണ്ടെങ്കിൽ, നിങ്ങളുടെ ഇന്റർസിസ്റ്റംസ് ഉൽപ്പന്നം പുനരാരംഭിക്കുക.

ഡോക്കർ

കണ്ടെയ്നറുകൾ ഉപയോഗിക്കുന്നതിന് നിരവധി ഗുണങ്ങളുണ്ട്:

പോർട്ടബിലിറ്റി
ഫലപ്രാപ്തി
ഇൻസുലേഷൻ
ലഘുത്വം
മാറ്റമില്ലാത്തത്

ഇത് പരിശോധിക്കുക ലേഖനങ്ങളുടെ പരമ്പര ഇന്റർസിസ്റ്റംസ് ഉൽപ്പന്നങ്ങൾക്കൊപ്പം ഡോക്കർ ഉപയോഗിക്കുന്നതിനെക്കുറിച്ചുള്ള കൂടുതൽ വിവരങ്ങൾക്ക്.

എല്ലാ പൈത്തൺ ഗേറ്റ്‌വേ ബിൽഡുകളും നിലവിൽ കണ്ടെയ്‌നർ അടിസ്ഥാനമാക്കിയുള്ളതാണ് 2019.4.

തയ്യാറായ ചിത്രം

പ്രവർത്തിപ്പിക്കുക: docker run -d -p 52773:52773 --name irispy intersystemscommunity/irispy-community:latestഇന്റർസിസ്റ്റംസ് ഐആർഐഎസ് കമ്മ്യൂണിറ്റി പതിപ്പിനൊപ്പം പൈത്തൺ ഗേറ്റ്‌വേ ഡൗൺലോഡ് ചെയ്ത് പ്രവർത്തിപ്പിക്കാൻ. അത്രയേയുള്ളൂ.

നിങ്ങളുടെ സ്വന്തം രൂപം സൃഷ്ടിക്കുക

ഒരു ഡോക്കർ ഇമേജ് നിർമ്മിക്കുന്നതിന്, റിപ്പോസിറ്ററിയുടെ റൂട്ടിൽ പ്രവർത്തിപ്പിക്കുക: docker build --force-rm --tag intersystemscommunity/irispy:latest ..
സ്ഥിരസ്ഥിതിയായി, ഇമേജിനെ അടിസ്ഥാനമാക്കിയാണ് ചിത്രം നിർമ്മിച്ചിരിക്കുന്നത് store/intersystems/iris-community:2019.4.0.383.0, എന്നിരുന്നാലും ഒരു വേരിയബിൾ സജ്ജീകരിച്ച് നിങ്ങൾക്ക് ഇത് മാറ്റാവുന്നതാണ് IMAGE.
InterSystems IRIS-ൽ നിന്ന് നിർമ്മിക്കാൻ, പ്രവർത്തിപ്പിക്കുക: `docker build --build-arg IMAGE=store/intersystems/iris:2019.4.0.383.0 --force-rm --tag intersystemscommunity/irispy:latest ".

ഇതിനുശേഷം നിങ്ങൾക്ക് ഡോക്കർ ഇമേജ് പ്രവർത്തിപ്പിക്കാൻ കഴിയും:

docker run -d 
  -p 52773:52773 
  -v /<HOST-DIR-WITH-iris.key>/:/mount 
  --name irispy 
  intersystemscommunity/irispy:latest 
  --key /mount/iris.key

നിങ്ങൾ InterSystems IRIS കമ്മ്യൂണിറ്റി പതിപ്പിനെ അടിസ്ഥാനമാക്കിയുള്ള ഒരു ചിത്രമാണ് ഉപയോഗിക്കുന്നതെങ്കിൽ, നിങ്ങൾക്ക് കീ ഒഴിവാക്കാവുന്നതാണ്.

അഭിപ്രായങ്ങള്

ടെസ്റ്റ് പ്രക്രിയ isc.py.test.Process ഒരു താൽക്കാലിക ഡയറക്‌ടറിയിലേക്ക് നിരവധി ചിത്രങ്ങൾ സംരക്ഷിക്കുന്നു. നിങ്ങൾ ഈ പാത മൌണ്ട് ചെയ്ത ഡയറക്ടറിയിലേക്ക് മാറ്റാൻ ആഗ്രഹിച്ചേക്കാം. ഇത് ചെയ്യുന്നതിന്, ക്രമീകരണം എഡിറ്റുചെയ്യുക WorkingDir മൌണ്ട് ചെയ്ത ഡയറക്ടറി വ്യക്തമാക്കുന്നു.
ടെർമിനൽ റൺ ആക്സസ് ചെയ്യുന്നതിന്: docker exec -it irispy sh.
ലോഗിൻ വഴി സിസ്റ്റം മാനേജ്മെന്റ് പോർട്ടലിലേക്കുള്ള ആക്സസ് SuperUser/SYS.
കണ്ടെയ്നർ നിർത്താൻ, പ്രവർത്തിപ്പിക്കുക: docker stop irispy && docker rm --force irispy.

ഇൻസ്റ്റാളേഷൻ പരിശോധിക്കുന്നു

നിങ്ങൾ പൈത്തൺ ഗേറ്റ്‌വേ ഇൻസ്റ്റാൾ ചെയ്തുകഴിഞ്ഞാൽ, അത് പ്രവർത്തിക്കുന്നുണ്ടോയെന്ന് പരിശോധിക്കേണ്ടതാണ്. InterSystems IRIS ടെർമിനലിൽ ഈ കോഡ് എക്സിക്യൂട്ട് ചെയ്യുക:

set sc = ##class(isc.py.Callout).Setup() 
set sc = ##class(isc.py.Main).SimpleString("x='HELLO'", "x", , .var).
write var

ഫലം ഇതായിരിക്കണം: HELLO - പൈത്തൺ വേരിയബിൾ മൂല്യം x. മടക്കം നില എങ്കിൽ sc ഒരു പിശക് അല്ലെങ്കിൽ var ശൂന്യം, പരിശോധിക്കുക Readme - ട്രബിൾഷൂട്ടിംഗ് വിഭാഗം.

എപിഐ

പൈത്തൺ ഗേറ്റ്‌വേ ഇൻസ്റ്റാൾ ചെയ്തു, അത് പ്രവർത്തിക്കുന്നുവെന്ന് നിങ്ങൾ പരിശോധിച്ചു. ഇത് ഉപയോഗിക്കാൻ തുടങ്ങാൻ സമയമായി!
പൈത്തണിന്റെ പ്രധാന ഇന്റർഫേസ് ആണ് isc.py.Main. ഇത് ഇനിപ്പറയുന്ന രീതികളുടെ ഗ്രൂപ്പുകൾ വാഗ്ദാനം ചെയ്യുന്നു (എല്ലാം റിട്ടേൺ %Status):

കോഡ് എക്സിക്യൂഷൻ
ഡാറ്റ കൈമാറ്റം
സഹായ

കോഡ് എക്സിക്യൂഷൻ

അനിയന്ത്രിതമായ പൈത്തൺ കോഡ് എക്സിക്യൂട്ട് ചെയ്യാൻ ഈ രീതികൾ നിങ്ങളെ അനുവദിക്കുന്നു.

SimpleString

SimpleString - ഇതാണ് പ്രധാന രീതി. ഇതിന് 4 ഓപ്ഷണൽ ആർഗ്യുമെന്റുകൾ ആവശ്യമാണ്:

code - എക്സിക്യൂട്ട് ചെയ്യാനുള്ള കോഡിന്റെ വരി. ലൈൻ ഫീഡ് പ്രതീകം: $c(10).
returnVariable - തിരികെ നൽകേണ്ട വേരിയബിളിന്റെ പേര്.
serialization - എങ്ങനെ സീരിയൽ ചെയ്യാം returnVariable. 0 - സ്ട്രിംഗ് (സ്ഥിരസ്ഥിതി), 1 - repr.
result - മൂല്യം എഴുതിയിരിക്കുന്ന വേരിയബിളിലേക്കുള്ള ByRef റഫറൻസ് returnVariable.

മുകളിൽ ഞങ്ങൾ ചെയ്തു:

set sc = ##class(isc.py.Main).SimpleString("x='HELLO'", "x", , .var).

ഈ ഉദാഹരണത്തിൽ, ഞങ്ങൾ ഒരു പൈത്തൺ വേരിയബിളിലേക്ക് അസൈൻ ചെയ്യുന്നു x അർത്ഥം Hello ഒരു പൈത്തൺ വേരിയബിളിന്റെ മൂല്യം തിരികെ നൽകണം x ഒരു ഒബ്ജക്റ്റ്സ്ക്രിപ്റ്റ് വേരിയബിളിലേക്ക് var.

എക്സിക്യൂട്ട്കോഡ്

എക്‌സിക്യൂട്ട് കോഡ് സുരക്ഷിതവും നിയന്ത്രണമില്ലാത്തതുമായ ഒരു ബദലാണ് SimpleString.
InterSystems IRIS പ്ലാറ്റ്‌ഫോമിലെ ലൈനുകൾ 3 പ്രതീകങ്ങളായി പരിമിതപ്പെടുത്തിയിരിക്കുന്നു, നിങ്ങൾക്ക് ഒരു ദൈർഘ്യമേറിയ കോഡ് എക്‌സിക്യൂട്ട് ചെയ്യണമെങ്കിൽ, നിങ്ങൾ ത്രെഡുകൾ ഉപയോഗിക്കേണ്ടതുണ്ട്.
രണ്ട് വാദങ്ങൾ അംഗീകരിക്കുന്നു:

code - എക്സിക്യൂട്ട് ചെയ്യേണ്ട പൈത്തൺ കോഡിന്റെ ഒരു ലൈൻ അല്ലെങ്കിൽ സ്ട്രീം.
variable - (ഓപ്ഷണൽ) നിർവ്വഹണത്തിന്റെ ഫലം നൽകുന്നു code ഈ പൈത്തൺ വേരിയബിൾ.

ഉപയോഗിക്കാനുള്ള ഉദാഹരണം:

set sc = ##class(isc.py.Main).ExecuteCode("2*3", "y").

ഈ ഉദാഹരണത്തിൽ, നമ്മൾ 2 കൊണ്ട് 3 കൊണ്ട് ഗുണിച്ച് ഫലം ഒരു പൈത്തൺ വേരിയബിളിലേക്ക് എഴുതുന്നു y.

ഡാറ്റ കൈമാറ്റം

പൈത്തണിലേക്കും പുറത്തേക്കും ഡാറ്റ കൈമാറുക.

പൈത്തൺ -> ഇന്റർസിസ്റ്റംസ് IRIS

നിങ്ങൾക്ക് ആവശ്യമുള്ള സീരിയലൈസേഷൻ അനുസരിച്ച്, InterSystems IRIS-ൽ ഒരു പൈത്തൺ വേരിയബിളിന്റെ മൂല്യം ലഭിക്കുന്നതിന് 4 വഴികളുണ്ട്:

String ലളിതമായ ഡാറ്റ തരങ്ങൾക്കും ഡീബഗ്ഗിംഗിനും.
Repr ലളിതമായ വസ്തുക്കൾ സംഭരിക്കുന്നതിനും ഡീബഗ്ഗിംഗിനും.
JSON ഇന്റർസിസ്റ്റംസ് IRIS വശത്ത് എളുപ്പത്തിൽ ഡാറ്റ കൈകാര്യം ചെയ്യുന്നതിനായി.
Pickle വസ്തുക്കൾ സംരക്ഷിക്കാൻ.

പൈത്തണിൽ നിന്ന് ഒരു സ്ട്രിംഗ് അല്ലെങ്കിൽ സ്ട്രീം ആയി വേരിയബിളുകൾ വീണ്ടെടുക്കാൻ ഈ രീതികൾ നിങ്ങളെ അനുവദിക്കുന്നു.

GetVariable(variable, serialization, .stream, useString) - നേടുക serialization വേരിയബിൾ variable в stream. എങ്കിൽ useString 1 ആണ്, സീരിയലൈസേഷൻ ഒരു സ്ട്രിംഗിൽ സ്ഥാപിക്കുന്നു, തുടർന്ന് ഒരു സ്ട്രിംഗ് തിരികെ നൽകുന്നു, ഒരു സ്ട്രീം അല്ല.
GetVariableJson(variable, .stream, useString) — ഒരു വേരിയബിളിന്റെ JSON സീരിയലൈസേഷൻ നേടുക.
GetVariablePickle(variable, .stream, useString, useDill) ഒരു വേരിയബിളിന്റെ അച്ചാർ (അല്ലെങ്കിൽ ചതകുപ്പ) സീരിയലൈസേഷൻ നേടുക.

നമുക്ക് നമ്മുടെ വേരിയബിൾ ലഭിക്കാൻ ശ്രമിക്കാം y.

set sc = ##class(isc.py.Main).GetVariable("y", , .val, 1)
write val
>6

ഇന്റർസിസ്റ്റംസ് IRIS -> പൈത്തൺ

InterSystems IRIS-ൽ നിന്ന് പൈത്തണിലേക്ക് ഡാറ്റ ലോഡ് ചെയ്യുന്നു.

ExecuteQuery(query, variable, type, namespace) - ഒരു ഡാറ്റാസെറ്റ് സൃഷ്ടിക്കുന്നു (പാണ്ടകൾ dataframe അഥവാ list) sql ചോദ്യത്തിൽ നിന്ന് അത് ഒരു പൈത്തൺ വേരിയബിളായി സജ്ജമാക്കുന്നു variable. പ്ലാസ്റ്റിക് സഞ്ചി isc.py പ്രദേശത്ത് ലഭ്യമായിരിക്കണം namespace - അഭ്യർത്ഥന അവിടെ നടപ്പിലാക്കും.
ExecuteGlobal(global, variable, type, start, end, mask, labels, namespace) - ആഗോള ഡാറ്റ ലോഡ് ചെയ്യുന്നു global സബ്സ്ക്രിപ്റ്റിൽ നിന്ന് start ഇതിനായി end ഒരു തരം വേരിയബിളായി പൈത്തണിൽ type: list, അല്ലെങ്കിൽ പാണ്ടകൾ dataframe. ഓപ്ഷണൽ ആർഗ്യുമെന്റുകളുടെ വിവരണം mask ഒപ്പം labels ക്ലാസ് ഡോക്യുമെന്റേഷനിലും റിപ്പോസിറ്ററിയിലും ലഭ്യമാണ് ഡാറ്റ ട്രാൻസ്ഫർ ഡോക്‌സ്.
ExecuteClass(class, variable, type, start, end, properties, namespace) - ക്ലാസ് ഡാറ്റ ലോഡ് ചെയ്യുന്നു class ഐഡിയിൽ നിന്ന് start ഇതിനായി end ഒരു തരം വേരിയബിളായി പൈത്തണിൽ type: list, അല്ലെങ്കിൽ പാണ്ടകൾ dataframe. properties — ഡാറ്റാ സെറ്റിലേക്ക് ലോഡ് ചെയ്യേണ്ട ക്ലാസ് പ്രോപ്പർട്ടികളുടെ ഒരു ലിസ്റ്റ് (കോമയാൽ വേർതിരിച്ചിരിക്കുന്നു). മാസ്കുകൾ പിന്തുണയ്ക്കുന്നു * и ?. സ്ഥിരസ്ഥിതി - * (എല്ലാ സ്വത്തുക്കളും). സ്വത്ത് %%CLASSNAME അവഗണിച്ചു.
ExecuteTable(table, variable, type, start, end, properties, namespace) - പട്ടിക ഡാറ്റ ലോഡ് ചെയ്യുന്നു table ഐഡിയിൽ നിന്ന് start ഇതിനായി end പൈത്തണിൽ.

ExecuteQuery — സാർവത്രികം (ഏത് ശരിയായ SQL അന്വേഷണവും പൈത്തണിലേക്ക് കൈമാറും). എന്നിരുന്നാലും, ExecuteGlobal അതിന്റെ പൊതികളും ExecuteClass и ExecuteTable നിരവധി നിയന്ത്രണങ്ങളോടെ പ്രവർത്തിക്കുക. അവ വളരെ വേഗതയുള്ളതാണ് (ODBC ഡ്രൈവറിനേക്കാൾ 3-5 മടങ്ങ് വേഗതയും 20 മടങ്ങ് വേഗതയും ExecuteQuery). കൂടുതൽ വിവരങ്ങൾ ഇവിടെ ഡാറ്റ ട്രാൻസ്ഫർ ഡോക്‌സ്.
ഈ രീതികളെല്ലാം ഏത് പ്രദേശത്തുനിന്നും ഡാറ്റ കൈമാറ്റത്തെ പിന്തുണയ്ക്കുന്നു. പ്ലാസ്റ്റിക് സഞ്ചി isc.py ടാർഗെറ്റ് ഏരിയയിൽ ലഭ്യമായിരിക്കണം.

എക്സിക്യൂട്ട് ക്വറി

ExecuteQuery(request, variable, type, namespace) - ഏതെങ്കിലും ശരിയായ SQL അന്വേഷണത്തിന്റെ ഫലങ്ങൾ പൈത്തണിലേക്ക് മാറ്റുന്നു. ഇതാണ് ഏറ്റവും വേഗത കുറഞ്ഞ ഡാറ്റ കൈമാറ്റ രീതി. ഉണ്ടെങ്കിൽ അത് ഉപയോഗിക്കുക ExecuteGlobal കൂടാതെ അതിന്റെ പൊതികളും ലഭ്യമല്ല.

വാദങ്ങൾ:

query - sql അന്വേഷണം.
variable — ഡാറ്റ എഴുതിയിരിക്കുന്ന പൈത്തൺ വേരിയബിളിന്റെ പേര്.
type - list അല്ലെങ്കിൽ പാണ്ടകൾ dataframe.
namespace - അഭ്യർത്ഥന നടപ്പിലാക്കുന്ന പ്രദേശം.

എക്സിക്യൂട്ട് ഗ്ലോബൽ

ExecuteGlobal(global, variable, type, start, end, mask, labelels, namespace) - പൈത്തണിൽ ഒരു ഗ്ലോബൽ കടന്നുപോകുന്നു.

വാദങ്ങൾ:

global - ഇല്ലാതെ ആഗോള നാമം ^
variable — ഡാറ്റ എഴുതിയിരിക്കുന്ന പൈത്തൺ വേരിയബിളിന്റെ പേര്.
type - list അല്ലെങ്കിൽ പാണ്ടകൾ dataframe.
start - ഗ്ലോബലിന്റെ ആദ്യ സബ്സ്ക്രിപ്റ്റ്. നിർബന്ധമായും %Integer.
end - ഗ്ലോബലിന്റെ അവസാന സബ്സ്ക്രിപ്റ്റ്. നിർബന്ധമായും %Integer.
mask - ആഗോള മൂല്യ മാസ്ക്. ഗ്ലോബൽ ഫീൽഡുകളുടെ എണ്ണത്തേക്കാൾ ചെറുതായിരിക്കും മാസ്ക് (അങ്ങനെയെങ്കിൽ അവസാനത്തെ ഫീൽഡുകൾ ഒഴിവാക്കപ്പെടും). ഒരു മാസ്ക് എങ്ങനെ ഫോർമാറ്റ് ചെയ്യാം:
- + മൂല്യം അതേപടി കൈമാറുക.
- - മൂല്യം ഒഴിവാക്കുക.
- b - ബൂളിയൻ തരം (0 - False, ബാക്കി എല്ലാം - True).
- d — തീയതി ($ horolog മുതൽ, 1970 മുതൽ Windows-ൽ, 1900 മുതൽ Linux-ൽ).
- t — സമയം ($horolog, അർദ്ധരാത്രിക്ക് ശേഷമുള്ള സെക്കന്റുകൾ).
- m - ടൈംസ്റ്റാമ്പ് (ഫോർമാറ്റ് സ്ട്രിംഗ് വർഷം-മാസം-ദിവസം HOUR:MINUTE:SECOND).
labels — % കോളം പേരുകളുടെ ലിസ്റ്റ്. ആദ്യ ഘടകം സബ്സ്ക്രിപ്റ്റിന്റെ പേരാണ്.
namespace - അഭ്യർത്ഥന നടപ്പിലാക്കുന്ന പ്രദേശം.

എക്സിക്യൂട്ട്ക്ലാസ്

പൊതിയുക ExecuteGlobal. ക്ലാസ് നിർവചനത്തെ അടിസ്ഥാനമാക്കി, ഒരു കോൾ തയ്യാറാക്കുന്നു ExecuteGlobal അവനെ വിളിക്കുന്നു.

ExecuteClass(class, variable, type, start, end, properties, namespace) - പൈത്തണിൽ ക്ലാസ് ഡാറ്റ കടന്നുപോകുന്നു.

വാദങ്ങൾ:

class - ക്ലാസ്സിന്റെ പേര്
variable — ഡാറ്റ എഴുതിയിരിക്കുന്ന പൈത്തൺ വേരിയബിളിന്റെ പേര്.
type - list അല്ലെങ്കിൽ പാണ്ടകൾ dataframe.
start - ആരംഭ ഐഡി.
end - അന്തിമ ഐഡി
properties — ഡാറ്റാ സെറ്റിലേക്ക് ലോഡ് ചെയ്യേണ്ട ക്ലാസ് പ്രോപ്പർട്ടികളുടെ ഒരു ലിസ്റ്റ് (കോമയാൽ വേർതിരിച്ചിരിക്കുന്നു). മാസ്കുകൾ പിന്തുണയ്ക്കുന്നു * и ?. സ്ഥിരസ്ഥിതി - * (എല്ലാ സ്വത്തുക്കളും). സ്വത്ത് %%CLASSNAME അവഗണിച്ചു.
namespace - അഭ്യർത്ഥന നടപ്പിലാക്കുന്ന പ്രദേശം.

തരം പ്രോപ്പർട്ടികൾ ഒഴികെ എല്ലാ പ്രോപ്പർട്ടികളും പാസ്സാക്കുന്നു %Date, %Time, %Boolean и %TimeStamp - അവ അനുബന്ധ പൈത്തൺ ക്ലാസുകളിലേക്ക് പരിവർത്തനം ചെയ്യപ്പെടുന്നു.

എക്സിക്യൂട്ട് ടേബിൾ

പൊതിയുക ExecuteClass. പട്ടികയുടെ പേര് ക്ലാസ് നാമത്തിലേക്കും കോളുകളിലേക്കും വിവർത്തനം ചെയ്യുന്നു ExecuteClass. കയ്യൊപ്പ്:

ExecuteTable(table, variable, type, start, end, properties, namespace) - പൈത്തണിലേക്ക് ടേബിൾ ഡാറ്റ കൈമാറുന്നു.

വാദങ്ങൾ:

table - പട്ടികയുടെ പേര്.
മറ്റെല്ലാ വാദങ്ങളും അതേപടി പാസാക്കുന്നു ExecuteClass.

കുറിപ്പുകൾ

ExecuteGlobal, ExecuteClass и ExecuteTable ഒരേ വേഗത്തിൽ പ്രവർത്തിക്കുക.
ExecuteGlobal 20 മടങ്ങ് വേഗത്തിൽ ExecuteQuery വലിയ ഡാറ്റാ സെറ്റുകളിൽ (കൈമാറ്റ സമയം>0.01 സെക്കൻഡ്).
ExecuteGlobal, ExecuteClass и ExecuteTable ഈ ഘടന ഉപയോഗിച്ച് ആഗോളതലത്തിൽ പ്രവർത്തിക്കുക: ^global(key) = $lb(prop1, prop2, ..., propN) എവിടെ key - ഒരു പൂർണ്ണസംഖ്യ.
വേണ്ടി ExecuteGlobal, ExecuteClass и ExecuteTable മൂല്യങ്ങളുടെ പിന്തുണയുള്ള ശ്രേണി %Date ശ്രേണിയുമായി പൊരുത്തപ്പെടുന്നു mktime കൂടാതെ OS-നെ ആശ്രയിച്ചിരിക്കുന്നു (Windows: 1970-01-01, ലിനക്സ് 1900-01-01, മാക്). ഉപയോഗിക്കുക %TimeStampഈ ശ്രേണിക്ക് പുറത്ത് ഡാറ്റ കൈമാറുന്നതിനോ അല്ലെങ്കിൽ പാണ്ടാസ് ഡാറ്റഫ്രെയിം ഉപയോഗിക്കുന്നതിനോ കാരണം ഇതൊരു ലിസ്റ്റ് മാത്രമുള്ള പരിമിതിയാണ്.
വേണ്ടി ExecuteGlobal, ExecuteClass и ExecuteTable ഡാറ്റ ഉറവിടവും (ഗ്ലോബൽ, ക്ലാസ് അല്ലെങ്കിൽ ടേബിൾ) വേരിയബിളും ഒഴികെയുള്ള എല്ലാ ആർഗ്യുമെന്റുകളും ഓപ്ഷണൽ ആണ്.

ഉദാഹരണങ്ങൾ

ടെസ്റ്റ് ക്ലാസ് isc.py.test.Person എല്ലാ ഡാറ്റാ ട്രാൻസ്ഫർ ഓപ്ഷനുകളും പ്രദർശിപ്പിക്കുന്ന ഒരു രീതി അടങ്ങിയിരിക്കുന്നു:

set global = "isc.py.test.PersonD"
set class = "isc.py.test.Person"
set table = "isc_py_test.Person"
set query = "SELECT * FROM isc_py_test.Person"

// Общие аргументы
set variable = "df"
set type = "dataframe"
set start = 1
set end = $g(^isc.py.test.PersonD, start)

// Способ 0: ExecuteGlobal без аргументов
set sc = ##class(isc.py.Main).ExecuteGlobal(global, variable _ 0, type)

// Способ 1: ExecuteGlobal с аргументами    
// При передаче глобала названия полей задаются вручную
// globalKey - название сабсткрипта 
set labels = $lb("globalKey", "Name", "DOB", "TS", "RandomTime", "AgeYears", "AgeDecimal", "AgeDouble", "Bool")

// mask содержит на 1 элемент меньше чем labels потому что "globalKey" - название сабскипта
// Пропускаем %%CLASSNAME
set mask = "-+dmt+++b"

set sc = ##class(isc.py.Main).ExecuteGlobal(global, variable _ 1, type, start, end, mask, labels)

// Способ 2: ExecuteClass
set sc = ##class(isc.py.Main).ExecuteClass(class, variable _ 2, type, start, end)

// Способ 3: ExecuteTable
set sc = ##class(isc.py.Main).ExecuteTable(table, variable _ 3, type, start, end)

// Способ 4: ExecuteTable
set sc = ##class(isc.py.Main).ExecuteQuery(query, variable _ 4, type)

രീതി വിളിക്കുക do ##class(isc.py.test.Person).Test() എല്ലാ ഡാറ്റ കൈമാറ്റ രീതികളും എങ്ങനെ പ്രവർത്തിക്കുന്നുവെന്ന് കാണാൻ.

സഹായ രീതികൾ

GetVariableInfo(variable, serialization, .defined, .type, .length) - വേരിയബിളിനെക്കുറിച്ചുള്ള വിവരങ്ങൾ നേടുക: അത് നിർവചിച്ചിട്ടുണ്ടോ, അതിന്റെ ക്ലാസും സീരിയലൈസേഷൻ ദൈർഘ്യവും.
GetVariableDefined(variable, .defined) - വേരിയബിൾ നിർവചിച്ചിട്ടുണ്ടോ എന്ന്.
GetVariableType(variable, .type) - വേരിയബിളിന്റെ ക്ലാസ് നേടുക.
GetStatus() - പൈത്തൺ വശത്തെ അവസാനത്തെ ഒഴിവാക്കൽ നേടുകയും നീക്കം ചെയ്യുകയും ചെയ്യുക.
GetModuleInfo(module, .imported, .alias) - മൊഡ്യൂൾ വേരിയബിളും ഇറക്കുമതി നിലയും നേടുക.
GetFunctionInfo(function, .defined, .type, .docs, .signature, .arguments) - പ്രവർത്തനത്തെക്കുറിച്ചുള്ള വിവരങ്ങൾ നേടുക.

പരസ്പര പ്രവർത്തനക്ഷമത

ടെർമിനലിൽ നിന്ന് പൈത്തൺ ഗേറ്റ്‌വേയെ എങ്ങനെ വിളിക്കാമെന്ന് നിങ്ങൾ പഠിച്ചു, ഇപ്പോൾ നമുക്ക് അത് നിർമ്മാണത്തിൽ ഉപയോഗിക്കാൻ തുടങ്ങാം. ഈ മോഡിൽ പൈത്തണുമായി സംവദിക്കുന്നതിനുള്ള അടിസ്ഥാനം isc.py.ens.Operation. ഇത് ഞങ്ങളെ അനുവദിക്കുന്നു:

പൈത്തണിൽ കോഡ് എക്സിക്യൂട്ട് ചെയ്യുക
പൈത്തൺ സന്ദർഭം സംരക്ഷിക്കുക/പുനഃസ്ഥാപിക്കുക
പൈത്തണിൽ നിന്ന് ഡാറ്റ ലോഡുചെയ്യുക, സ്വീകരിക്കുക

അടിസ്ഥാനപരമായി, ഒരു പൈത്തൺ ഓപ്പറേഷൻ ഒരു റാപ്പർ ഓവർ ആണ് isc.py.Main. ഓപ്പറേഷൻ isc.py.ens.Operation InterSystems IRIS ഉൽപ്പന്നങ്ങളിൽ നിന്ന് പൈത്തൺ പ്രക്രിയയുമായി സംവദിക്കാനുള്ള കഴിവ് നൽകുന്നു. അഞ്ച് ചോദ്യങ്ങൾ പിന്തുണയ്ക്കുന്നു:

isc.py.msg.ExecutionRequest പൈത്തൺ കോഡ് എക്സിക്യൂട്ട് ചെയ്യാൻ. മടങ്ങുന്നു isc.py.msg.ExecutionResponse എക്സിക്യൂഷൻ ഫലവും ആവശ്യപ്പെട്ട വേരിയബിളുകളുടെ മൂല്യങ്ങളും.
isc.py.msg.StreamExecutionRequest പൈത്തൺ കോഡ് എക്സിക്യൂട്ട് ചെയ്യാൻ. മടങ്ങുന്നു isc.py.msg.StreamExecutionResponse നിർവ്വഹണത്തിന്റെ ഫലവും അഭ്യർത്ഥിച്ച വേരിയബിളുകളുടെ മൂല്യങ്ങളും. അനലോഗ് isc.py.msg.ExecutionRequest, എന്നാൽ സ്ട്രീമുകൾക്ക് പകരം സ്ട്രീമുകൾ സ്വീകരിക്കുകയും തിരികെ നൽകുകയും ചെയ്യുന്നു.
isc.py.msg.QueryRequest ഒരു SQL അന്വേഷണം നടപ്പിലാക്കുന്നതിന്റെ ഫലം കൈമാറാൻ. മടങ്ങുന്നു Ens.Response.
isc.py.msg.GlobalRequest/isc.py.msg.ClassRequest/isc.py.msg.TableRequest ആഗോള/ക്ലാസ്/ടേബിൾ ഡാറ്റ കടന്നുപോകുന്നതിന്. മടങ്ങുന്നു Ens.Response.
isc.py.msg.SaveRequest പൈത്തൺ സന്ദർഭം സംരക്ഷിക്കാൻ. മടങ്ങുന്നു Ens.StringResponse സന്ദർഭ ഐഡി ഉപയോഗിച്ച്.
isc.py.msg.RestoreRequest പൈത്തൺ സന്ദർഭം പുനഃസ്ഥാപിക്കാൻ.

കൂടാതെ, isc.py.ens.Operation രണ്ട് ക്രമീകരണങ്ങൾ ഉണ്ട്:
- Initializer — ഇന്റർഫേസ് നടപ്പിലാക്കുന്ന ഒരു ക്ലാസ് തിരഞ്ഞെടുക്കുന്നു isc.py.init.Abstract. ഫംഗ്‌ഷനുകൾ, മൊഡ്യൂളുകൾ, ക്ലാസുകൾ മുതലായവ ലോഡ് ചെയ്യാൻ ഇത് ഉപയോഗിക്കാം. പ്രക്രിയ ആരംഭിക്കുമ്പോൾ ഇത് ഒരിക്കൽ എക്സിക്യൂട്ട് ചെയ്യുന്നു.
- PythonLib - (ലിനക്സ് മാത്രം) ലോഡുചെയ്യുമ്പോൾ പിശകുകൾ കാണുകയാണെങ്കിൽ, അതിന്റെ മൂല്യം ഇതായി സജ്ജമാക്കുക libpython3.6m.so അല്ലെങ്കിൽ പൈത്തൺ ലൈബ്രറിയിലേക്കുള്ള മുഴുവൻ പാതയിലും.

ബിസിനസ്സ് പ്രക്രിയകളുടെ സൃഷ്ടി

ബിസിനസ്സ് പ്രക്രിയകളുടെ വികസനം സുഗമമാക്കുന്ന രണ്ട് ക്ലാസുകൾ ലഭ്യമാണ്:

isc.py.ens.ProcessUtils വേരിയബിൾ സബ്സ്റ്റിറ്റ്യൂഷനോടുകൂടിയ പ്രവർത്തനങ്ങളിൽ നിന്ന് വ്യാഖ്യാനങ്ങൾ വേർതിരിച്ചെടുക്കാൻ നിങ്ങളെ അനുവദിക്കുന്നു.
isc.py.util.BPEmulator പൈത്തൺ ഉപയോഗിച്ച് ബിസിനസ്സ് പ്രക്രിയകൾ പരിശോധിക്കുന്നത് എളുപ്പമാക്കുന്നു. ഇതിന് നിലവിലെ പ്രക്രിയയിൽ ഒരു ബിസിനസ് പ്രക്രിയ (പൈത്തൺ ഭാഗങ്ങൾ) നടപ്പിലാക്കാൻ കഴിയും.

വേരിയബിൾ സബ്സ്റ്റിറ്റ്യൂഷൻ

എല്ലാ ബിസിനസ് പ്രക്രിയകളും പാരമ്പര്യമായി ലഭിക്കുന്നു isc.py.ens.ProcessUtils, രീതി ഉപയോഗിക്കാം GetAnnotation(name) പ്രവർത്തന വ്യാഖ്യാന മൂല്യം അതിന്റെ പേരിൽ ലഭിക്കാൻ. പ്രവർത്തന വ്യാഖ്യാനത്തിൽ പൈത്തണിലേക്ക് കൈമാറുന്നതിന് മുമ്പ് ഇന്റർസിസ്റ്റംസ് IRIS വശത്ത് കണക്കാക്കുന്ന വേരിയബിളുകൾ അടങ്ങിയിരിക്കാം. വേരിയബിൾ സബ്സ്റ്റിറ്റ്യൂഷനുള്ള വാക്യഘടന ഇതാ:

${class:method:arg1:...:argN} - രീതി കോൾ
#{expr} — ഒബ്ജക്റ്റ്സ്ക്രിപ്റ്റ് ഭാഷയിൽ കോഡ് എക്സിക്യൂട്ട് ചെയ്യുക.

ടെസ്റ്റ് ബിസിനസ് പ്രക്രിയയിൽ ഒരു ഉദാഹരണം ലഭ്യമാണ് isc.py.test.Process, ഉദാഹരണത്തിന്, പ്രവർത്തനത്തിൽ Correlation Matrix: Graph: f.savefig(r'#{process.WorkDirectory}SHOWCASE${%PopulateUtils:Integer:1:100}.png'). ഈ ഉദാഹരണത്തിൽ:

#{process.WorkDirectory} വസ്തുവിന്റെ വർക്ക്ഡയറക്‌ടറി പ്രോപ്പർട്ടി തിരികെ നൽകുന്നു process, ഇത് ക്ലാസിന്റെ ഒരു ഉദാഹരണമാണ് isc.py.test.Process ആ. നിലവിലെ ബിസിനസ്സ് പ്രക്രിയ.
${%PopulateUtils:Integer:1:100} ഒരു രീതി വിളിക്കുന്നു Integer ക്ലാസ് %PopulateUtils, വാദങ്ങൾ പാസാക്കുന്നു 1 и 100, ശ്രേണിയിൽ ഒരു ക്രമരഹിത പൂർണ്ണസംഖ്യ നൽകുന്നു 1...100.

ബിസിനസ്സ് പ്രക്രിയ പരീക്ഷിക്കുക

പൈത്തൺ ഗേറ്റ്‌വേയുടെ ഭാഗമായി ടെസ്റ്റ് ഉൽപ്പന്നങ്ങളും ടെസ്റ്റ് ബിസിനസ് പ്രക്രിയകളും ഡിഫോൾട്ടായി ലഭ്യമാണ്. അവ ഉപയോഗിക്കുന്നതിന്:

OS ടെർമിനലിൽ, പ്രവർത്തിപ്പിക്കുക: pip install pandas matplotlib seaborn.
InterSystems IRIS ടെർമിനലിൽ, പ്രവർത്തിപ്പിക്കുക: do ##class(isc.py.test.CannibalizationData).Import() ടെസ്റ്റ് ഡാറ്റ പൂരിപ്പിക്കുന്നതിന്.
ഉൽപ്പന്നങ്ങൾ സമാരംഭിക്കുക isc.py.test.Production.
അഭ്യർത്ഥന തരം അയയ്ക്കുക Ens.Request в isc.py.test.Process.

എല്ലാം ഒരുമിച്ച് എങ്ങനെ പ്രവർത്തിക്കുന്നുവെന്ന് നോക്കാം. തുറക്കുക isc.py.test.Process BPL എഡിറ്ററിൽ:

കോഡ് എക്സിക്യൂഷൻ

പൈത്തൺ കോഡ് നടപ്പിലാക്കുക എന്നതാണ് ഏറ്റവും പ്രധാനപ്പെട്ട വെല്ലുവിളി:

ചോദ്യം ഉപയോഗിച്ചു isc.py.msg.ExecutionRequest, അതിന്റെ ഗുണങ്ങൾ ഇതാ:

Code - പൈത്തൺ കോഡ്.
SeparateLines - നിർവ്വഹണത്തിനായി കോഡ് വരികളായി വിഭജിക്കണോ എന്ന്. $c(10) (n) സ്ട്രിംഗുകൾ വേർതിരിക്കാൻ ഉപയോഗിക്കുന്നു. മുഴുവൻ സന്ദേശവും ഒരേസമയം പ്രോസസ്സ് ചെയ്യാൻ ശുപാർശ ചെയ്യുന്നില്ല എന്നത് ശ്രദ്ധിക്കുക, ഈ ഫംഗ്‌ഷൻ പ്രോസസ്സ് ചെയ്യാൻ ഉദ്ദേശിച്ചുള്ളതാണ് def സമാനമായ മൾട്ടിലൈൻ എക്സ്പ്രഷനുകളും. സ്ഥിരസ്ഥിതി 0.
Variables — പ്രതികരണത്തിൽ ചേർക്കുന്ന വേരിയബിളുകളുടെ കോമയാൽ വേർതിരിച്ച ലിസ്റ്റ്.
Serialization — ഞങ്ങൾ തിരികെ നൽകാൻ ആഗ്രഹിക്കുന്ന വേരിയബിളുകൾ എങ്ങനെ സീരിയലൈസ് ചെയ്യാം. ഓപ്ഷനുകൾ: Str, Repr, JSON, Pickle и Dill, സ്ഥിരസ്ഥിതി Str.

ഞങ്ങളുടെ കാര്യത്തിൽ, ഞങ്ങൾ പ്രോപ്പർട്ടി മാത്രമേ സജ്ജമാക്കൂ Code, അതിനാൽ മറ്റെല്ലാ പ്രോപ്പർട്ടികളും ഡിഫോൾട്ട് മൂല്യങ്ങൾ ഉപയോഗിക്കുന്നു. വിളിച്ച് ഞങ്ങൾ അത് സജ്ജമാക്കി process.GetAnnotation("Import pandas"), ഇത് റൺടൈമിൽ വേരിയബിൾ സബ്സ്റ്റിറ്റ്യൂഷൻ നടത്തിയതിന് ശേഷം ഒരു വ്യാഖ്യാനം നൽകുന്നു. എല്ലാത്തിനുമുപരി, കോഡ് import pandas as pd പൈത്തണിന് കൈമാറും. GetAnnotation മൾട്ടി-ലൈൻ പൈത്തൺ സ്ക്രിപ്റ്റുകൾ ലഭിക്കുന്നതിന് ഉപയോഗപ്രദമായേക്കാം, എന്നാൽ കോഡ് നേടുന്നതിനുള്ള ഈ രീതിക്ക് നിയന്ത്രണങ്ങളൊന്നുമില്ല. നിങ്ങൾക്ക് പ്രോപ്പർട്ടി സജ്ജമാക്കാൻ കഴിയും Code നിങ്ങൾക്ക് സൗകര്യപ്രദമായ ഏതെങ്കിലും വിധത്തിൽ.

വേരിയബിളുകൾ നേടുന്നു

ഉപയോഗിക്കുന്നത് മറ്റൊരു രസകരമായ വെല്ലുവിളി isc.py.msg.ExecutionRequest - Correlation Matrix: Tabular:

ഇത് പൈത്തൺ വശത്തുള്ള കോറിലേഷൻ മാട്രിക്സ് കണക്കാക്കുകയും വേരിയബിൾ എക്സ്ട്രാക്റ്റ് ചെയ്യുകയും ചെയ്യുന്നു corrmat അഭ്യർത്ഥന പ്രോപ്പർട്ടികൾ സജ്ജീകരിച്ചുകൊണ്ട് JSON ഫോർമാറ്റിലുള്ള InterSystems IRIS-ലേക്ക് മടങ്ങുക:

Variables: "corrmat"
Serialization: "JSON"

വിഷ്വൽ ട്രേസിൽ നമുക്ക് ഫലങ്ങൾ കാണാൻ കഴിയും:

ബിപിയിൽ ഈ മൂല്യം വേണമെങ്കിൽ, നമുക്ക് ഇത് ഇതുപോലെ ലഭിക്കും: callresponse.Variables.GetAt("corrmat").

ഡാറ്റ കൈമാറ്റം

അടുത്തതായി, InterSystems IRIS-ൽ നിന്ന് Python-ലേക്ക് ഡാറ്റ കൈമാറുന്നതിനെക്കുറിച്ച് സംസാരിക്കാം; ഡാറ്റ കൈമാറ്റത്തിനുള്ള എല്ലാ അഭ്യർത്ഥനകളും ഇന്റർഫേസ് നടപ്പിലാക്കുന്നു isc.py.msg.DataRequestഇത് ഇനിപ്പറയുന്ന ഗുണങ്ങൾ നൽകുന്നു:

Variable — ഡാറ്റ എഴുതിയിരിക്കുന്ന ഒരു പൈത്തൺ വേരിയബിൾ.
Type - വേരിയബിൾ തരം: dataframe (പാണ്ടസ് ഡാറ്റാഫ്രെയിം) അല്ലെങ്കിൽ list.
Namespace — ഞങ്ങൾക്ക് ഡാറ്റ ലഭിക്കുന്ന മേഖല. പ്ലാസ്റ്റിക് സഞ്ചി isc.py ഈ മേഖലയിൽ ലഭ്യമാകണം. ഇത് ഉൽപ്പന്ന പിന്തുണയില്ലാത്ത ഒരു മേഖലയായിരിക്കാം.

ഈ ഇന്റർഫേസിനെ അടിസ്ഥാനമാക്കി, 4 തരം അഭ്യർത്ഥനകൾ നടപ്പിലാക്കുന്നു:

isc.py.msg.QueryRequest - സ്വത്ത് സജ്ജമാക്കുക Query ഒരു SQL അന്വേഷണം അയയ്ക്കാൻ.
isc.py.msg.ClassRequest - സ്വത്ത് സജ്ജമാക്കുക Class ക്ലാസ് ഡാറ്റ കൈമാറാൻ.
isc.py.msg.TableRequest - സ്വത്ത് സജ്ജമാക്കുക Table പട്ടിക ഡാറ്റ കൈമാറാൻ.
isc.py.msg.GlobalRequest - സ്വത്ത് സജ്ജമാക്കുക Global ആഗോള ഡാറ്റ കൈമാറ്റത്തിനായി.

പരീക്ഷണ പ്രക്രിയയിൽ, പ്രവർത്തനം നോക്കുക RAWഎവിടെ isc.py.msg.QueryRequest പ്രവർത്തനത്തിൽ കാണിച്ചിരിക്കുന്നു.

പൈത്തൺ സന്ദർഭം സംരക്ഷിക്കുന്നു/പുനഃസ്ഥാപിക്കുന്നു

അവസാനമായി, നമുക്ക് പൈത്തൺ സന്ദർഭം InterSystems IRIS-ൽ സംരക്ഷിക്കാൻ കഴിയും, ഇത് ചെയ്യുന്നതിന് ഞങ്ങൾ അയയ്ക്കും isc.py.msg.SaveRequest വാദങ്ങൾക്കൊപ്പം:

Mask — മാസ്കുമായി പൊരുത്തപ്പെടുന്ന വേരിയബിളുകൾ മാത്രമേ സംരക്ഷിക്കപ്പെടുകയുള്ളൂ. പിന്തുണച്ചു * и ?. ഉദാഹരണം: "Data*, Figure?". സ്ഥിരസ്ഥിതി *.
MaxLength - സംഭരിച്ചിരിക്കുന്ന വേരിയബിളിന്റെ പരമാവധി ദൈർഘ്യം. ഒരു വേരിയബിളിന്റെ സീരിയലൈസേഷൻ ദൈർഘ്യമേറിയതാണെങ്കിൽ, അത് അവഗണിക്കപ്പെടും. ഏത് നീളത്തിലുമുള്ള വേരിയബിളുകൾ ലഭിക്കുന്നതിന് 0 ആയി സജ്ജമാക്കുക. സ്ഥിരസ്ഥിതി $$$MaxStringLength.
Name - സന്ദർഭ നാമം (ഓപ്ഷണൽ).
Description - സന്ദർഭത്തിന്റെ വിവരണം (ഓപ്ഷണൽ).

റിട്ടേൺസ് Ens.StringResponse с Id സംരക്ഷിച്ച സന്ദർഭം. ടെസ്റ്റ് പ്രക്രിയയിൽ, പ്രവർത്തനം നോക്കുക Save Context.

ബന്ധപ്പെട്ട അഭ്യർത്ഥന isc.py.msg.RestoreRequest InterSystems IRIS-ൽ നിന്ന് പൈത്തണിലേക്ക് സന്ദർഭം ലോഡ് ചെയ്യുന്നു:

ContextId - സന്ദർഭ ഐഡന്റിഫയർ.
Clear - പുനഃസ്ഥാപിക്കുന്നതിന് മുമ്പ് സന്ദർഭം മായ്‌ക്കുക.

ജൂപ്പിറ്റർ നോട്ട്ബുക്ക്

ജൂപ്പിറ്റർ നോട്ട്ബുക്ക് കോഡ്, വിഷ്വലൈസേഷനുകൾ, ടെക്സ്റ്റ് എന്നിവ അടങ്ങിയ നോട്ട്ബുക്കുകൾ സൃഷ്ടിക്കാനും പ്രസിദ്ധീകരിക്കാനും നിങ്ങളെ അനുവദിക്കുന്ന ഒരു ഓപ്പൺ സോഴ്സ് വെബ് ആപ്ലിക്കേഷനാണ്. ഒരു ജൂപ്പിറ്റർ നോട്ട്ബുക്കിന്റെ രൂപത്തിൽ BPL പ്രക്രിയകൾ കാണാനും എഡിറ്റ് ചെയ്യാനും പൈത്തൺ ഗേറ്റ്‌വേ നിങ്ങളെ അനുവദിക്കുന്നു. സാധാരണ പൈത്തൺ 3 എക്സിക്യൂട്ടർ ആണ് നിലവിൽ ഉപയോഗിക്കുന്നത് എന്നത് ശ്രദ്ധിക്കുക.

വ്യാഖ്യാനങ്ങളിൽ പൈത്തൺ കോഡ് ഉണ്ടെന്നും പ്രവർത്തന നാമങ്ങൾ മുൻ ശീർഷകങ്ങളായി ഉപയോഗിക്കുമെന്നും ഈ വിപുലീകരണം അനുമാനിക്കുന്നു. ജൂപ്പിറ്റർ നോട്ട്ബുക്കിൽ പൈത്തൺഗേറ്റ്‌വേ ബിസിനസ് പ്രക്രിയകൾ വികസിപ്പിക്കുന്നത് ഇപ്പോൾ സാധ്യമാണ്. സാധ്യമായത് ഇതാ:

പുതിയ ബിസിനസ്സ് പ്രക്രിയകൾ സൃഷ്ടിക്കുക
ബിസിനസ്സ് പ്രക്രിയകൾ ഇല്ലാതാക്കുക
പുതിയ പ്രവർത്തനങ്ങൾ സൃഷ്ടിക്കുക
പ്രവർത്തനങ്ങൾ മാറ്റുക
പ്രവർത്തനങ്ങൾ ഇല്ലാതാക്കുക

ഇവിടെ ഡെമോ വീഡിയോ. കൂടാതെ കുറച്ച് സ്ക്രീൻഷോട്ടുകളും:

പ്രോസസ്സ് എക്സ്പ്ലോറർ

പ്രോസസ്സ് എഡിറ്റർ

ഇൻസ്റ്റലേഷൻ

നിങ്ങൾക്ക് InterSystems IRIS 2019.2+ ആവശ്യമാണ്.
PythonGateway v0.8+ ഇൻസ്റ്റാൾ ചെയ്യുക (ആവശ്യത്തിന് മാത്രം isc.py.util.Jupyter, isc.py.util.JupyterCheckpoints и isc.py.ens.ProcessUtils).
റിപ്പോസിറ്ററിയിൽ നിന്ന് ഒബ്ജക്റ്റ്സ്ക്രിപ്റ്റ് കോഡ് അപ്ഡേറ്റ് ചെയ്യുക.
പ്രവർത്തിപ്പിക്കുക do ##class(isc.py.util.Jupyter).Install() നിർദ്ദേശങ്ങൾ പിന്തുടരുക.

ഡോക്യുമെന്റേഷൻ.

കണ്ടെത്തലുകൾ

MLToolkit എന്നത് മോഡലുകളും ഒരു ഇടപാട് അന്തരീക്ഷവും സംയോജിപ്പിക്കുക എന്ന ലക്ഷ്യത്തോടെയുള്ള ഉപകരണങ്ങളുടെ ഒരു കൂട്ടമാണ്, അതിലൂടെ നിർമ്മിച്ച മോഡലുകൾ നിങ്ങളുടെ ബിസിനസ്സ് പ്രക്രിയകളിൽ നേരിട്ട് ഉപയോഗിക്കാൻ കഴിയും. MLToolkit-ന്റെ ഭാഗമാണ് പൈത്തൺ ഗേറ്റ്‌വേ, പൈത്തൺ ഭാഷയുമായി സംയോജനം നൽകുന്നു, പൈത്തണിൽ (പല ഡാറ്റാ സയന്റിസ്റ്റുകളുടെയും പ്രധാന പരിസ്ഥിതി) സൃഷ്ടിച്ച ഏതെങ്കിലും മെഷീൻ ലേണിംഗ് അൽഗോരിതം ക്രമീകരിക്കാൻ നിങ്ങളെ അനുവദിക്കുന്നു, അഡാപ്റ്റീവ്, റോബോട്ടിക് അനലിറ്റിക്കൽ AI / വേഗത്തിൽ സൃഷ്ടിക്കാൻ നിരവധി റെഡിമെയ്ഡ് ലൈബ്രറികൾ ഉപയോഗിക്കുക. ഇന്റർസിസ്റ്റംസ് പ്ലാറ്റ്‌ഫോമായ IRIS-ലെ ML പരിഹാരങ്ങൾ.

റെഫറൻസുകൾ

MLToolkit

MLToolkit ഉപയോക്തൃ ഗ്രൂപ്പ് ഇന്റർസിസ്റ്റംസ് കോർപ്പറേറ്റ് GitHub ഓർഗനൈസേഷന്റെ ഭാഗമായി സൃഷ്ടിച്ച ഒരു സ്വകാര്യ GitHub ശേഖരമാണ്. പൈത്തൺ ഗേറ്റ്‌വേ ഉൾപ്പെടെയുള്ള MLToolkit ഘടകങ്ങൾ ഇൻസ്റ്റാൾ ചെയ്യുന്നതോ പഠിക്കുന്നതോ ഇതിനകം ഉപയോഗിക്കുന്നതോ ആയ ബാഹ്യ ഉപയോക്താക്കൾക്കായി ഇത് ഉദ്ദേശിച്ചുള്ളതാണ്. മാർക്കറ്റിംഗ്, മാനുഫാക്ചറിംഗ്, മെഡിസിൻ, മറ്റ് പല വ്യവസായ മേഖലകളിലും ഗ്രൂപ്പിന് നടപ്പിലാക്കിയ നിരവധി കേസുകൾ (സോഴ്സ് കോഡും ടെസ്റ്റ് ഡാറ്റയും സഹിതം) ഉണ്ട്. ML ടൂൾകിറ്റ് ഉപയോക്തൃ ഗ്രൂപ്പിൽ ചേരുന്നതിന്, ദയവായി ഇനിപ്പറയുന്ന വിലാസത്തിലേക്ക് ഒരു ചെറിയ ഇമെയിൽ അയയ്ക്കുക: [ഇമെയിൽ പരിരക്ഷിച്ചിരിക്കുന്നു] കൂടാതെ നിങ്ങളുടെ കത്തിൽ ഇനിപ്പറയുന്ന വിവരങ്ങൾ ഉൾപ്പെടുത്തുക:

GitHub ഉപയോക്തൃനാമം
സ്ഥാപനം (നിങ്ങൾ ജോലി ചെയ്യുകയോ പഠിക്കുകയോ ചെയ്യുക)
സ്ഥാനം (നിങ്ങളുടെ സ്ഥാപനത്തിലെ നിങ്ങളുടെ യഥാർത്ഥ സ്ഥാനം, ഒന്നുകിൽ "വിദ്യാർത്ഥി" അല്ലെങ്കിൽ "സ്വതന്ത്ര").
രാജ്യം

ആർട്ടിഫിഷ്യൽ ഇന്റലിജൻസ്, മെഷീൻ ലേണിംഗ് എഞ്ചിനുകൾ എന്നിവ വികസിപ്പിക്കുന്നതിനോ ഹോസ്റ്റുചെയ്യുന്നതിനോ ഉള്ള ഒരു പ്ലാറ്റ്‌ഫോമായി ഇന്റർസിസ്റ്റംസ് ഐറിസിന്റെ കഴിവുകളിൽ താൽപ്പര്യമുള്ള ലേഖനം വായിച്ചിട്ടുള്ളവർക്കായി, നിങ്ങളുടെ സംരംഭത്തിന് താൽപ്പര്യമുള്ള സാഹചര്യങ്ങൾ ചർച്ച ചെയ്യാൻ ഞങ്ങൾ നിങ്ങളെ ക്ഷണിക്കുന്നു. നിങ്ങളുടെ കമ്പനിയുടെ ആവശ്യങ്ങൾ വിശകലനം ചെയ്യുന്നതിനും സംയുക്തമായി ഒരു പ്രവർത്തന പദ്ധതി നിർണ്ണയിക്കുന്നതിനും ഞങ്ങൾ സന്തുഷ്ടരാണ്; ഞങ്ങളുടെ AI/ML വിദഗ്‌ധ ടീമിന്റെ ഇമെയിൽ വിലാസവുമായി ബന്ധപ്പെടുക – [ഇമെയിൽ പരിരക്ഷിച്ചിരിക്കുന്നു].

അവലംബം: www.habr.com

ഇന്റർസിസ്റ്റംസ് ഐറിസിലെ പൈത്തൺ ഗേറ്റ്‌വേ

പദ്ധതി

ആമുഖം

ടൂൾകിറ്റ്

സാങ്കേതികവിദ്യയുടെ

ലൈബ്രറികൾ

ഇൻസ്റ്റലേഷൻ

OS

വിൻഡോസ്

ലിനക്സ് (ഡെബിയൻ/ഉബുണ്ടു)

മാക്

ഡോക്കർ

തയ്യാറായ ചിത്രം

നിങ്ങളുടെ സ്വന്തം രൂപം സൃഷ്ടിക്കുക

അഭിപ്രായങ്ങള്

ഇൻസ്റ്റാളേഷൻ പരിശോധിക്കുന്നു

എപിഐ

കോഡ് എക്സിക്യൂഷൻ

SimpleString

എക്സിക്യൂട്ട്കോഡ്

ഡാറ്റ കൈമാറ്റം

പൈത്തൺ -> ഇന്റർസിസ്റ്റംസ് IRIS

ഇന്റർസിസ്റ്റംസ് IRIS -> പൈത്തൺ

എക്സിക്യൂട്ട് ക്വറി

എക്സിക്യൂട്ട് ഗ്ലോബൽ

എക്സിക്യൂട്ട്ക്ലാസ്

എക്സിക്യൂട്ട് ടേബിൾ

കുറിപ്പുകൾ

ഉദാഹരണങ്ങൾ

സഹായ രീതികൾ

പരസ്പര പ്രവർത്തനക്ഷമത

ബിസിനസ്സ് പ്രക്രിയകളുടെ സൃഷ്ടി

വേരിയബിൾ സബ്സ്റ്റിറ്റ്യൂഷൻ

ബിസിനസ്സ് പ്രക്രിയ പരീക്ഷിക്കുക

കോഡ് എക്സിക്യൂഷൻ

വേരിയബിളുകൾ നേടുന്നു

ഡാറ്റ കൈമാറ്റം

പൈത്തൺ സന്ദർഭം സംരക്ഷിക്കുന്നു/പുനഃസ്ഥാപിക്കുന്നു

ജൂപ്പിറ്റർ നോട്ട്ബുക്ക്

പ്രോസസ്സ് എക്സ്പ്ലോറർ

പ്രോസസ്സ് എഡിറ്റർ

ഇൻസ്റ്റലേഷൻ

കണ്ടെത്തലുകൾ

റെഫറൻസുകൾ

MLToolkit

ഒരു അഭിപ്രായം ചേർക്കുക മറുപടി റദ്ദാക്കാൻ

ഒരു അഭിപ്രായം ചേർക്കുക