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

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

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

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.

2.5

IMPLEMENTAO

#include <stdio.h>
#include <time.h>
#include <stdlib.h>
#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;

}
}
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 <= amostra[j].apRelativa)
{
contador++;
}
}
if(contador >= 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);

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;

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 <= 10)
{
novo[i].ssd =! novo[i+1].ssd;
novo[i].qntRAM = novo[i].qntRAM + rand() % 4+1;
novo[i].gpuRAM = novo[i].gpuRAM + rand() % 2+1;
}
}
}
void realoca()
{
int id = 0;
int i;
for(i = 0; i < SELECAO; i++)
{
id = menor();
amostra[id].qntRAM
= novo[i].qntRAM;
amostra[id].velRAM
= novo[i].velRAM;
amostra[id].cpuCore = novo[i].cpuCore;
amostra[id].velCore = novo[i].velCore;
amostra[id].velGpu = novo[i].velGpu;
amostra[id].gpuRAM
= novo[i].gpuRAM;
amostra[id].bitsGpu = novo[i].bitsGpu;
amostra[id].ssd
= novo[i].ssd;
}
}

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.

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.