Puissance 4 en Python

Introduction d’un peu d’aléatoire au niveau des IA : Si plusieurs positions sont possibles (égalité de poids), l’IA tire au hasard parmi ces meilleures positions plutôt que de s’arrêter à la première dans la liste. Reste à voir ce que cela va changer au niveau de la compétition précédente.

Le codage des IA devient donc :

IA0 : Priorité H
IA1 : Priorité PH
IA2 : Priorités A4PH / A3PH / A2PH / PH
IA3 : Priorités B4PH / B3PH / B2PH / PH
IA4 : Priorités A4PH / B4PH / A3PH / B3PH / A2PH / B2PH / PH
IA5 : Priorités A4PH / B4PH / A3PH / B3PH / B2PH / A2PH / PH
IA6 : Priorités A4PH / B4PH / B3PH / A3PH / A2PH / B2PH / PH
IA7 : Priorités A4PH / B4PH / B3PH / A3PH / B2PH / A2PH / PH
IA8 : Priorités A4PH / B4PH / A2PH / B2PH / PH
IA9 : Priorités A4PH / B4PH / B2PH / A2PH / PH

Code source sur GitHub.

Puissance 4 en Python : Compétition entre intelligences artificielles

Dans un premier temps, l’objectif est de mettre au point une intelligence artificielle (IA) la meilleure possible pour jouer à Puissance 4, sans avoir à descendre en profondeur dans un arbre comme avec l’algorithme minimax ou alpha-bêta. Viendra ensuite le temps des arbres, puis de l’apprentissage…

Présentation des IA :

Codage de la stratégie :

H veut dire Hasard
P veut dire Poids des cases (il y a plus de possibilités d’alignements pour certaines cases)
AX veut dire Alignement de X pions (l’IA essaye d’aligner X pions ; les alignements « troués » de 2 ou 3 pions ne sont pas encore pris en compte)
BX veut dire Blocage de X pions (l’IA essaye d’empêcher l’adversaire d’aligner X pions ; les alignements « troués » de 2 ou 3 pions ne sont pas encore pris en compte)

IA0 : Priorité H
IA1 : Priorité P
IA2 : Priorités A4P / A3P / A2P / P
IA3 : Priorités B4P / B3P / B2P / P
IA4 : Priorités A4P / B4P / A3P / B3P / A2P / B2P / P
IA5 : Priorités A4P / B4P / A3P / B3P / B2P / A2P / P
IA6 : Priorités A4P / B4P / B3P / A3P / A2P / B2P / P
IA7 : Priorités A4P / B4P / B3P / A3P / B2P / A2P / P
IA8 : Priorités A4P / B4P / A2P / B2P / P
IA9 : Priorités A4P / B4P / B2P / A2P / P

Présentation des résultats :

Sur 1 million de parties (ou 10 000 pour des mécaniques répétitives bien que 2 suffiraient), les résultats bruts sont :

IA0 / IA0 / Nulles : 498 180 / 499 269 / 2 551
IA1 / IA0 / Nulles : 878 082 / 121 899 / 19
IA2 / IA0 / Nulles : 971 125 / 28 874 / 1
IA3 / IA0 / Nulles : 962 081 / 26 922 / 10 997
IA4 / IA0 / Nulles : 987 349 / 12 637 / 14
IA5 / IA0 / Nulles : 984 923 / 14 995 / 82
IA6 / IA0 / Nulles : 989 355 / 10 538 / 107
IA7 / IA0 / Nulles : 986 549 / 13 043 / 408
IA8 / IA0 / Nulles : 971 554 / 28 431 / 15
IA9 / IA0 / Nulles : 948 080 / 51 821 / 99

IA1 / IA1 / Nulles : 5 000 / 5 000 / 0 (l’IA qui commence gagne en 10 coups)
IA2 / IA1 / Nulles : 10 000 / 0 / 0
IA3 / IA1 / Nulles : 10 000 / 0 / 0
IA4 / IA1 / Nulles : 5 000 / 5 000 / 0 (l’IA qui commence gagne)
IA5 / IA1 / Nulles : 10 000 / 0 / 0
IA6 / IA1 / Nulles : 5 000 / 5 000 / 0 (l’IA qui commence gagne)
IA7 / IA1 / Nulles : 10 000 / 0 / 0
IA8 / IA1 / Nulles : 10 000 / 0 / 0
IA9 / IA1 / Nulles : 5 000 / 0 / 5 000 (quand IA9 commence, IA9 gagne)

IA2 / IA2 / Nulles : 5 000 / 5 000 / 0 (l’IA qui commence gagne en 4 coups)
IA3 / IA2 / Nulles : 0 / 5 000 / 5 000 (quand IA2 commence, IA2 gagne)
IA4 / IA2 / Nulles : 10 000 / 0 / 0
IA5 / IA2 / Nulles : 10 000 / 0 / 0
IA6 / IA2 / Nulles : 10 000 / 0 / 0
IA7 / IA2 / Nulles : 10 000 / 0 / 0
IA8 / IA2 / Nulles : 5 000 / 5 000 / 0 (l’IA qui commence gagne)
IA9 / IA2 / Nulles : 0 / 10 000 / 0

IA3 / IA3 / Nulles : 0 / 0 / 10 000 *
IA4 / IA3 / Nulles : 0 / 5 000 / 5 000 (quand IA4 commence, IA3 gagne)
IA5 / IA3 / Nulles : 10 000 / 0 / 0
IA6 / IA3 / Nulles : 0 / 10 000 / 0
IA7 / IA3 / Nulles : 0 / 5 000 / 5 000 (quand IA7 commence, IA3 gagne)
IA8 / IA3 / Nulles : 5 000 / 0 / 5 000 (quand IA8 commence, IA8 gagne)
IA9 / IA3 / Nulles : 0 / 0 / 10 000 *

IA4 / IA4 / Nulles : 5 000 / 5 000 / 0 (l’IA qui commence perd en 17 coups)
IA5 / IA4 / Nulles : 10 000 / 0 / 0
IA6 / IA4 / Nulles : 0 / 0 / 10 000 *
IA7 / IA4 / Nulles : 5 000 / 0 / 5 000 (quand IA7 commence, IA7 gagne)
IA8 / IA4 / Nulles : 0 / 10 000 / 0
IA9 / IA4 / Nulles : 0 / 10 000 / 0

IA5 / IA5 / Nulles : 5 000 / 5 000 / 0 (l’IA qui commence gagne en 13 coups)
IA6 / IA5 / Nulles : 0 / 10 000 / 0
IA7 / IA5 / Nulles : 0 / 10 000 / 0
IA8 / IA5 / Nulles : 5 000 / 5 000 / 0 (l’IA qui commence perd)
IA9 / IA5 / Nulles : 0 / 10 000 / 0

IA6 / IA6 / Nulles : 0 / 0 / 10 000 *
IA7 / IA6 / Nulles : 10 000 / 0 / 0
IA8 / IA6 / Nulles : 5 000 / 5 000 / 0 (l’IA qui commence gagne)
IA9 / IA6 / Nulles : 5 000 / 5 000 / 0 (l’IA qui commence gagne)

IA7 / IA7 / Nulles : 5 000 / 5 000 / 0 (l’IA qui commence perd en 19 coups)
IA8 / IA7 / Nulles : 10 000 / 0 / 0
IA9 / IA7 / Nulles : 0 / 5 000 / 5 000 (quand IA7 commence, IA7 gagne)

IA8 / IA8 / Nulles : 5 000 / 5 000 / 0 (l’IA qui commence gagne en 8 coups)
IA9 / IA8 / Nulles : 5 000 / 5 000 / 0 (l’IA qui commence gagne)

IA9 / IA9 / Nulles : 5 000 / 5 000 / 0 (l’IA qui commence gagne en 11 coups)

Bilan (Nombre de victoires franches) :

IA0 : 0
IA1 : 1
IA2 : 3
IA3 : 3
IA4 : 4
IA5 : 8
IA6 : 2
IA7 : 4
IA8 : 3
IA9 : 1

Sur les parties entre IA4, IA5, IA6 et IA7 : IA5 écrase les autres IA.

Si on compare les stratégies IA4 et IA5 (une seule inversion), B2P doit être avant A2P pour gagner. Si on compare les stratégies IA6 et IA7 (une seule inversion), B2P doit être avant A2P pour gagner. Si on compare les stratégies IA5 et IA7 (une seule inversion), A3P doit être avant B3P pour gagner. Si on compare les stratégies IA4 et IA6 (une seule inversion), A3P avant B3P n’apporte aucun gain (match nul).

Dans tous les cas, B2P doit être avant A2P pour gagner. A3P avant B3P ne prend tout son potentiel que si B2P est avant A2P. Supprimons A3P et B3P pour voir… (IA8 et IA9)

Petite réflexion pour le futur : Si on décompose une stratégie en micro-stratégies, cela nous amène comme ici à un codage (une sorte d’ADN de la stratégie). Je verrais bien comme développement futur quelque chose avec les algorithmes génétiques…

Quel est ce paradoxe ? IA5 écrase IA4, IA4 écrase IA8 et pourtant on n’arrive pas à départager IA5 et IA8. C’est un peu comme si des micro-logiques internes s’interpénétraient jusqu’à s’anéantir… un peu comme le mangeur de planeurs dans le jeu de la vie.

Code source sur GitHub.

* Extrait de WarGames (1983) :

GREETINGS PROFESSOR FALKEN

HELLO

A STRANGE GAME.
THE ONLY WINNING MOVE IS
NOT TO PLAY.

HOW ABOUT A NICE GAME OF CHESS?

Puissance 4 en Python

Bien que le travail sur l’IA ne soit pas encore fini (il reste quelques manques comme les alignements « troués » de 2 ou 3 pions), on a déjà des résultats intéressants (98 % de victoires pour l’IA / 2 % pour un jeu aléatoire). Notez que je n’ai pas encore implémenté les algorithmes minimax et alpha-bêta qui amèneront eux de la profondeur. Pour jouer contre l’ordinateur, le code source est sur GitHub.

Pour l’IA à base de minimax et d’alpha-bêta, voir le code de Christian Schmidt qui a fait ce travail en JavaScript.

Installation du scanner Epson Perfection V37 sous Debian 10

Brancher et allumer le scanner.

Dans la console :
lsusb (Pour récupérer ID idVendor:idProduct)
sudo nano /etc/udev/rules.d/60-sane-missing-scanner.rules

Compléter le fichier ci-dessus avec :
# Epson Perfection V37
ATTRS{idVendor}=="04b8", ATTRS{idProduct}=="014a", MODE="0664", GROUP="scanner", ENV{libsane_matched}="yes"

Télécharger le fichier iscan-perfection-v370-bundle-2.30.4.x64.deb.tar.gz depuis cette adresse. En cas de lien rompu, faire une nouvelle recherche depuis EPSON Download Center et adapter les instructions ci-dessous.

Dans la console :
cd Téléchargements
tar -zxvf iscan-perfection-v370-bundle-2.30.4.x64.deb.tar.gz
cd iscan-perfection-v370-bundle-2.30.4.x64.deb
sudo gdebi data/iscan-data_1.39.2-1_all.deb => IGNORER LE PROBLÈME
sudo gdebi core/iscan_2.30.4-2_amd64.deb
sudo gdebi plugins/iscan-plugin-perfection-v370_1.0.1-1_amd64.deb

Installer Arduino 1.0.6 sous Debian 10

Les sites officiels : Arduino et Debian

Dans la console :

Si le répertoire Arduino n’existe pas déjà, je le crée :
sudo mkdir /usr/share/arduino

Je télécharge la version 64 bits (à adapter) :
cd Téléchargements
wget -c http://downloads.arduino.cc/arduino-1.0.6-linux64.tgz

Je décompresse l’archive et l’installe à l’endroit voulu :
tar -zxvf arduino-1.0.6-linux64.tgz
sudo mv arduino-1.0.6 /usr/share/arduino

Je télécharge l’icône Arduino et l’installe à l’endroit voulu :
wget http://entropie.org/3615/download/arduino.png
sudo mv arduino.png /usr/share/arduino

Pour effacer une version précédente d’Arduino (x à adapter) :
sudo rm -rf /usr/share/arduino/arduino-1.x.x

Pour intégrer le programme au menu de Xfce, je crée un fichier arduino-1.0.6.desktop dans le répertoire /usr/share/applications :
cd /usr/share/applications
sudo nano arduino-1.0.6.desktop

[Desktop Entry]
Type=Application
Name=Arduino 1.0.6
Comment=Un environnement de développement pour Arduino
GenericName=Create physical computing projects
Exec=/usr/share/arduino/arduino-1.0.6/arduino
Icon=/usr/share/arduino/arduino.png
Terminal=false
Categories=Development;Engineering;Electronics;
MimeType=text/x-arduino
Keywords=embedded electronics;electronics;avr;microcontroller;

Pour que le port série soit accessible et éviter de devoir utiliser Arduino en mode administrateur :
sudo usermod -a -G tty $USER ($USER à adapter)
sudo usermod -a -G dialout $USER ($USER à adapter)
Redémarrer.

Installer Arduino 1.8.15 sous Debian 10

Article mis à jour le 9 juillet 2021.

Les sites officiels : Arduino et Debian

Dans la console :

Je télécharge la version 64 bits (à adapter) :
cd Téléchargements
wget -c http://downloads.arduino.cc/arduino-1.8.15-linux64.tar.xz

Je décompresse l’archive et l’installe à l’endroit voulu :
tar -xJf arduino-1.8.15-linux64.tar.xz
sudo mv arduino-1.8.15 /usr/share/arduino

Je télécharge l’icône arduino et l’installe à l’endroit voulu :
wget http://entropie.org/3615/download/arduino.png
sudo mv arduino.png /usr/share/arduino/

Pour effacer une version précédente d’Arduino :
sudo rm -rf /usr/share/arduino

Pour intégrer le programme au menu de Xfce, je crée un fichier arduino.desktop dans le répertoire /usr/share/applications :
cd /usr/share/applications
sudo nano arduino.desktop

[Desktop Entry]
Type=Application
Name=Arduino
Comment=Un environnement de développement pour Arduino
GenericName=Create physical computing projects
Exec=/usr/share/arduino/arduino
Icon=/usr/share/arduino/arduino.png
Terminal=false
Categories=Development;Engineering;Electronics;
MimeType=text/x-arduino
Keywords=embedded electronics;electronics;avr;microcontroller;

Pour que le port série soit accessible et éviter de devoir utiliser Arduino en mode administrateur :
sudo usermod -a -G tty $USER ($USER à adapter)
sudo usermod -a -G dialout $USER ($USER à adapter)
Redémarrer.

Compléments (ATtiny, ATmega Mighty, ESP32) :

Pour ATtiny (45/85/44 notamment) :
https://github.com/SpenceKonde/ATTinyCore
Pour ATmega (644P/1284P notamment) :
https://github.com/MCUdude/MightyCore
Voir également : https://entropie.org/3615/index.php/2015/09/25/resolution-du-probleme-lie-a-la-bibliotheque-sd-arduino-1-0-5-sur-latmega1284p/
Pour ESP32 :
https://github.com/espressif/arduino-esp32

Fichier > Préférences > URL de gestionnaire de cartes supplémentaires :
http://drazzy.com/package_drazzy.com_index.json,https://mcudude.github.io/MightyCore/package_MCUdude_MightyCore_index.json,https://raw.githubusercontent.com/espressif/arduino-esp32/gh-pages/package_esp32_index.json

Puis aller dans le gestionnaire de carte (Outils > Type de carte > Gestionnaire de carte) pour installer :
ATTinyCore by Spence Conde,
MightyCore by MCUdude,
esp32 by Espressif Systems.

L’éthique des hackers

Un livre publié en 1984 et paru en France en 2013 :

Quatrième de couverture :

Précision : un « hacker » n’est pas un vulgaire pirate informatique. Un hacker est un « bricoleur de code ». Son truc : plonger dans les entrailles de la machine. Bill Gates, Steve Jobs, Steve Wozniak, Mark Zuckerberg ont commencé leurs brillantes carrières comme hackers… La plupart ne paient pas de mine mais tous partagent une même philosophie, une idée simple et élégante comme la logique qui gouverne l’informatique : l’ouverture, le partage, le refus de l’autorité et la nécessité d’agir par soi-même, quoi qu’il en coûte, pour changer le monde. C’est ce que Steven Levy appelle l’Ethique des hackers, une morale qui ne s’est pas exprimée dans un pesant manifeste, mais que les hackers authentiques ont mise en pratique dans leur vie quotidienne. Ce sont eux qui ont œuvré, dans l’obscurité, à la mise en marche de la révolution informatique. Depuis les laboratoires d’intelligence artificielle du MIT dans les années 1950 jusqu’aux gamers des années 1980, en passant par toutes les chambres de bonne où de jeunes surdoués ont consacré leurs nuits blanches à l’informatique, Steven Levy les a presque tous rencontrés. Voici leur histoire.

Mise à jour de la centrale Alpha 3

  • Alpha 1
  • Alpha 1
  • Alpha 2
  • Alpha 2
  • Alpha 3
  • Alpha 3

Je viens de mettre à jour la centrale Alpha 3. Elle est le 3ème prototype d’une centrale d’acquisition LIBRE à destination des enseignants de physique-chimie. Elle est actuellement conçue autour d’une carte Arduino Mega 2560 (par conséquent, entièrement reprogrammable par le port USB). Les périodes d’échantillonnages sont adaptées à des phénomèmes relativement lents : elles varient du dixième de seconde à l’heure. Un mode manuel (acquisition pas à pas) est également disponible. Les données (horodatées) sont enregistrées au format texte sur une carte SD. Elles se récupèrent par l’intermédiaire d’un câble USB connecté à un ordinateur sous Linux, Windows ou Mac OS X. Les données brutes sont ensuite facilement exploitables dans un tableur ou avec Python (format CSV). La centrale fonctionne sur batterie ou sur secteur. Elle peut être également alimentée par le port USB. Elle intègre un certain nombre de capteurs dont une boussole qui mesure l’azimut, le roulis et le tangage ; un baro-altimètre qui mesure la pression absolue, la pression relative et l’altitude ; enfin un accéléromètre qui mesure les accélérations suivant 2 axes actuellement. Les mesures renvoyées par la boussole font l’objet d’un traitement informatique en temps réel afin de compenser certaines erreurs de mesures liées à des perturbations électromagnétiques à l’intérieur du boîtier.

Code source sur GitHub

Le logiciel de récupération et traitement des données est désormais développé en Python. Il permet d’effectuer plusieurs types de régression (linéaire, quadratique, cubique, quartique, exponentielle, logarithmique, puissance, trigonométrique) :