Rock Paper Scissor AI : 11 étapes

2024 Auteur: John Day | [email protected]. Dernière modifié: 2024-01-30 09:06

Vous êtes-vous déjà ennuyé seul ? Jouons à la pierre, au papier et aux ciseaux contre un système interactif alimenté par l'intelligence.

Étape 1: Éléments utilisés dans ce projet

Composants matériels

• Raspberry Pi 3 modèle B+ × 1
• Module de caméra Raspberry Pi V2 × 1
• Micro-servomoteur SG90 × 1

Applications logicielles

• Framboise Pi Raspbian
• OpenCV
• TensorFlow

Étape 2: Idée ?

Après avoir travaillé sur divers projets dans différents domaines, j'ai prévu de faire un projet amusant, et j'ai décidé de faire un jeu pierre-papier-ciseaux:)

Dans ce projet, nous allons créer un jeu interactif et jouer contre l'ordinateur alimenté par l'IA pour prendre des décisions. AI utilise la caméra connectée au Raspberry Pi pour reconnaître les mouvements que l'utilisateur a faits avec la main, les classer dans la meilleure catégorie (étiquette) pierre, papier ou ciseaux. Une fois que l'ordinateur a effectué son mouvement, le moteur pas à pas connecté au Raspberry Pi pointe vers la direction en fonction de son mouvement.

Règles à prendre en compte pour ce jeu:

• La roche émousse le ciseau
• Le papier recouvre le rocher
• Papier découpé aux ciseaux

Le gagnant sera déterminé en fonction des trois conditions ci-dessus. Voyons une démo rapide du projet ici.

Étape 3: Commencer ?

Tarte aux framboises

J'ai utilisé un Raspberry Pi 3 Model B+ qui a de grandes améliorations et est plus puissant que le Raspberry Pi 3 Model B précédent.

Raspberry Pi 3 B+ est intégré au processeur quadricœur 1,4 GHz 64 bits, au réseau local sans fil double bande, au Bluetooth 4.2/BLE, à un Ethernet plus rapide et à la prise en charge de l'alimentation sur Ethernet (avec PoE HAT séparé).

Spécifications: Broadcom BCM2837B0, Cortex-A53 (ARMv8) SoC 64 bits à 1,4 GHz, 1 Go de SDRAM LPDDR2, 2,4 GHz et 5 GHz IEEE 802.11.b/g/n/ac LAN sans fil, Bluetooth 4.2, BLE, Gigabit Ethernet sur USB 2.0 (débit maximum de 300 Mbps), L'en-tête GPIO 40 broches étendu, Ports HDMI4 USB 2.0 pleine taille, Port caméra CSI pour connecter une caméra Raspberry Pi, Port d'affichage DSI pour connecter un écran tactile Raspberry Pi Sortie stéréo 4 pôles et composite port vidéo, port Micro SD pour charger votre système d'exploitation et stocker des données Entrée d'alimentation CC 5 V/2,5 A, prise en charge de l'alimentation sur Ethernet (PoE) (nécessite un chapeau PoE séparé).

Servomoteur

Nous utilisons un servomoteur SG-90, un moteur à couple élevé pouvant supporter une charge allant jusqu'à 2,5 kg (1 cm).

Caméra USB

Une caméra USB pour rendre le jeu interactif avec le traitement d'image

Certains câbles Jumper sont utilisés pour câbler le moteur pas à pas et le Raspberry Pi.

Étape 4: Graver Raspbian sur la carte SD ?

Raspbian est la distribution Linux de choix fonctionnant sur le Raspberry Pi. Dans ce guide, nous utiliserons la version Lite, mais la version Desktop (fournie avec un environnement graphique) peut également être utilisée.

• Téléchargez Etcher et installez-le.
• Connectez un lecteur de carte SD avec la carte SD à l'intérieur.
• Ouvrez Etcher et sélectionnez sur votre disque dur le fichier Raspberry Pi.img ou.zip que vous souhaitez écrire sur la carte SD.
• Sélectionnez la carte SD sur laquelle vous souhaitez écrire votre image.
• Vérifiez vos sélections et cliquez sur « Flash ! » pour commencer à écrire des données sur la carte SD.

Connectez l'appareil à votre réseau

• Activez l'accès SSH en ajoutant un fichier ssh vide, à nouveau placé à la racine du volume de démarrage sur votre carte SD.
• Insérez la carte SD dans le Raspberry Pi. Il démarrera dans environ 20 secondes. Vous devriez maintenant avoir un accès SSH à votre Raspberry Pi. Par défaut, son nom d'hôte sera raspberrypi.local. Sur votre ordinateur, ouvrez une fenêtre de terminal et tapez ce qui suit:

ssh [email protected]

Le mot de passe par défaut est framboise

Ici, j'ai utilisé un moniteur séparé pour l'interface avec le Raspberry Pi.

Étape 5: Collecte de l'ensemble de données ?️

La première étape de ce projet est la collecte de données. Le système doit identifier le geste de la main et reconnaître l'action et le faire bouger en conséquence.

Nous installons plusieurs bibliothèques sur le Raspberry Pi en utilisant pip install

commander.

sudo apt-get update && sudo apt-get upgradesudo apt-get install libjpeg-dev libtiff5-dev libjasper-dev libpng12-dev pip installer opencv pip installer numpy pip installer scikit-learn pip installer scikit-image pip installer h5py pip installer Keras pip installer tensorflow pip installer Werkzeug pip installer Keras-Applications pip installer Keras-Preprocessing pip installer keras-squeezenet pip installer astor pip installer tensorboard pip installer tensorflow-estimator pip installer mock pip installer grpcio pip installer absl-pypip installer gast pip installer joblib pip installer Markdown pip installer protobuf pip installer PyYAML pip installer six

Si vous rencontrez des problèmes avec OpenCVpackage, je vous recommande fortement d'installer ces packages.

sudo apt-get install 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

Nous avons installé toutes les dépendances requises pour ce projet. L'ensemble de données est constitué de collections et d'arrangements des images sous l'étiquette appropriée.

Ici, nous créons les images de l'ensemble de données pour la pierre d'étiquette, le papier et les ciseaux à l'aide de l'extrait suivant.

roi = cadre[100:500, 100:500]

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

L'image est capturée pour chaque étiquette (pierre, papier, ciseaux et Aucun).

Étape 6: Concevoir un NN et entraîner le modèle ⚒️⚙️

Le noyau de ce projet est un classificateur d'images qui classe l'une des trois catégories. Pour fabriquer ce classificateur, nous utilisons le CNN (réseau convolutif) pré-entraîné appelé SqueezeNet.

Ici, nous utilisons Keras et TensorFlow pour générer le modèle SqueezeNet qui peut identifier le geste. Les images que nous avons générées à l'étape précédente sont utilisées pour entraîner le modèle. Le modèle est entraîné à l'aide de l'ensemble de données généré pour aucune des époques (cycles) mentionnées.

Le modèle est configuré avec les hyperparamètres comme indiqué ci-dessous.

modèle = Séquentiel([SqueezeNet(input_shape=(227, 227, 3), include_top=False), Abandon (0,5), Convolution2D(NUM_CLASSES, (1, 1), padding='valid'), Activation('relu'), GlobalMoyennePooling2D(), Activation('softmax')])

Pendant que le modèle s'entraîne, vous pouvez trouver la perte et la précision du modèle pour chaque époque et la précision augmente à un moment donné après quelques époques.

Il a fallu environ 2 heures pour générer le modèle avec la plus grande précision après 10 époques. Si vous rencontrez des erreurs d'allocation de mémoire, procédez comme suit (Merci à Adrian)

Pour augmenter votre espace d'échange, ouvrez /etc/dphys-swapfile puis éditez la variable CONF_SWAPSIZE:

# CONF_SWAPSIZE=100

CONF_SWAPSIZE=1024

Notez que j'augmente le swap de 100 Mo à 1024 Mo. À partir de là, redémarrez le service de swap:

$ sudo /etc/init.d/dphys-swapfile stop

$ sudo /etc/init.d/dphys-swapfile start

Noter:

L'augmentation de la taille de swap est un excellent moyen de brûler votre carte mémoire, alors assurez-vous d'annuler cette modification et de redémarrer le service de swap lorsque vous avez terminé. Vous pouvez en savoir plus sur les cartes mémoire de grande taille qui corrompent ici.

Étape 7: Tester le modèle ✅

Une fois le modèle généré, il produit le fichier de sortie "rock-paper-scissors-model.h5". Ce fichier est utilisé comme source pour tester si le système peut identifier différents gestes de la main et est capable de différencier les actions.

Le modèle est chargé dans le script python comme suit

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

La caméra lit l'image de test et transforme le modèle de couleur requis, puis redimensionne l'image à 227 x 227 pixels (même taille que celle utilisée pour la génération du modèle). Les images qui ont été utilisées pour entraîner le modèle peuvent être utilisées pour tester le modèle généré.

img = cv2.imread(chemin du fichier)

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

Une fois le modèle chargé et l'image acquise par la caméra, le modèle prédit l'image capturée à l'aide du modèle SqueezeNet chargé et effectue la prédiction des mouvements de l'utilisateur.

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

move_code = np.argmax(pred[0]) move_name = mapper(move_code) print("Prédit: {}".format(move_name))

Exécutez le script test.py pour tester le modèle avec différentes images de test.

python3 test.py

Le modèle est maintenant prêt à détecter et à comprendre les gestes de la main.

Étape 8: Jeu Pierre-Papier-Ciseaux

Le jeu utilise une fonction de génération de nombres aléatoires pour décider du mouvement de l'ordinateur. Il suit les règles susmentionnées pour déterminer le gagnant. Le jeu est conçu avec deux modes: le mode normal et le mode intelligent, où le mode intelligent contre-attaque le mouvement de l'utilisateur, c'est-à-dire que l'ordinateur gagne tous les mouvements contre l'utilisateur.

cap = cv2. VideoCapture(0) # Pour capturer l'image de la caméra

Faisons maintenant le jeu en mode Normal où le système/Raspberry Pi prend la photo de la main et analyse et identifie le geste de la main. Ensuite, à l'aide d'un générateur de nombres aléatoires, le coup de l'ordinateur est joué. Le gagnant est choisi en fonction des règles puis affiché à l'écran. Lancez le jeu en utilisant la commande suivante.

python3 play.py

Étape 9: Intégration du servomoteur ?

Enfin, ajoutez le servomoteur à ce projet. Le servomoteur est la broche GPIO 17 du Raspberry Pi, qui a la fonction PWM pour contrôler l'angle de rotation.

Le servomoteur utilisé dans ce projet est le SG-90. Il peut effectuer des rotations dans le sens horaire et antihoraire jusqu'à 180°

Les connexions sont données comme suit.

Servomoteur - Raspberry Pi

Vcc - +5V

TERRE - TERRE

Signal - GPIO17

Les bibliothèques telles que RPi. GPIO et time sont utilisées dans ce projet.

importer RPi. GPIO en tant que GPIO

heure d'importation

La broche GPIO est ensuite configurée sur PWM en utilisant les lignes suivantes

ServoPIN = 17

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

La broche GPIO 17 est configurée pour être utilisée comme PWM à la fréquence de 50 Hz. L'angle du servomoteur est obtenu en réglant le rapport cyclique (Ton & Toff) du PWM

devoir = angle/18 + 2

GPIO.output(servoPIN, True) p. ChangeDutyCycle(duty) time.sleep(1) GPIO.output(servoPIN, False) p. ChangeDutyCycle(0)

Cela produira l'angle de pas souhaité pour chaque impulsion, ce qui donnera l'angle de rotation souhaité.

Maintenant, j'ai pris le tableau et je l'ai découpé en trois sections, pour la pierre, le papier et les ciseaux. Le servomoteur est fixé au centre du graphique. Le pointeur/volet est relié à l'arbre du servomoteur. Cet arbre indique le mouvement de l'ordinateur selon la logique calculée dans le script.

Étape 10: Fonctionnement du projet ?

Et maintenant, c'est l'heure de la récréation. Voyons le fonctionnement du projet.

Si vous avez rencontré des problèmes dans la construction de ce projet, n'hésitez pas à me demander. S'il vous plaît, suggérez de nouveaux projets que vous voulez que je fasse ensuite.

Donnez un coup de pouce si cela vous a vraiment aidé et suivez ma chaîne pour des projets intéressants.:)

Partagez cette vidéo si vous le souhaitez.

Heureux de vous avoir abonné:

Merci d'avoir lu!

Étape 11: Code - Projet Repo

Le code est ajouté au référentiel GitHub qui se trouve dans la section code.

Rahul24-06 / Rock-Paper-Scissors -