Theory
Data ની પાછળ પાછળ
તમે હવે છૂટા છૂટા ભાગ જાણો છો: sensors, connectivity, gateways, cloud અને AI. Unit નો આ છેલ્લો પાઠ એ બધાને ગતિમાં મૂકે છે, એટલે કે data ભૌતિક જગતથી છેક AI ના નિર્ણય સુધી અને ત્યાંથી પાછું કોઈ ક્રિયા સુધી કઈ રીતે વહે છે એની આખી લકીર દોરે છે.
એને એક pipeline તરીકે વિચારો: અનુભવો, મોકલો, પ્રક્રિયા કરો, નિર્ણય લો, ક્રિયા કરો, અને ફરી એ જ. આ પ્રવાહને અનુસરવાથી આખું unit એકસૂત્રે બંધાય છે અને પછીના unit ના AIoT integration માટે પાયો તૈયાર થાય છે. Smart farm પર આપણે જમીનના એક જ વાચનને ધરતીથી માંડીને સિંચાઈના valve સુધી અનુસરી શકીએ, અને દરેક તબક્કો પોતાનું કામ કરતો જોઈ શકીએ.
Follow along
AIoT નું data pipeline
- ભેગું કરો Sensors ભૌતિક જગતમાંથી કાચો data ઝીલે છે (દાખલા તરીકે જમીનના ભેજનું વાચન).
- મોકલો એ data connectivity દ્વારા (Wi-Fi, LoRaWAN વગેરે) gateway મારફતે મોકલાય છે.
- પ્રક્રિયા કરો AI એ data નું વિશ્લેષણ કરે છે, કાં તો edge પર (ઉપકરણની નજીક, ઝડપ માટે) કાં તો cloud માં (ભારે વિશ્લેષણ માટે).
- નિર્ણય લો અને ક્રિયા કરો AI નું output કોઈ નિર્ણય કે આદેશ બનીને actuator સુધી પહોંચે છે, અથવા વપરાશકારને દેખાડાતી સમજ બને છે.
- ફરી એ જ પરિસ્થિતિ બદલાતી રહે એમ આ ચક્ર સતત ચાલ્યા કરે છે.
Theory
ધરતીથી valve સુધી
Smart farm પરના એક વાચનને અનુસરો. જમીનના ભેજનું sensor એવું વાચન ભેગું કરે છે જે બતાવે છે કે ખેતર સૂકું છે. એ data LoRaWAN પર મોકલાય છે અને gateway સુધી પહોંચે છે, જે એને આગળ રવાના કરે છે. Cloud માં AI એની પ્રક્રિયા કરે છે, પાકની જરૂરિયાત તથા હવામાન સાથે સરખાવે છે, અને નક્કી કરે છે કે ખેતરને પાણી આપવું જોઈએ. એ નિર્ણય આદેશ બનીને પાછો actuator સુધી, એટલે કે સિંચાઈના valve સુધી વહે છે, અને valve ખૂલે છે. પાકને પાણી મળે છે, અને sensor વાચન લેતું જ રહે છે, એટલે ચક્ર ફરી ચાલે છે.
વચ્ચે ઘણી વાર AI એ data વાપરે એ પહેલાં એને સાફ કે preprocess કરવો પડે છે (ઘોંઘાટ કાઢવો, ઘાટ બેસાડવો), કારણ કે ખરા sensor નો data અવ્યવસ્થિત હોય છે. આ pipeline એક કાચા ભૌતિક માપને આપોઆપ ખરી દુનિયાની ક્રિયામાં ફેરવી નાખે છે.
Quiz
AIoT ના data pipeline નો સાચો ક્રમ કયો છે?
- પ્રક્રિયા કરો, પછી ભેગું કરો, પછી ક્રિયા કરો, પછી મોકલો
- ભેગું કરો (sensors), મોકલો (connectivity અને gateway), પ્રક્રિયા કરો (edge કે cloud પર AI), પછી નિર્ણય લો અને ક્રિયા કરો (actuator કે સમજ)
- પહેલાં ક્રિયા કરો, અને data પછીથી ભેગો કરો
- ફક્ત data ભેગો કરો; AI systems એના પર કદી ક્રિયા કરતી નથી
Show the answer
ભેગું કરો (sensors), મોકલો (connectivity અને gateway), પ્રક્રિયા કરો (edge કે cloud પર AI), પછી નિર્ણય લો અને ક્રિયા કરો (actuator કે સમજ)
Pipeline આ રીતે વહે છે: sensors કાચો data ભેગો કરે છે, connectivity એને gateway મારફતે મોકલે છે, AI એની પ્રક્રિયા કરે છે (edge પર કે cloud માં), અને પછી system નિર્ણય લઈને ક્રિયા કરે છે (actuator ને આદેશ મોકલીને કે વપરાશકારને સમજ આપીને), અને આ ચક્ર ફરી ફરી ચાલે છે. વિકલ્પ A ક્રમ ગૂંચવી નાખે છે: data ભેગો કર્યા વગર એની પ્રક્રિયા થઈ જ ન શકે. વિકલ્પ C ઊંધો છે: ક્રિયા ભેગા કરેલા data ની પ્રક્રિયા પછી આવે છે, પહેલાં નહીં. વિકલ્પ D ખોટો છે: AIoT systems ઘણી વાર data પર ક્રિયા કરે છે (actuators દ્વારા) અથવા સમજ રજૂ કરે છે; ભેગું કરવું એ તો ફક્ત પહેલો તબક્કો છે. તાર્કિક ક્રમ છે: અનુભવો, મોકલો, વિચારો, ક્રિયા કરો, ફરી એ જ.
Think first
આખી વાતને એક વારની પ્રક્રિયા નહીં પણ સતત ચાલતું ચક્ર કેમ ગણવી?
Pipeline એક જ વાર ચાલવાને બદલે ફરી ફરી ચાલે છે અને ચક્ર બનાવે છે, એ વાત પર ભાર કેમ મૂકવો? વિચારીને પછી tap કરો.
Show the answer
કારણ કે ખરી દુનિયા સતત બદલાય છે, એટલે AIoT system ઉપયોગી રહેવા માટે સતત અનુભવતી, નિર્ણય લેતી અને ક્રિયા કરતી રહેવી પડે છે. એક જ વારનો ફેરો ઝડપથી જૂનો અને નકામો થઈ જાય.
Smart farm નો દાખલો લો. જમીનનો ભેજ સ્થિર રહેતો નથી: પાક પાણી પીએ અને તડકો એને ઉડાડે એમ ઘટે છે, અને વરસાદ પડે કે system સિંચાઈ કરે એમ વધે છે. જો pipeline ફક્ત એક જ વાર ચાલે, એટલે કે એક વાચન લે, નિર્ણય લે અને અટકી જાય, તો system એક જ ક્ષણના ચિત્ર પર કામ કરીને પછી આંધળી થઈ જાય: એને ખબર જ ન પડે કે કાલે જમીન ફરી સુકાઈ રહી છે, કે એની પોતાની જ સિંચાઈથી ખેતર હવે પૂરતું ભીનું થઈ ગયું છે અને અટકવું જોઈએ, કે વરસાદ આવી ગયો છે અને હવે પાણી આપવાની જરૂર જ નથી.
સતત ચાલતા ચક્ર તરીકે ચાલવાથી sensors નવાં વાચનો લેતાં રહે છે, AI વર્તમાન પરિસ્થિતિ સામે ફરી ફરી મૂલ્યાંકન કરતું રહે છે, અને ક્રિયાઓ પણ ગોઠવાતી રહે છે. એટલે system વાસ્તવિકતા બદલાય એમ એની સાથે ચાલે છે અને સમય જતાં યોગ્ય પ્રતિભાવ આપે છે.
આ ચક્ર જ closed-loop નિયંત્રણ અને શીખવાનું શક્ય બનાવે છે: કોઈ ક્રિયાની અસર (સિંચાઈની અસર) પછીના વાચનોના ફેરામાં અનુભવાય છે, એટલે system જોઈ શકે છે કે એનો નિર્ણય કામ લાગ્યો કે નહીં અને દિશા સુધારી શકે છે, જમીન હજી સૂકી હોય તો વધુ પાણી આપી શકે અને ભીની થાય એટલે અટકી શકે. વળી એનાથી system અચાનક બનતી ઘટનાઓ સામે (લૂ, કોઈ ખરાબી) તરત પ્રતિભાવ આપી શકે છે, નહીં કે ફક્ત નક્કી કરેલી એકાદ ક્ષણે.
લગભગ દરેક ઉપયોગી AIoT system આ જ રીતે કામ કરે છે: ઘરમાં કોણ હાજર છે એ પ્રમાણે ગોઠવાતાં smart homes, machines ની તંદુરસ્તી પર નજર રાખતાં કારખાનાં, હૃદયના ધબકારા નોંધતાં wearables. બધામાં અનુભવવું, પ્રક્રિયા કરવી, ક્રિયા કરવી અને ફરી અનુભવવું એ કદી ન અટકતું ચક્ર ચાલે છે.
એટલે એને એક વારની પ્રક્રિયા નહીં પણ ચક્ર ગણવું એ આ systems નો મૂળ સ્વભાવ પકડે છે: એ સતત ચાલુ, પ્રતિભાવ આપતી અને જાતે ગોઠવાતી હોય છે, કારણ કે જે જગતને એ સંભાળે છે તે કદી બદલાવાનું બંધ કરતું નથી. સતત અનુભવવું અને સતત ક્રિયા કરવી એ જ AIoT system ને બદલાતા જગત સાથે તાલમાં રાખે છે.
Summary
Key takeaways
- AIoT system data ને એક pipeline માંથી પસાર કરે છે: ભેગું કરો, મોકલો, પ્રક્રિયા કરો, નિર્ણય લો અને ક્રિયા કરો, પછી ફરી એ જ.
- ભેગું કરવું: sensors ભૌતિક જગતમાંથી કાચો data ઝીલે છે.
- મોકલવું: એ data connectivity દ્વારા gateway મારફતે આગળ જાય છે.
- પ્રક્રિયા કરવી: AI એ data નું વિશ્લેષણ કરે છે, edge પર (ઉપકરણની નજીક, ઝડપ માટે) કે cloud માં (ભારે વિશ્લેષણ માટે); data ઘણી વાર પહેલાં સાફ કરાય છે.
- નિર્ણય અને ક્રિયા: AI નું output actuator માટેનો આદેશ બને છે અથવા વપરાશકાર માટેની સમજ બને છે.
- Pipeline એક ચક્ર તરીકે સતત ચાલે છે, કારણ કે ખરી દુનિયાની પરિસ્થિતિ બદલાતી જ રહે છે.
- યાદ રાખવાની કડી: અનુભવો, મોકલો, વિચારો, ક્રિયા કરો, ફરી એ જ; કાચું ભૌતિક માપ વારંવાર ખરી દુનિયાની ક્રિયામાં ફેરવાતું રહે છે.