როკ ქაღალდის მაკრატელი AI: 11 ნაბიჯი

2024 ავტორი: John Day | [email protected]. ბოლოს შეცვლილი: 2024-01-30 10:17

ოდესმე მოგწყინდათ მარტოობა? მოდით ვითამაშოთ როკი, ქაღალდი და მაკრატელი ინტელექტუალური სისტემის წინააღმდეგ, რომელსაც აქვს ინტელექტი.

ნაბიჯი 1: ნივთები, რომლებიც გამოიყენება ამ პროექტში

აპარატურის კომპონენტები

• ჟოლო Pi 3 მოდელი B+ × 1
• Raspberry Pi კამერის მოდული V2 × 1
• SG90 მიკრო სერვო ძრავა × 1

პროგრამული პროგრამები

• ჟოლო პი რასპბიანი
• OpenCV
• TensorFlow

ნაბიჯი 2: იდეა?

სხვადასხვა დომენზე სხვადასხვა პროექტზე მუშაობის შემდეგ, დავგეგმე სახალისო პროექტის გაკეთება და გადავწყვიტე გამეკეთებინა როკ-ქაღალდის მაკრატლის თამაში:)

ამ პროექტში ჩვენ გავაკეთებთ ინტერაქტიულ თამაშს და ვითამაშებთ კომპიუტერთან, რომელიც გადაწყვეტილებების მისაღებად იკვებება ხელოვნური ინტელექტით. AI იყენებს Raspberry Pi– სთან დაკავშირებულ კამერას, რომ ამოიცნოს რა მოძრაობს მომხმარებელი ხელით, დაალაგოს ისინი საუკეთესო კატეგორიაში (ეტიკეტი) როკ, ქაღალდი ან მაკრატელი. მას შემდეგ რაც კომპიუტერი მოძრაობს, ჟოლოს Pi- სთან დაკავშირებული სტეპერიანი ძრავა მიემართება მიმართულებისკენ მისი მოძრაობის საფუძველზე.

წესები, რომლებიც გასათვალისწინებელია ამ თამაშისთვის:

• როკი ბლაგვს მაკრატელს
• ქაღალდი ფარავს კლდეს
• მაკრატელი დაჭრილი ქაღალდი

გამარჯვებული გამოვლინდება ზემოაღნიშნული სამი პირობის გათვალისწინებით. მოდით ვნახოთ პროექტის სწრაფი დემო აქ.

ნაბიჯი 3: დავიწყოთ?

ჟოლო პი

მე გამოვიყენე Raspberry Pi 3 Model B+, რომელსაც აქვს დიდი გაუმჯობესებები და უფრო მძლავრია, ვიდრე ადრინდელი Raspberry Pi 3 მოდელი B.

Raspberry Pi 3 B+ არის ინტეგრირებული 1.4 GHz 64 ბიტიანი ოთხ ბირთვიანი პროცესორით, ორმაგი ბენდის უკაბელო LAN, Bluetooth 4.2/BLE, უფრო სწრაფი Ethernet და Power-over-Ethernet მხარდაჭერით (ცალკე PoE HAT).

სპეციფიკაციები: Broadcom BCM2837B0, Cortex-A53 (ARMv8) 64-bit SoC @ 1.4GHz, 1GB LPDDR2 SDRAM, 2.4GHz and 5GHz IEEE 802.11.b/g/n/ac wireless LAN, Bluetooth 4.2, BLE, Gigabit Ethernet over USB 2.0 (მაქსიმალური გამტარუნარიანობა 300 Mbps), გაფართოებული 40 პინიანი GPIO სათაური, სრული ზომის HDMI4 USB 2.0 პორტები, CSI კამერის პორტი Raspberry Pi კამერის დასაკავშირებლად, DSI ჩვენების პორტი Raspberry Pi სენსორული ეკრანის დასაკავშირებლად 4 პოლუსიანი სტერეო გამომავალი და კომპოზიტური ვიდეო პორტი, მიკრო SD პორტი თქვენი ოპერაციული სისტემის ჩატვირთვისა და მონაცემების შესანახად 5V/2.5A DC ენერგიის შეყვანა, Power-over-Ethernet (PoE) მხარდაჭერა (მოითხოვს ცალკე PoE HAT).

სერვო მოტორი

ჩვენ ვიყენებთ SG-90 სერვო ძრავას, მაღალი ბრუნვის ძრავას, რომელსაც შეუძლია გაუძლოს დატვირთვას 2.5 კგ-მდე (1 სმ).

USB კამერა

USB კამერა თამაშის ინტერაქტიული გამოსახულების დამუშავებასთან ერთად

ზოგიერთი Jumper კაბელი გამოიყენება სტეპერ ძრავისა და ჟოლოს Pi- ს დასაკავშირებლად.

ნაბიჯი 4: ჩაწეროთ რასბბიანი SD ბარათზე?

Raspbian არის Linux– ის არჩეული დისტრიბუცია, რომელიც მუშაობს Raspberry Pi– ზე. ამ სახელმძღვანელოში ჩვენ ვიყენებთ Lite ვერსიას, მაგრამ Desktop ვერსია (რომელსაც გააჩნია გრაფიკული გარემო) ასევე შეიძლება გამოყენებულ იქნას.

• ჩამოტვირთეთ Etcher და დააინსტალირეთ.
• შეაერთეთ SD ბარათის წამკითხველი SD ბარათით შიგნით.
• გახსენით Etcher და შეარჩიეთ თქვენი მყარი დისკიდან Raspberry Pi.img ან.zip ფაილი, რომლის ჩაწერა გსურთ SD ბარათზე.
• შეარჩიეთ SD ბარათი, რომელზეც გსურთ დაწეროთ თქვენი სურათი.
• გადახედეთ თქვენს არჩევანს და დააწკაპუნეთ 'Flash!' SD ბარათზე მონაცემების ჩაწერის დასაწყებად.

შეაერთეთ მოწყობილობა თქვენს ქსელში

• ჩართეთ SSH წვდომა ცარიელი ფაილის ssh დამატებით, კვლავ მოთავსებული თქვენს SD ბარათზე ჩატვირთვის მოცულობის ძირში.
• ჩადეთ SD ბარათი Raspberry Pi- ში. ის ჩაირთვება დაახლოებით 20 წამში. ახლა თქვენ უნდა გქონდეთ SSH წვდომა თქვენს Raspberry Pi– ზე. სტანდარტულად, მისი მასპინძლის სახელი იქნება raspberrypi.local. თქვენს კომპიუტერში გახსენით ტერმინალის ფანჯარა და ჩაწერეთ შემდეგი:

ssh [email protected]

ნაგულისხმევი პაროლი არის ჟოლო

აქ მე ცალკე მონიტორი გამოვიყენე Raspberry Pi– თან დასაკავშირებლად.

ნაბიჯი 5: მონაცემთა ნაკრების შეგროვება? ️

ამ პროექტის პირველი ნაბიჯი არის მონაცემთა შეგროვება. სისტემამ უნდა განსაზღვროს ხელის ჟესტი და ამოიცნოს მოქმედება და შესაბამისად გადაადგილოს იგი.

ჩვენ ვაყენებთ რამდენიმე ბიბლიოთეკას Raspberry Pi– ზე pip install– ის გამოყენებით

ბრძანება.

sudo apt-get განახლება && sudo apt-get განახლებებიudo apt-get install libjpeg-dev libtiff5-dev libjasper-dev libpng12-dev pip install opencv pip install numpy pip install scikit-learn pip install scikit-image pip install h5py pip install Keras pip დააინსტალირეთ tensorflow pip დააინსტალირეთ Werkzeug pip install Keras-Applications pip install Keras-preprocessing pip install keras-squeezenet pip install astor pip install tensorboard pip install tensorflow-estator pip install mock pip install grpcio pip install absl-pypip install gast pip install joblib pip install Markdown pip დააინსტალირეთ protobuf pip დააინსტალირეთ PyYAML pip install six

თუ OpenCVpackage– სთან დაკავშირებით რაიმე პრობლემა შეგექმნებათ, მე მკაცრად გირჩევთ ამ პაკეტების დაყენებას.

sudo apt-get დააინსტალირეთ libhdf5-dev

sudo apt-get install libhdf5-serial-dev sudo apt-get install libatlas-base-dev sudo apt-get install libjasper-dev sudo apt-get install libqtgui4 sudo apt-get install libqt4-test

ჩვენ დავაყენეთ ყველა საჭირო დამოკიდებულება ამ პროექტისთვის. მონაცემთა ნაკრები მზადდება სურათების შეგროვებით და მოწყობით შესაბამისი ეტიკეტის ქვეშ.

აქ ჩვენ ვქმნით მონაცემთა ნაკრების სურათებს ეტიკეტის ქვის, ქაღალდისა და მაკრატლისთვის შემდეგი ნაწყვეტის გამოყენებით.

როი = ჩარჩო [100: 500, 100: 500]

save_path = os.path.join (img_class_path, '{}.jpg'.format (count + 1)) cv2.imwrite (save_path, roi)

სურათი გადაღებულია თითოეული ეტიკეტისთვის (როკი, ქაღალდი, მაკრატელი და არცერთი).

ნაბიჯი 6: NN- ის შემუშავება და მოდელის მომზადება ⚒️⚙️

ამ პროექტის ბირთვი არის გამოსახულების კლასიფიკატორი, რომელიც განასხვავებს სამიდან ერთ კატეგორიას. ამ კლასიფიკატორის შესაქმნელად ჩვენ ვიყენებთ წინასწარ მომზადებულ CNN- ს (კონვოლუციური ქსელი) სახელწოდებით SqueezeNet.

აქ ჩვენ ვიყენებთ Keras- ს და TensorFlow- ს SqueezeNet მოდელის შესაქმნელად, რომელსაც შეუძლია ჟესტის იდენტიფიცირება. სურათები, რომლებიც ჩვენ წინა ეტაპზე შევქმენით, გამოიყენება მოდელის მომზადებისთვის. მოდელი გაწვრთნილია მონაცემთა ნაკრების გამოყენებით, რომელიც არ არის ნახსენები არცერთ ეპოქაში (ციკლში).

მოდელი არის კონფიგურირებული ჰიპერპარამეტრებით, როგორც ნაჩვენებია ქვემოთ.

მოდელი = თანმიმდევრული ([SqueezeNet (input_shape = (227, 227, 3), include_top = false), გასვლა (0.5), Convolution2D (NUM_CLASSES, (1, 1), padding = 'valid'), გააქტიურება ('relu'), GlobalAveragePooling2D (), გააქტიურება ('softmax')])

სანამ მოდელი ვარჯიშობს, თქვენ შეგიძლიათ იპოვოთ მოდელის დანაკარგი და სიზუსტე თითოეული ეპოქისთვის და სიზუსტე იზრდება რაღაც მომენტში რამდენიმე ეპოქის შემდეგ.

დაახლოებით 2 საათი დასჭირდა მოდელის ყველაზე მაღალი სიზუსტით 10 ეპოქის შემდგომ. თუ რაიმე სახის მეხსიერების გამოყოფის შეცდომების წინაშე აღმოჩნდებით, გააკეთეთ შემდეგი ნაბიჯები (ადრიანის წყალობით)

გაცვლის სივრცის გასაზრდელად გახსენით /etc /dphys-swapfile და შემდეგ შეცვალეთ CONF_SWAPSIZE ცვლადი:

# CONF_SWAPSIZE = 100

CONF_SWAPSIZE = 1024

გაითვალისწინეთ, რომ მე გავზარდე სვოპი 100 მბ -დან 1024 მბ -მდე. იქიდან გადატვირთეთ სვოპის სერვისი:

$ sudo /etc/init.d/dphys-swapfile გაჩერება

$ sudo /etc/init.d/dphys-swapfile დაწყება

Შენიშვნა:

სვოპის ზომის გაზრდა შესანიშნავი საშუალებაა თქვენი მეხსიერების ბარათის დასაწვავად, ასე რომ დარწმუნდით, რომ დააბრუნებთ ამ ცვლილებას და გადატვირთეთ სვოპის სერვისი დასრულების შემდეგ. თქვენ შეგიძლიათ წაიკითხოთ მეტი დიდი ზომის გაფუჭებული მეხსიერების ბარათების შესახებ აქ.

ნაბიჯი 7: მოდელის ტესტირება

როდესაც მოდელი გენერირდება, ის აწარმოებს გამომავალ ფაილს "rock-paper-scissors-model.h5". ეს ფაილი გამოიყენება როგორც წყარო იმის შესამოწმებლად, შეუძლია თუ არა სისტემას ხელების სხვადასხვა ჟესტების იდენტიფიცირება და ქმედებების დიფერენცირება.

მოდელი დატვირთულია პითონის სკრიპტში შემდეგნაირად

model = load_model ("rock-paper-scissors-model.h5")

კამერა კითხულობს ტესტის სურათს და გარდაქმნის საჭირო ფერის მოდელს, შემდეგ კი გამოსახულების ზომას 227 x 227 პიქსელზე (იგივე ზომა გამოიყენება მოდელის წარმოებისთვის). სურათები, რომლებიც გამოყენებულ იქნა მოდელის სწავლებისთვის, შეიძლება გამოყენებულ იქნას გენერირებული მოდელის შესამოწმებლად.

img = cv2.imread (ფაილის გზა)

img = cv2.cvtColor (img, cv2. COLOR_BGR2RGB) img = cv2.resize (img, (227, 227))

მას შემდეგ, რაც მოდელი დატვირთულია და გამოსახულება მიიღება კამერით, მოდელი წინასწარმეტყველებს გადაღებულ სურათს SqueezeNet მოდელის დატვირთვის გამოყენებით და წინასწარმეტყველებს მომხმარებლის მოძრაობებს.

pred = model.predict (np.array ())

move_code = np.argmax (pred [0]) move_name = mapper (move_code) ამობეჭდვა ("წინასწარმეტყველება: {}". ფორმატი (move_name))

გაუშვით test.py სკრიპტი მოდელის შესამოწმებლად სხვადასხვა სატესტო გამოსახულებით.

python3 ტესტი. py

ახლა მოდელი მზად არის აღმოაჩინოს და გაიგოს ხელის ჟესტები.

ნაბიჯი 8: როკ-ქაღალდის მაკრატლის თამაში

თამაში იყენებს შემთხვევითი რიცხვების წარმოქმნის ფუნქციას კომპიუტერის გადასაწყვეტად. ის მიჰყვება ზემოაღნიშნულ წესებს გამარჯვებულის დასადგენად. თამაში შექმნილია ორი რეჟიმით: ნორმალური რეჟიმი და ინტელექტუალური რეჟიმი, სადაც ინტელექტუალური რეჟიმი ეწინააღმდეგება მომხმარებლის მოძრაობას, ანუ კომპიუტერი იმარჯვებს მომხმარებლის წინააღმდეგ გადადგმულ ყველა მოძრაობაზე.

cap = cv2. ვიდეო გადაღება (0) # კამერიდან სურათის გადასაღებად

ახლა მოდით გავაკეთოთ თამაში ნორმალურ რეჟიმში, სადაც სისტემა/ ჟოლო Pi იღებს სურათს ხელზე და აანალიზებს და ამოიცნობს ხელის ჟესტს. შემდეგ შემთხვევითი რიცხვების გენერატორის გამოყენებით ხდება კომპიუტერის მოძრაობა. გამარჯვებული ირჩევა წესების საფუძველზე და შემდეგ გამოჩნდება ეკრანზე. დაიწყეთ თამაში შემდეგი ბრძანების გამოყენებით.

python3 play.py

ნაბიჯი 9: სერვო ძრავის ინტეგრაცია?

დაბოლოს, დაამატეთ სერვო ძრავა ამ პროექტს. Servo motor არის Raspberry Pi– ს GPIO pin 17, რომელსაც აქვს PWM ფუნქცია როტაციის კუთხის გასაკონტროლებლად.

ამ პროექტში გამოყენებული სერვო ძრავა არის SG-90. მას შეუძლია ბრუნავს საათის ისრის მიმართულებით და საათის ისრის საწინააღმდეგოდ 180 ° -მდე

კავშირები მოცემულია შემდეგნაირად.

სერვო მოტორი - ჟოლო პი

Vcc - +5V

GND - GND

სიგნალი - GPIO17

ამ პროექტში გამოიყენება ბიბლიოთეკები, როგორიცაა RPi. GPIO და დრო.

იმპორტი RPi. GPIO როგორც GPIO

იმპორტის დრო

GPIO პინი კონფიგურირებულია PWM– ზე შემდეგი ხაზების გამოყენებით

servoPIN = 17

GPIO.setmode (GPIO. BCM) GPIO.setup (servoPIN, GPIO. OUT)

GPIO Pin 17 არის კონფიგურირებული გამოიყენოს როგორც PWM სიხშირე 50 Hz. სერვო ძრავის კუთხე მიიღწევა PWM– ის სამუშაო ციკლის (Ton & Toff) დაყენებით

მოვალეობა = კუთხე/18 + 2

GPIO.output (servoPIN, True) p. ChangeDutyCycle (მოვალეობა) დრო. ძილი (1) GPIO.output (servoPIN, ყალბი) p. ChangeDutyCycle (0)

ეს გამოიმუშავებს სასურველ საფეხურს ყველა პულსისათვის, რაც მისცემს ბრუნვის სასურველ კუთხეს.

ახლა ავიღე სქემა და დავყავი სამ ნაწილად, როკის, ქაღალდისა და მაკრატლისთვის. სერვო ძრავა ფიქსირდება დიაგრამის ცენტრში. მაჩვენებელი/ფლაპი დაკავშირებულია სერვო ძრავის ლილვთან. ეს შახტი მიუთითებს კომპიუტერის სვლაზე სკრიპტში გამოთვლილი ლოგიკის მიხედვით.

ნაბიჯი 10: პროექტის მუშაობა?

ახლა კი, თამაშის დროა. ვნახოთ პროექტის მუშაობა.

თუ თქვენ შეექმნათ რაიმე პრობლემა ამ პროექტის მშენებლობაში, მოგერიდებათ მკითხეთ. გთხოვთ შემოგვთავაზოთ ახალი პროექტები, რომელთა შესრულებაც გსურთ შემდგომში.

ცალი თითი მიაწოდეთ, თუ ეს ნამდვილად დაგეხმარათ და მიჰყევით ჩემს არხს საინტერესო პროექტებისთვის.:)

თუ მოგეწონებათ გააზიარეთ ეს ვიდეო.

ბედნიერი ვარ, რომ გამოიწერე:

Მადლობა წაკითხვისთვის!

ნაბიჯი 11: კოდი - პროექტის რეპო

კოდი ემატება GitHub საცავში, რომელიც შეგიძლიათ იხილოთ კოდის განყოფილებაში.

Rahul24-06/Rock-Paper-Scissors-https://github.com/Rahul24-06/Rock-Paper-Scissors