UNIVERSIDADE FEDERAL DO RIO GRANDE - FURG

CENTRO DE CIENCIAS COMPUTACIONAIS C3

ENGENHARIA DE AUTOMAO

DELIEL OLIVEIRA - 63766

RAFAEL ANDREI VIZZOTTO -63763

ALGORITMOS GENTICOS PARA

OTIMIZAR UM COMPUTADOR PARA

JOGOS

DISCIPLINA: SISTEMAS INTELIGENTES

PROFESSOR: DR. SLVIA BOTELHO

RIO GRANDE

2015

1

SUMRIO ALGORITMOS GENTICOS PARA OTIMIZAR UM COMPUTADOR PARA JOGOS ..... 0

1 INTRODUO .................................................................................................................. 2

2 DESENVOLVIMENTO ..................................................................................................... 3

2.1 PROBLEMA ................................................................................................................ 3

2.2 SOLUO ................................................................................................................... 3

2.3 METODOLOGIA ........................................................................................................ 3

2.4 FUNCIONAMENTO DO ALGORITMO ................................................................... 3

2.5 IMPLEMENTAO ................................................................................................... 4

2.6 TESTES E RESULTADOS ......................................................................................... 8

3 CONCLUSO .................................................................................................................... 9

2

1 INTRODUO

Um algoritmo gentico (AG) uma tcnica de busca utilizada na cincia da

computao para achar solues aproximadas em problemas de otimizao e busca,

fundamentado principalmente pelo americano John Henry Holland. Algoritmos genticos so

uma classe particular de algoritmos evolutivos que usam tcnicas inspiradas pela biologia

evolutiva como hereditariedade, mutao, seleo natural e recombinao (ou crossing over).

3

2 DESENVOLVIMENTO

2.1 PROBLEMA

Nos dias de hoje realmente um problema montar um PC com configuraes boas e

pouco dinheiro e que ainda consiga alcanar altos FPS (frames por segundo) nos seus jogos.

O que ocorre que devido a isso as pessoas acabam priorizando um componente ou

outro, porm os jogos e aplicaes grficas hoje em dia utilizam por muitas vezes a potncia

de diversos componentes e no s um em especifico.

2.2 SOLUO

Para solucionar isso resolvemos criar um algoritmo gentico que ir testar diversas

configuraes de hardware em um jogo e ao final ir nos trazer uma tima configurao para

alcanar um nvel de FPS desejado.

2.3 METODOLOGIA

Criamos um algoritmo gentico do tipo de seleo por torneio, reproduo pontual e

taxa de mutao de 0.01%, o cromossomo possuir 8 variveis de interesse que sero as

caractersticas dos componentes.

Como sabemos, o algoritmo gentico tem como objetivo otimizar uma soluo, visto

que para isso temos apenas as entradas e as sadas aps passar por uma caixa preta, a caixa preta

nesse problema em questo o jogo.

2.4 FUNCIONAMENTO DO ALGORITMO

Primeiramente o usurio deve especificar as configuraes do computador, entrar no

jogo e fazer a captura da taxa de FPS. Aps entrar com os dados de 16 computadores (esse

nmero pode ser alterado) a amostra est criada.

Aps isso selecionamos uma parada por interao, em nosso trabalho optamos por 20

interaes, a amostra levada para a fase de seleo, onde atravs do modo torneio so feitas

4 disputas com 3 indivduos escolhidos aleatoriamente.

Depois de feita a seleo passamos ento a fase de reproduo onde sero gerados 2

filhos a cada 2 pais com 50% de caractersticas de cada um, no final resultando em 4 filhos.

Logo aps a reproduo eles so enviados para a funo de mutao, onde h a possibilidade

de 0.01% de sofrerem mutao, essa mutao especfica e altera variveis especficas. Ento

j com os filhos prontos feita a reinsero deles na amostra, para isso sero removidos os 4

indivduos com a menor aptido relativa. O processo todo se reinicia a partir da fase de seleo

novamente e repetido tanto quanto for o nmero de interaes.

4

2.5 IMPLEMENTAO

#include

#include

#include

#define TAMANHO 8

#define SELECAO 4

int total = 0;

int escolhido[3];

struct population

{

int qntRAM;

int velRAM;

int cpuCore;

int velCore;

int velGpu;

int gpuRAM;

int bitsGpu;

int ssd;

float fps;

float apRelativa;

};

struct population amostra[TAMANHO];

struct population novo[SELECAO];

int maior(int n1, int n2, int n3)

{

if((amostra[n1].apRelativa >= amostra[n2].apRelativa) && (amostra[n1].apRelativa >=

amostra[n3].apRelativa))

{

return n1;

}

else if((amostra[n2].apRelativa >= amostra[n1].apRelativa) && (amostra[n2].apRelativa

>= amostra[n3].apRelativa))

{

return n2;

}

else if((amostra[n3].apRelativa >= amostra[n1].apRelativa) && (amostra[n3].apRelativa

>= amostra[n2].apRelativa))

{

return n3;

5

}

}

int menor()

{

int i, j, k;

int contador = 0;

for(i = 0; i < TAMANHO; i++)

{

contador = 0;

for(j = 0; j < TAMANHO; i++)

{

if(amostra[i].apRelativa = TAMANHO)

{

return i;

}

}

}

void criar()

{

int i;

for(i = 0; i < TAMANHO; i++)

{

printf("\nQuantidade de Memoria RAM (GB) individuo %i: ", i+1);

scanf("%i", &amostra[i].qntRAM);

printf("\nVelocidade de Memoria RAM (MHz) individuo %i: ", i+1);

scanf("%i", &amostra[i].velRAM);

printf("\nQuantidade de Nucleos do Processador (Cores) individuo %i: ", i+1);

scanf("%i", &amostra[i].cpuCore);

printf("\nVelocidade do Processador (MHz) individuo %i: ", i+1);

scanf("%i", &amostra[i].velCore);

printf("\nVelocidade de Processamento da Placa Grafica (MHz) individuo %i: ", i+1);

scanf("%i", &amostra[i].velGpu);

printf("\nQuantidade de Memoria da Placa Grafica (GB) individuo %i: ", i+1);

scanf("%i", &amostra[i].gpuRAM);

printf("\nQuantidade de bits da memoria da Placa Grafica (bits) individuo %i: ", i+1);

scanf("%i", &amostra[i].bitsGpu);

printf("\nSSD? (Sim ou nao) Individuo %i: ", i+1);

6

scanf("%i", &amostra[i].ssd);

printf("\nQuantidade de Frames por Segundo (FPS) dentro do jogo (caixa preta) do

individuo %i: ");

scanf("%f", &amostra[i].fps);

printf("\n\n");

}

}

void selecao()

{

int i, j;

int id = 0;

for(i = 0; i < TAMANHO; i++)

{

total = total + amostra[i].fps;

}

for(i = 0; i < TAMANHO; i++)

{

amostra[i].apRelativa = (amostra[i].fps/total);

}

for(j = 0; j < SELECAO; j++)

{

id = maior(rand() % TAMANHO + 1, rand() % TAMANHO + 1, rand() % TAMANHO

+ 1);

escolhido[j] = id;

}

}

void reproducao()

{

int i;

for(i = 0; i < SELECAO; i = i+2)

{

novo[i].qntRAM = amostra[escolhido[i]].qntRAM;

novo[i].velRAM = amostra[escolhido[i]].velRAM;

novo[i].cpuCore = amostra[escolhido[i]].cpuCore;

novo[i].velCore = amostra[escolhido[i]].velCore;

novo[i].velGpu = amostra[escolhido[i+1]].velGpu;

novo[i].gpuRAM = amostra[escolhido[i+1]].gpuRAM;

novo[i].bitsGpu = amostra[escolhido[i+1]].bitsGpu;

novo[i].ssd = amostra[escolhido[i+1]].ssd;

7

novo[i+1].qntRAM = amostra[escolhido[i+1]].qntRAM;

novo[i+1].velRAM = amostra[escolhido[i+1]].velRAM;

novo[i+1].cpuCore = amostra[escolhido[i+1]].cpuCore;

novo[i+1].velCore = amostra[escolhido[i+1]].velCore;

novo[i+1].velGpu = amostra[escolhido[i]].velGpu;

novo[i+1].gpuRAM = amostra[escolhido[i]].gpuRAM;

novo[i+1].bitsGpu = amostra[escolhido[i]].bitsGpu;

novo[i+1].ssd = amostra[escolhido[i]].ssd;

}

}

void mutacao()

{

int i, mut;

for(i = 0; i < SELECAO; i++)

{

mut = rand() % 1000+1;

if(mut

8

int main()

{

int inter;

criar();

for(inter = 0; inter < 3; inter++)

{

selecao();

reproducao();

mutacao();

realoca();

}

}

2.6 TESTES E RESULTADOS

Para a realizao do teste, utilizamos a amostra indicada pela figura 1.

Figura 1 amostra utilizada no algoritmo gentico.

Para nosso problema escolhemos como mtodo de parada quando o algoritmo tivesse

um mximo de 20 interaes. Aps isso obtivemos uma nova amostra, desta amostra o

indivduo que teve a maior aptido relativa foi o da figura 2.

Figura 2 amostra com melhor aptido.

9

3 CONCLUSO

Conclumos que o resultado trazido pelo AG melhor dentro dessas 20 interaes,

conseguiu alcanar a maior taxa de FPS. Podemos notar tambm que ele sofreu mutaes.

Nesse trabalho tivemos a oportunidade de usar o conhecimento aprendido em Sistemas

Inteligentes para suprir uma necessidade nossa, alm disso o tema abordado possibilitou um

grande interesse por parte dos integrantes.