Un exemple simple de l'intelligence artificielle à l'aide de delphi tableau

Un exemple simple de l'intelligence artificielle a l'aide de delphi tableau

Un exemple simple de l'intelligence artificielle a l'aide de delphi tableau : Plusieurs milliers de conseils pour vous faciliter la vie.

(Ordinateur simule le processus d'apprentissage de l'homme, de l'apprentissage par correction d'erreurs !)
l'Intelligence Artificielle (IA) est une avance branche de la science qui etudie le processus de la pensee humaine et tente d'appliquer les connaissances pour simuler le meme processus dans les machines. Comme les ordinateurs sont tres en avance dans le marathon de machines de traitement, l'IA est considere comme la branche de l'Informatique que celui de la Science en General.
Il y a eu beaucoup de recherche et de developpement dans le domaine de l'Intelligence Artificielle. La zone de recherche portent sur les discours et la reconnaissance des formes, traitement du langage naturel, l'apprentissage a partir des experiences anterieures (apprendre en faisant et en corrigeant les erreurs!), raisonnement dans les situations de fournir limitee ou d'informations incompletes, etc. L'IA est pratiquement appliquee dans le domaine des jeux sur ordinateur, les systemes experts, reseaux de neurones, de la robotique et de nombreux autres domaines de la science et de la technologie.
Dans cet article, nous allons essayer de demontrer un tres simple exemple pratique de l'Intelligence artificielle programmation en Delphi en utilisant Delphi tableaux. J'ai choisi un Nepalais jeu nomme 'GATTA TIPNE KHEL' (sens de galets cueillette de jeu) a cette fin. On peut y voir des petits enfants de jouer a ce jeu dans la cour de recreation.
(En passant, du Nepal, de ma nation, est un petit pays d'Asie entre l'Inde et la Chine. Recemment, le Nepal a ete le principal point d'interet des medias pour le celebre Royal du Massacre de toute la famille du roi regnant ont ete cruellement tues.)
Dans ce caillou de la cueillette de jeu un tas de certains cailloux sont conservees dans le sol. L'un des deux joueurs choisit un, deux ou trois cailloux a la fois dans son tour, laissant la pile pour l'autre joueur a choisir pour son suppleant tour. Dans cette autre processus de la cueillette, le joueur qui prend le dernier caillou(s) sera le perdant et a appele a un destin dans le Nepalais.
La logique principale du jeu est de laisser le tas de cailloux avec 13, 9, 5 ou 1 galet(s) pour l'adversaire de choix.
Dans le programme, le numero de depart de cailloux sont fixes a 17, 21, 25, 29 ... etc. de sorte que l'ordinateur pourrait gagner toujours si il ne fait pas une erreur. Mais dans le veritable jeu d'ordinateur semble etre progressivement l'apprentissage en corrigeant les erreurs de la deja joue a des jeux. Enfin il trouve toutes ses erreurs et les corrige pour devenir un champion imbattable. Il semble que l'ordinateur simule le psychologique processus d'apprentissage de l'animal, de l'apprentissage par correction et de ne pas repeter les erreurs.
Un tableau multidimensionnel d'elements (1..4,1..3) est choisi comme le livre d'instruction de l'ordinateur pour prendre les cailloux. Le livre d'instruction contient quatre pages avec trois lignes d'instructions pour ramasser des cailloux. La premiere ligne indique a choisir un seul caillou, la deuxieme ligne indique de choisir 2, et la troisieme ligne indique a choisir 3 cailloux. Au debut, l'ordinateur choisit une page au hasard et aleatoire d'une ligne d'instruction pour ramasser le caillou. Lorsque le jeu se termine, si l'ordinateur perd le jeu, la derniere instruction est rouge-marque (efface) et de l'instruction ne sera pas le lire dans l'avenir. Apres avoir joue a de nombreux jeux, toutes les instructions conduisant a la perte d'un match sera marque en rouge, et il n'y aura laisse que les instructions de ceux qui conduisent a la victoire.
eh Bien, c'est suffisant pour la description du jeu.
Laissez-nous atteindre directement le code ci-dessous:
unit Unit1
interface

& nbsp & nbsp Windows, Messages, SysUtils, Classes, Graphics, Controls, Forms, Dialogs,
& nbsp & nbsp StdCtrls, ExtCtrls, Boutons
type
& nbsp & nbsp TForm1 = class(TForm)
& ! & ! & ! & nbsp Panel1: TPanel
& ! & ! & ! & nbsp LabelPeb1: TLabel
& ! & ! & ! & nbsp LabelPeb2: TLabel
& ! & ! & ! & nbsp Seance 2: TPanel
& ! & ! & ! & nbsp Panel3: TPanel
& ! & ! & ! & nbsp Panel4: TPanel
& ! & ! & ! & nbsp Label1: TLabel
& ! & ! & ! & nbsp ComboBox1: TComboBox
& ! & ! & ! & nbsp Label2: TLabel
& ! & ! & ! & nbsp Label3: TLabel
& ! & ! & ! & nbsp Label4: TLabel
& ! & ! & ! & nbsp Label5: TLabel
& ! & ! & ! & nbsp Label6: TLabel
& ! & ! & ! & nbsp LabelIWon: TLabel
& ! & ! & ! & nbsp LabelYouWon: TLabel
& ! & ! & ! & nbsp LabelTotPlayed: TLabel
& ! & ! & ! & nbsp ListBox1: TListBox
& ! & ! & ! & nbsp GroupBox1: TGroupBox
& ! & ! & ! & nbsp BitBtn1: TBitBtn
& ! & ! & ! & nbsp BitBtn2: TBitBtn
& ! & ! & ! & nbsp BitBtn3: TBitBtn
& ! & ! & ! & nbsp BitBtn5: TBitBtn
& ! & ! & ! & nbsp Panel5: TPanel
& ! & ! & ! & nbsp Labelbtn: TLabel
& ! & ! & ! & nbsp BitBtnResign: TBitBtn
& ! & ! & ! & nbsp Label7: TLabel
& ! & ! & ! & nbsp procedure FormCreate(Sender: TObject)
& ! & ! & ! & nbsp procedure ComboBox1Change(Sender: TObject)
& ! & ! & ! & nbsp procedure BitBtnResignClick(Sender: TObject)
& ! & ! & ! & nbsp procedure LabelbtnClick(Sender: TObject)
& ! & ! & ! & nbsp procedure BitBtn1Click(Sender: TObject)
& nbsp & nbsp prive
& ! & ! & ! & nbsp { Private declarations }
& ! & ! & ! & nbsp //Procedure pour afficher les Galets restants
& ! & ! & ! & nbsp procedure DispPebbles(const nPebs:integer)
& ! & ! & ! & nbsp //Procedure pour reinitialiser les Variables et les Etiquettes apres un match est fini
& ! & ! & ! & nbsp procedure de Finition
& ! & ! & ! & nbsp //Procedure pour activer ou Desactiver certaines commandes
& ! & ! & ! & nbsp procedure ManageEnabling(lValue:Boolean)
& ! & ! & ! & nbsp //Procedure d'affichage de gagner ou de perdre des messages
& ! & ! & ! & nbsp procedure de Messagerie(const perdu:Boolean const demissionnaire:Boolean)
& ! & ! & ! & nbsp //Reel Procedure pour le jeu
& ! & ! & ! & nbsp Procedure LearnByMistakes
& nbsp & nbsp public
& ! & ! & ! & nbsp { declarations Publiques }
& nbsp & nbsp fin
var
& nbsp & nbsp Form1: TForm1
application
{$R *.DFM}
var
PlayedGames,ComputerWon:Integer
totPebs,RemainPebs,nTurn:Integer
OldPageNum,OldLineNum:Integer
//18 permutations possibles de 3 chiffres: 1, 2 et 3
//pour determiner le nombre de cailloux a prendre pour l'ordinateur
aPermutations:Array[1..6,1..3] of integer
// Un livre contenant les pages d'instruction(4) et les lignes(3 de chaque page) pour dessiner les cailloux pour l'ordinateur
aPages:Array[1..4,1..3] of integer
procedure TForm1.FormCreate(Sender: TObject)
// Permutations de 1, 2 et 3 dans le groupe de 3s pour remplir la Matrice de permutation
const cPermutations='123132213231312321'
var
x,y: Integer
begin
& nbsp & nbsp //Remplissage de la Matrice de Permutation
& nbsp & nbsp pour x:=1 a 6 ne
& ! & ! & ! & nbsp pour y:=1 to 3 do
& ! & ! & ! & ! & ! & nbsp aPermutations[x,y]:=strtoInt(copie(cPermutations,(x-1)*3 o,1))
& nbsp & nbsp & nbsp //Remplissage des lignes de toutes les pages du Livre d'instruction (tableau aPages[1..4,1..3]).
& nbsp & nbsp & nbsp pour x:=1 to 4 do
& ! & ! & ! & ! & nbsp pour y:=1 to 3 do
& ! & ! & ! & ! & ! & ! & nbsp aPages[x,y]:=y
& nbsp & nbsp ComboBox1.ItemIndex:=1
& nbsp & nbsp PlayedGames:=0
& nbsp & nbsp ComputerWon:=0
& nbsp & nbsp totPebs:=17 {par Defaut a 17 cailloux}
& nbsp & nbsp RemainPebs:=17 {Tous sont intacts jusqu'a Maintenant}
fin
procedure TForm1.DispPebbles(const nPebs:entier)
begin
LabelPeb1.Caption:=intToStr(nPebs)
LabelPeb2.Legende:=LabelPeb1.Legende
fin
procedure TForm1.ManageEnabling(lValue:Boolean)
begin
& nbsp & nbsp BitBtn1.Enabled:=lValue
& nbsp & nbsp BitBtn2.Enabled:=lValue
& nbsp & nbsp BitBtn3.Enabled:=lValue
& nbsp & nbsp Labelbtn.Enabled:=lValue
& nbsp & nbsp BitBtnResign.Enabled:=lValue
& nbsp & nbsp GroupBox1.Enabled:=lValue
& nbsp & nbsp si (RemainPebs<3) et (RemainPebs>0) et lValue puis
& nbsp & nbsp commencer
& ! & ! & ! & nbsp si RemainPebs<3 puis BitBtn3.Enabled:=False
& ! & ! & ! & nbsp si RemainPebs<2 alors BitBtn2.Enabled:=False
& nbsp & nbsp fin
fin
procedure TForm1.Finition
begin
& nbsp & nbsp LabelTotPlayed.caption:=intToStr(PlayedGames)
& nbsp & nbsp LabelIWon.caption:=intToStr(ComputerWon)
& nbsp & nbsp LabelYouWon.caption:=intToStr(PlayedGames-ComputerWon)
& nbsp & nbsp DispPebbles(strToInt(ComboBox1.Les Articles[ComboBox1.ItemIndex]))
& nbsp & nbsp totPebs:=strtoint(LabelPeb1.La legende)
& nbsp & nbsp RemainPebs:=totPebs
& nbsp & nbsp ManageEnabling(True)
& nbsp & nbsp ComboBox1.Enabled:=True
& nbsp & nbsp Labelbtn.Enabled:=False
& nbsp & nbsp BitBtnResign.Enabled:=False
fin
procedure TForm1.ComboBox1Change(Sender: TObject)
begin
DispPebbles(strToInt(ComboBox1.Les Articles[ComboBox1.ItemIndex]))
totPebs:=strtoint(LabelPeb1.La legende)
RemainPebs:=totPebs
fin
procedure TForm1.De messagerie(const perdu:Boolean const demissionnaire:Boolean)
begin
& nbsp & nbsp inc(PlayedGames)
& nbsp & nbsp MESSAGEBEEP(0)
& nbsp & nbsp si perdu, alors
& nbsp & nbsp commencer
& ! & ! & ! & nbsp cas de demission alors showmessage('je demissionne ! Vous avez gagne le jeu !!')
& ! & ! & ! & nbsp else showmessage('Felicitations ! Vous avez gagne !! Je reconnaît la defaite !')
& nbsp & nbsp fin
& nbsp & nbsp else
& nbsp & nbsp commencer
& ! & ! & ! & nbsp inc(ComputerWon)
& ! & ! & ! & nbsp showmessage('Salut ! Vous avez perdu ! J'AI GAGNE CE JEU !!')
& nbsp & nbsp fin
& nbsp & nbsp Finition
fin
Procedure TForm1.LearnByMistakes
var
x,PageNum,Numligne,nTemp,nTakes:integer
begin
& nbsp & nbsp si RemainPebs<=0 then
& nbsp & nbsp commencer
& ! & ! & ! & nbsp //Openent a attire le dernier caillou(s) ! L'ordinateur a gagne !!
& ! & ! & ! & nbsp //DispPebbles(0)
& ! & ! & ! & nbsp Messagerie(False,False)
& ! & ! & ! & nbsp sortie
& nbsp & nbsp fin
& nbsp & nbsp nTemp:=random(6) 1
& nbsp & nbsp PageNum:=RemainPebs mod 4
& nbsp & nbsp si PageNum=0 alors PageNum:=4
& nbsp & nbsp pour x:= 1 to 3 do
& nbsp & nbsp commencer
& ! & ! & ! & nbsp Numligne:= aPermutations[nTemp,x]
& ! & ! & ! & nbsp si (aPages[PageNum,Numligne]>0 ) puis pause
& nbsp & nbsp fin
& nbsp & nbsp si x>3 then {Pas banalisee instructions sont restes ! Tous sont redmarked !!}
& nbsp & nbsp commencer
& ! & ! & ! & nbsp // L'effet de ce deplacement etait inconnu auparavant. Mais il s'est avere fatal cette fois-ci !
& ! & ! & ! & nbsp // RedMark Ce oldLineNum de cette oldPageNum !
& ! & ! & ! & nbsp aPages[OldPageNum,OldLineNum]:=-99
& ! & ! & ! & nbsp // Perdu avec Demissionnaire Message !
& ! & ! & ! & nbsp ListBox1.Elements.ajouter(intTostr(nTurn) '. J'ai demissionne ')
& ! & ! & ! & nbsp DispPebbles(RemainPebs)
& ! & ! & ! & nbsp Messagerie(True,True)
& ! & ! & ! & nbsp sortie
& nbsp & nbsp fin
& nbsp & nbsp nTakes:=aPages[PageNum,Numligne]
& nbsp & nbsp si nTakes>=RemainPebs puis
& nbsp & nbsp commencer
& ! & ! & ! & nbsp ListBox1.Elements.ajouter(intTostr(nTurn) '. J' (Ordinateur): 'intTostr(RemainPebs))
& ! & ! & ! & nbsp //je suis le dernier tiroir et je l'ai perdu !!
& ! & ! & ! & nbsp // RedMark Ce Numligne de cette PageNum !
& ! & ! & ! & nbsp aPages[PageNum,Numligne]:=-99
& ! & ! & ! & nbsp DispPebbles(0)
& ! & ! & ! & nbsp Messagerie(True,False)
& ! & ! & ! & nbsp sortie
& nbsp & nbsp fin
& nbsp & nbsp ListBox1.Elements.ajouter(intTostr(nTurn) '. J' (Ordinateur): 'intTostr(nTakes))
& nbsp & nbsp showmessage('I (Ordinateur):' IntTostr(nTakes) ' Pebble(s) pour ce tour !')
& nbsp & nbsp OldPageNum:=PageNum
& nbsp & nbsp oldLineNum:=Numligne
& nbsp & nbsp RemainPebs:=RemainPebs-nTakes
& nbsp & nbsp ManageEnabling(True)
& nbsp & nbsp DispPebbles(RemainPebs)
fin
procedure TForm1.BitBtnResignClick(Sender: TObject)
begin
inc(PlayedGames)
inc(ComputerWon)
inc(nTurn)
ListBox1.Elements.ajouter(intTostr(nTurn) '. Vous demissionne')
Finition
fin
procedure TForm1.LabelbtnClick(Sender: TObject)
begin
BitBtnResign.SetFocus
BitBtnResign.Cliquez sur
fin
procedure TForm1.BitBtn1Click(Sender: TObject)
var
nTaken:Integer
begin
& nbsp & nbsp avec l'Expediteur comme TBitBtn ne nTaken:=Balise
& nbsp & nbsp ManageEnabling(False)
& nbsp & nbsp si (RemainPebs=totPebs)
& nbsp & nbsp commencer
& ! & ! & ! & nbsp ComboBox1.Enabled:=False
& ! & ! & ! & nbsp ListBox1.Clair
& ! & ! & ! & nbsp nTurn:=1
& nbsp & nbsp fin
& nbsp & nbsp else
& ! & ! & ! & nbsp inc(nTurn)
& nbsp & nbsp ListBox1.Elements.ajouter(intTostr(nTurn) '. Vous: 'intTostr(nTaken))
& nbsp & nbsp RemainPebs:=RemainPebs-nTaken
& nbsp & nbsp DispPebbles(RemainPebs)
& nbsp & nbsp LearnByMistakes
fin
a la fin.
Un fichier zippe game.zip contient tous les aliments pour animaux (les formes, les unites et le fichier de projet) du projet en cours d'execution de ce jeu. Ce projet a ete compile et execute avec Delphi 3.
enfin, pour les amis interesses:
j'ai programme un jeu de reflexion strategique en utilisant les principes de l'Intelligence Artificielle. Le jeu est en quelque sorte comme les Echecs.
Le jeu a ete programme a l'aide de PowerBasic et Langage d'Assemblage. Ce jeu a remporte le Premier Prix dans La Premiere Tous Nepal Logiciel de la Concurrence, de LOGICIELS de REPONDRE a 2000. Le jeu peut etre telecharge a: http//:www.viewnepal.com/gamezip.exe (un auto-extractible pkzip fichier). Je serai heureux de vous fournir une copie par e-mail si le telechargement ne fonctionne pas.
game.zip