AWS मशीन लर्निंग और IoT सेवाओं के साथ एक लॉन मॉनिटर और खरपतवार का पता लगाने का समाधान बनाना

नए घर खरीदारों के लिए, एक आम चुनौती यह समझना है कि प्रभावी रूप से उनके लॉन की जरूरतों का प्रबंधन कैसे करें। अब सोचिए कि अगर आप एक किसान हैं और आपको कई एकड़ जमीन के लिए यह करना है। एक किसान के रूप में, आपके सामने आमतौर पर आने वाली कुछ चुनौतियाँ शामिल होंगी कब (जब पानी का सही समय हो), द जहां (जहां वास्तव में पानी या उर्वरक जोड़ने के लिए), और कैसे (कैसे खरपतवार से निपटने के लिए)। वीड साइंस सोसायटी ऑफ अमेरिका (WSSA) द्वारा किए गए एक शोध अध्ययन में, अनियंत्रित मातम के कारण मकई और सोयाबीन की फसलों में संयुक्त नुकसान कुल मिलाकर $ 43 बिलियन सालाना होगा। अधिक जानकारी के लिए देखें WSSA अनियंत्रित मातम से संभावित आर्थिक नुकसान में अरबों की गणना करता है WSSA वेबसाइट पर।

क्या होगा यदि आप इस समस्या को हल करने के लिए कंप्यूटर दृष्टि और मशीन लर्निंग (एमएल) के क्षेत्र में प्रौद्योगिकी और नवीनतम प्रगति का उपयोग कर सकते हैं?

यह हल करने के लिए एक जटिल समस्या है, और कई उद्यम एक समाधान पर काम कर रहे हैं। इस पोस्ट में बताया गया है कि AWS स्टार्टर किट का उपयोग करके कैसे शुरुआत करें और एक समाधान का निर्माण करें। समाधान के दो घटक हैं:

छवि वर्गीकरण का उपयोग करके खरपतवार का पता लगाना और AWS डीप लैंस
AWS IoT का उपयोग करके लॉन की स्थितियों की वास्तविक समय की निगरानी (मिट्टी की नमी का स्तर, प्रजनन स्तर और धूप) के पास

.. पूर्वापेक्षाएँ

इस समाधान को लागू करने के लिए, आपके पास निम्नलिखित आवश्यक शर्तें होनी चाहिए:

छवि वर्गीकरण का उपयोग कर मातम का पता लगाना

जैसे-जैसे हर्बीसाइड प्रतिरोध अधिक से अधिक सामान्य होता जा रहा है, खरपतवार नियंत्रण कृषि डोमेन में अधिक महत्व प्राप्त कर रहा है। खेत की उत्पादकता बढ़ाने के लिए खरपतवारों का पता लगाना और निवारक कार्रवाइयों को जल्दी करना महत्वपूर्ण है। यह अब एडब्ल्यूएस डीपलेन्स के साथ संभव है। AWS DeepLens डेवलपर्स के लिए दुनिया का पहला गहरा सीखने योग्य वीडियो कैमरा है। AWS DeepLens के साथ, आप मिनटों में शुरू कर सकते हैं पूरी तरह से प्रोग्रामेबल वीडियो कैमरा, ट्यूटोरियल, कोड और पूर्व-प्रशिक्षित मॉडल के साथ जो गहन शिक्षण कौशल का विस्तार करने के लिए डिज़ाइन किया गया है। यह आपको सीखने के नवीनतम आर्टिफिशियल इंटेलिजेंस (एआई) टूल्स और तकनीक का भी पता लगाता है और एक गहरे शिक्षण मॉडल के आधार पर कंप्यूटर विज़न एप्लिकेशन विकसित करने के लिए तैयार करता है।

AWS DeepLens के साथ, आप वास्तविक समय में घास या घास के रूप में छवियों को वर्गीकृत कर सकते हैं। खरपतवार को मारने के लिए स्प्रे को ट्रिगर करने के लिए आप एडब्ल्यूएस डीपलेन को एक माइक्रोकंट्रोलर से भी जोड़ सकते हैं।

यह पोस्ट दर्शाता है कि इमेज वर्गीकरण एल्गोरिदम का उपयोग करके मातम का पता कैसे लगाया जाए अमेज़न SageMaker। Amazon SageMaker पूरी तरह से प्रबंधित ML सेवा है। अमेज़ॅन सैजमेकर के साथ, आप जल्दी और आसानी से एमएल मॉडल बना सकते हैं और प्रशिक्षित कर सकते हैं, और सीधे उत्पादन-तैयार होस्ट किए गए वातावरण में उन्हें तैनात कर सकते हैं। यह अन्वेषण और विश्लेषण के लिए आपके डेटा स्रोतों तक आसान पहुँच के लिए एक एकीकृत जुपिटर नोटबुक प्रदान करता है, इसलिए आपको सर्वरों का प्रबंधन करने की आवश्यकता नहीं है। यह पोस्ट दर्शाता है कि अमेज़ॅन सैजमेकर के पूरी तरह से प्रबंधित और ऑन-डिमांड प्रशिक्षण बुनियादी ढांचे में एक मॉडल को कैसे प्रशिक्षित किया जाए। इसके अलावा, यह यह भी दर्शाता है कि AWS DeepLens पर प्रशिक्षित मॉडल को कैसे तैनात किया जाए।

निम्नलिखित आर्किटेक्चर आरेख खरपतवार का पता लगाने के समाधान का एक उच्च-स्तरीय अवलोकन देता है:

यह समाधान Amazon SageMaker में छवि वर्गीकरण एल्गोरिथ्म का उपयोग करता है सीखने का स्थानांतरण मोड नए डेटासेट को वर्गीकृत करने के लिए एक पूर्व-प्रशिक्षित मॉडल (इमेजनेट डेटा पर प्रशिक्षित) को ठीक करने के लिए। यदि आप किसी मॉडल को स्क्रैच से प्रशिक्षित करना चाहते हैं तो ट्रांसफर लर्निंग आपको काफी कम डेटा वाले गहरे नेटवर्क को प्रशिक्षित करने की अनुमति देता है। ट्रांसफर लर्निंग के साथ, आप अनिवार्य रूप से उस ज्ञान को स्थानांतरित कर रहे हैं जो एक मॉडल ने पिछले कार्य से अपने वर्तमान कार्य में सीखा है। यह विचार यह है कि दो कार्य असंतुष्ट नहीं हैं, और आप जो भी नेटवर्क पैरामीटर उस मॉडल को अपने प्रशिक्षण के बिना सीखे हैं, उसका व्यापक प्रशिक्षण के माध्यम से उपयोग कर सकते हैं।

वास्तुकला में निम्नलिखित चरण शामिल हैं:

अपने चित्रों के डेटासेट को अपने स्थानीय कंप्यूटर पर घास और घास से डाउनलोड करें। अपने स्थानीय कंप्यूटर पर छवियों को दो अलग-अलग फ़ोल्डरों में व्यवस्थित करें।
RecordIO टूल का उपयोग करके दो .lst फाइलें बनाएं im2rec। एक फ़ाइल डाटासेट (80%) के प्रशिक्षण भाग के लिए है। अन्य परीक्षण (20%) के लिए है। अधिक जानकारी के लिए देखें RecordIO का उपयोग करके एक डेटासेट बनाएँ MXNet वेबसाइट पर।
दोनों उत्पन्न करें .rec से फाइलें .lst फ़ाइलें और प्रतिलिपि दोनों .rec फ़ाइलें (प्रशिक्षण और सत्यापन चित्र) अमेज़न S3
ट्रांसफर लर्निंग मोड में अमेज़ॅन सैजमेकर इमेज वर्गीकरण एल्गोरिदम का उपयोग करके अपने मॉडल को प्रशिक्षित करें।
जब आप मॉडल को प्रशिक्षित करते हैं, तो प्रशिक्षण कार्य आपके S3 बाल्टी में मॉडल कलाकृतियों को अपलोड करता है। वैकल्पिक रूप से, AWS DeepLens पर अपने प्रशिक्षित मॉडल को वास्तविक समय के लिए किनारे पर तैनात करें।

निम्नलिखित अनुभाग समाधान के विस्तृत कार्यान्वयन का वर्णन करते हैं।

डेटासेट को समझना

RSI स्प्रेयर खोलें कागले वेबसाइट पर छवियों के डेटासेट में व्यापक-लीक्ड डॉक (मातम) के चित्र और व्यापक-लीक्ड डॉक (घास) के बिना भूमि के चित्र शामिल हैं। डेटासेट में खरपतवारों की 1,306 छवियां और घास की 5,391 छवियां होती हैं, जिसमें 256 पिक्सल के लगभग 256 पिक्सल का एक विशिष्ट आकार होता है। डेटासेट एक अनुशंसित ट्रेन / मान्य विभाजन प्रदान करता है। निम्नलिखित छवि में घास और घास की छवियों का एक संग्रह दिखाया गया है।

छवि डाटासेट तैयार करना

यह पोस्ट दर्शाता है कि कैसे छवि वर्गीकरण के लिए रिकॉर्डियो फ़ाइल प्रारूप का उपयोग करना है पाइप मोड। पाइप मोड में, आपका प्रशिक्षण कार्य Amazon S3 से सीधे डेटा स्ट्रीम करता है। पाइप मोड के साथ, आप के आकार को कम करते हैं अमेज़ॅन ईबीएस आपके प्रशिक्षण उदाहरणों के लिए वॉल्यूम। अधिक जानकारी के लिए देखें अमेज़ॅन सैजमेकर एल्गोरिदम के लिए पाइप इनपुट मोड का उपयोग करना। आप फ़ाइल या पाइप इनपुट मोड के साथ छवि वर्गीकरण एल्गोरिदम का उपयोग कर सकते हैं। भले ही बड़े डेटासेट के लिए पाइप मोड की सिफारिश की जाती है, लेकिन फ़ाइल मोड अभी भी छोटी फ़ाइलों के लिए उपयोगी है जो मेमोरी में फिट होती हैं और जहां एल्गोरिथ्म में बड़ी संख्या में युग हैं।

MXNet नामक एक उपकरण प्रदान करता है im2rec अपने डेटासेट के लिए RecordIO फ़ाइलें बनाने के लिए। टूल का उपयोग करने के लिए, आप लिस्टिंग फाइलें प्रदान करते हैं जो छवियों के सेट का वर्णन करती हैं। के बारे में अधिक जानकारी के लिए im2rec, देखें im2rec GitHub रेपो.

अपनी छवि डेटासेट तैयार करने के लिए, स्थानीय पायथन इंटरप्रेटर का उपयोग करके या अमेज़ॅन SMMaker पर एक Jupyter नोटबुक के माध्यम से निम्नलिखित चरणों को पूरा करें। आप इन चरणों को उस पथ से निष्पादित करते हैं जहां आपने अपनी छवि डेटासेट संग्रहीत किया है।

लिस्टिंग फ़ाइलों का उपयोग कर उत्पन्न करें im2rec.py। निम्नलिखित कोड देखें:
```
python3 im2rec.py --list --recursive --train-ratio .75 --test-ratio .25 </path/to/folder>
```
उपयोग im2rec निम्नलिखित कोड दर्ज करके RecordIO फ़ाइलें बनाने के लिए उपयोगिता:
```
python3 im2rec.py --num-thread 2 --resize 50 --quality 80 </path/to/folder>
```
im2rec निम्नलिखित पैरामीटर लेता है:

- सूची - im2rec रूट फ़ोल्डर और आउटपुट को ट्रैवर्स करके एक छवि सूची बनाता है .lst।
- पुनरावर्ती - पुनरावर्ती उपनिर्देशिका के माध्यम से चलता है और प्रत्येक फ़ोल्डर में छवियों के लिए एक अनूठा लेबल प्रदान करता है।
- ट्रेन अनुपात - प्रशिक्षण के लिए उपयोग करने के लिए छवियों का अनुपात।
- परीक्षण अनुपात - परीक्षण के लिए उपयोग करने के लिए छवियों का अनुपात।
- संख्या धागा - एन्कोडिंग के लिए उपयोग करने के लिए थ्रेड्स की संख्या। यह मूल्य जितना अधिक होगा, प्रसंस्करण उतना ही तेज होगा।
- आकार बदलें - नए आकार में एक छवि के छोटे किनारे का आकार बदलें; मूल चित्र डिफ़ॉल्ट रूप से पैक किए जाते हैं।
- गुणवत्ता - एन्कोडिंग के लिए जेपीईजी गुणवत्ता, 1-100; या एन्कोडिंग के लिए पीएनजी संपीड़न, 1-9 (डिफ़ॉल्ट: 95)।

अधिक जानकारी के लिए देखें एमएक्सनेट ने सरल बनाया: इमेज रिकॉर्डियो इम 2 आरईसी और डेटा लोडिंग के साथ.

कोड लागू करना

समाधान के प्रत्येक चरण को प्रदर्शित करने के लिए, यह पोस्ट Jupyter नोटबुक का उपयोग करता है गीथहब रेपो.

अपने S3 बाल्टी की स्थापना

RecordIO प्रारूप में प्रशिक्षण और सत्यापन फ़ाइलों के साथ-साथ मॉडल कलाकृतियों को अपलोड करने के लिए एक S3 बाल्टी बनाएँ। उपयोग default_bucket() सत्र का पैरामीटर सेजमेकर पायथन एसडीके। मैन्युअल रूप से S3 बाल्टी बनाने के निर्देशों के लिए, देखें एक बाल्टी बनाना.

bucket = sagemaker.Session().default_bucket()

RecordIO फ़ाइलें छवि वर्गीकरण एल्गोरिथ्म के इनपुट के रूप में काम करती हैं। प्रशिक्षण डेटा एक उपनिर्देशिका के अंदर होना चाहिए जिसे ट्रेन कहा जाता है और सत्यापन डेटा उप-नाम के अंदर होना चाहिए validation:

def upload_to_s3(channel, file): s3 = boto3.resource('s3') data = open (file, "rb") key = channel + '/' + file s3.Bucket(bucket).put_object(Key=key, Body=data) s3_train_key = "image-classification-transfer-learning/train"
s3_validation_key = "image-classification-transfer-learning/validation"
s3_train = 's3://{}/{}/'.format(bucket, s3_train_key)
s3_validation = 's3://{}/{}/'.format(bucket, s3_validation_key) upload_to_s3(s3_train_key, 'Data_train.rec')
upload_to_s3(s3_validation_key, 'Data_test.rec')

अधिक जानकारी के लिए, देखें गीथहब रेपो.

अमेज़ॅन सैजमेकर अंतर्निहित एल्गोरिथ्म का उपयोग करके छवि वर्गीकरण मॉडल का प्रशिक्षण

अमेज़ॅन एस 3 में उपलब्ध छवियों के साथ, आप मॉडल को प्रशिक्षित करने के लिए तैयार हैं। इस पोस्ट में कुछ हाइपरपैरामीटर ब्याज के हैं:

वर्गों और प्रशिक्षण नमूनों की संख्या
बैच आकार, युगांतर, छवि आकार और पूर्व-प्रशिक्षित मॉडल

अधिक जानकारी के लिए देखें छवि वर्गीकरण हाइपरपरमेटर्स.

अमेज़ॅन SageMaker छवि वर्गीकरण एल्गोरिथ्म आपको एक GPU उदाहरण प्रकार, जैसे ml.p2.xlarge पर मॉडल को प्रशिक्षित करने की आवश्यकता है। हाइपरपरमीटर को निम्न मानों पर सेट करें:

num_layers = 18। नेटवर्क के लिए परतों (गहराई) की संख्या। यह पोस्ट 18 का उपयोग करता है, लेकिन आप अन्य मानों का उपयोग कर सकते हैं, जैसे कि 50 और 152।
image_shape = 3,224,224। इनपुट छवि आयाम, num_channelsनेटवर्क के लिए ऊंचाई, और चौड़ाई। यह वास्तविक छवि आकार से बड़ा नहीं होना चाहिए। चैनलों की संख्या वास्तविक छवि के समान होनी चाहिए। यह पोस्ट 3, 224, 224 के छवि आयामों का उपयोग करता है, जो कि इमेजनेट डेटासेट के समान है।
num_training_samples = 4520। इनपुट डेटासेट में प्रशिक्षण उदाहरणों की संख्या।
num_classes = 2। नए डेटासेट के लिए आउटपुट कक्षाओं की संख्या। यह पद 2 का उपयोग करता है क्योंकि दो वस्तु श्रेणियां हैं: मातम और घास।
mini_batch_size = 128। प्रत्येक मिनी-बैच के लिए प्रयुक्त प्रशिक्षण नमूनों की संख्या।
epochs = 10। प्रशिक्षण युगों की संख्या।
learning_rate =001। प्रशिक्षण के लिए सीखने की दर।
top_k = 2। प्रशिक्षण के दौरान शीर्ष-कश्मीर सटीकता की रिपोर्ट करता है। यह पैरामीटर 1 से अधिक होना चाहिए क्योंकि शीर्ष -1 प्रशिक्षण सटीकता नियमित प्रशिक्षण सटीकता के समान है जो पहले ही रिपोर्ट की जा चुकी है।
use_pretrained_model = 1। करने के लिए सेट 1 स्थानांतरण सीखने के लिए पूर्व-प्रशिक्षित मॉडल का उपयोग करना।

जब आप Amazon S3 पर डेटासेट अपलोड करते हैं और हाइपरपैरामीटर सेट करते हैं, तो आप Amazon SageMaker से प्रशिक्षण शुरू कर सकते हैं CreateTrainingJob एपीआई। क्योंकि आप प्रशिक्षण के लिए रिकॉर्डियो प्रारूप का उपयोग कर रहे हैं, इसलिए आप ट्रेन और सत्यापन चैनल दोनों को मान के लिए निर्दिष्ट करते हैं InputDataConfig का पैरामीटर CreateTrainingJob निवेदन। आप ट्रेन चैनल में एक RecordIO (.rec) फ़ाइल और सत्यापन चैनल में एक RecordIO फ़ाइल निर्दिष्ट करते हैं। एप्लिकेशन / x-recordio दोनों चैनलों के लिए सामग्री प्रकार सेट करें। निम्नलिखित कोड देखें:

"InputDataConfig": [ { "ChannelName": "train", "DataSource": { "S3DataSource": { "S3DataType": "S3Prefix", "S3Uri": s3_train, "S3DataDistributionType": "FullyReplicated" } }, "ContentType": "application/x-recordio", "CompressionType": "None" }, { "ChannelName": "validation", "DataSource": { "S3DataSource": { "S3DataType": "S3Prefix", "S3Uri": s3_validation, "S3DataDistributionType": "FullyReplicated" } }, "ContentType": "application/x-recordio", "CompressionType": "None" } ]

जब प्रशिक्षण कार्य पूरा हो जाए, तो आपको निम्नलिखित संदेश देखना चाहिए:

Training job ended with status: Completed

आउटपुट मॉडल द्वारा निर्दिष्ट आउटपुट पथ में संग्रहीत किया जाता है training_params['OutputDataConfig']:

"OutputDataConfig": { "S3OutputPath": 's3://{}/{}/output'.format(bucket, job_name_prefix)

मॉडल प्रशिक्षण के लिए पूर्ण कोड के लिए, देखें गीथहब रेपो.

वास्तविक समय के अनुमान के लिए मॉडल को तैनात करना

अब आप मॉडल का उपयोग प्रदर्शन करने के लिए करना चाहते हैं। इस पोस्ट के लिए, इसका मतलब है कि छवियों को मातम या घास के रूप में भविष्यवाणी करना।

इस अनुभाग में निम्नलिखित चरण शामिल हैं:

प्रशिक्षण आउटपुट के लिए एक मॉडल बनाएं।
वास्तविक समय के अनुमान के लिए मॉडल की मेजबानी करें। एक निष्कर्ष समापन बिंदु बनाएँ और वास्तविक समय निष्कर्ष निकालें। इसमें निम्न चरण शामिल हैं:
1. एक कॉन्फ़िगरेशन बनाएँ जो एक समापन बिंदु को परिभाषित करता है।
2. एक अनुमान समापन बिंदु बनाने के लिए कॉन्फ़िगरेशन का उपयोग करें।
3. समापन बिंदु का उपयोग करते हुए कुछ इनपुट डेटा पर अनुमान लगाएं।

एक मॉडल बनाना

निम्नलिखित पायथन कोड का उपयोग करके प्रशिक्षण आउटपुट से एक SageMaker मॉडल बनाएं:

model_name="deeplens-image-classification-model"
info = sage.describe_training_job(TrainingJobName=job_name)
model_data = info['ModelArtifacts']['S3ModelArtifacts']
print(model_data) hosting_image = get_image_uri(boto3.Session().region_name, 'image-classification') primary_container = { 'Image': hosting_image, 'ModelDataUrl': model_data,
} create_model_response = sage.create_model( ModelName = model_name, ExecutionRoleArn = role, PrimaryContainer = primary_container) print(create_model_response['ModelArn'])

वास्तविक समय अनुमान

अब आप एक समापन बिंदु के साथ मॉडल की मेजबानी कर सकते हैं और वास्तविक समय में निष्कर्ष निकाल सकते हैं।

एक समापन बिंदु कॉन्फ़िगरेशन बनाना

एक समापन बिंदु कॉन्फ़िगरेशन बनाएँ जो अमेज़ॅन SageMaker होस्टिंग सेवाएँ मॉडल को परिनियोजित करने के लिए उपयोग करता है। निम्नलिखित कोड देखें:

endpoint_config_name = job_name_prefix + '-epc-' + timestamp
endpoint_config_response = sage.create_endpoint_config( EndpointConfigName = endpoint_config_name, ProductionVariants=[{ 'InstanceType':'ml.m4.xlarge', 'InitialInstanceCount':1, 'ModelName':model_name, 'VariantName':'AllTraffic'}])

एक समापन बिंदु बनाना

उस अंतिम बिंदु को बनाएं जो आपके द्वारा पहले परिभाषित किए गए नाम और कॉन्फ़िगरेशन को निर्दिष्ट करके मॉडल का कार्य करता है। परिणाम एक समापन बिंदु है जिसे आप उत्पादन अनुप्रयोगों में मान्य और शामिल कर सकते हैं। यह एक m9.xlarge उदाहरण पर पूरा करने के लिए लगभग 11 मिनट लगते हैं। निम्नलिखित कोड देखें:

endpoint_name = job_name_prefix + '-ep-' + timestamp
print('Endpoint name: {}'.format(endpoint_name)) endpoint_params = { 'EndpointName': endpoint_name, 'EndpointConfigName': endpoint_config_name,
}
endpoint_response = sagemaker.create_endpoint(**endpoint_params)

निम्नलिखित कोड के साथ समापन बिंदु बनाएँ:

response = sagemaker.describe_endpoint(EndpointName=endpoint_name)
status = response['EndpointStatus']
print('EndpointStatus = {}'.format(status))
# wait until the status has changed
sagemaker.get_waiter('endpoint_in_service').wait(EndpointName=endpoint_name)
# print the status of the endpoint
endpoint_response = sagemaker.describe_endpoint(EndpointName=endpoint_name)
status = endpoint_response['EndpointStatus']
print('Endpoint creation ended with EndpointStatus = {}'.format(status)) if status != 'InService': raise Exception('Endpoint creation failed.')

आप समापन बिंदु कॉन्फ़िगरेशन और स्थिति की पुष्टि कर सकते हैं endpoints Amazon SageMaker कंसोल में टैब।

अब आप एक रनटाइम ऑब्जेक्ट बना सकते हैं जिसमें से आप समापन बिंदु को लागू कर सकते हैं।

आक्षेप करना

उपयोग के लिए मॉडल को मान्य करने के लिए, पिछले संचालन से परिणाम का उपयोग करके क्लाइंट लाइब्रेरी से समापन बिंदु प्राप्त करें और उस समापन बिंदु का उपयोग करके प्रशिक्षित मॉडल से वर्गीकरण उत्पन्न करें। कोड हमारे परीक्षण के लिए एक घास की नमूना छवि का उपयोग करता है। निम्नलिखित कोड देखें:

runtime = boto3.Session().client(service_name='runtime.sagemaker')
file_name = 'rsz_photo-1.jpg'
# test image
from IPython.display import Image
Image(file_name)

import json
import numpy as np
with open(file_name, 'rb') as f: payload = f.read() payload = bytearray(payload)
response = runtime.invoke_endpoint(EndpointName=endpoint_name, ContentType='application/x-image', Body=payload)
result = response['Body'].read()
# result will be in json format and convert it to ndarray
result = json.loads(result)
# the result will output the probabilities for all classes
# find the class with maximum probability and print the class index
index = np.argmax(result)
object_categories = ['weed','grass']
print("Result: label - " + object_categories[index] + ", probability - " + str(result[index])) Result: label - weed, probability - 0.9998767375946045

AWS DeepLens का उपयोग करके अपने मॉडल को किनारे पर चलाना

AWS DeepLens आपको किनारे पर गहन सीखने के साथ प्रयोग करने देता है, जो आपको प्रशिक्षित मॉडल को तैनात करने और दिलचस्प अनुप्रयोगों के साथ आने के लिए पायथन कोड का उपयोग करने का एक आसान तरीका देता है। अपने खरपतवार पहचानकर्ता के लिए, आप अपने लॉन को देखने वाले तार पर AWS DeepLens डिवाइस माउंट कर सकते हैं। यह उपकरण अमेज़ॅन S3 के लिए पहचाने गए मातम और फसलों की फसली छवियों को खिलाता है। जब यह खरपतवारों का पता लगाता है तो यह आपके मोबाइल फोन पर एक पाठ को भी ट्रिगर कर सकता है।

एक एडब्ल्यूएस डीपलेन्स प्रोजेक्ट में एक प्रशिक्षित मॉडल और एक है AWS लाम्बा समारोह। फ़ंक्शन का उपयोग करता है AWS IoT ग्रीनग्रास निम्न कार्य करने के लिए AWS दीपलों पर:

वीडियो स्ट्रीम से छवि कैप्चर करें
तैनात एमएल मॉडल के खिलाफ उस छवि का उपयोग करके एक आक्षेप करें
AWS IoT और आउटपुट वीडियो स्ट्रीम को परिणाम प्रदान करें

AWS IoT ग्रीनग्रास आपको लैम्ब्डा कार्यों को स्थानीय रूप से निष्पादित करने की सुविधा देता है, जो एम्बेडेड सॉफ़्टवेयर को विकसित करने की जटिलता को कम करता है। अधिक जानकारी के लिए देखें AWS DeepLens Inference लैम्ब्डा फंक्शन बनाएं और प्रकाशित करें.

जब आप अमेज़ॅन सैजमेकर द्वारा निर्मित कस्टम छवि वर्गीकरण मॉडल का उपयोग करते हैं, तो आपके एडब्ल्यूएस डीपेंसेंस लैम्बिंग फ़ंक्शन में एक अतिरिक्त कदम होता है। एमएक्सईएनटी को कॉल करने के लिए इनफेक्शन फंक्शन की जरूरत होती है मॉडल अनुकूलक अपने मॉडल का उपयोग करते हुए कोई भी निष्कासन करने से पहले। मॉडल का अनुकूलन और लोड करने के लिए, निम्न कोड देखें:

model_path = '/opt/awscam/artifacts/image-classification.xml'
error, model_path = mo.optimize(model_name,224,224,aux_inputs={'--epoch':10}) model = awscam.Model(model_path, {'GPU': 1})

एडब्ल्यूएस डीपलेनेंस पर मॉडल इंट्रेंस प्रदर्शन करना

आपके लैम्ब्डा फ़ंक्शन का मॉडल निष्कर्ष, अमेज़ॅन सेजमेकर द्वारा होस्ट किए गए एंडपॉइंट का उपयोग करके मॉडल को लागू करने के लिए पिछले चरणों के समान है। निम्नलिखित पायथन कोड एक फ्रेम में मातम और घास पाता है जो AWS डीपलेन्स वीडियो कैमरा प्रदान करता है:

frame_resize = cv2.resize(frame, (512, 512)) # Run the images through the inference engine and parse the results using
# the parser API. Note it is possible to get the output of doInference
# and do the parsing manually, but since it is a ssd model,
# a simple API is provided.
parsed_inference_results = model.parseResult( model_type, model.doInference(frame_resize))

इस छवि वर्गीकरण मॉडल के साथ AWS DeepLens पर उपयोग करने के लिए एक पूर्ण इंजेक्शन लैम्ब्डा फ़ंक्शन के बारे में जानकारी के लिए, देखें गीथहब रेपो। लैम्ब्डा फ़ंक्शन JWS प्रारूप में IoT विषय पर पाठ-आधारित आउटपुट प्रकाशित करने के लिए AWS IoT Greengrass SDK का उपयोग करता है। यहाँ हैं IoT कंसोल में आउटपुट कैसे देखें, इस पर निर्देश.

नीचे दी गई तस्वीर हमारे नमूना सेटअप को दिखाती है:

खेत की स्थिति की वास्तविक समय की निगरानी के पास

खेत की उत्पादकता में सुधार के लिए पानी और पोषक तत्वों की सही मात्रा महत्वपूर्ण है। उन तरीकों में से एक जो आप प्राप्त कर सकते हैं जो क्षेत्र की वास्तविक समय की निगरानी के माध्यम से है, जो आपको पानी और उर्वरक की खपत पर लागत बचाने में मदद करता है। वास्तविक समय की निगरानी से एकत्र की गई जानकारी आपको यह पहचानने में मदद कर सकती है कि कब और कहाँ मिट्टी को पानी देना या निषेचन करना है।

मिट्टी की स्थिति की निगरानी के लिए, इस पोस्ट ने चार मिट्टी के सेंसर का इस्तेमाल किया और 2 फीट-दर-1-पैर के पौधे के बिस्तर के एक पैच की निगरानी की। ये सेंसर मिट्टी की वर्तमान नमी के स्तर और उर्वरता, प्राप्त प्रकाश, और परिवेश के तापमान का पता लगा सकते हैं। यह ब्लूटूथ सक्षम के साथ रास्पबेरी पाई के माध्यम से यह जानकारी एकत्र करता है। वास्तविक उत्पादन के लिए, आपको लोरा की तरह अधिक लंबी दूरी के प्रोटोकॉल का उपयोग करना चाहिए। रास्पबेरी पाई सेंसर लगाता है, इस जानकारी को एकत्र करता है, और इसे भेजता है AWS IoT कोर। आप डेटा एकत्र करने और इसे अग्रेषित करने के लिए एक IoT नियम का उपयोग करते हैं अमेज़ॅन किनेसिस डेटा एनालिटिक्स वास्तविक समय के विश्लेषण के लिए। अब, जब खेत के एक विशिष्ट भाग के लिए नमी का स्तर थ्रेसहोल्ड मूल्य से कम हो जाता है, तो यह एक चेतावनी सूचना को ट्रिगर करेगा। आप इस जानकारी का उपयोग स्प्रिंकलर सिस्टम के नियंत्रण को स्वचालित करने के लिए भी कर सकते हैं।

स्थानीय मौसम की स्थिति को प्रदूषित करने के लिए सिस्टम में अंतर्निहित तर्क भी हैं। स्प्रिंकलर कब और कैसे चालू करें, यह तय करने के लिए आप इस जानकारी का उपयोग कर सकते हैं।

आर्किटेक्चर

निम्नलिखित चित्र इस वर्कफ़्लो की वास्तुकला को दिखाता है।

आर्किटेक्चर में निम्नलिखित उच्च-स्तरीय चरण शामिल हैं:

रास्पबेरी पाई एक बढ़त गेटवे डिवाइस के रूप में कार्य करता है और ब्लूटूथ के माध्यम से मिट्टी की नमी सेंसर से जानकारी एकत्र करता है।
प्रमाणीकरण के बाद, रास्पबेरी पाई एक IoT विषय की सदस्यता लेता है और इसके लिए संदेश प्रकाशित करना शुरू करता है।
IoT नियम इंजन का उपयोग, डेटा के लिए चलता है अमेज़न Kinesis डेटा Firehose, जिसमें दो गंतव्य हैं: वास्तविक भंडारण के लिए अमेजन S3 और निरंतर भंडारण के लिए Kinesis Data Analytics।
Kinesis Data Analytics का आउटपुट एक लैम्ब्डा फंक्शन है, जो SNS अलर्ट्स को ट्रिगर करता है जब नमी का स्तर थ्रेशोल्ड वैल्यू से कम हो जाता है।
अंत में, आप बनाने के लिए अमेज़न S3 डेटा का उपयोग करें अमेज़न क्विकसाइट

इस वास्तुकला को तैयार करने के लिए, आपको रास्पबेरी पाई और मिट्टी की नमी सेंसर की आवश्यकता होती है।

अपना IoT डिवाइस सेट करना

डेटा उत्पन्न करने के लिए रास्पबेरी पाई स्थापित करने के लिए, निम्नलिखित चरणों को पूरा करें:

रास्पबेरी पाई कॉन्फ़िगर करें और इसे AWS IoT से कनेक्ट करें। अधिक जानकारी के लिए, रास्पबेरी पाई पर AWS IoT SDK का उपयोग करना देखें
पायथन का नवीनतम संस्करण डाउनलोड करें एडब्ल्यूएस आईओटी एसडीके रास्पबेरी पाई पर या तो SSH द्वारा या पुट्टी में कमांड प्रॉम्प्ट। आप pip3 प्रोग्राम कमांड का उपयोग कर सकते हैं। निम्नलिखित कोड देखें:
```
pip3 install AWSIoTPythonSDK
```
अजगर 3.4 या उच्चतर का उपयोग करें क्योंकि धब्बा लगाना miflora सेंसर के लिए उपयोग की जाने वाली लाइब्रेरी केवल Python 3.4 या इसके बाद के संस्करण के साथ काम करती है।
निम्न कोड वाले सेंसर से बात करने के लिए मिफ्लोरा सेंसर लाइब्रेरी डाउनलोड करें:
```
pip3 install miflora
```
कोड भी स्वचालित रूप से miflora के लिए आवश्यक bltewrap लाइब्रेरी डाउनलोड करता है। अधिक जानकारी के लिए, देखें गीथहब रेपो.
से फार्मबोटस्टॉक स्क्रिप्ट डाउनलोड करें GitHub और निम्न मापदंडों को अद्यतन करें:

- ग्राहक ID - IoT और IoT छाया ग्राहक आईडी (चरण 1 से)
- कॉन्फ़िगर करें - IoT और IoT छाया समापन बिंदु आपके AWS प्रबंधन कंसोल से
- कॉन्फ़िगर करें - रास्पबेरी पाई पर IoT और IoT छाया साख स्थान (चरण 1 से)
- सेंसर - सेंसर के मैक एड्रेस वैल्यू को अपडेट करें

रास्पबेरी पाई में एसएसएच और पायथन पी स्क्रिप्ट शुरू करें। स्क्रिप्ट पिछले चरण में कॉन्फ़िगर की गई मिट्टी की नमी सेंसर को प्रदूषित करती है। निम्नलिखित कोड देखें:
```
python3 farmbot.py
```

लैम्ब्डा ट्रांसफॉर्मेशन के साथ फायरहॉस डिलीवरी स्ट्रीम बनाना

यह पोस्ट एक का उपयोग करता है अमेज़न Kinesis डेटा Firehose वितरण स्ट्रीम डेटा स्ट्रीम करने के लिए। आप किन्हिस डेटा एनालिटिक्स के इनपुट के रूप में फायरहोस डिलीवरी स्ट्रीम से डेटा का उपयोग करते हैं और इसे इमारत के लिए अमेज़ॅन एस 3 में संग्रहीत करते हैं अमेज़न क्विकसाइट डैशबोर्ड। अपनी वितरण स्ट्रीम बनाने के लिए, निम्नलिखित चरणों को पूरा करें:

Kinesis डेटा Firehose कंसोल पर, चुनें वितरण स्ट्रीम बनाएं.
एक Firehose वितरण स्ट्रीम बनाएँ नाम के साथ IoT-data-Stream.
स्रोत को डिफ़ॉल्ट के रूप में चुनें प्रत्यक्ष पीयूटी या अन्य स्रोत और निकलो सर्वर साइड एन्क्रिप्शन डिफ़ॉल्ट के रूप में अनियंत्रित
चुनें अगला
के लिए एडब्ल्यूएस लाम्बा के लिए ट्रांसफॉर्म सोर्स रिकॉर्ड, चुनते हैं सक्षम.
चुनें नया बनाएँ.
इस लैम्ब्डा फ़ंक्शन का उपयोग करके, डिलीवरी स्ट्रीम से अमेज़ॅन एस 3 तक भेजे गए डेटा के लिए प्रत्येक रिकॉर्ड के अंत में नई लाइन वर्ण जोड़ें। अधिक जानकारी के लिए, देखें गीथहब रेपो.

Amazon QuickSight में एक विज़ुअलाइज़ेशन बनाने के लिए यह आवश्यक है। निम्नलिखित कोड देखें:

'use strict';
console.log('Loading function'); exports.handler = (event, context, callback) => { /* Process the list of records and transform them */ /* The following must be the schema of the returning record Otherwise you will get processing-failed exceptions {recordId: <id>, result: 'Ok/Processing/Failed', data: <base64 encoded JSON string> } */ const output = event.records.map((record) => ({ /* This transformation is the "identity" transformation, the data is left intact */ recordId: record.recordId, result: 'Ok', data: record.data+"Cg==", })); console.log(`Processing completed. Successful records ${output.length}.`); callback(null, { records: output });
};

के लिए रिकॉर्ड स्वरूप परिवर्तित करें, विकलांग का चयन करें।
चुनें अगला.
के लिए गंतव्य, चुनें अमेज़न S3.
नाम से एक नया S3 बाल्टी बनाएँ <your unique name>-kinesis.
अन्य सभी फ़ील्ड डिफ़ॉल्ट रखें।
चुनें अगला.
के अंतर्गत S3 बफर की स्थितिके लिए, बफर अंतराल, दर्ज 60 सेकंड.
के लिए बफर आकार, दर्ज 1 एमबी.
चुनें एक IAM भूमिका बनाएँ। Kinesis Data Firehose आपकी बाल्टी तक पहुँचने के लिए इस भूमिका का उपयोग करता है।
अन्य सभी फ़ील्ड डिफ़ॉल्ट रखें।
चुनें अगला.
सभी क्षेत्रों की समीक्षा करें और चुनें वितरण स्ट्रीम बनाएं.

डिलीवरी स्ट्रीम में डेटा को अग्रेषित करने के लिए AWS IoT की स्थापना

अपनी वितरण स्ट्रीम में डेटा अग्रेषित करने के लिए, निम्नलिखित चरणों को पूरा करें:

AWS IoT कोर कंसोल पर, चुनें अधिनियम.
चुनें नियम बनाएं.

एक नया AWS IoT नियम बनाएँ निम्नलिखित क्षेत्र मूल्यों के साथ:

 Name: 'IoT_to_Firehose' Attribute :' * ' Rule Querry Statement : SELECT * FROM 'farmbot/#' Add Action : " Send messages to an Amazon Kinesis Data Firehose stream (select IoT-Source-Stream from the Stream name dropdown)" Select Separator: " n (newline) "

IAM भूमिका के लिए, चुनें नई भूमिका बनाएं.

कंसोल, KWSis Data Firehose तक पहुँचने के लिए AWS IoT के लिए उपयुक्त अनुमतियों के साथ IAM भूमिका बनाता है। यदि आप किसी मौजूदा भूमिका का उपयोग करना पसंद करते हैं, तो ड्रॉप-डाउन मेनू से भूमिका का चयन करें और चुनें अद्यतन भूमिका। यह आपकी चयनित IAM भूमिका के लिए आवश्यक अनुमतियाँ जोड़ता है।

एनालिटिक्स एप्लिकेशन के लिए गंतव्य बनाना

एनालिटिक्स एप्लिकेशन के लिए गंतव्य बनाने के लिए, निम्नलिखित चरणों को पूरा करें:

अमेज़ॅन एसएनएस कंसोल पर, एक विषय बनाएं और ईमेल या पाठ के माध्यम से इसकी सदस्यता लें। अधिक जानकारी के लिए, चरण 1 और चरण 2 देखें Amazon SNS से शुरुआत करना
पाठ फ़ाइल में SNS विषय के लिए ARN की प्रतिलिपि बनाएँ।

डेटा को संसाधित करने के लिए एक एनालिटिक्स एप्लिकेशन बनाना

अपना विश्लेषण एप्लिकेशन बनाने के लिए, निम्नलिखित चरणों को पूरा करें:

Amazon Kinesis कंसोल पर, चुनें डेटा विश्लेषण.
चुनें एप्लिकेशन बनाएं.
अपने आवेदन नाम के लिए, दर्ज करें Farmbot-application.
अपने रनटाइम के लिए, का चयन करें SQL और चुनें एप्लिकेशन बनाएं
स्रोत के लिए, चुनें स्ट्रीमिंग डेटा कनेक्ट करें का चयन करें और स्रोत चुनें.
चुनें Kinesis डेटा Firehose वितरण स्ट्रीम.
चुनें IoT-स्रोत-स्ट्रीम.
छोड़ना लैंबडा के साथ रिकॉर्ड पूर्व प्रसंस्करण
के अंतर्गत पहुंच अनुमति, सांत्वना बनाने और KAMis डेटा एनालिटिक्स के साथ उपयोग करने के लिए एक IAM भूमिका अद्यतन करें।

यदि आपके पास पहले से ही एक उपयुक्त IAM भूमिका है जिसे Kinesis Data Analytics मान सकता है, तो ड्रॉप-डाउन मेनू से उस भूमिका को चुनें।

चुनें स्कीमा की खोज करें।
परिणाम दिखाने के लिए आवेदन के लिए प्रतीक्षा करें और फिर चुनें सहेजें और जारी रखें.

यदि आपने सब कुछ सही ढंग से कॉन्फ़िगर किया है, तो आपको सेंसर नाम, पैरामीटर और टाइमस्टैम्प के साथ एक तालिका दिखाई देती है। निम्नलिखित स्क्रीनशॉट देखें।

वास्तविक समय विश्लेषिकी प्रसंस्करण के लिए, चुनें SQL एडिटर पर जाएं।
निम्नलिखित पैरामीटर दर्ज करें:

SOURCE_SQL_STREAM_001 - आने वाली धारा से मूल्य और टाइमस्टैम्प के साथ नाम और सेंसर पैरामीटर शामिल हैं।
इंटरमीडिएट_एसक्यूएल_STREAM - के साथ सभी रिकॉर्ड शामिल हैं Moisture मूल्य से कम है 25 और कम पैरामीटर्स को फ़िल्टर करता है, जो इस पोस्ट के लिए है Moisture और Conductivity.
DESTINATION_SQL_HHR_STREAM - निर्दिष्ट कॉलम के लिए 2 मिनट की स्लाइडिंग विंडो पर कुल पंक्ति पर कार्य करता है। यह पता लगाता है कि क्या कोई सेंसर लगातार 2 मिनट तक नमी के स्तर को कम कर रहा है।

निम्नलिखित उदाहरण कोड देखें:

-- Create an output stream with seven columns, which is used to send IoT data to the destination
SELECT STREAM "Moisture","Temperature","Name","Conductivity","Light","Battery","DateTime" FROM "SOURCE_SQL_STREAM_001"; CREATE OR REPLACE STREAM "INTERMIDIATE_SQL_STREAM" (Moisture INT, Conductivity INT, Name VARCHAR(16));
-- Create pump to insert into output CREATE OR REPLACE PUMP "STREAM_PUMP_001" AS INSERT IGNORE INTO "INTERMIDIATE_SQL_STREAM" -- Select all columns from source stream
SELECT STREAM "Moisture","Conductivity","Name"
FROM "SOURCE_SQL_STREAM_001"
-- LIKE compares a string to a string pattern (_ matches all char, % matches substring)
-- SIMILAR TO compares string to a regex, may use ESCAPE
WHERE "Moisture" < 25; -- ** Aggregate (COUNT, AVG, etc.) + Sliding time window **
-- Performs function on the aggregate rows over a 2 minute sliding window for a specified column. -- .----------. .----------. .----------. -- | SOURCE | | INSERT | | DESTIN. | -- Source-->| STREAM |-->| & SELECT |-->| STREAM |-->Destination
-- | | | (PUMP) | | | -- '----------' '----------' '----------' CREATE OR REPLACE STREAM "DESTINATION_SQL_HHR_STREAM" (Name VARCHAR(16), high_count INTEGER);
-- Create a pump which continuously selects from a source stream (SOURCE_SQL_STREAM_001) -- performs an aggregate count that is grouped by columns ticker over a 2-minute sliding window
CREATE OR REPLACE PUMP "STREAM_PUMP_002" AS INSERT IGNORE INTO "DESTINATION_SQL_HHR_STREAM"
-- COUNT|AVG|MAX|MIN|SUM|STDDEV_POP|STDDEV_SAMP|VAR_POP|VAR_SAMP)
SELECT STREAM *
FROM ( SELECT STREAM Name, COUNT(*) OVER THIRTY_SECOND_SLIDING_WINDOW AS high_count FROM "INTERMIDIATE_SQL_STREAM" WINDOW TWO_MINUTE_SLIDING_WINDOW AS ( PARTITION BY Name RANGE INTERVAL '2' MINUTE PRECEDING)
) AS a
WHERE (high_count >3);

पर रीयल-टाइम एनालिटिक्स टैब, आप SQL क्वेरी के परिणाम देख सकते हैं। निम्नलिखित स्क्रीनशॉट देखें।

एनालिटिक्स एप्लिकेशन के लिए गंतव्य को जोड़ना

अपने एनालिटिक्स एप्लिकेशन के लिए गंतव्य कनेक्ट करने के लिए, निम्नलिखित चरणों को पूरा करें:

के लिए गंतव्य, चुनते हैं AWS लाम्बा समारोह.
एक नया लैम्ब्डा फ़ंक्शन बनाएं और लैम्ब्डा ब्लूप्रिंट चुनें।
खोज बार में, दर्ज करें SNS.
चुनें Kinesis-विश्लेषण-उत्पादन-एसएनएस .
फ़ंक्शन का नाम दर्ज करें।
JSON के रूप में आउटपुट स्वरूप का चयन करें
निष्पादन भूमिका के लिए, का चयन करें बुनियादी लैम्ब्डा अनुमतियों के साथ एक नई भूमिका बनाएँ.

लैम्ब्डा फ़ंक्शन अनुप्रयोग के परिणामों को संसाधित करता है और आपके द्वारा बनाए गए SNS विषय पर परिणाम भेजता है।

निम्नलिखित फ़ंक्शन कोड को संशोधित करें और आपके द्वारा दर्ज एआरएन विषय जोड़ें:

import base64
import json
import boto3
from botocore.vendored import requests #import requests snsClient = boto3.client('sns')
print('Loading function') for record in event['records']: # Kinesis data is base64 encoded so decode here print 'Number of records {}.'.format(len(event['records'])) payload = json.loads(base64.b64decode(record['data'])) #payload = base64.b64decode(record['kinesis']['data']) print payload response = snsClient.publish( TopicArn= 'arn:aws:sns:<region>:<account_id>:<topic_name>', Message='Based on current soil moisture level you need to water your lawn! ', Subject='Lawn maintenance reminder ', MessageStructure='string', MessageAttributes={ 'String': { 'DataType': 'String', 'StringValue': 'New records have been processed.' } } ) return 'Successfully processed {} records.'.format(len(event['records']))

चुनें फ़ंक्शन बनाएं.
केनिस डेटा एनालिटिक्स कंसोल पर, के तहत इन-एप्लिकेशन स्ट्रीम, चुनते हैं मौजूदा इन-एप्लिकेशन स्ट्रीम।
ड्रॉप-डाउन मेनू से, चुनें DESTINATION_SQL_HHR_STREAM JSON आउटपुट फॉर्मेट के साथ।
के अंतर्गत पहुंच अनुमति Kinesis Data Analytics के साथ उपयोग करने के लिए IAM भूमिका बनाएं या अपडेट करें।

डेटा विज़ुअलाइज़ेशन के लिए अमेज़ॅन क्विकसाइट कनेक्ट करना

Amazon QuickSight डैशबोर्ड बनाने के लिए, आपको KSONis Data Firehose से JSON कच्चे डेटा को निगलना होगा। निम्नलिखित चरणों को पूरा करें:

कंसोल पर, चुनें क्विकसाइट.

यदि आप पहली बार Amazon QuickSight का उपयोग कर रहे हैं, तो आपको एक नया खाता बनाना होगा।

आप लॉग इन करने के बाद चुनें नया विश्लेषण.
चुनें नया डेटा सेट।
उपलब्ध स्रोत से, चुनें S3.
डेटा स्रोत नाम दर्ज करें।
चुनें अपलोड मैनिफ़ेस्ट फ़ाइल।

मैनिफ़ेस्ट फ़ाइल S3 बाल्टी का स्थान और अमेज़न S3 में डेटा का प्रारूप प्रदान करती है। अधिक जानकारी के लिए देखें Amazon S3 Manifest फ़ाइलों के लिए समर्थित प्रारूप। निम्नलिखित उदाहरण कोड देखें:

{ "fileLocations": [ {"URIPrefixes": ["https://s3.amazonaws.com/<YOUR_BUCKET_NAME>/data/<YEAR>/<MONTH>/<DATE>/<HOUR>/" ]} ], "globalUploadSettings": { "format": "JSON" }
}

अमेज़न क्विकसाइट आयात और डेटा को पार्स करता है।

रूपांतरित डेटा को बदलने और प्रारूपित करने के लिए, चुनें डेटा संपादित करें / पूर्वावलोकन करें.
आपके द्वारा प्रारूपण करने के बाद, चुनें डेटा सहेजें और कल्पना करें.

विज़ुअलाइज़ेशन स्क्रीन पर एक विश्लेषण बनाने के लिए, निम्नलिखित चरणों को पूरा करें:

के लिए दृश्य प्रकार, चुनें लाइन चार्ट.
खींचें और छोड़ें DateTime को फ़ील्ड फील्ड वेल्स X- अक्ष।
चाल Light को वैल्यू
चाल Name को रंग

यह एक डैशबोर्ड बनाता है जो चार सेंसर स्थानों के लिए समय की अवधि में प्रकाश की मात्रा दिखाता है।

बदलाव DateTime से कुल विकल्प DAY सेवा मेरे MINUTE.
परिवर्तन Light से Sum सेवा मेरे Average.
X- अक्ष, Y- अक्ष या किंवदंती गुणों को बदलने के लिए प्रारूप दृश्य विकल्प चुनें।

निम्न ग्राफ़ समय के साथ औसत प्रकाश दिखाता है। आप इसी तरह नमी, तापमान और मिट्टी की उर्वरता के स्तर के लिए एक निर्माण कर सकते हैं।

निष्कर्ष

इस पोस्ट में दिखाया गया है कि सार्वजनिक रूप से उपलब्ध डेटासेट के आधार पर घास से मातम का पता लगाने और अमेज़ॅन काइनिस और एडब्ल्यूएसटी टीटी का उपयोग करके एक वास्तविक समय लॉन निगरानी प्रणाली का निर्माण करने के लिए एडब्ल्यूएस डीपलेन्स और अमेज़ॅन सेजमेकर में अंतर्निहित छवि वर्गीकरण एल्गोरिदम का उपयोग कैसे करें। आप अमेज़ॅन क्विकसाइट का उपयोग करके डेटा की कल्पना भी कर सकते हैं। आप अपने स्वयं के उपयोग के मामलों के लिए इस उदाहरण को क्लोन और विस्तारित कर सकते हैं।

लेखक के बारे में

रवि गुप्ता अमेज़ॅन वेब सेवाओं में एंटरप्राइज सॉल्यूशन आर्किटेक्ट हैं। वह एक उत्साही प्रौद्योगिकी उत्साही है जो ग्राहकों के साथ काम करने और नवीन समाधानों का निर्माण करने में उनकी मदद करता है। फोकस के उनके मुख्य क्षेत्र IoT, Analytics और मशीन लर्निंग हैं। अपने खाली समय में, रवि को अपने परिवार और फोटोग्राफी के साथ समय बिताना अच्छा लगता है।

शायोन सान्याल अमेज़ॅन वेब सर्विसेज में ग्लोबल फाइनेंशियल सर्विसेज के साथ एक वरिष्ठ डेटा आर्किटेक्ट (डेटा लेक) हैं। वह एडब्ल्यूएस ग्राहकों और भागीदारों को जटिल / चुनौतीपूर्ण एआई / एमएल, आईओटी और डेटा एनालिटिक्स समस्याओं को हल करने में सक्षम बनाता है और उन्हें डेटा-संचालित उद्यम के अपने दृष्टिकोण का एहसास करने में मदद करता है। अपने खाली समय में, शायोन को यात्रा करने, दौड़ने और लंबी पैदल यात्रा का आनंद मिलता है।

स्रोत: https://aws.amazon.com/blogs/machine-learning/building-a-lawn-monitor-and-weed-detection-solution-with-aws-machine-learning-and-iot/services/

जनरेटिव डेटा इंटेलिजेंस

AWS मशीन लर्निंग और IoT सेवाओं के साथ लॉन मॉनिटर और वीड डिटेक्शन सॉल्यूशन का निर्माण