ปกป้องผู้คนจากพื้นที่อันตรายผ่านขอบเขตเสมือนจริงด้วย Computer Vision

ประทับเวลา: 13 เมษายน 2021 2:49 น
โหนดต้นทาง: 807925

ในขณะที่บริษัทต่างๆ ยินดีต้อนรับหุ่นยนต์ที่ทำงานอัตโนมัติและอุปกรณ์หนักอื่นๆ เข้ามาในสถานที่ทำงาน เราจำเป็นต้องตรวจสอบให้แน่ใจว่าอุปกรณ์สามารถทำงานได้อย่างปลอดภัยเมื่ออยู่ร่วมกับเพื่อนร่วมทีมที่เป็นมนุษย์ ในโพสต์นี้เราจะแสดงวิธีสร้างขอบเขตเสมือนจริงด้วยคอมพิวเตอร์วิทัศน์และ AWS DeepLensซึ่งเป็นกล้องวิดีโอที่เปิดใช้งานการเรียนรู้เชิงลึกของ AWS ที่ออกแบบมาสำหรับนักพัฒนาเพื่อเรียนรู้การเรียนรู้ของเครื่อง (ML) เมื่อใช้เทคนิคการเรียนรู้ของเครื่องในโพสต์นี้ คุณสามารถสร้างขอบเขตเสมือนสำหรับพื้นที่จำกัดที่จะปิดอุปกรณ์โดยอัตโนมัติหรือส่งเสียงเตือนเมื่อมนุษย์เข้ามาใกล้

สำหรับโปรเจ็กต์นี้ คุณจะฝึกโมเดลการตรวจจับวัตถุแบบกำหนดเองด้วย อเมซอน SageMaker และปรับใช้โมเดลกับอุปกรณ์ AWS DeepLens การตรวจจับวัตถุเป็นอัลกอริธึม ML ที่ใช้รูปภาพเป็นอินพุตและระบุวัตถุและตำแหน่งของวัตถุภายในรูปภาพ นอกเหนือจากโซลูชันขอบเขตเสมือนจริง คุณสามารถใช้เทคนิคที่เรียนรู้ในโพสต์นี้เมื่อคุณต้องการตรวจจับว่าวัตถุบางอย่างอยู่ภายในรูปภาพหรือไม่ หรือนับจำนวนอินสแตนซ์ของวัตถุที่ต้องการในภาพ เช่น การนับรายการในถังเก็บข้อมูล หรือ บนชั้นวางขายปลีก

ภาพรวมโซลูชัน

คำแนะนำรวมถึงขั้นตอนต่อไปนี้:

  1. เตรียมชุดข้อมูลของคุณเพื่อป้อนเข้าสู่อัลกอริทึม ML
  2. ฝึกโมเดลด้วย Amazon SageMaker
  3. โมเดลทดสอบพร้อมโซนข้อจำกัดแบบกำหนดเอง
  4. ปรับใช้โซลูชันกับ AWS DeepLens

เรายังหารือกรณีการใช้งานจริงอื่นๆ ที่คุณสามารถใช้โซลูชันนี้ได้

ไดอะแกรมต่อไปนี้แสดงสถาปัตยกรรมโซลูชัน

เบื้องต้น

คุณต้องมีข้อกำหนดเบื้องต้นต่อไปนี้:

เตรียมชุดข้อมูลของคุณเพื่อป้อนเข้าสู่อัลกอริทึม ML

โพสต์นี้ใช้อัลกอริธึม ML ที่เรียกว่าโมเดลการตรวจจับวัตถุเพื่อสร้างโซลูชันที่ตรวจพบว่าบุคคลนั้นอยู่ในโซนจำกัดที่กำหนดเองหรือไม่ คุณใช้ที่เปิดเผยต่อสาธารณะ ชุดข้อมูลการตรวจจับคนเดินเท้า มีอยู่ใน Kaggle ซึ่งมีภาพมากกว่า 2,000 ภาพ ชุดข้อมูลนี้มีป้ายกำกับสำหรับวัตถุที่เหมือนมนุษย์และเหมือนมนุษย์ (เช่น หุ่นจำลอง) ดังนั้นแบบจำลองที่ได้รับการฝึกอบรมจึงสามารถแยกแยะระหว่างมนุษย์จริงกับอุปกรณ์ประกอบฉากหรือรูปปั้นจากกระดาษแข็งได้แม่นยำยิ่งขึ้น

ตัวอย่างเช่น รูปภาพต่อไปนี้เป็นตัวอย่างของคนงานก่อสร้างที่ตรวจพบ และหากพวกเขาอยู่ในเขตจำกัดที่กำหนดเอง (โครงร่างสีแดง)

เพื่อเริ่มฝึกโมเดลของคุณ ขั้นแรกให้สร้างที่เก็บข้อมูล S3 เพื่อเก็บข้อมูลการฝึกและเอาท์พุตแบบจำลองของคุณ สำหรับโปรเจ็กต์ AWS DeepLens ชื่อบัคเก็ต S3 ต้องขึ้นต้นด้วยคำนำหน้า deeplens-. คุณใช้ข้อมูลนี้เพื่อฝึกโมเดลด้วย SageMaker ซึ่งเป็นบริการที่มีการจัดการเต็มรูปแบบซึ่งให้ความสามารถในการสร้าง ฝึกฝน และปรับใช้โมเดล ML ได้อย่างรวดเร็ว

ฝึกโมเดลด้วย Amazon SageMaker

คุณใช้โน้ตบุ๊ก SageMaker Jupyter เป็นสภาพแวดล้อมการพัฒนาเพื่อฝึกโมเดล Jupyter Notebook เป็นเว็บแอปพลิเคชันโอเพนซอร์ซที่ให้คุณสร้างและแบ่งปันเอกสารที่มีโค้ด สมการ การสร้างภาพ และข้อความบรรยาย สำหรับโพสต์นี้เราจัดให้ Train_Object_Detection_People_DeepLens.ipynb,โน๊ตบุ๊คตัวเต็มให้คุณติดตาม.

ในการสร้างแบบจำลองการตรวจหาวัตถุแบบกำหนดเอง คุณต้องใช้อินสแตนซ์งานการฝึกอบรมที่เปิดใช้งานการประมวลผลกราฟิก (GPU) GPU นั้นยอดเยี่ยมในการคำนวณแบบขนานที่จำเป็นในการฝึกโครงข่ายประสาทเทียม แม้ว่าตัวโน้ตบุ๊กจะเป็นอินสแตนซ์ ml.t2.medium ตัวเดียว แต่งานการฝึกอบรมนั้นใช้อินสแตนซ์ ml.p2.xlarge เป็นพิเศษ ในการเข้าถึงอินสแตนซ์งานการฝึกอบรมที่เปิดใช้งาน GPU คุณต้อง ยื่นคำขอเพิ่มขีดจำกัดบริการ ไปที่ AWS Support Center

หลังจากที่คุณได้รับขีดจำกัดเพิ่มขึ้น ให้ทำตามขั้นตอนต่อไปนี้เพื่อสร้างอินสแตนซ์โน้ตบุ๊ก SageMaker:

  1. บนคอนโซล SageMaker ให้เลือก อินสแตนซ์โน้ตบุ๊ก.
  2. Choose สร้างอินสแตนซ์สมุดบันทึก.
  3. สำหรับ ชื่ออินสแตนซ์สมุดบันทึกป้อนชื่ออินสแตนซ์สมุดบันทึกของคุณ
  4. สำหรับ ประเภทอินสแตนซ์เลือก t2.ปานกลาง

นี่เป็นประเภทอินสแตนซ์ที่ถูกที่สุดที่อินสแตนซ์ของโน้ตบุ๊กรองรับ และเพียงพอสำหรับบทช่วยสอนนี้

  1. สำหรับ บทบาท IAMเลือก สร้างบทบาทใหม่.

มั่นใจได้เลยว่า AWS Identity และการจัดการการเข้าถึง บทบาท (IAM) มีสิทธิ์เข้าถึงบัคเก็ต S3 ที่คุณสร้างไว้ก่อนหน้านี้ (คำนำหน้า deeplens-).

  1. Choose สร้างอินสแตนซ์สมุดบันทึก. อินสแตนซ์โน้ตบุ๊กของคุณอาจใช้เวลาสองสามนาทีในการเริ่มต้น
  1. เมื่อสถานะบนหน้าอินสแตนซ์โน้ตบุ๊กเปลี่ยนเป็น InService ให้เลือก เปิด Jupyter เพื่อเปิดใช้อินสแตนซ์โน้ตบุ๊ก Jupyter ที่สร้างขึ้นใหม่
  2. Choose อัพโหลด เพื่ออัปโหลด Train_Object_Detection_people_DeepLens.ipynb ไฟล์ที่คุณดาวน์โหลดมาก่อนหน้านี้

  1. เปิดสมุดบันทึกและทำตามจนจบ
  2. หากระบบถามเกี่ยวกับการตั้งค่าเคอร์เนล ให้เลือก conda_mxnet_p36.

สมุดบันทึก Jupyter ประกอบด้วยเซลล์ข้อความและรหัสผสมกัน หากต้องการเรียกใช้โค้ด ให้เลือกเซลล์แล้วกด Shift + Enter. ในขณะที่เซลล์กำลังทำงาน เครื่องหมายดอกจันจะปรากฏถัดจากเซลล์นั้น เมื่อเซลล์เสร็จสมบูรณ์ หมายเลขเอาต์พุตและเซลล์เอาต์พุตใหม่จะปรากฏใต้เซลล์เดิม

  1. ดาวน์โหลดชุดข้อมูลจากบัคเก็ต S3 สาธารณะลงในอินสแตนซ์ SageMaker ในเครื่องแล้วคลายซิปข้อมูล ซึ่งสามารถทำได้โดยทำตามรหัสในสมุดบันทึก: 
     !aws s3 cp s3://deeplens-public/samples/pedestriansafety/humandetection_data.zip . !rm -rf humandetection/ !unzip humandetection_data.zip -d humandetection

  2. แปลงชุดข้อมูลให้อยู่ในรูปแบบ (บันทึกIO) ที่สามารถป้อนเข้าสู่อัลกอริทึม SageMaker: 
     !python $mxnet_path/tools/im2rec.py --pass-through --pack-label $DATA_PATH/train_mask.lst $DATA_PATH/ !python $mxnet_path/tools/im2rec.py --pass-through --pack-label $DATA_PATH/val_mask.lst $DATA_PATH/

  3. โอนไฟล์ RecordIO กลับไปที่ Amazon S3

เมื่อคุณเตรียมข้อมูลเสร็จแล้ว คุณก็พร้อมที่จะฝึกตัวตรวจจับวัตถุแล้ว

มีอัลกอริธึมการตรวจจับวัตถุหลายประเภท สำหรับโพสต์นี้ คุณใช้ อัลกอริธึมการตรวจจับ MultiBox แบบ Single-Shot (SSD). อัลกอริธึม SSD มีความสมดุลระหว่างความเร็วและความแม่นยำ ทำให้เหมาะสำหรับการรันบนอุปกรณ์ Edge เช่น AWS DeepLens

เป็นส่วนหนึ่งของงานการฝึกอบรม คุณมีตัวเลือกมากมายสำหรับไฮเปอร์พารามิเตอร์ที่ช่วยกำหนดค่าพฤติกรรมการฝึก (เช่น จำนวนยุค อัตราการเรียนรู้ ประเภทเครื่องมือเพิ่มประสิทธิภาพ และขนาดชุดย่อย) ไฮเปอร์พารามิเตอร์ช่วยให้คุณปรับความเร็วในการฝึกและความแม่นยำของแบบจำลองของคุณได้ สำหรับข้อมูลเพิ่มเติมเกี่ยวกับไฮเปอร์พารามิเตอร์ โปรดดูที่ อัลกอริธึมการตรวจจับวัตถุ.

  1. ตั้งค่าไฮเปอร์พารามิเตอร์และช่องข้อมูลของคุณ พิจารณาใช้ตัวอย่างคำจำกัดความของไฮเปอร์พารามิเตอร์ต่อไปนี้: 
     od_model = sagemaker.estimator.Estimator(training_image, role, train_instance_count=1, train_instance_type='ml.p2.xlarge', train_volume_size = 50, train_max_run = 360000, input_mode= 'File', output_path=s3_output_location, sagemaker_session=sess) od_model.set_hyperparameters(base_network='resnet-50', use_pretrained_model=1, num_classes=2, mini_batch_size=32, epochs=100, learning_rate=0.003, lr_scheduler_step='3,6', lr_scheduler_factor=0.1, optimizer='sgd', momentum=0.9, weight_decay=0.0005, overlap_threshold=0.5, nms_threshold=0.45, image_shape=300, num_training_samples=n_train_samples)

โน้ตบุ๊กมีไฮเปอร์พารามิเตอร์เริ่มต้นที่เลือกไว้ล่วงหน้า สำหรับการตรวจจับคนเดินถนน คุณต้องฝึกแบบจำลองสำหรับ 100 ยุค ขั้นตอนการฝึกอบรมนี้ควรใช้เวลาประมาณ 2 ชั่วโมงโดยใช้หนึ่งอินสแตนซ์ ml.p2.xlarge คุณสามารถทดลองกับไฮเปอร์พารามิเตอร์หลายๆ แบบรวมกัน หรือฝึกเพื่อให้มียุคสมัยมากขึ้นสำหรับการปรับปรุงประสิทธิภาพ สำหรับข้อมูลเกี่ยวกับราคาล่าสุด โปรดดูที่ ราคา Amazon SageMaker.

  1. คุณสามารถเริ่มงานการฝึกอบรมด้วยรหัสบรรทัดเดียวและตรวจสอบความถูกต้องเมื่อเวลาผ่านไปบนคอนโซล SageMaker: 
    od_model.fit(inputs=data_channels, logs=True)

สำหรับข้อมูลเพิ่มเติมเกี่ยวกับวิธีการทำงานของการฝึกอบรม โปรดดูที่ สร้างงานฝึกอบรม. การจัดเตรียมและการดาวน์โหลดข้อมูลต้องใช้เวลา ขึ้นอยู่กับขนาดของข้อมูล ดังนั้น อาจใช้เวลาสองสามนาทีก่อนที่คุณจะเริ่มรับบันทึกข้อมูลสำหรับงานการฝึกอบรมของคุณ

คุณสามารถติดตามความคืบหน้าของงานการฝึกของคุณผ่านเมตริกเฉลี่ยความแม่นยำเฉลี่ย (mAP) ซึ่งช่วยให้คุณตรวจสอบคุณภาพของความสามารถของแบบจำลองในการจำแนกวัตถุและตรวจจับกรอบขอบเขตที่ถูกต้อง บันทึกข้อมูลยังพิมพ์ mAP บนข้อมูลการตรวจสอบ ท่ามกลางการสูญเสียอื่นๆ สำหรับการรันชุดข้อมูลทุกครั้ง หนึ่งครั้งสำหรับหนึ่งยุค ตัวชี้วัดนี้เป็นพร็อกซีสำหรับคุณภาพของประสิทธิภาพของอัลกอริธึมในการตรวจจับคลาสอย่างแม่นยำและขอบเขตที่แม่นยำรอบๆ

เมื่องานเสร็จสิ้น คุณสามารถค้นหาไฟล์โมเดลที่ได้รับการฝึกในบัคเก็ต S3 และโฟลเดอร์ที่ระบุก่อนหน้านี้ใน s3_output_location:

s3_output_location = 's3://{}/{}/output'.format(BUCKET, PREFIX)

สำหรับโพสต์นี้ เราแสดงผลในชุดการตรวจสอบเมื่อสิ้นสุดยุคที่ 10 และยุคที่ 100 ในตอนท้ายของยุคที่ 10 เราเห็น mAP การตรวจสอบความถูกต้องที่ประมาณ 0.027 ในขณะที่ยุคที่ 100 อยู่ที่ประมาณ 0.42

เพื่อให้ได้ผลการตรวจจับที่ดีขึ้น คุณสามารถลองปรับไฮเปอร์พารามิเตอร์โดยใช้ความสามารถที่มีอยู่ใน SageMaker for การปรับรุ่นอัตโนมัติ และฝึกแบบจำลองสำหรับยุคสมัยที่มากขึ้น คุณมักจะหยุดการฝึกเมื่อเห็นว่าความแม่นยำเพิ่มขึ้นน้อยลง

โมเดลทดสอบพร้อมโซนข้อจำกัดที่กำหนดเอง

ก่อนที่คุณจะปรับใช้โมเดลที่ผ่านการฝึกอบรมกับ AWS DeepLens คุณสามารถทดสอบในระบบคลาวด์ได้โดยใช้ปลายทางที่โฮสต์โดย SageMaker ตำแหน่งข้อมูล SageMaker เป็นบริการที่มีการจัดการเต็มรูปแบบซึ่งช่วยให้คุณทำการอนุมานแบบเรียลไทม์ผ่าน REST API SageMaker ช่วยให้คุณปรับใช้ปลายทางใหม่ได้อย่างรวดเร็วเพื่อทดสอบโมเดลของคุณ คุณจึงไม่ต้องโฮสต์โมเดลบนอินสแตนซ์ในเครื่องที่ใช้ในการฝึกโมเดล สิ่งนี้ทำให้คุณสามารถคาดการณ์ (หรืออนุมาน) จากแบบจำลองบนภาพที่อัลกอริทึมไม่เห็นระหว่างการฝึก

คุณไม่จำเป็นต้องโฮสต์บนอินสแตนซ์ประเภทเดียวกับที่คุณใช้ในการฝึก การฝึกอบรมเป็นงานที่ใช้เวลานานและต้องใช้การประมวลผลสูง ซึ่งต้องใช้ข้อกำหนดด้านการประมวลผลและหน่วยความจำชุดอื่นซึ่งโดยทั่วไปแล้วการโฮสต์ไม่ต้องการ คุณสามารถเลือกประเภทอินสแตนซ์ที่ต้องการโฮสต์โมเดลได้ ในกรณีนี้ เราเลือกอินสแตนซ์ ml.p3.2xlarge เพื่อฝึกฝน แต่เราเลือกที่จะโฮสต์โมเดลบนอินสแตนซ์ CPU ที่มีราคาถูกกว่า ml.m4.xlarge ข้อมูลโค้ดต่อไปนี้แสดงการปรับใช้ปลายทางของเรา

object_detector = od_model.deploy(initial_instance_count = 1, instance_type = 'ml.m4.xlarge')

การตรวจหาในเขตจำกัดที่กำหนดเอง (ภูมิภาคที่สนใจ)

รูปแบบของผลลัพธ์สามารถแสดงเป็น [class_index, trust_score, xmin, ymin, xmax, ymax] การคาดคะเนที่มั่นใจต่ำมักจะมีโอกาสสูงที่จะเกิดผลบวกลวงหรือลบลวง ดังนั้นคุณจึงควรละทิ้งการคาดคะเนความมั่นใจต่ำ คุณสามารถใช้รหัสต่อไปนี้เพื่อตรวจสอบว่ากล่องขอบเขตของบุคคลนั้นทับซ้อนกับโซนที่ถูกจำกัดหรือไม่

def inRestrictedSection(ImShape = None, R1 = None, restricted_region = None, kclass = None, score = None, threshold = None): statement = 'Person Not Detected in Restricted Zone' if (kclass == 1) and (score > threshold): Im1 = np.zeros((ImShape[0],ImShape[1],3), np.int32) cv2.fillPoly(Im1, [R1], 255) Im2 = np.zeros((ImShape[0],ImShape[1],3), np.int32) if restricted_region is None: restricted_region = np.array([[0,ImShape[0]],[ImShape[1],ImShape[0]],[ImShape[1],0], [0,0]], np.int32) cv2.fillPoly(Im2, [restricted_region], 255) Im = Im1 * Im2 if np.sum(np.greater(Im, 0))>0: statement = 'Person Detected in Restricted Zone' else: statement = statement return statement

โดยค่าเริ่มต้น กรอบทั้งหมดจะถูกประเมินสำหรับการมีอยู่ของมนุษย์ อย่างไรก็ตาม คุณสามารถระบุภูมิภาคที่สนใจได้โดยง่ายซึ่งถือว่าบุคคลมีความเสี่ยงสูง หากคุณต้องการเพิ่มโซนการจำกัดที่กำหนดเอง ให้เพิ่มพิกัดของจุดยอดของพื้นที่ที่แสดงโดย [แกน X, แกน Y] และสร้างรูปหลายเหลี่ยม พิกัดต้องป้อนตามเข็มนาฬิกาหรือทวนเข็มนาฬิกา ดูรหัสต่อไปนี้:

restricted_region = None #restricted_region = np.array([[0,200],[100,200],[100,0], [10,10]], np.int32)

รหัสตัวอย่างต่อไปนี้แสดงคนเดินถนนที่ระบุภายในเขตหวงห้าม:

file_name = 'humandetection/test_images/t1_image.jpg' img = cv2.imread(file_name) img =cv2.cvtColor(img,cv2.COLOR_BGR2RGB) thresh = 0.2 height = img.shape[0] width = img.shape[1] colors = dict() with open(file_name, 'rb') as image: f = image.read() b = bytearray(f) ne = open('n.txt','wb') ne.write(b) results = object_detector.predict(b, initial_args={'ContentType': 'image/jpeg'}) detections = json.loads(results) object_categories = ['no-person', 'person'] for det in detections['prediction']: (klass, score, x0, y0, x1, y1) = det if score < thresh: continue cls_id = int(klass) prob = score if cls_id not in colors: colors[cls_id] = (random.random(), random.random(), random.random()) xmin = int(x0 * width) ymin = int(y0 * height) xmax = int(x1 * width) ymax = int(y1 * height) R1 = np.array([[xmin,ymin],[xmax,ymin],[xmax,ymax], [xmin,ymax]], np.int32) cv2.polylines(img,[R1],True, (255,255,0), thickness = 5) cv2.polylines(img,[restricted_region],True, (255,0,0), thickness = 5) plt.imshow(img) print(inRestrictedSection(img.shape,R1 = R1, restricted_region= restricted_region, kclass = cls_id, score = prob, threshold=0.2))

ภาพต่อไปนี้แสดงผลลัพธ์ของเรา

ปรับใช้โซลูชันกับ AWS DeepLens

แปลงโมเดลสำหรับการปรับใช้เป็น AWS DeepLens

เมื่อปรับใช้โมเดล SSD ที่ฝึกโดย SageMaker กับ AWS DeepLens คุณต้องเรียกใช้ .ก่อน Deploy.py เพื่อแปลงสิ่งประดิษฐ์ของแบบจำลองเป็นแบบจำลองที่ปรับใช้ได้:

!rm -rf incubator-mxnet !git clone -b v1.7.x https://github.com/apache/incubator-mxnet MODEL_PATH = od_model.model_data TARGET_PATH ='s3://'+BUCKET+'/'+PREFIX+'/patched/' !rm -rf tmp && mkdir tmp rm -rf tmp && mkdir tmp !aws s3 cp $MODEL_PATH tmp !tar -xzvf tmp/model.tar.gz -C tmp !mv tmp/model_algo_1-0000.params tmp/ssd_resnet50_300-0000.params !mv tmp/model_algo_1-symbol.json tmp/ssd_resnet50_300-symbol.json !python incubator-mxnet/example/ssd/deploy.py --network resnet50 --data-shape 300 --num-class 2 --prefix tmp/ssd_ !tar -cvzf ./patched_model.tar.gz -C tmp ./deploy_ssd_resnet50_300-0000.params ./deploy_ssd_resnet50_300-symbol.json ./hyperparams.json !aws s3 cp patched_model.tar.gz $TARGET_PATH

นำเข้าโมเดลของคุณไปยัง AWS DeepLens

ในการรันโมเดลบนอุปกรณ์ AWS DeepLens คุณต้องสร้างโปรเจ็กต์ AWS DeepLens เริ่มต้นด้วยการนำเข้าโมเดลของคุณไปยัง AWS DeepLens

  1. บนคอนโซล AWS DeepLens ภายใต้ แหล่งข้อมูลเลือก Models.
  2. Choose นำเข้าโมเดล.

  1. สำหรับ แหล่งนำเข้าให้เลือก โมเดลที่ได้รับการฝึกฝนจากภายนอก.
  2. ป้อนตำแหน่ง Amazon S3 ของ รุ่นแพทช์ ที่คุณบันทึกไว้จากการเรียกใช้ deploy.py ในขั้นตอนด้านบน
  3. สำหรับ กรอบแบบจำลองเลือก MX เน็ต.
  4. Choose นำเข้าโมเดล.

สร้างฟังก์ชันการอนุมาน

ฟังก์ชันอนุมานจะป้อนเฟรมของกล้องแต่ละตัวลงในโมเดลเพื่อรับการคาดการณ์และเรียกใช้ตรรกะทางธุรกิจที่กำหนดเองโดยใช้ผลการอนุมาน คุณใช้ AWS แลมบ์ดา เพื่อสร้างฟังก์ชันที่คุณปรับใช้กับ AWS DeepLens ฟังก์ชันนี้เรียกใช้การอนุมานภายในอุปกรณ์ AWS DeepLens

อันดับแรก เราต้องสร้างฟังก์ชัน Lambda เพื่อปรับใช้กับ AWS DeepLens

  1. ดาวน์โหลด การอนุมานฟังก์ชันแลมบ์ดา.
  2. บนคอนโซล Lambda ให้เลือก ฟังก์ชั่น.
  3. Choose สร้างฟังก์ชัน.
  4. เลือก ผู้เขียนตั้งแต่เริ่มต้น.
  5. สำหรับ ชื่อฟังก์ชัน, ป้อนชื่อ
  6. สำหรับ Runtimeเลือก งูหลาม 3.7.
  7. สำหรับ เลือกหรือสร้างบทบาทการดำเนินการเลือก ใช้บทบาทที่มีอยู่.
  8. Choose บทบาทบริการ/AWSDeepLensLambdaRole.
  9. Choose สร้างฟังก์ชัน.

  1. ในหน้ารายละเอียดของฟังก์ชัน บน สถานะ เมนูให้เลือก อัปโหลดไฟล์ .zip.

  1. อัปโหลดไฟล์ การอนุมานแลมบ์ดา ไฟล์ที่คุณดาวน์โหลดมาก่อนหน้านี้
  2. Choose ลด เพื่อบันทึกรหัสที่คุณป้อน
  3. เกี่ยวกับ สถานะ เมนูให้เลือก เผยแพร่เวอร์ชันใหม่.

การเผยแพร่ฟังก์ชันทำให้ใช้งานได้บนคอนโซล AWS DeepLens เพื่อให้คุณสามารถเพิ่มลงในโปรเจ็กต์ที่คุณกำหนดเองได้

  1. ป้อนหมายเลขเวอร์ชันแล้วเลือก สาธารณะ.

ทำความเข้าใจกับฟังก์ชันอนุมาน

ส่วนนี้จะอธิบายส่วนสำคัญของฟังก์ชันอนุมานบางส่วนให้คุณทราบ ขั้นแรก คุณควรให้ความสนใจกับไฟล์เฉพาะสองไฟล์:

  • label.txt – ประกอบด้วยการแมปเอาต์พุตจากโครงข่ายประสาทเทียม (จำนวนเต็ม) กับป้ายกำกับที่มนุษย์อ่านได้ (สตริง)
  • lambda_function.py – มีโค้ดสำหรับเรียกใช้ฟังก์ชันเพื่อสร้างการคาดคะเนในทุกเฟรมของกล้องแล้วส่งกลับผลลัพธ์

ใน lambda_function.py คุณต้องโหลดและปรับโมเดลให้เหมาะสมก่อน เมื่อเทียบกับเครื่องเสมือนบนระบบคลาวด์ที่มี GPU แล้ว AWS DeepLens มีพลังในการประมวลผลน้อยกว่า AWS DeepLens ใช้เครื่องมือเพิ่มประสิทธิภาพโมเดล Intel OpenVino เพื่อเพิ่มประสิทธิภาพโมเดลที่ได้รับการฝึกอบรมใน SageMaker เพื่อทำงานบนฮาร์ดแวร์ โค้ดต่อไปนี้ปรับโมเดลของคุณให้ทำงานภายในเครื่อง:

client.publish(topic=iot_topic, payload='Optimizing model...') ret, model_path = mo.optimize('deploy_ssd_resnet50_300', INPUT_W, INPUT_H) # Load the model onto the GPU. client.publish(topic=iot_topic, payload='Loading model...') model = awscam.Model(model_path, {'GPU': 1})

จากนั้นคุณเรียกใช้โมเดลเฟรมต่อเฟรมบนภาพจากกล้อง ดูรหัสต่อไปนี้:

while True: # Get a frame from the video stream ret, frame = awscam.getLastFrame() if not ret: raise Exception('Failed to get frame from the stream') # Resize frame to the same size as the training set. frame_resize = cv2.resize(frame, (INPUT_H, INPUT_W)) # 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 แต่ละเครื่องมี iot_topic เฉพาะที่สร้างขึ้นโดยอัตโนมัติเพื่อรับผลการอนุมาน ดูรหัสต่อไปนี้:

# Send results to the cloud client.publish(topic=iot_topic, payload=json.dumps(cloud_output))

สร้างโปรเจ็กต์ AWS DeepLens แบบกำหนดเอง

ในการสร้างโครงการ AWS DeepLens ใหม่ ให้ทำตามขั้นตอนต่อไปนี้:

  1. บนคอนโซล AWS DeepLens บน โครงการ หน้าให้เลือก สร้างโครงการ.
  2. สำหรับ ประเภทโครงการให้เลือก สร้างโครงการเปล่าใหม่.
  3. Choose ถัดไป.

  1. ตั้งชื่อโครงการของคุณ yourname-pedestrian-detector-.
  2. Choose เพิ่มรุ่น.
  3. เลือกรุ่นที่คุณเพิ่งสร้างขึ้น
  4. Choose เพิ่มฟังก์ชัน.
  5. ค้นหาฟังก์ชัน Lambda ที่คุณสร้างไว้ก่อนหน้านี้โดยใช้ชื่อ
  6. Choose สร้างโครงการ.
  7. เกี่ยวกับ โครงการ หน้า เลือกโครงการที่คุณต้องการปรับใช้
  8. เลือก ปรับใช้กับอุปกรณ์.
  9. สำหรับ อุปกรณ์เป้าหมาย, เลือกอุปกรณ์ของคุณ
  10. Choose รีวิว.
  11. ตรวจสอบการตั้งค่าและเลือก ปรับใช้.

การปรับใช้อาจใช้เวลานานถึง 10 นาทีจึงจะเสร็จสมบูรณ์ ขึ้นอยู่กับความเร็วของเครือข่าย AWS DeepLens ของคุณเชื่อมต่ออยู่ เมื่อการปรับใช้เสร็จสมบูรณ์ คุณควรเห็นแบนเนอร์สีเขียวบนหน้าพร้อมข้อความ "ขอแสดงความยินดี ขณะนี้โมเดลของคุณทำงานบน AWS DeepLens ในเครื่องแล้ว!"

หากต้องการดูข้อความที่ส่งออก ให้เลื่อนลงบนหน้ารายละเอียดอุปกรณ์ไปที่ ผลผลิตโครงการ ส่วน. ทำตามคำแนะนำในส่วนเพื่อคัดลอกหัวข้อและไปที่ AWS IoT คอร์ คอนโซลเพื่อสมัครสมาชิกหัวข้อ คุณควรเห็นผลลัพธ์ตามภาพหน้าจอต่อไปนี้

สำหรับคำแนะนำทีละขั้นตอนในการดูสตรีมวิดีโอหรือเอาต์พุตข้อความ โปรดดูที่ การดูผลลัพธ์จาก AWS DeepLens.

กรณีใช้งานจริง

ตอนนี้คุณมีการคาดการณ์จากโมเดลของคุณที่ทำงานบน AWS DeepLens แล้ว มาแปลงการคาดการณ์เหล่านี้เป็นการแจ้งเตือนและข้อมูลเชิงลึกกัน การใช้งานทั่วไปบางประการสำหรับโครงการเช่นนี้ ได้แก่:

  • ทำความเข้าใจว่ามีคนกี่คนที่เข้ามาในเขตหวงห้ามเพื่อให้สถานที่ก่อสร้างสามารถระบุจุดที่ต้องมีป้ายความปลอดภัยเพิ่มเติม ซึ่งสามารถทำได้โดยการรวบรวมผลลัพธ์และใช้เพื่อสร้างแดชบอร์ดโดยใช้ อเมซอน QuickSight. สำหรับรายละเอียดเพิ่มเติมเกี่ยวกับการสร้างแดชบอร์ดโดยใช้ QuickSight โปรดดูที่ สร้างตัวติดตามท่าทางการทำงานจากที่บ้านด้วย AWS DeepLens และ GluonCV.
  • รวบรวมเอาต์พุตจาก AWS DeepLens และกำหนดค่า Raspberry Pi ให้ส่งเสียงเตือนเมื่อมีคนเดินเข้าไปในเขตหวงห้าม สำหรับรายละเอียดเพิ่มเติมเกี่ยวกับการเชื่อมต่ออุปกรณ์ AWS DeepLens กับอุปกรณ์ Raspberry Pi โปรดดูที่ การสร้างเครื่องคัดแยกขยะด้วย AWS DeepLens.

สรุป

ในโพสต์นี้ คุณได้เรียนรู้วิธีฝึกโมเดลการตรวจจับวัตถุและปรับใช้กับ AWS DeepLens เพื่อตรวจจับผู้ที่เข้าสู่โซนที่ถูกจำกัด คุณสามารถใช้บทช่วยสอนนี้เป็นข้อมูลอ้างอิงในการฝึกอบรมและปรับใช้โครงการตรวจจับวัตถุแบบกำหนดเองของคุณบน AWS DeepLens

สำหรับคำแนะนำโดยละเอียดเพิ่มเติมของบทช่วยสอนนี้และบทช่วยสอน ตัวอย่าง และแนวคิดโครงการอื่นๆ ด้วย AWS DeepLens โปรดดูที่ สูตร AWS DeepLens.

เกี่ยวกับผู้เขียน

ยัชชาห์ เป็นนักวิทยาศาสตร์ด้านข้อมูลใน Amazon ML Solutions Lab ซึ่งเขาทำงานเกี่ยวกับกรณีการใช้งานแมชชีนเลิร์นนิงหลากหลายรูปแบบ ตั้งแต่การดูแลสุขภาพไปจนถึงการผลิตและการขายปลีก เขามีพื้นฐานที่เป็นทางการในด้านปัจจัยมนุษย์และสถิติ และก่อนหน้านี้เคยเป็นส่วนหนึ่งของทีม Amazon SCOT ที่ออกแบบผลิตภัณฑ์เพื่อแนะนำผู้ขาย 3P ด้วยการจัดการสินค้าคงคลังที่มีประสิทธิภาพ

ภูเหงียน เป็นผู้จัดการผลิตภัณฑ์สำหรับ AWS Panorama เขาสร้างผลิตภัณฑ์ที่ช่วยให้นักพัฒนาทุกระดับทักษะสามารถแนะนำแมชชีนเลิร์นนิงได้ง่ายและลงมือปฏิบัติจริง

ที่มา: https://aws.amazon.com/blogs/machine-learning/protecting-people-through-virtual-boundaries-computer-vision/

ประทับเวลา:

เพิ่มเติมจาก บล็อก AWS Machine Learning