Download AI Programmer ​​- Download do código -fonte AI Programmer

AI Programmer

Outro código-fonte

1.0.0

Baixar

AI-Programa

Leia o artigo completo usando inteligência artificial para escrever programas auto-modificadores/aprimorados

Leia o Programador de Pesquisa AI: criando programas de software de forma autônoma usando algoritmos genéticos.

O AI-Programmer é um experimento para usar a inteligência artificial e os algoritmos genéticos para gerar automaticamente programas. Os programas criados com sucesso da IA incluem: Hello World, Hello, Adicionar, subtração, reversão de uma string, sequência de Fibonnaci, 99 garrafas de cerveja na parede e muito mais. Está ficando mais inteligente. Em resumo, é uma implementação de algoritmo genético da IA com código auto -modificador.

Motivação

É possível que um computador escreva seus próprios programas? Precisa de um processador de texto? Deixe o computador criar um para você. Precisa de uma ferramenta de captura de tela? Deixe o computador criar um para você. Dê um passo adiante e deixe o computador criar programas que simplificam sua vida, que você nem sabia que precisava!

Esta é a idéia por trás do experimento de AI-Programmer. O objetivo é criar um programa de computador que possa escrever seus próprios programas de computador para resolver problemas computacionais específicos. Embora a capacidade de um computador decidir que tipo de programa escrever está além dos nossos meios atuais, ainda podemos ter um computador gerar programas para resolver tarefas muito específicas, como a saída do texto, "Hello World". O programador de IA usa uma linguagem de programação esotérica para gerar programas de software.

Detalhes

A linguagem de programação subjacente consiste em apenas 8 instruções, enquanto está sendo completa. Teoricamente, é capaz de resolver qualquer problema computacional. Isso facilita o desenvolvimento de um intérprete, capaz de executar os programas gerados pela IA em um ambiente simulado. Dessa maneira, cada programa gerado pode ser executado e seu desempenho classificado como uma pontuação de condicionamento físico. Como a IA está usando uma linguagem de programação completa de Turing, a própria IA, também é teoricamente capaz de resolver qualquer problema computacional. No entanto, para este experimento, a IA se concentrará na saída de uma string simples para o console.

Como funciona

A-i-Programmer funciona da seguinte maneira:

Um genoma consiste em uma variedade de duplas.
Cada gene corresponde a uma instrução na linguagem de programação.
Comece com uma população de genomas aleatórios.
Decode cada genoma em um programa resultante convertendo cada duplo em sua instrução correspondente e execute o programa.
Obtenha a pontuação de fitness de cada programa, com base na saída que grava no console (se houver) e classifique -os.
Mate os melhores genomas usando a seleção de roleta, crossover e mutação para produzir uma nova geração.
Repita o processo com a nova geração até que a pontuação de aptidão de destino seja alcançada.

O método de aptidão

O método de aptidão funciona marcando a saída do programa gerado. A pontuação é calculada analisando a saída de cada caractere pelo programa e subtraindo seu valor do personagem desejado:

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

Conjunto de instruções do intérprete

 > 	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.

Resultados?

Lembre -se de que isso é uma prova de conceito. Até agora, o programa escreveu com sucesso vários programas em sua linguagem de programação de destino. Você pode visualizar capturas de tela de todos os resultados na pasta /Resultados. Esses testes foram executados em um Intel Core 2 Quad 2.5 GHz.

oi

A IA escreveu com sucesso um programa para produzir "HI" após 5.700 gerações em cerca de 1 minuto. Produziu o seguinte código:

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

Enquanto o código acima contém erros de análise, como suportes que não correspondem, nosso intérprete de simulação calcula o resultado até que o programa falhe; portanto, no caso acima, o erro de sintaxe (que está posteriormente no código, depois que uma solução é encontrada ) não afeta a aptidão.

Você pode tentar colar o código acima em um intérprete on -line. Clique em "Start Debugger", ignore os avisos e clique em Run To Breakpoint. Observe a saída.

Se apararmos o excesso de código, vemos o seguinte código sintaticamente valido:

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

olá

A IA escreveu com sucesso um programa para produzir "Hello" após 252.0000 gerações em cerca de 29 minutos. Produziu o seguinte código:

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

Durante o processo de geração, a IA chegou bem perto de uma solução, mas algumas letras estavam ligadas uma à outra, dentro de um loop. A IA foi capaz de superar isso criando um loop interno, dentro da problemática, que produzia com sucesso o caractere correto e o processamento contínuo.

Oi!

Em outro exemplo, a IA escreveu com sucesso um programa para produzir "Oi!" Após 1.219.400 gerações em cerca de 2 horas e 7 minutos. Produziu o seguinte código:

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

Eu amo todos os humanos

A IA escreveu com sucesso um programa para produzir "eu amo todos os humanos" após 6.057.200 gerações em cerca de 10 horas. Produziu o seguinte código:

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

Programas mais complexos provavelmente poderiam ser gerados enquanto usam PCs mais rápidos. As próximas etapas incluem tentar aceitar a entrada do usuário e os resultados do processo.

Guia de partida rápida para usar o código

Por padrão, o código está configurado para usar o conjunto de instruções clássicas e escrever um programa para produzir uma string. Para alterar a string que é gerada, basta expandir a seção "Variáveis privadas" e alterar o texto para o TargetString para o valor desejado.

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

Para alterar o tipo de programa que a IA escreve, altere o método de aptidão dentro do getFitnessMethod ().

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

Você pode alterar isso para qualquer classe no projeto AI.Progrmer.Fitness/Concrete. Exemplos:

 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);

Para usar sub-rotinas, você precisará ativar funções. Isso permitirá que a IA produza programas muito mais rápidos. Descubra o código do FunctionGenerator, como segue:

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

Defina o app.config para usar o BrainPlus, para que a IA tenha acesso a instruções sub-rotinas:

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

Ao usar sub-rotinas, menos código é necessário. Portanto, você pode usar um genomesize menor para a velocidade. Expanda a seção Configurações do algoritmo genético e altere o _Genomesize para um valor menor: