Aprendizado



Baixar 116,33 Kb.
Encontro23.06.2018
Tamanho116,33 Kb.


2

Aprendizado de Maquina



Aprendizado (02)
10.1 - Introdução:
A capacidade de aprender receber o nome de Protopeiria.

Seres humanos e animais aprendem absorvendo e reordenando conhecimentos.

As máquinas “inteligentes” devem ser capazes de aprender criando e aperfeiçoando programas ou calculando a intensidade de sinapses.

Durante muito tempo confundiu-se inteligência com protopeiria.

A aptidão para aprender é um conjunto de habilidades, dentre as quais destacam-se as seguintes capacidades:

- generalizar

- induzir

-fazer analogias

-receber instrução
10.2 - Indução:
Indução é o processo de usar observações para descobrir regras e procedimentos.

Chama-se de diagnóstico a informação que se deseja extrair de um conjunto de observações. Dado Relevante ou Fato Relevante é um conjunto de informações útil em um dado contexto. Cada informações contida em um dado relevante é chamada de indicador. Um indicador pode ter diversos valores. Pode-se estabelecer a analogia:

registro <=> dado relevante

atributo <=> indicador



Consideram-se observações feitas sobre o mercado de ouro.

Os dados relevantes tem os seguintes indicadores:

(1) econ(E) ..... desempenho da economia

(2) infl(I) ..... inflação

(3) p_aquis(P)..... poder aquisitivo da população

Nas estruturas que representam os indicadores o funtor é o nome do indicador e o argumento é o valor.

O indicador de desempenho da economia pode receber os valores:

econ(retr) --- Economia retraída. Recessão.

econ(recup) --- Economia se recuperando.

econ(aquec)--- Economia aquecida.

O indicador de inflação pode receber os valores:

infl(alta) --- Inflação alta.

infl(baixa)--- Inflação baixa.

O indicador de poder aquisitivo pode receber os valores:

p_aquis(peq) --- Poder aquisitivo pequeno.

p_aquis(norm) --- Poder aquisitivo normal.

p_aquis(gran) --- Poder aquisitivo grande.

Os diagnóstico possíveis são

ouro(cai) --- O preço do ouro tende a cair.

ouro(sobe) --- O preço do ouro tende a subir.

ouro(estac) --- O preço do ouro tende a estacionar.

Uma série de observações mostram o seguinte:

Examinando as observações nota-se que sempre o poder aquisitivo é grande e a inflação é alta, o preço do ouro sobe. (ver observações 1,3,4,9,13).

Pode-se concluir a seguinte regra:

ouro(s , sobe) :-- p_aquisitivo(s , gran), infl(alta).

10.3 - Indução por computador:
Uma ferramenta útil na construção de regras por indução é a árvore de decisões.

Para criar uma árvore de decisões dividem-se as observações de acordo com os valores de um dos indicadores, ou seja, a raiz terá tantos filhos quantos são os possíveis valores do indicador escolhido. Cada um dos filhos será uma observação, sem necessidade de exibir aquele indicador pois cada nó conterá observações com o mesmo valor daquele indicador.

Aplica-se o mesmo critério a cada folha utilizando-se outros indicadores e, ao final, chegar-se-á a uma árvore na qual cada folha nó contém observações de mesmo diagnóstico.

Exemplo:

Diagnóstico de desempenho de funcionários.

Os dados relevantes tem como indicadores:

- sexo, com valores

sx(m)

sx(f)

- experiência, com valores

exp(e) --- experiente

exp(i) --- d (b) <=> [sx(f), exp(e), esc(s)].

inexperiente

- escolaridade, com valores

esc(s) --- superior

esc(t) --- técnico

esc(c) --- colegial

As observações (diagnósticos do desempenho, foram bom e ruim) feitas foram:

d (b) <=> [sx(f), exp(e), esc(s)].

d (r) <=> [sx(f), exp(i), esc(t)].

d (b) <=> [sx(m), exp(e), esc(s)].

d (b) <=> [sx(m), exp(i), esc(s)].

d (b) <=> [sx(m), exp(e), esc(t)].

d (r) <=> [sx(m), exp(i), esc(t)].

d (r) <=> [sx(m), exp(i), esc(t)].

d (b) <=> [sx(f), exp(i), esc(s)].

d (r) <=> [sx(m), exp(i), esc(c)].

d (r) <=> [sx(f), exp(i), esc(c)].
Após a segunda ramificação todos os dados estão divididos em classes homogêneas.
experiência

exp(e) exp (i)


diag : b escolaridade

esc(s) esc(c) esc(t)
diag : b diag : r diag : r
Buscas em profundidade levam às seguintes trajetórias:

(1) [exp(e), d(b)].

(2) [exp(i), esc(s), d(b)].

(3) [exp(i), esc(c), d(r)].

(4) [exp(i), esc(t), d(r)].

As listas acima são chamados de Projetos de Regra.

Chamando de D um dado relevante de forma [f,i,s], a definição dos indicadores é:

sx ([x|_],x).

exp ([_,x|_],x).

esc ([_,_,x],x).

Com os projetos de regra anteriores pode-se criar as regras abaixo:

d (D,b) : exp (e).

d (D,b) : exp (i), esc(s).

d (D,r) : exp (i), esc(c).

d (D,r) : exp (i), esc(t).

? - d([ f,i,s ]), Qual).

Qual = b >.

Yes.
Utilizando-se o indicador experiência pode-se obter:
experiência

exp (e) exp (i)
d (b) <=> [ sx (f), esc (s) ] d (r) <=> [ sx (f), esc (t) ]

d (b) <=> [ sx (m), esc (s) ] d (b) <=> [ sx (m), esc (s) ]

d (b) <=> [ sx (m), esc (t) ] d (r) <=> [ sx (m), esc (t) ]

d (r) <=> [ sx (m), esc (t) ]

d (b) <=> [ sx (f), esc (s) ]

d (r) <=> [ sx (m), esc (c) ]

d (r) <=> [ sx (f), esc (c) ]

Já que o ramo exp(e) tem o mesmo diagnóstico pode-se substituir as observações pelo diagnóstico diag : b

Prosseguindo o processo pode-se obter per si.
esperiência
exp(e) exp(i)
escolaridade

esc(t)

diag : b esc(s) esc(c)
d (b)<=>[ sx(m) ] d (r)<=>[ sx(m) ] d (r)<=>[ sx(f) ]

d (b)<=>[ sx(f) ] d (r)<=>[ sx(f) ] d (r)<=>[ sx(m) ]

d (r)<=>[ sx(m) ]

10.4 - Entropia:



O tamanho e a complexidade de uma árvore de decisões dependem da ordem em que os indicadores são escolhidos para efetuar a ramificação.

Árvores pouco ramificadas são boas porque produzem um número pequeno de regras. Regras oriundas de árvores pouco ramificadas tem poucas condições e são mais eficientes.

No exemplo anterior, se a ramificação, ao invés de começar pela experiência, começasse pelo sexo obter-se-ia:
sexo
sx(m) sx(f)

experiência experiência



exp(e) exp(i) exp(e) exp(i)
diag : b escolaridade diag : b escolaridade

esc(s) esc(t) esc(s) esc(t)

esc(c) esc(c)

diag : b diag : r diag : r diag : b diag : r diag : r
As regras decorrentes seriam:

d (D,b):-- sx (D,m), exp (D,e).

d (D,b):-- sx (D,m), exp (D,i), esc (D,s).

d (D,r):-- sx (D,m), exp (D,i), esc (D,c).

d (D,r):-- sx (D,m), exp (D,i), esc (D,t).

d (D,b):-- sx (D,f), exp (D,e).

d (D,b):-- sx (D,f), exp (D,i), esc (D,s).

d (D,r):-- sx (D,f), exp (D,i), esc (D,c).

d (D,r):-- sx (D,f), exp (D,i), esc (D,t).
Estas oito regras fazem o mesmo papel que as quatro regras anteriores. As regras desnecessárias é o fato de que o indicador de sexo não tem nenhuma influência no desempenho dos funcionários.

É conveniente que se descubra “o melhor classificador” ou o indicador que deve ser utilizado para ramificar um nó para otimizar a árvore de decisões.

A descoberta do melhor classificador deve ser feita pela entropia da informação. Entropia é uma grandeza que mede a desordem. Quanto maior a entropia maior a desordem.
indicador

Num = N1 + N2 + ...
N1 N2

observações observações



Entropia E1 Entropia E2

10.5 - Um Programa que faz Induções:
O livro texto apresenta um programa que faz induções. O programa é invocado pelo predicado regra( ­_ ). regra ( _ ) chama ramifica_mais ( _ , _ ) com uma lista de observações. ramifica_mais ( _ , _ ) encontra os valores do indicador que produzirá uma boa árvore.

Os valores do “melhor indicador” e as observações são passadas para ramifica ( _ , _ , _ ). ramifica ( _ , _ , _ ) chama recursivamente ramifica_mais( _ , _ )

para produzir os sub-ramos dos ramos.

Deve-se escolher o indicador que produza a ramificação de menor entropia e, portanto, de maior organização. O ideal é obter entropia nula, quando todos os diagnósticos são idênticos em um ramo, ou seja, não há necessidade de mais ramificações.

Sejam PD1, PD2, ... as proporções com que cada um dos diagnósticos aparecem em um ramo. A entropia do ramo é igual a :
Entr is - PD1 * log(PD2) / log(2) - PD2 * log(PD2) / log(2) ...
Calculada a entropia de um ramo pode-se calcular a entropia de um grupo de ramos correspondentes a um indicador. Seja Num o número de observações; E1, E2, ... , E as entropias de cada grupo de ramos correspondentes a um indicador; N1, N2, ... o número de elementos em cada ramo. A entropia de toda a ramificação é dada por:

N1 * E1 / Num + N2 * E2 / Num + ...
Considere-se a árvore do exemplo:
escolaridade
esc(s) esc(c) esc(t)
diag (b) diag (r) experiência

exp(e) exp(i)
diag (b) diag (r)
A primeira chamada de ramifica_mais( _ , _ ) elege escolaridade como melhor indicador. Os ramos do indicador escolaridade são [ esc(s), esc(c), esc(t) ]. A primeira sentença de ramifica_mais( _ , _ ) interrompe a ramificação no caso de esc(c) e esc(s) pois estes ramos correspondem a folhas. A terceira sentença de ramifica_mais( _ , _ ) chama ramifica ( _ , _ , _ ) para produzir os sub-ramos exp(e) e exp(i) de esc(t).

O programa ramifica_mais( _ , _ ) produz percursos ao longo dos ramos da árvore, na ordem abaixo:

[ esc(c), d(r) ]

[ esc(s), d(b) ]

[ esc(t), exp(e), d(b) ]

[ esc(t), exp(i), d(r) ]

O programa monta_regra( D, _ , _ ) transforma estes percursos em regras expressas em PROLOG.___10.6'>PROLOG.

10.6 - Medindo a Entropia:
A entropia pode ser considerada uma medida da desordem ou da quantidade de informação de que se necessita para organizar conhecimentos e descobrir uma regra.

Quanto mais alternativas para um diagnóstico existem mais informações se precisa sobre ele. Se um diagnóstico não tem alternativas, sua entropia é nula e nada mais se precisa aprender sobre ele.

Quanto menos freqüente for um diagnóstico mais informação ele transmite.
Exemplos:

Para identificar um estudante entre seus pares pode-se utilizar vários indicadores:

- idade de universitários

20 anos traz pouca informação

60 anos traz muita informação

- sexo

- cor

- raça

- riqueza



Considere-se a busca de um suspeito entre 12 pessoas, dos quais 4 mulheres e 8 homens. Saber que o suspeito é mulher traz mais informação porque 12/4 é maior que 12/8.

A contribuição de um diagnóstico D é função do número de diagnósticos possíveis, A, e da freqüência F de D, ou seja, a contribuição de D é f(A/F).
f(A/F) = log(A/F) / (log(2) * A/F)

f(A/F) = - (F/A) * log(F/A) / (log(2)
F/A é a proporção do diagnóstico D entre as observações :

f(A/F) = - PD * log(PD) / (log(2)

10.7 - Generalização:
Diz-se que uma pessoa obtêm um conceito por meio de generalizações se ela observou um conjunto de objetos e descobriu, entre eles, uma classe cujos membros possuem características em comum. Esta classe é denominada Conceito.

Para aprender um conceito novo à partir de uma seqüência de observações verifica-seque algumas observações ilustram uma ocorrência do conceito, sendo observações positivas. Outras observações ilustram casos em que o conceito não está presente sendo ocorrências negativas.

Deve-se adotar uma linguagem especial para descrever observações e as características que definem um conceito. Deve-se poder verificar se uma observação possui características de um conceito.

Um conceito G é mais geral que um conceito H se todas as ocorrências positivas de H são também ocorrências positivas de G, que ainda possui outras mais. Neste caso H é mais específico do que G. Existe ordem parcial no universo dos conceitos.

Pela linguagem de conceitos deve-se, pela simples inspeção sintática de dois conceitos, descobrir se um é mais geral do que outro.

A linguagem de conceitos deve ter operadores tais que, dado um conceito, se obtenha um outro mais geral ou mais específico.

O aprendizado de conceitos pode ser resolvido por buscas. Os estados são os diferentes conceitos. As operações de mudança de estado são generaliza ( _ , _ ) e torna_mais_específico ( _ , _ ). a meta é encontrar um conceito que descreva todas as ocorrências positivas e nenhuma negativa.

Dado um conceito pode-se obter conceitos mais específicos acrescentando-se condições às suas características. Para obter conceitos mais genéricos pode-se suprimir condições ou transformar condições em alternativas do tipo “ou”.

No aprendizado de conceitos podem ser utilizados todos os tipos de busca. A busca em largura faz uso da ordem parcial para tornar-se mais eficiente que a busca em profundidade. A busca heurística mais utilizada é a busca em espaço de versões.

10.8 - Avaliação Parcial:
Em Inteligência Artificial muitas vezes é necessário utilizar-se de linguagens especiais a fim de atacar certos problemas.

Como exemplos pode-se citar as seguintes linguagens:

- robótica

- PLN

- Frames

- Regras de produção

- Conceitos

- Linguagens explicadoras
As linguagens especiais precisam ser transformadas em linguagens de programação ordinárias para que possam ser processados por computadores.

A transformação de linguagens, ou tradução, pode ser feita de 3 maneiras distintas:

- compilação que transforma um programa escrito em qualquer linguagem em um programa executável;

- Interpretação que examina cada sentença do programa a ser transformado, a traduz para linguagem executável e a executa de ...

- avaliação parcial que transforma um programa escrito em linguagem especial em um programa escrito em linguagem ordinária, como PROLOG, por exemplo.
Em PROLOG tanto os programas intérpretes quanto os avaliadores parciais são muito fáceis de escrever.

Considerando que os avaliadores parciais são muito mais rápidos de executar eles devem ter a preferência.

Os métodos de raciocínio mais destacados são:

- dedutivo

- indutivo

- analógico

Os modelos de Representação do Conhecimento usados em IA são:

- Representação Logica

- Representação Procedimental

- Sistemas de Produção

- Redes Semânticas e Frames

10.9- Exemplo dePrograma em Linguagem C:
A seguir apresentamos um programa escrito em linguagem C, que utiliza um metodo de aprendizado de descrições de classe que é algumas vezes chamado hit_and_near_miss( chutar-e-errar-por-pouco).

/* aprendendo descrições de classe usando o metodo bit-and-near-miss */


#define max 100
struct attribute {

char subject[80];

char verb[80];

char object[80];

char active;

};

struct attribute may[MAX]; /* banco de dados pode-ter */



struct attribute must[MAX]; /* banco de dados precisa-ter */
int may_pos=0;

int must_pos=0;


main( )

{

printf(“(A)prender, (E)xibir, ou (S)air?\n”);



for (; ;) {

switch( tolower (getc( ))) {

case ‘ A’: learn( );

break;


case ‘E’: display( );

break;


case ‘S’: exit( );

}

} printf (“\n”);



}
/* aprendendo a descrição de classe p/ um objeto */

learn( )


{

char sub[80], verb[80], obj[80];

char msub[80], mverb[80], mobj[80];

for (; ;) {

printf (“Entre com um exemplo.\n”);

if ( !get_example (sub, verb, obj) ) {

return;

}

if (find_may (sub, verb, obj) = = -1) {



assert_may (sub,verb,obj);

generalize(sub,verb,obj);

}

printf(“Entre com o quase-acerto (CR para sair). \n”);



get_example(msub,mverb,mobj);

restrict(msub,mverb,mobj);

}

}
/* coloca uma entrada no banco de dados pode-ter */



assert_may(n,v,o)

char *n,*v,*o;

{

if (may_pos < MAX) {



strcpy ( may[may_pos].subject,n);

strcpy ( may[may_pos].verb, v);

strcpy ( may[may_pos].object, o);

may[may_pos].active=1;

may_pos++;

}

else printf(“Estouro de memoria\n”);



}
/* coloca uma entrada no banco de dados precisa-ter */

assert_may(n,v,o)

char *n,*v,*o;

{

if (must_pos < MAX) {



strcpy ( must[must_pos].subject,n);

strcpy ( must[must_pos].verb, v);

strcpy ( must[must_pos].object, o);

must[must_pos].active=1;

must_pos++;

}

else printf(“Estouro de memoria\n”);



}

/* acha uma entrada no banco de dados may-have */

find_may( n,v,o)

char *n, *v, *o;

{

register int t;



for (t=0; t

if (!strcmp( may[t].subject,n) &&

! strcmp( may[t].verb,n) && !strcmp( may[t].object,n) &&

may[t].active)

return t;

return -1;

}
/* delimita a descrição de um objeto - p.ex., remove da list pode-ter e coloque

na lista precisa-ter */

restrict (ms,mv,mo)

char *ms, *mv, *mo;

{

register int t;



char temp[4];

for (t=0; t<3; t++) temp[t]=tolower (mv[t]);

temp[3]=‘\0’;

if (strcmp (temp, “not”)) return;

for (t=0; t

if (!strcmp(&mv[4], may[t].verb) &&

! strcmp( may[t].subject,ms) && may[t].active) {

assert_must (may[t].subject, may[t].verb, may[t].object);

may[t].active=0; /* retira da lista */

return;


}

}

}



/* generalizando novos exemplos */

generalize (n, v, o)

char *n, *v, *o;

{

register int t, i;



/* verificar a lista may-have */
for (t=0; t< may_pos; t++) {

if (strcmp

!strcmp(may[t].verb,v) &&

!strcmp(may[t].object, o) && may[t].active) {

strcat (may[t].subject, “ or “);

strcat(may[t].subject, n);

}

}

for (t=0; t< may_pos; t++) {



if (strcmp

!strcmp(may[t].verb,v) &&

!strcmp(may[t].object, o) /* não é o mesmo objeto */

&& may[t].active) {

strcat (may[t].object, “ or “);

strcat(may[t].object, n);

}

}
/* verifica a lista precisa-ter */



for (t=0; t< must_pos; t++) {

if (strcmp

!strcmp(must[t].verb,v) && !strcmp(must[t].object, o) ) {

strcat (must[t].subject, “ or “);

strcat(must[t].subject, n);

i=find_may(n,v,o);

may[i].active=0; /* retira da lista may-have */

}

}



for (t=0; t< must_pos; t++) {

if (strcmp

!strcmp(must[t].verb,v) &&

!strcmp(must[t].object, o) { /* não é o mesmo objeto */

strcat (must[t].object, “ or “);

strcat(must[t].object, n);

i=find_may(n,v,o);

may[i].active=0; /* retira da lista may-have */

}

}

}



/* entrada da descrição */

get_exemple(n, v, o)

char *n, *v, *o;

{

printf(“\sujeito: “);



gets(n);

if (!*n) return 0;

printf(“verbo: “);

gets(v);


printf(“objeto: “);

gets(o);


return 1;

}

display ( )



{

int t;


printf(“\npode ter: \n”);

for (t=0; t

if (may[t].active)

printf (“ %s %s %s \n”, may[t].subject,

may[t].verb, may[t].object);

}

printf(“precisa ter: \n”);



for (t=0; t

printf (“ %s %s %s \n”, must[t].subject,

must[t].verb, must[t].object);

}

}


USANDO O PROGRAMA
Este programa requer que você (o professor) siga um formato restrito para que não confunda o computador(o estudante).

Primeiro, todas as descrições devem ser do tipo sujeito, verbo, objeto. Por exemplo, aqui estão algumas descrições válidas:



pneus são redondos

mesa tem quatro pernas

gravidade empurra para baixo



O programa esperará pelo sujeito, verbo e objeto separadamente, e desta forma você poderá usar seqüências de palavras para cada parte sem a preocupação de comfundir o sistema. Resposta vazia ao pedido de sujeito finaliza a entrada.

Segundo, as diferenças entre os exemplos corretos e os erros-por-pouco devem se representadas como relações Não. Por exemplo, se um exemplo tem a cor vermelha e a descrição de classe requer a cor vermelha, então um erro-por-pouco não precisa conter a cor vermelha. Assim, para ensinar o computador que “blocos vermelhos são vermelhos”, primeiro você deve dizer a ele que “blocos vermelhos são vermelhos”, e então, para um erro-por-pouco, você diria que “blocos vermelhos não são vermelhos”. Dessa maneira, o computador seria capaz de ver que vermelho é um atributo necessário dos blocos vermelhos.



Para ver como o programa realmente funciona, execute o programa neste instante e introduza as informações conforme apresentadas.

(E)nsinar, (M)ostrar, (S)air ? E
Insira um exemplo.

sujeito: bloco

verbo: em cima de

objeto: lados
Insira o quase acerto (CR para sair):

sujeito: bloco

verbo: nao em cima de

objeto: lados
Insira um exemplo.

sujeito: lado 1

verbo: a esquerda de

objeto: lado 2
Insira o quase acerto (CR para sair):

sujeito:
Insira um exemplo.

sujeito: lados

verbo: feitos de

objeto: madeira
Insira o quase acerto (CR para sair):

sujeito:
Insira um exemplo.

sujeito:
(E)nsinar, (M)ostrar, (S)air ? M

pode ter:

lado 1 a esquerda de lado 2

precisa ter:

bloco ou cilindro em cima de lados
(E)nsinar, (M)ostrar, (S)air ? E
Insira um exemplo.

sujeito: lados

verbo: feitos de

objeto: madeira
Insira o quase acerto (CR para sair):

sujeito: lados

verbo: nao feitos de

objeto: madeira

Insira um exemplo.

sujeito: lados

verbo: feitos de

objeto: metal
Insira o quase acerto (CR para sair):

sujeito:
Insira um exemplo.

sujeito:

(E)nsinar, (M)ostrar, (S)air ? M

pode ter:

lado 1 a esquerda de lado 2

precisa ter:

bloco ou cilindro em cima de lados

lados feitos de madeira ou metal






10.10 - A linguagem de Descrição:
Realmente a escolha da representação para codificar o conhecimento do sistema é no mínimo tão importante quanto os detalhes do algoritmo de aprendizado. Um dos maiores sucessos dos recentes programas descobertos, EURISKO, deve seu grande sucesso a alta flexibilidade de sua linguagem de descrição. Todos o antecessores a heurística do EURISKO são expressos em um formato simples, e como unidades. Unidades sã estruturas de recado que são manipuladas por regras (outras unidades). A sintaxe básica que muda em uma unidade conduzirá a coisas significativas, a possivelmente valores e novas unidades. Em contraste, pequenas alterações em um programa convencional ou em sua estrutura de dados provavelmente produzirá algo sem sentido.

Assim antes da construção de um sistema de aprendizado é útil certificar-se que a linguagem de descrição é capaz de expressar os tipos de diferença que serão necessários. Isso não é um problema trivial.

É conveniente se a representação para os dados de entrada for o mesmo que para as descrições (as regras) mas esse não é sempre o caso. Algumas representações que tem sido usadas na prática são tabuladas abaixo:
Sistema Formalismo de Entrada Formalismo de Regra

Perceptron Vetores de caracter Vetores de peso

ID3 Vetores de caracter Árvore de decisão

AQ11/INCUDE Cálculo de predicados Cálculo de predicados

LS-1 Vetores de caracter Strings de regra

BEAGLE Registro de dados Expressão booleana

EURISKO ‘Units’(frames) ‘Units’(frames)
Um vetor de caracteres, como usado no Perceptron e outros sistemas é apenas um array de números. Cada número caracteriza o estado de um atributo de entrada.

O IDA , programa de indução, usa vetores de caracteres para a entrada mas uma estrutura de árvore para a decisão de regras que ele construirá.

A série de programas projetados por Michalski e seus associados incluem o AQ11 e INCUDE empregam expressões lógicas em uma notação de cálculo estendido de predicado para representar exemplos de entrada, descrição de classes. O programa AQ11 induz uma descrição de exemplos que o habilita a classificar doenças melhor do que um sistema especialista em biologia agrícola.

LS-1 é um programa baseado no algoritmo de aprendizado genético. Ele foi testado em uma partida de poker usando vetores de caracteres para representar o estado do jogo e uma string de comprimento fixo para representar regras de produção em uma linguagem especial. Essas strings eram manipuladas por operadores pseudo-genéticos e eram representadas pelo sistema especialista que controlara as divisões de jogada.

BEAGLE é outro programa de aprendizado. Ele usa recado de base de dados ‘flat-file’ para seus exemplos de entrada e expressões booleanas, representadas internamente como estrutura de árvores, para suas regras.

Finalmente, EURISKO como mencionado acima, que é um dos mais expressivos programas de aprendizado usa estruturas de dados framelike chamadas unidades para representar praticamente tudo no sistema, induzindo objetos, conceitos e regras heurísticas. Para mostrar como é uma unidade aqui está um dos conceitos usados pelo EURISKO em uma batalha naval.
Name: Energygun.

Generalizations: (anything, weapon)

Allisa: (gameconcept, gameobj, anything, abstractobj, physicalobj, physgameobj).

Isa: (defensiveweapontype, offensiveweapon, physgameobj).

Myworth: 400.

Myinitialworth: 500.

Worth: 100.

Initialworth: 500.

Damegeinfo: (smallweapondamege).

Attackinfo: (energygun-attackinfo).

Numpresent: Nenergyguns.

USPpresent: energygunUSP.

Defendsas: (beamdefense).

Rarity: (0.11/19).

Focustask: (Focusonenergygun).

Mycreator: Dlenat.

Mytimeofcreation: 4-june-81 16:19:46.

Mymodeofcreation: (EDIT nucmissile).
Cada campo na unidade é chamado ‘slot’ e descreve um aspecto do conceito. Por exemplo o slot ISA diz que uma arma de energia é um tipo de armamento defensivo entre outras coisas e o slot WORTH especifica seu valor, em uma escala de 0 a 100.

É importante notar que regras podem ser descritas como unidades , daí como conceitos, esse é um dos poderes do EURISKO.

Da variedade de notações usadas nós podemos concluir que não há uma linguagem de representação ideal para aprendizado de máquinas. Entretanto, é importante que a representação usada seja adequadamente expressiva para a tarefa.


Bibliografia:
INTELIGÊNCIA ARTIFICIAL , G. Araribóia , Editora Livros Técnicos e Científico

ARTIFICIAL INTELLIGENCE, Masound Yazdany, Editora Chapman and Hall



INTELIGÊNCIA ARTIFICIAL, Schildt




Aprend02 – Fls.




©livred.info 2017
enviar mensagem

    Página principal