Իրական ժամանակում օբյեկտների հայտնաբերման համակարգի կառուցում YOLO ալգորիթմով

Վերջին տարիներին համակարգչային տեսողության ոլորտը ականատես է եղել ուշագրավ առաջընթացների, որտեղ իրական ժամանակում օբյեկտների հայտնաբերումը ամենահետաքրքիր և ազդեցիկ ոլորտներից մեկն է: Իրական ժամանակում օբյեկտների հայտնաբերումը վերաբերում է պատկերների կամ տեսանյութերի օբյեկտները իրական ժամանակում հայտնաբերելու և նույնականացնելու ունակությանը, ինչը հնարավորություն է տալիս կիրառությունների լայն շրջանակ, ինչպիսիք են ինքնավար մեքենաները, հսկման համակարգերը, ընդլայնված իրականությունը և այլն: Այս ձեռնարկում մենք կուսումնասիրենք, թե ինչպես կառուցել իրական ժամանակի օբյեկտների հայտնաբերման համակարգ՝ օգտագործելով Python-ը և YOLO (You Only Look One) ալգորիթմը:

YOLO ալգորիթմը հեղափոխեց օբյեկտների հայտնաբերումը` ներմուծելով մեկ միասնական մոտեցում, որն իրականացնում է և՛ օբյեկտների տեղայնացումը, և՛ դասակարգումը մեկ անցումով: Ի տարբերություն ավանդական մեթոդների, որոնք օգտագործում են բարդ խողովակաշարեր, որոնք ներառում են բազմաթիվ փուլեր, YOLO ալգորիթմը հասնում է տպավորիչ արագության և ճշգրտության՝ դիտարկելով օբյեկտների հայտնաբերումը որպես ռեգրեսիայի խնդիր: Այն մուտքագրված պատկերը բաժանում է ցանցի և կանխատեսում է սահմանափակող տուփեր և դասերի հավանականություններ անմիջապես ցանցի բջիջներից:

Python-ն իր պարզությամբ, բազմակողմանիությամբ և գրադարանների հարուստ էկոհամակարգով հիանալի ընտրություն է իրական ժամանակում օբյեկտների հայտնաբերման համակարգերի ներդրման համար: Մենք կօգտագործենք Darknet շրջանակը, որը բաց կոդով նեյրոնային ցանցի շրջանակ է, որը գրված է C և CUDA-ով, որպեսզի վարժեցնենք մեր մոդելը՝ օգտագործելով YOLO ալգորիթմը: Darknet Framework-ի և Python-ի օգնությամբ մենք կկառուցենք իրական ժամանակի օբյեկտների հայտնաբերման համակարգ, որը կարող է հայտնաբերել և դասակարգել օբյեկտները կենդանի վիդեո հոսքերից կամ ձայնագրված տեսանյութերից:

Սկսել

Python-ի և YOLO ալգորիթմի միջոցով իրական ժամանակում օբյեկտների հայտնաբերման մեր համակարգը կառուցելու համար մենք պետք է ստեղծենք մեր զարգացման միջավայրը և տեղադրենք անհրաժեշտ գրադարանները: Հետևյալ քայլերը ձեզ կառաջնորդեն տեղադրման գործընթացում

Քայլ 1. Տեղադրեք OpenCV

OpenCV-ն համակարգչային տեսողության հանրաճանաչ գրադարան է, որն ապահովում է պատկերների և տեսանյութերի մշակման հիմնական գործիքներն ու գործառույթները: Մենք կարող ենք տեղադրել OpenCV-ն՝ օգտագործելով pip-ը՝ Python փաթեթների կառավարիչը, տերմինալում գործարկելով հետևյալ հրամանը −

pip install opencv-python

Քայլ 2. Տեղադրեք Darknet-ը

Darknet-ն այն շրջանակն է, որը մենք կօգտագործենք մեր YOLO մոդելը մարզելու համար: Darknet-ը տեղադրելու համար բացեք տերմինալի պատուհանը և հետևեք այս քայլերին

Կլոնավորեք Darknet պահեստը GitHub-ից

git clone https://github.com/AlexeyAB/darknet.git

Փոխեք Darknet տեղեկատուի մեջ

cd darknet

Կառուցեք Darknet-ը

պատրաստել

Այս քայլը կարող է որոշ ժամանակ տևել, քանի որ այն կազմում է C կոդը և կառուցում Darknet շրջանակը: Կառուցման գործընթացն ավարտվելուց հետո դուք պետք է պատրաստ ունենաք Darknet գործարկիչը օգտագործման համար:

YOLO-ի հետ իրական ժամանակում օբյեկտների հայտնաբերման համակարգի կառուցում

Այժմ, երբ մենք ստեղծեցինք մեր զարգացման միջավայրը և տեղադրեցինք անհրաժեշտ գրադարանները, մենք կարող ենք շարունակել իրական ժամանակում օբյեկտների հայտնաբերման մեր համակարգի կառուցումը: Ես բաժանել եմ օբյեկտների հայտնաբերման հետ կապված բոլոր տարբեր քայլերը, որին հաջորդում է ամբողջական կոդը՝ ամբողջ խողովակաշարն ու գործընթացը ավելի լավ հասկանալու համար: Սա կկանխի կոդերի փոքր կտորների հետ կապված շփոթությունը:

Համակարգի կառուցման հիմնական քայլերը հետևյալն են

• Տվյալների հավաքածուի պատրաստում – Մեր YOLO մոդելը վարժեցնելու համար մեզ անհրաժեշտ է պիտակավորված տվյալների հավաքածու, որը պարունակում է պատկերներ և համապատասխան ծանոթագրություններ: Տվյալների հավաքածուն պետք է բաղկացած լինի պատկերներից՝ պիտակավորված սահմանափակող տուփերով այն օբյեկտների շուրջ, որոնք մենք ցանկանում ենք հայտնաբերել: Անոտացիաները սովորաբար ներառում են դասի պիտակը և սահմանող տուփի կոորդինատները:

• YOLO մոդելի կազմաձևում - YOLO ալգորիթմն ունի տարբեր տատանումներ, ինչպիսիք են YOLOv1, YOLOv2, YOLOv3 և YOLOv4: Յուրաքանչյուր տարբերակ ունի իր կոնֆիգուրացիայի ֆայլը, որը նշում է ցանցի ճարտարապետությունը, հիպերպարամետրերը և վերապատրաստման կարգավորումները: Մենք պետք է ընտրենք YOLO-ի համապատասխան տարբերակը և կարգավորենք այն՝ ելնելով մեր պահանջներից:

• YOLO մոդելի ուսուցում – Տվյալների հավաքածուի և կազմաձևման առկայության դեպքում մենք կարող ենք սկսել մեր YOLO մոդելի ուսուցումը` օգտագործելով Darknet շրջանակը: Դասընթացը ներառում է պիտակավորված պատկերները մոդելին մատակարարելը, ցանցի կշիռների օպտիմիզացումը՝ օգտագործելով ետ տարածումը և պարամետրերի կարգավորումը՝ հայտնաբերման սխալները նվազագույնի հասցնելու համար:

• Փորձարկում և գնահատում – Երբ մոդելը վերապատրաստվի, մենք կարող ենք գնահատել դրա կատարումը՝ փորձարկելով այն առանձին պատկերների կամ տեսանյութերի վրա: Մենք չափում ենք այնպիսի չափումներ, ինչպիսիք են ճշգրտությունը, հետ կանչումը և միջին միջին ճշգրտությունը (mAP)՝ գնահատելու մեր օբյեկտների հայտնաբերման համակարգի ճշգրտությունն ու հուսալիությունը:

• Իրական ժամանակում օբյեկտների հայտնաբերում – Մոդելը հաջողությամբ ուսուցանելուց և գնահատելուց հետո մենք կարող ենք այն ինտեգրել ուղիղ վիդեո հոսքի կամ ձայնագրված տեսանյութերի հետ՝ իրական ժամանակում օբյեկտների հայտնաբերում իրականացնելու համար: Մենք կօգտագործենք OpenCV-ն՝ վիդեո շրջանակներ նկարահանելու, օբյեկտների հայտնաբերման YOLO ալգորիթմը կիրառելու և արդյունքներն իրական ժամանակում ցուցադրելու համար:

Այժմ եկեք խորանանք կոդի իրականացման յուրաքանչյուր քայլի մեջ՝ իրական ժամանակում օբյեկտների հայտնաբերման մեր համակարգը կառուցելիս:

Ամբողջական կոդը

Օրինակ

Ահա ամբողջական կոդը −

import cv2

# Load YOLO weights and configuration
net = cv2.dnn.readNet("yolov3.weights", "yolov3.cfg")
classes = []
with open("coco.names", "r") as f:
   classes = [line.strip() for line in f.readlines()]

# Set up output layers
layer_names = net.getLayerNames()
output_layers = [layer_names[i[0] - 1] for i in net.getUnconnectedOutLayers()]

# Load video stream
cap = cv2.VideoCapture(0)

while True:
   # Read frames from the video stream
   ret, frame = cap.read()
   if not ret:
      break

   # Preprocess frame for object detection
   blob = cv2.dnn.blobFromImage(frame, 0.00392, (416, 416), (0, 0, 0), True, crop=False)
   net.setInput(blob)
   outs = net.forward(output_layers)

   # Process the outputs
   class_ids = []
   confidences = []
   boxes = []
   for out in outs:
      for detection in out:
         scores = detection[5:]
         class_id = np.argmax(scores)
         confidence = scores[class_id]
         if confidence > 0.5:
            # Object detected
            center_x = int(detection[0] * frame.shape[1])
            center_y = int(detection[1] * frame.shape[0])
            width = int(detection[2] * frame.shape[1])
            height = int(detection[3] * frame.shape[0])
            x = int(center_x - width / 2)
            y = int(center_y - height / 2)

            boxes.append([x, y, width, height])
            confidences.append(float(confidence))
            class_ids.append(class_id)

   # Apply non-maximum suppression to remove overlapping detections
   indices = cv2.dnn.NMSBoxes(boxes, confidences, 0.5, 0.4)
   # Draw bounding boxes and labels on the frame
   font = cv2.FONT_HERSHEY_PLAIN
   colors = np.random.uniform(0, 255, size=(len(classes), 3))
   if len(indices) > 0:
      for i in indices.flatten():
         x, y, w, h = boxes[i]
         label = str(classes[class_ids[i]])
         confidence = confidences[i]
         color = colors[i]
         cv2.rectangle(frame, (x, y), (x + w, y + h), color, 2)
         cv2.putText(frame, f"{label} {confidence:.2f}", (x, y - 5), font, 1, color, 2)

   # Display the resulting frame
   cv2.imshow("Real-time Object Detection", frame)
   if cv2.waitKey(1) == ord("q"):
      break

# Release resources
cap.release()
cv2.destroyAllWindows()

Եզրակացություն

Այս ձեռնարկում մենք ուսումնասիրել ենք, թե ինչպես կառուցել իրական ժամանակի օբյեկտների հայտնաբերման համակարգ՝ օգտագործելով Python-ը և YOLO ալգորիթմը: Մենք սկսեցինք ներկայացնելով իրական ժամանակում օբյեկտների հայտնաբերման հայեցակարգը և YOLO ալգորիթմի նշանակությունը համակարգչային տեսողության ոլորտում: Այնուհետև մենք լուսաբանեցինք անհրաժեշտ գրադարանների տեղադրումը, ներառյալ Python-ը, OpenCV-ն և Darknet Framework-ը:

Հիմնական բովանդակության ընթացքում մենք քննարկեցինք իրական ժամանակում օբյեկտների հայտնաբերման համակարգի կառուցմանն առնչվող էական քայլերը, ինչպիսիք են տվյալների բազայի պատրաստումը, YOLO մոդելի կազմաձևումը, մոդելի ուսուցումը և դրա կատարողականի փորձարկումն ու գնահատումը: Մենք նաև տրամադրեցինք կոդի ամբողջական օրինակ, որը ցույց էր տալիս իրական ժամանակում օբյեկտների հայտնաբերման գործընթացը՝ օգտագործելով Python, OpenCV և YOLO ալգորիթմը:

Հետևելով այս ձեռնարկում նկարագրված քայլերին, դուք կարող եք ստեղծել իրական ժամանակում օբյեկտների հայտնաբերման ձեր սեփական համակարգը, որը կարող է հայտնաբերել և դասակարգել օբյեկտները կենդանի վիդեո հոսքերում կամ ձայնագրված տեսանյութերում: Սա հնարավորություններ է բացում կիրառությունների լայն շրջանակի համար, ներառյալ հսկողության համակարգերը, ինքնավար մեքենաները և հավելյալ իրականության փորձը:

Օբյեկտների հայտնաբերումը հետաքրքիր և արագ զարգացող ոլորտ է, և YOLO ալգորիթմը հասանելի բազմաթիվ տեխնիկաներից միայն մեկն է: Համակարգչային տեսողության աշխարհը հետագայում ուսումնասիրելիս մտածեք այլ ալգորիթմների, տվյալների հավաքածուների և ուսուցման ռազմավարությունների հետ փորձերի մասին՝ բարձրացնելու ձեր օբյեկտների հայտնաբերման համակարգերի ճշգրտությունն ու կատարումը: