Téléchargement AI Programmer - Téléchargement du code source AI Programmer

AI Programmer

Autre code source

1.0.0

Télécharger

Programmeur AI

Lisez l'article complet en utilisant l'intelligence artificielle pour écrire des programmes d'auto-modification / d'amélioration

Lisez le programme de recherche sur le programmeur AI: création de logiciels de création de manière autonome utilisant des algorithmes génétiques.

Le programmeur AI est une expérience avec l'utilisation de l'intelligence artificielle et des algorithmes génétiques pour générer automatiquement des programmes. Les programmes créés avec succès par l'IA incluent: Hello World, Hello, Addition, Soustraction, inversion d'une chaîne, séquence Fibonnaci, 99 bouteilles de bière sur le mur, et plus encore. Ça devient plus intelligent. En bref, il s'agit d'une implémentation d'algorithme génétique AI avec du code auto-modifiant.

Motivation

Est-il possible pour un ordinateur d'écrire ses propres programmes? Besoin d'un traitement de texte? Laissez l'ordinateur en créer un pour vous. Besoin d'un outil de capture d'écran? Laissez l'ordinateur en créer un pour vous. Allez plus loin et laissez l'ordinateur créer des programmes qui simplifient votre vie, dont vous ne saviez même pas que vous aviez besoin!

C'est l'idée derrière l'expérience du programmeur AI. L'objectif est de créer un programme informatique qui peut rédiger ses propres programmes informatiques pour résoudre des problèmes de calcul spécifiques. Bien que la capacité d'un ordinateur décidant du type de programme à écrire dépasse nos moyens actuels, nous pouvons toujours avoir un ordinateur générer des programmes pour résoudre des tâches très spécifiques, telles que la sortie du texte, "Hello World". Le programmeur AI utilise un langage de programmation ésotérique pour générer des logiciels.

Détails

Le langage de programmation sous-jacent ne se compose que de 8 instructions, tout en étant complète. Théoriquement, il est capable de résoudre tout problème de calcul. Cela facilite le développement d'un interprète, capable d'exécuter les programmes générés par l'IA dans un environnement simulé. De cette manière, chaque programme généré peut être exécuté et ses performances sont classées comme un score de fitness. Étant donné que l'IA utilise un langage de programmation complet Turing, l'IA elle-même, est également théoriquement capable de résoudre tout problème de calcul. Cependant, pour cette expérience, l'IA se concentrera sur la sortie d'une chaîne simple à la console.

Comment ça marche

AI-Programmer fonctionne comme suit:

Un génome se compose d'un éventail de doubles.
Chaque gène correspond à une instruction dans le langage de programmation.
Commencez par une population de génomes aléatoires.
Décodez chaque génome dans un programme résultant en convertissant chaque double en ses instructions correspondantes et en exécutant le programme.
Obtenez le score de fitness de chaque programme, en fonction de la sortie qu'il écrit à la console (le cas échéant), et classez-les.
S'accoupler les meilleurs génomes ensemble en utilisant la sélection, le croisement et la mutation de la roulette pour produire une nouvelle génération.
Répétez le processus avec la nouvelle génération jusqu'à ce que le score de fitness cible soit atteint.

La méthode de fitness

La méthode de fitness fonctionne en notant la sortie du programme généré. Le score est calculé en examinant chaque sortie de caractère par le programme et en soustrayant sa valeur du caractère souhaité:

 fitness += 256 - Math.Abs(console[i] - targetString[i]);

Ensemble d'instructions interprètes

 > 	Increment the pointer.
< 	Decrement the pointer.
+ 	Increment the byte at the pointer.
- 	Decrement the byte at the pointer.
. 	Output the byte at the pointer.
, 	Input a byte and store it in the byte at the pointer.
[ 	Jump forward past the matching ] if the byte at the pointer is zero.
] 	Jump backward to the matching [ unless the byte at the pointer is zero.

Résultats?

Gardez à l'esprit que c'est une preuve de concept. Jusqu'à présent, le programme a réussi à rédiger plusieurs programmes dans son langage de programmation cible. Vous pouvez afficher des captures d'écran de tous les résultats dans le dossier / résultats. Ces tests ont été effectués sur un quad 2,5 GHz Intel Core 2.

Salut

L'IA a écrit avec succès un programme pour produire "HI" après 5 700 générations en environ 1 minute. Il a produit le code suivant:

 +[+++++-+>++>++-++++++<<]>++.[+.]-.,-#>>]<]

Alors que le code ci-dessus contient des erreurs d'analyse, telles que les supports non correspondants, notre interprète de simulation calcule le résultat jusqu'à l'échec du programme, donc dans le cas ci-dessus, l'erreur de syntaxe (qui est plus tard dans le code, après une solution trouvée ) n'a pas d'impact sur la forme physique.

Vous pouvez essayer de coller le code ci-dessus dans un interprète en ligne. Cliquez sur "Démarrer le débogueur", ignorez les avertissements, puis cliquez sur Exécuter sur BreakPoint. Notez la sortie.

Si nous supprimons l'excès de code, nous voyons le code suivant syntaxiquement valide:

 +[+++++-+>++>++-++++++<<]>++.[+.]

Bonjour

L'IA a écrit avec succès un programme pour produire "Hello" après 252 0000 générations en environ 29 minutes. Il a produit le code suivant:

 +-+-+>-<[++++>+++++<+<>++]>[-[---.--[[-.++++[+++..].+]],]<-+<+,.+>[[.,],+<.+-<,--+.]],+][[[.+.,,+].-

Pendant le processus de génération, l'IA s'est approchée d'une solution, mais quelques lettres étaient liées les unes aux autres, dans une boucle. L'IA a été en mesure de surmonter cela en créant une boucle intérieure, dans la boucle problématique, qui publie avec succès le caractère correct et le traitement continu.

Salut!

Dans un autre exemple, l'IA a écrit avec succès un programme pour sortir "HI!" Après 1 219 400 générations en environ 2 heures et 7 minutes. Il a produit le code suivant:

 >-----------<++[[++>++<+][]>-.+[+++++++++++++++++++++++++++++><+++.<><-->>>+].]

J'aime tous les humains

L'IA a écrit avec succès un programme pour produire "I Love All Humans" après 6 057 200 générations en environ 10 heures. Il a produit le code suivant:

 +[>+<+++]+>------------.+<+++++++++++++++++++++++++++++++.>++++++++++++++++++++++++++++++++++.+++.+++++++.-----------------.--<.>--.+++++++++++..---<.>-.+++++++++++++.--------.------------.+++++++++++++.+++++.

Des programmes plus complexes pourraient probablement être générés lors de l'utilisation de PC plus rapides. Les étapes suivantes incluent la tentative d'accepter les résultats de l'entrée et du processus des utilisateurs.

Guide de démarrage rapide pour utiliser le code

Par défaut, le code est configuré pour utiliser le jeu d'instructions classique et pour écrire un programme pour sortir une chaîne. Pour modifier la chaîne générée, développez simplement la section "Variables privées" et modifiez le texte pour TargetString en valeur souhaitée.

 private static TargetParams _targetParams = new TargetParams { TargetString = "hello world" };

Pour changer le type de programme que l'IA écrit, modifiez la méthode de fitness à l'intérieur de GetFitnessMethod ().

 private static IFitness GetFitnessMethod()
{
	return new StringStrictFitness(_ga, _maxIterationCount, _targetParams.TargetString, _appendCode);
}

Vous pouvez changer cela en n'importe quelle classe du projet AI.Programmer.Fitness/Concrete. Exemples:

 return new StringStrictFitness(_ga, _maxIterationCount, _targetParams.TargetString, _appendCode);
return new AddFitness(_ga, _maxIterationCount);
return new SubtractFitness(_ga, _maxIterationCount);
return new ReverseStringFitness(_ga, _maxIterationCount);
return new HelloUserFitness(_ga, _maxIterationCount, _targetString);

Pour utiliser les sous-routines, vous devrez activer les fonctions. Cela permettra à l'IA de produire des programmes beaucoup plus rapidement. Décommente le code pour le fonctionnaire Fonctionning, comme suit:

 private static IFunction _functionGenerator = new StringFunction(() => GetFitnessMethod(), _bestStatus, fitnessFunction, OnGeneration, _crossoverRate, _mutationRate, _genomeSize, _targetParams);

Définissez l'application.config pour utiliser BrainPlus, de sorte que l'IA a accès aux instructions de sous-routine:

 <appSettings>
	<add key="BrainfuckVersion" value="2"/> <!-- 1 = BF Classic, 2 = BrainPlus (BF Extended Type 3, Functions, Faster) -->
</appSettings>

Lorsque vous utilisez des sous-routines, moins de code est requis. Ainsi, vous pouvez utiliser une génomesize plus petite pour la vitesse. Développez la section des paramètres d'algorithme génétique et modifiez le _GenomeSize en une valeur plus petite: