Sistemas Multi-Agentes - OSIM 0001

Sistemas Multi-Agentes - OSIM 0001
Rogério Eduardo da Silva - [email protected]
Universidade do Estado de Santa Catarina
Departamento de Ciência da Computação
5 de março de 2015
Conteúdo Programático
Apresentação da Disciplina
Revisão de Conceitos
Programação orientada a objetos em C++
Documentação de Código - Doxygen
Computação Gráfica - OPENGL
PROLOG
Introdução aos Agentes Inteligentes
O que são agentes?
Ambientes
Representação do Conhecimento
Agentes
Agentes Reativos
Agentes
Agentes
Agentes
Agentes
Agentes
Puramente Reativos
com Gatilhos
baseados em Objetivos
baseados em Utilidade
Qualquer Tempo
Agentes Deliberativos
Agentes BDI
Agentes EBDI
Abordagens Multi-Agentes
Storytelling Interativo
Psicologia Computacional
Atitudes Mentais: Emoção
2 of 173
Atitudes Mentais: Personalidade
Tomada de Decisão
Objetivo da Disciplina
Permitir ao aluno desenvolver habilidades de modelagem e criação de
agentes e sistemas multi-agentes;
Estudar problemas que possam ser mais facilmente resolvidos através de
Inteligência Artificial distribuı́da;
Desenvolver uma aplicação-exemplo completa através da utilização de
SMA;
3 of 173
Domı́nio sugerido pelo professor: Storytelling Digital Interativo
Método de Ensino
Aulas expositivas em sala e em laboratório
Listas de exercı́cios teóricos e práticos
Atendimento presencial (sala do professor) e/ou através da lista de emails
da disciplina [email protected]
4 of 173
Avaliações
Serão realizadas 3 avaliações:
[Byl, 2004, Iurgel and Marcos, 2007, Perlin and Seidman, 2008]1
1 prova teórica (peso: 30%):
1. Agentes (conceitos, taxonomia, implementações) e Abordagens
Multi-agentes.
2. Conceitos de Psicologia Computacional
Implementação de um agente reativo (peso: 35%)
Projeto de Implementação de um Sistema de Storytelling Interativo
(peso: 35%)
Exame Final (caso média semestral < 7.0)
Data prevista: 07 de Julho de 2015
1
E vários outros artigos a serem apresentados durante o semestre
5 of 173
Bibliografia Básica Sugerida
Byl, P. B.-d. (2004).
Programming Believable Characters for Computer Games.
Charles River Media.
Iurgel, I. A. and Marcos, A. F. (2007).
Employing personality-rich virtual persons–New tools required.
Computers & Graphics, 31(6):827–836.
Perlin, K. and Seidman, G. (2008).
Autonomous digital actors.
In Motion in Games, volume 5277/2008 of Lecture Notes in Computer Science,
pages 246–255. Springer Verlag.
6 of 173
Figura 1: Personagem “Sonny” do filme “Eu, Robô” de 2004 (20th Century Fox)
7 of 173
Video “Sonny”: 3m30s
8 of 173
Figura 2: Assistente de Compras online (Amazon Prime)
9 of 173
Figura 3: Robôs Industriais em Linhas de Produção
10 of 173
Figura 4: Brinquedos Eletrônicos Interativos
11 of 173
Figura 5: Personagens Autônomos (adversários ou não) em Jogos Eletrônicos
12 of 173
Figura 6: Figuração Virtual em Filmes (Digital Extras)
13 of 173
Figura 7: Assistentes Virtuais
14 of 173
Video “Eureka: S.A.R.A.H.”: 2m12s
15 of 173
Video “SEMAINE project”: 2m12s
16 of 173
Revisão de Conceitos
Programação Orientada a Objetos (C++)
Computação Gráfica (OpenGL)
Lógica Matemática (Prolog)
17 of 173
Programação Orientada a Objetos (C++)
Classe & Objeto Classes são descrições expandidas de estruturas de dados
que podem conter membros: atributos e métodos. Objetos
são instanciações das classes. Objetos podem ser estáticos ou
dinâmicos.
Polı́ticas de Acesso são identificadores que definem o escopo de acesso aos
membros de uma classe. Podem ser públicos, privados ou
protegidos.
Construtores & Destrutor Construtor é um método especial que é chamado
no momento em que um objeto é criado. Destrutor é o
método chamado no momento em que um objeto é
desalocado da memória.
Uma classe pode conter vários construtores (polimorfismo)
porém apenas um destrutor.
18 of 173
Programação Orientada a Objetos (C++)
1
2
3
4
5
6
7
8
9
10
11
12
13
14
15
16
17
18
19
20
class Circle
{
private :
int raio ;
float centro x , centro y ;
public :
Circle ();
Circle ( float , float , int );
Circle (const Circle &);
Circle ( Circle ∗);
//
//
//
//
default
inicializador
clonagem
clonagem dinamica
˜ Circle ();
void setRadius( int );
void setCenter( float , float );
};
...
Circle circle , circle1 (1.0 f,−2.0f, 5), circle2 ( circle1 );
19 of 173
Programação Orientada a Objetos (C++)
Ponteiros para Classes referenciação dinâmica a objetos de uma classe. Uso
dos operadores new e delete.
Referenciação dinâmica através do operador ‘->’.
Parâmetro Default permite especificar um valor inicial a um parâmetro de
um método caso um valor formal não seja fornecidos no
momento da sua chamada.
Métodos inline método que não produz desvio de execução nas chamadas
(substituição de código).
20 of 173
Programação Orientada a Objetos (C++)
1
2
3
4
5
6
7
8
9
10
11
12
13
14
15
16
17
18
19
20
21
22
23
class Circle
{
private :
int raio ;
float centro x , centro y ;
public :
Circle ();
// default
Circle ( float , float , int = 1); // inicializador aceita 2 ou 3 parametros
Circle (const Circle &);
// clonagem
Circle ( Circle ∗);
// clonagem dinamica
˜ Circle ();
void setRadius( int );
inline int getRadius() { return this −>raio; }
void setCenter( float , float );
};
...
Circle ∗ ptrCircle = new Circle (), circle (−1,−1);
ptrCircle −>setRadius(10);
(∗ ptrCircle ). setCenter(−1.0f, 3.4 f );
...
delete ptrCircle ;
21 of 173
Programação Orientada a Objetos (C++)
Cabeçalho & Implementação abordagem popular para especificação do
código-fonte em um programa C++.
Etapas:
1. Criar um projeto (geralmente uma Console Application)
2. Incluir nos arquivos de cabeçalhos (*.h) apenas os protótipos
para a classe, exceto nos casos de funções inline e descrição de
templates.
Importante :! os cabeçalhos devem ser envolvidos por uma
diretiva de compilação #ifndef CONST e #endif a fim de
evitar erros de duplicidade de compilação.
3. Descrever nos arquivos de implementação (*.cpp) as
implementações para os métodos declarados nos protótipos
Pré-inicializadores em C++ é possı́vel efetuarmos inicializações de atributos
mesmo antes da execução do construtor. Para tal declara-se
na implementação do construtor uma seção com o operador
‘:’ seguido de uma lista de variáveis e seus respectivos valores
entre parênteses
22 of 173
Programação Orientada a Objetos (C++)
circle.h
1
2
3
4
5
6
7
8
9
10
11
12
13
14
15
16
17
18
19
20
21
22
circle.cpp
#ifndef CIRCLE H
#define CIRCLE H
class Circle
{
private :
int raio ;
float centro x , centro y ;
public :
Circle ();
Circle ( float , float , int = 1);
Circle (const Circle &);
Circle ( Circle ∗);
˜ Circle ();
void setRadius( int );
inline int getRadius()
{ return this −>raio; }
void setCenter( float , float );
};
#endif
23 of 173
1
2
3
4
5
6
7
8
9
10
11
12
13
14
15
16
#include ” circle .h”
Circle :: Circle () :
raio (0),
centro x (0.0 f ),
centro y (0.0 f )
{ }
...
void Circle :: setRadius( int raio )
{
this −>raio = raio;
}
...
Programação Orientada a Objetos (C++)
Sobrecarga & Polimorfismo definição de múltiplas funcionalidades para um
mesmo membro da classe. Dois tipos: método ou operador.
24 of 173
Na sobrecarga de operador, redefine-se a funcionalidade
de um operador (existente na linguagem C). Por exemplo:
operador atribuição para a classe Circle
Através do polimorfismo de método é possı́vel se definir
métodos que executem diferentes ações em diferentes
contextos.
Programação Orientada a Objetos (C++)
1
2
3
4
5
6
7
8
9
10
11
12
13
14
15
class Circle
{
private :
int raio ;
float centro x , centro y ;
public :
Circle ( float = 0.0f, float = 0.0f, int = 1); // inicializador
Circle (const Circle &);
// clonagem
Circle ( Circle ∗);
// clonagem dinamica
˜ Circle ();
Circle
bool
};
25 of 173
operator = (const Circle &);
operator == (const Circle &);
aceita ate 3 parametros
Programação Orientada a Objetos (C++)
Herança especificação de uma hierarquia de classes onde uma
classe-pai compartilha seus membros públicos e protegidos
com suas classes subordinadas.
Um classe-pai pode ter mais de uma classe subordinada, bem
como uma classe pode estar subordinada a mais de uma
classe-pai, porém não pode haver ambiguidade de herança
(ciclos).
Tipos de herança:
Pública os membros (públicos e protegidos) da classe-pai
serão todos herdados e a polı́tica de acesso será
mantida
Protegida os membros (públicos e protegidos) da classe-pai
serão todos herdados porém usando acesso
protegido
Privada os membros (públicos e protegidos) da classe-pai
serão todos herdados porém usando acesso
privado.
26 of 173
Programação Orientada a Objetos (C++)
1
2
3
4
5
6
7
8
9
10
11
12
13
14
15
16
17
18
19
class Mother {
public :
Mother ()
{ cout << ”Mother: no parameters\n”; }
Mother (int a)
{ cout << ”Mother: int parameter\n”; }
};
class Daughter : public Mother {
public :
Daughter (int a)
{ cout << ”Daughter: int parameter\n\n”; }
};
class Son : public Mother {
public :
Son ( int a) : Mother (a)
{ cout << ”Son: int parameter\n\n”; }
};
27 of 173
Programação Orientada a Objetos (C++)
Membros Estáticos (ou variáveis de classe) são membros que podem ser
consultados externamente porém só podem ser modificados
pelos próprios métodos da classe
Membros e Classes Constantes não podem ser modificados, apenas
consultados
28 of 173
Programação Orientada a Objetos (C++)
1
2
3
4
5
6
7
8
9
10
11
12
13
14
15
16
17
18
class Dummy {
public :
static int n;
Dummy () { n++; };
˜Dummy () { n−−; };
};
int Dummy::n=0;
int main () {
Dummy a;
Dummy b[5];
Dummy ∗ c = new Dummy;
cout << a.n << ’\n’;
delete c;
cout << Dummy::n << ’\n’;
return 0;
}
29 of 173
1
2
3
4
5
6
7
8
9
10
11
int main() {
const MyClass foo(10);
// invalido : x nao pode ser modificado
// foo .x = 20;
// ok: os membros da classe podem ser acessados
cout << foo.x << ’\n’;
return 0;
}
Programação Orientada a Objetos (C++)
Templates permitem a especificação de tipos parametrizáveis para
classes e membros
30 of 173
Programação Orientada a Objetos (C++)
1
2
3
4
5
6
7
8
9
10
11
#include <iostream>
using namespace std;
template <class T>
class mypair {
T a, b;
public :
mypair (T first , T second)
{a= first ; b=second;}
T getmax ();
};
31 of 173
1
2
3
4
5
6
7
template <class T>
T mypair<T>::getmax ()
{
T retval ;
retval = a>b? a : b;
return retval ;
}
1
2
3
4
5
int main () {
mypair <int> myobject (100, 75);
cout << myobject.getmax();
return 0;
}
Gerador de Documentação de Código
Ferramenta sugerida: DOXYGEN
http://www.doxygen.org/
Originalmente proposta para C++, hoje permite suporte a múltiplas
linguagens: C, Objective-C, C#, PHP, Java, Python, IDL, Fortran,
VHDL, Tcl
Suporte a Windows, Mac OS X e Linux
Três possı́veis aplicações:
1. Gerador online de documentação (HTML) e offline (LATEX, RTF, PS, PDF,
CHM, man pages)
2. Visualizador de relações entre os arquivos não documentados do
código-fonte
3. Gerador de documentação normal
32 of 173
Gerador de Documentação de Código
Uso do Doxygen para C++:
A documentação é realizada dentro de blocos especiais de comentários
definidos por:
/**
...
*/
Alternativamente, pode-se adotar o comentário por linha, como em
/// ...
//! ...
//< ...
33 of 173
Gerador de Documentação de Código
\file
\class
\brief
\param
\sa (see also)
\struct
\union
\enum
\fn (function)
\def (#define)
\typedef
\namespace
34 of 173
Gerador de Documentação de Código
1
2
3
4
5
6
7
8
9
10
11
12
13
14
15
16
17
18
19
20
21
22
23
24
25
26
27
28
29
30
/∗∗
\ file Application .h
\ brief Definicao do prototipo da classe Application para gerencimento do IDS<p>
Desenvolvido por <b>Rogerio Eduardo da Silva</b><br>
Fevereiro , 2015. Universidade do Estado de Santa Catarina (UDESC)
∗/
#include <string>
using namespace std;
/∗∗
\ class Application
\ brief Classe responsavel por
∗/
class Application
{
private :
string
strAppName,
strCurrentFPS;
unsigned int uiWindowWidth,
uiWindowHeight,
uiFrames;
double
dCounterTimer;
controlar o ambiente grafico e gerenciamento do ambiente IDS.
//! nome do titulo da janela da aplicacao
//! valor corrente ( convertido em texto) do FPS disponivel para execucao da aplicacao
//! largura da janela da aplicacao
//! altura da janela da aplicacao
//! contador de frames para o calculo do FPS
//! contador de tempo para o calculo do FPS
void setWindowSize( unsigned int , unsigned int );
/∗∗
\ brief Retorna o valor corrente da largura da janela da aplicacao
\return unsigned int o valor da largura da janela
∗/
...
35 of 173
Gerador de Documentação de Código
36 of 173
Gerador de Documentação de Código
37 of 173
Computação Gráfica (OpenGL)
1. Inicialização do ambiente GLUT
2. Inicialização do ambiente OPENGL
3. Especificação das funções de callback = tratamento de eventos
4. Execução do loop principal
Função importante! Time-based Rendering
Controle do tempo transcorrido entre duas chamadas consecutivas das
rotinas GLUT
38 of 173
Computação Gráfica (OpenGL)
1
2
3
4
5
6
7
8
9
10
11
12
13
14
15
16
17
18
19
20
21
22
23
int main( int argc , char ∗∗ argv )
{
// inicializacao do ambiente da GLUT
glutInit ( &argc, argv );
glutInitWindowSize( 1027, 768 );
glutInitDisplayMode ( GLUT RGBA | GLUT DOUBLE | GLUT DEPTH );
glutCreateWindow( ”OSIM 2015” );
OnStartGL();
// define as funcoes callback do sistema
glutDisplayFunc( OnRenderEvent );
glutReshapeFunc( OnReshapeEvent );
glutKeyboardFunc( OnKeyboardEvent );
glutSpecialFunc ( OnSpecialKeyboardEvent );
glutMouseFunc( OnMouseButtonEvent );
glutMotionFunc( OnMouseMotionEvent );
glutIdleFunc ( OnIdleEvent );
glutMainLoop();
return 1;
}
39 of 173
main.cpp
Computação Gráfica (OpenGL)
1
2
3
4
5
6
7
8
9
10
11
12
13
14
#include <time.h>
clock t LastTime = clock(); // armazena o clock da maquina no inicio da execucao do loop
...
// armazena o clock da maquina novamente na proxima execucao do loop ...
clock t currTime = clock();
// ... e calcula a diferenca de tempo entre 2 chamadas consecutivas
double elapsedTime = (( double) ( currTime − LastTime )) / CLOCKS PER SEC;
// o novo valor do clock passa a ser antigo para o calculo da proxima iteracao
LastTime = currTime;
40 of 173
Computação Gráfica (OpenGL)
41 of 173
Computação Gráfica (OpenGL)
1
2
3
4
5
6
7
8
9
10
11
12
13
14
15
16
17
18
19
20
21
22
23
24
class Application
{
private :
string
strAppName,
strCurrentFPS;
unsigned int uiWindowWidth,
uiWindowHeight,
uiFrames,
cor ;
double
dCounterTimer;
//! nome do titulo da janela da aplicacao
//! valor corrente ( convertido em texto) do FPS disponivel para execucao da aplicacao
//! largura da janela da aplicacao
//! altura da janela da aplicacao
//! contador de frames para o calculo do FPS
//! contador de tempo para o calculo do FPS
void CalculateFPS( double );
public :
Application ( string = ”OSIM 2015” );
˜Application ();
void setWindowSize( unsigned int , unsigned int );
inline unsigned int getWidth() { return this −>uiWindowWidth; }
inline unsigned int getHeight() { return this −>uiWindowHeight; }
inline string getTitle () { return this −>strAppName + ” − [” + this−>strCurrentFPS + ”]”; }
int Execute( double );
void RenderFrame();
};
Application.h
42 of 173
Computação Gráfica (OpenGL)
1
2
3
4
5
6
7
8
9
10
11
12
13
14
15
16
void OnRenderEvent()
{
ptrApp−>RenderFrame();
}
void OnIdleEvent()
{
clock t currTime = clock();
double elapsedTime = (( double) ( currTime − LastTime )) / CLOCKS PER SEC;
LastTime = currTime;
ptrApp−>Execute( elapsedTime );
glutSetWindowTitle( ptrApp−>getTitle().c str() );
glutPostRedisplay ();
}
main.cpp
43 of 173
Computação Gráfica (OpenGL)
44 of 173
Computação Gráfica (OpenGL)
1
2
3
4
5
6
7
8
9
10
11
12
13
14
15
16
17
18
19
20
21
22
23
24
Application :: Aplication () {
this −>ptrCurrentCamera = new Camera();
this −>ptrCurrentCamera−>setTranslate( Vector3( 25.0f, 5.0f, 35.0f ) );
this −>ptrCurrentCamera−>LookAt( Vector3( 0.0f, 2.0f, 0.0f ) );
}
void Application :: LoadContent()
{
BRep∗ ptrBRepFarm = new BRep( ”Farm” );
ptrBRepFarm−>LoadfromFile( string( ”obj/farm.obj” ) );
this −>addEntity( ptrBRepFarm );
BRep∗ ptrBRepCrate = new BRep( ”Crate” );
ptrBRepCrate−>LoadfromFile( string( ”obj/crate.obj” ) );
ptrBRepCrate−>setTranslate( Vector3( −3.0f, −3.8f, 2.0f ) );
ptrBRepCrate−>setRotate( Vector3( 0.0f, 60.0f, 0.0 f ) );
this −>addEntity( ptrBRepCrate );
BRep∗ ptrCrate2 = new BRep( ptrBRepCrate );
ptrCrate2−>setID( ”Crate2” );
ptrCrate2−>setTranslate( Vector3( 7.0f, −3.8f, −8.0f ) );
ptrCrate2−>setScale( Vector3( 0.75f, 0.75f , 0.75f ) );
this −>addEntity( ptrCrate2 );
}
Application.cpp
45 of 173
Computação Gráfica (OpenGL)
46 of 173
Computação Gráfica (OpenGL)
47 of 173
PROLOG
1. Inicialização do ambiente SWI-Prolog
2. Carregamento de uma base de conhecimento
3. Construção de uma base de conhecimento (*.pl) com fatos e regras
O que são predicados dinâmicos ?
4. Operações de Assert e Retract
5. Consultas à base de conhecimento
48 of 173
PROLOG
1
2
3
4
5
6
7
8
9
10
11
12
13
14
15
16
17
18
19
20
// inicializa o ambiente PROLOG
putenv( ”SWI HOME DIR=C:\\Program Files (x86)\\pl\\” );
ptrPrologEngine = new PlEngine( ”C:\\Program Files (x86)\\pl\\” );
loadPL( ”kb. pl ” );
...
assertPL( ”fato (barata , nojento )” ); // adiciona fatos na base de conhecimento ativa
retractPL( ”fato (bola , divertido )” ); // remove fatos da base de conhecimento ativa
...
// consulta um fato na base de conhecimento ativa
PlTermv t(2);
PlQuery Consult( ”acao ”, t );
while ( Consult. next solution () )
{
// DO SOMETHING HERE!
printf ( ”%s %s\n”, ( char∗ )t [0], ( char∗ )t [1] );
}
PrologEngine.cpp
49 of 173
PROLOG
1
2
3
4
5
6
7
8
9
10
11
% define um fato dinamico. Fatos dinamicos podem ser modificados via operaoes de
% ASSERT e RETRACT
:−dynamic(fato/2).
fato (casa, grande).
fato (bola , divertido ).
acao( fugir , QUEM) :− fato(QUEM, nojento).
acao(pegar, QUEM) :− fato(QUEM, divertido).
acao(olhar , QUEM) :− fato(QUEM, grande).
kb.pl
50 of 173
Agentes Inteligentes
Introduç~
ao
51 of 173
O que são agentes?
52 of 173
O que são agentes?
“Agentes autônomos são sistemas computacionais que habitam um
ambiente dinâmico e complexo, onde percebem e agem
autonomamente neste ambiente e, fazendo isso, executam uma série
de tarefas ou objetivos para os quais foram projetados.”
53 of 173
O que são agentes?
“Um agente é qualquer coisa que possa perceber um ambiente através
de sensores e atuar nele através de atuadores”
54 of 173
Para que servem agentes?
Resolver problemas simples de forma autônoma e eficiente.
Exemplos de aplicações:
Animações Digitais - Digital Extras, Atores Digitais Autônomos
Jogos Computacionais - Non-Player Characters
Robótica - Brinquedos eletrônicos
Automação e Controle - Monitoramento de Máquinas, Serviços,
Indústria, etc.
Assistentes Virtuais - Sites de Compras, Buscas Online, ...
55 of 173
Para que servem Sistemas Multi-Agentes?
Resolução de problemas complexos através da coordenação de múltiplos
esforços individuais de um(vários) grupo(s) de agentes.
Exemplos:
56 of 173
Simulação
Automação e controle
Sistemas distribuı́dos
Video “Robotcup”: 9m23s
57 of 173
Agentes Inteligentes
Ambientes
58 of 173
Tipos de Agentes
Reativos: estı́mulo ⇒ resposta
Deliberativos: estı́mulo ⇒ inferência ⇒ seleção ⇒ resposta
59 of 173
Ambientes
É uma memória compartilhada por todos os agentes que de forma ativa e
independente torna possı́vel a coordenação decentralizada de ações.
É qualquer especificação (fı́sica ou virtual) que age como produtora de
estı́mulos e receptora de ações.
Algumas dimensões de representação de ambientes:
60 of 173
Dinâmicos vs. Estáticos
Persistentes vs. Amnésicos
Fı́sicos vs. Virtuais
Acessı́vel vs Inacessı́vel
Determinı́stico vs Não-determinı́stico
Ambientes
Dinâmicos vs. Estáticos
Um ambiente (E ) é dito ser estático em relação a um agente (A) se os
estı́mulos recebidos por A a partir de E dependem exclusivamente das
ações realizadas por A em E .
Ambientes dinâmicos mudam autonomamente (não dependente da ação
do agente).
Exemplo:
estático Acionamento de uma lâmpada através de um botão
dinâmico Acionamento de uma lâmpada através de um sensor de
luminosidade
61 of 173
Ambientes
Persistente/Amnésico
Um ambiente (E ) é dito ser persistente se os estı́mulos produzidos por E
não dependem somente das ações imediatamente anteriores recebidas em
E.
Exemplo:
persistente Acionamento de uma lâmpada através de um botão
amnésico Cantar para um auditório
62 of 173
Ambientes
Fı́sico/Virtual
Um ambiente (E ) é dito ser fı́sico se somente pode ser observador por
sensores analógicos e virtual se pode ser digitalmente acessado.
63 of 173
Ambientes
Acessı́vel/Inacessı́vel
Um ambiente (E ) é dito ser acessı́vel a um agente (A) se este puder
produzir ações/receber estı́mulos sobre todo o ambiente (E ), e inacessı́vel
se apenas puder fazê-lo sobre parte deste.
Exemplo:
acessı́vel Ser o motorista de um carro.
inacessı́vel Ser o passageiro de um carro.
64 of 173
Ambientes
Determinı́stico/Não-determinı́stico
Um ambiente (E ) é dito ser determinı́stico se for possı́vel a um agente
(A) prever a resposta produzida por (E ) para um dada ação.
Exemplo:
determinı́stico Cair ao andar além da borda de um penhasco.
não-determinı́stico Passar de fase ao andar além da borda de um
penhasco.
65 of 173
Interação com Ambientes
Interação é a troca de dados entre participantes (agentes ou ambientes)
de tal forma que a resposta de cada participante possa afetar seus futuros
estı́mulos.
Exemplos:
interativo Controlar um personagem em um ambiente de jogo
não-interativo Falar com a personagem da TV
Aspecto essencial para o entretenimento digital
66 of 173
Interação com Ambientes
Tipos de Interação
Direta Diz-se que dois participantes A e B estão involvidos em
interação direta quando uma ação produzida por um dos
participantes seja a causa primária da reação produzida no
outro
Indireta Ocorre quando um participante A produz reações em outro
participante B através da ação aplicada em um terceiro
participante C (intermediário)
Exemplos:
A empurra B e este cai no chão
A abre a porta e B entra na sala
A atira em B e B morre
AMBIENTES PRECISAM SER PERSISTENTES PARA PERMITIR
INTERAÇÃO INDIRETA
67 of 173
Interação com Ambientes
Formas de Interação
Sequencial Ocorre quando um único fluxo de interação
(estı́mulos/respostas) é produzido entre dois participantes
Assı́ncrono Ocorre quando múltiplos participantes geram fluxos de
interação entre si e com o ambiente
68 of 173
Ambientes - Exercı́cios
Classifique os ambientes abaixo em função das 5 dimensões vistas:
1. Jogo de xadrez
2. Jogo de video-game
3. Assistir a um filme
4. Sortear números em uma roleta
69 of 173
Ambientes - Exercı́cios
Classifique os ambientes abaixo em função das 5 dimensões vistas:
1. Jogo de xadrez
Dinâmico, Persistente, Fı́sico, Acessı́vel, Determinı́stico, Interativo
2. Jogo de video-game
Dinâmico, Persistente, Virtual, Inacessı́vel, Determinı́stico, Interativo
3. Assistir a um filme
Estático, Persistente, Virtual, Inacessı́vel, Não-Determinı́stico,
Não-Interativo
4. Sortear números em uma roleta
70 of 173
Estático, Amnésico, Fı́sico, Acessivel, Determinı́stico, Não-Interativo
Representação de Ambientes
Descrição computacional do ambiente em termos de seus componentes,
estados correntes, atributos e métodos (funções).
Discretos descreve o ambiente como um conjunto de ‘células’ que
contêm um elemento (ou parte de) do ambiente.
Tabuleiros (Boards)
Baseados em ‘azulejos’ (Tile-based)
Baseados em sub-volumes (Voxel-based)
Contı́nuos descreve o ambiente através de informações
semânticas/gráficas/geométricas dos elementos que o
compõe.
Modelagem Hierárquica
Particionamento Espacial Binário (Binary-Space Partition BSP)
Quadtree e Octree
71 of 173
Representação de Ambientes - Discretos
72 of 173
Representação de Ambientes - Discretos
Representação: Tile-based
73 of 173
Representação de Ambientes - Contı́nuos
74 of 173
Representação de Ambientes - Contı́nuos
Representação: Modelagem Hierárquica
1. Casa: [Posição (0, 0, 0); Dimensões (100, 100, 100)]
1.1 Sala: [Posição (0, 0, 0); Dimensões (10, 10, 5)]
1.1.1 Sofá: [Posição (1, 1, 0); Dimensões (2, 1, 1)]
1.1.2 Mesa de Centro: [Posição (5, 1, 0); Dimensões (1, 0.5, 0.5)]
1.2 Quarto: [Posição (10, 0, 0); Dimensões (10, 10, 5)]
1.2.1 Cama: [Posição (1, 0, 0); Dimensões (1.8, 2.2, 0.8)]
1.2.2 Guarda-Roupa: [Posição (9, 1, 0); Dimensões (3, 1, 3)]
75 of 173
Representação de Ambientes
Gerenciamento de Processos
1. initializeEnvironment()
2. displayEnvironment()
3. while( not endOfExecution )
3.1
3.2
3.3
3.4
getSystemMessages()
processSystemMessages()
processAgents()
displayEnvironment()
4. finalizeEnvironment()
76 of 173
Representação do Conhecimento
“Representação do Conhecimento e Raciocı́nio é a área da Inteligência
Artificial dedicada à como conhecimento pode ser representado
simbolicamente e manipulado de formas autônomas através de programas
de raciocı́nio”
Alguns exemplos clássicos:
77 of 173
Lógica de Primeira Ordem
Regras em Sistemas de Produção
Representação Orientada a Objetos
Lógica Nebulosa
Vetores de Classificação
Representação do Conhecimento
Lógica de Primeira Ordem conhecimento é representado através de fatos e
regras. Exemplo:
printColor(X) :- color(X,Y), !, write("It’s "), write(Y), write(".").
printColor(X) :- write("Beats me").
color(snow, white).
color(sky, blue).
color(X,Y) :- madeof(X,Z), color(Z,Y).
madeof(grass, vegetation).
color(vegetation, green).
78 of 173
Representação do Conhecimento
Regras em Sistemas de Produção conhecimento é representado através de
regras da forma
Se condição Então Ação
O processo é dividido em três etapas:
1. Reconhecimento: etapa onde cada uma das regras é avaliada a fim de se
encontrar aquelas ‘aplicáveis’ ao contexto corrente
2. Resolução de Conflito: escolher, entre as regras ativadas na etapa
anterior, aquela que deve ser executada
3. Ação: executar a regra selecionada, alterando os estados corrente da
memória
79 of 173
Representação do Conhecimento
Representação Orientada a Objetos conhecimento é representado através de
hierarquia de classes e objetos por operações como
associações, especializações e generalizações.
Exemplo: Transporte
Transporte Aéreo
Avião
Balão de Ar Quente
Transporte Fluvial
Canoa
Navio
Paraglider
Jet-sky
Transporte Terrestre
Por estrada
Carro
Caminhão
Motocicleta
Por trilho
Trem
Metrô
80 of 173
Representação de Conhecimento
Lógica Nebulosa lógica na qual se permite a categorização de atributos em
conjuntos de forma a modelar a incerteza através de conjuntos
nebulosos (ou Fuzzy Sets). Essa teoria define que um dado
atributo α apresenta grau de pertinência (δ) a certo conjunto
nebuloso através de uma função dada por:
δ = µ(α)
◦
Exemplo: a temperatura 30 C pode ser categorizado como
δ = {0/frio; 0.3/morno; 0.3/quente} conforme demonstrado pela
figura abaixo:
81 of 173
Representação de Conhecimento
Lógica Nebulosa o processo para se raciocinar a partir de lógica nebulosa
segue quatro passos:
1. Fuzzificação: determina-se o grau de pertinência das variáveis de interesse δ = µ(α)
para cada conjunto nebuloso
2. Avaliação: utilizando os graus de pertinência obtidos, avalia quais regras na base de
conhecimento são ativadas. Uma regra nebulosa é da forma
se saude é baixo e armadura é mdio então risco é alto
onde cada par atributo é valor é substituı́do por seu respectivo grau de pertinência.
Operações lógica “e” representa o mı́nimo entre os operadores, enquanto que a
operação “ou” representa o máximo entre eles.
3. Composição: dado os resultados da avaliação das regras, utiliza-se o grau de
pertinência do atributo de saı́da como ‘linha de corte’ no gráfico do conjunto Fuzzy
produzindo um novo polı́gono de saı́da (ver Figura no próximo slide)
4. Defuzzificação: encontra-se o centro de gravidade do polı́gono resultante por
Pb
µ(x)x
G = Px=a
b
x=a µ(x)
82 of 173
Representação de Conhecimento
83 of 173
Vetores de Classificação
84 of 173
Memórias
Memória Episódica também chamada de autobiográfica permite o
armazenamento das situações experimentadas, seus efeitos e
recorda situações semelhantes. Está associada a lugares e
momentos particulares. Exemplo: “assisti um filme na minha
casa semana passada comendo pipoca”
Memória Semântica organiza o conhecimento de sı́mbolos verbais, regras,
fórmulas, algoritmos, inferência, generalização, entre outros.
A memória semântica é responsável por manipular e dar
sentido às informações episódicas. Exemplo: “o nome do
diretor do filme era Martin Scorsese” ou “o que significa
‘chuva’ ?”
Memória Procedural representa o conhecimento acerca do repertório de
ações do agente, ou seja: “como fazer” determinadas ações.
Exemplo: “para caminhar mova as pernas e os braços de
forma sincronizada e alternada”
85 of 173
Agentes Reativos
Arquiteturas
86 of 173
Agentes Reativos
A forma mais simples de representação de agentes (também chamados de
reflexivos)
Mecanismo de funcionamento: estı́mulo = resposta
Não possui qualquer tipo de armazenamento de informação = sem
memória
Tem por objetivo modelar reações instintivas ao invés de pensamento
crı́tico
Construção de agentes baseados em quatro módulos principais:
Percepção responsável por detectar estı́mulos do ambiente, através de
sensores
Inferência responsável por determinar um conjunto de ‘ações
plausı́veis’ como resposta ao estı́mulo detectado
Seleção determina a ordem de prioridade de execução entre as
ações produzidas na inferência
Ação executa as ações no ambiente (através de atuadores)
87 of 173
Agentes Reativos
88 of 173
Agentes Reativos - Módulo: Percepção
1. Capta estı́mulos do ambiente
2. Analisa caracterı́sticas do estı́mulo detectado
3. Compara com uma base de conhecimento de experiências prévias
4. Determina a experiência prévia mais similar ao estı́mulo sob análise
5. Associa a informação da experiência prévia ao estı́mulo
6. Produz um novo percept (estı́mulo + informações semânticas)
7. Envia o percept para o módulo de inferência
Exemplo: estı́mulo = “criatura de quatro patas, 2 orelhas, rabo balançante,
porte pequeno”
Americano: percept = dog
Brasileiro: percept = c~
ao
Criança de 2 anos: percept = vaca
89 of 173
Agentes Reativos - Módulo: Percepção
Emulação de Sensores: simulação de um campo visual (distância e
ângulo) onde, caso uma entidade seja detectada, é considerado ‘sentido’
pelo agente
Tipos clássicos de sensores: visão, audição
Exemplo de percept: see( dog )
90 of 173
Agentes Reativos - Módulo: Inferência
É um conjunto de regras da forma “if percept then action” que
representam o conhecimento do agente
Uma ação é relativa às capacidades do agente de executar ações através
de seus atuadores: andar, piscar, emitir sons, alterar estados internos, etc.
Exemplo:
if see(dog) then action(run)
Um agente pode ativar múltiplas ações a cada instante de tempo, em
função de diferentes percepts ou de diferentes abordagens para responder
a um mesmo percept.
A lista de ações inferidas por este módulo é denominada “lista de ações
plausı́veis” e é posteriormente enviada ao módulo de seleção
91 of 173
Agentes Reativos - Módulo: Seleção
Implementa algum critério de tomada de decisão em relação às
múltiplas ações plausı́veis escolhidas pelo módulo anterior
Em um agente reativo um critério simples como FIFO - First-in First-out
pode ser adotado
Alternativamente, uma escolha aleatória pode ser realizada
Critérios mais sofisticados serão estudados posteriormente.
92 of 173
Agentes Reativos - Módulo: Ação
Executa a ação seleciona pelo módulo anterior
Abordagem tradicional em aplicações interativas: procedures
Cada ação é pré-implementada como um procedimento parametrizável.
Por exemplo: andar(X, Y)
A execução de uma ação pode acarretar dois tipos de consequências:
Internas quando apenas estados internos ao agente são modificados
Externas quando o ambiente no qual o agente está inserido é
modificado
No caso de ações externas, o agente envia uma mensagem de requisição
de alteração ao ambiente, que processa esta requisição e devolve uma
resposta ao agente (p.ex.: a nova configuração do ambiente).
93 of 173
Agentes Reativos - Implementação
94 of 173
Agentes Reativos - Implementação com Python
1
2
3
4
5
6
7
8
9
10
11
12
13
14
15
16
17
18
19
20
21
22
23
24
25
26
27
28
class Agent:
distance = 1
angle = 60
position = [10, 4]
direction = [1, 0]
def Sensors( self , env ):
percept = {}
for entity in env. listOfEntities :
if distance ( self , entity ) < distance and dotProduct(vecToEntity, direction ):
percept = { ’type ’: ’ vision ’, ’ value ’: entity . type }
return percept
def Inference ( self , percept ):
listOfPlausibleActions = []
if percept [’ type ’] == ’vision’ and percept [’ value ’] == ’dog’:
listOfPlausibleActions .append( ’run’ )
return listOfPlausileActions
def Selection ( self , listOfPlausibleActions
return listOfPlausibleActions [0]
):
def Action( self , selectedAction ):
if selectedAction == ’run’:
run()
def Update( self , env ):
Action( Selection ( Inference ( Sensor( env )))
95 of 173
Agentes Reativos - Implementação com Blender
96 of 173
Agentes Reativos - Implementação com Blender
97 of 173
Agentes Reativos - Implementação com Blender
29
30
31
32
33
34
35
36
37
38
39
40
41
42
43
44
45
46
47
48
49
50
51
52
53
54
55
56
57
58
59
60
61
import bge
import random
def getWaypoints(scene):
list = []
for obj in scene . objects :
if ’wp’ in obj :
list .append(obj)
return list
def main():
cont = bge.logic . getCurrentController ()
own = cont.owner
sens
sens
sens
sens
actu
onWaypoint = cont.sensors [’ onWaypoint’]
onRedPortal = cont.sensors [’ onRedPortal’]
onGreenPortal = cont.sensors [’ onGreenPortal ’]
onBluePortal = cont.sensors [’ onBluePortal ’]
seekWaypoint = cont.actuators [’ seekWaypoint’]
if sens onWaypoint. positive :
wpList = getWaypoints(bge.logic.getCurrentScene())
idx = random.randint(0,len(wpList)−1)
actu seekWaypoint.target = wpList[idx ]
cont. activate (actu seekWaypoint)
if sens onRedPortal. positive :
own.color = [1,0,0,1]
if sens onGreenPortal . positive :
own.color = [0,1,0,1]
if sens onBluePortal . positive :
own.color = [0,0,1,1]
main()
98 of 173
Agentes Reativos com Gatilhos
Ou Trigger-based Agents são agentes reativos com estados internos que
funcionam como uma espécie de ‘memória primitiva’
Tem por objetivo modelar reações instintivas com base em estados
correntes (máquina de estados finitos - FSM)
Mecanismo de funcionamento: estı́mulo + FSM = resposta
Construção de agentes baseados em quatro módulos principais:
Percepção responsável por detectar tanto estı́mulos do ambiente
(através de sensores) quanto internos (através de query)
Inferência idem ao anterior porém consideram também os estados
internos
Seleção idem ao anterior
Ação permitem tanto ações internas (mudanças do estado
corrente) quanto externas (requisições ao ambiente)
99 of 173
Agentes Reativos com Gatilhos
Exemplo de regra com gatilhos:
if hear(noise) and state(awake) then action(run)
100 of 173
Agentes Reativos com Gatilhos
101 of 173
Agentes com Gatilhos - Implementação com Blender
102 of 173
Agentes com Gatilhos - Implementação com Blender
103 of 173
Agentes com Gatilhos - Implementação com Blender
62
63
64
65
66
67
68
69
70
71
72
73
74
75
76
77
78
79
80
81
82
83
84
85
86
87
88
maxEnergyLevel = 1000
generateWP = bEmergency = False
own[’energy ’] = own[’energy’] − 1
if sens isRunningLow. positive :
bEmergency = True
own.color ∗= own[’energy’]/maxEnergyLevel
powersource = getObjectsWithProp(bge.logic.getCurrentScene(), ’powersource’)
actu seekWaypoint.target = powersource[0]
cont. activate (actu seekWaypoint)
if sens onPowerSource. positive :
own[’energy ’] = maxEnergyLevel
own.color = [1,1,1,1]
generateWP = True
bEmergency = False
if not bEmergency and sens onWaypoint.positive or generateWP:
wpList = getObjectsWithProp(bge.logic.getCurrentScene(), ’wp’)
idx = random.randint(0,len(wpList)−1)
actu seekWaypoint.target = wpList[idx ]
cont. activate (actu seekWaypoint)
if not bEmergency and sens onRedPortal.positive :
own.color = [1,0,0,1]
if not bEmergency and sens onGreenPortal.positive :
own.color = [0,1,0,1]
if not bEmergency and sens onBluePortal. positive :
own.color = [0,0,1,1]
104 of 173
Agentes baseados em Objetivos
ou Goal-based Agents definem estados internos preferenciais
denominados objetivos.
Escolhe uma sequência de ações (plano) que fazem o agente ir do estado
corrente para o estado preferencial.
Exemplo:
Regra #1: se ouvir(som) então objetivo(avisar outros)
Regra #2: se objetivo(avisar outros) então objetivo(ativar alarme)
Regra #3: se objetivo(avisar outros) então objetivo(usar radio)
Regra #4: se objetivo(ativar alarme) então plano(localizar alarme,
andar ate alarme, acionar alarme)
Regra #5: se objetivo(usar radio) então plano(pegar radio,
selecionar frequencia, chamar ajuda)
Regra #6: se plano(X,Y,Z) então ação(X), ação(Y), ação(Z)
Regra #7: se ouvir(alarme) então não objetivo(ativar alarme)
105 of 173
Agentes baseados em Objetivos
106 of 173
Agentes baseados em Objetivos
107 of 173
Agentes baseados em Objetivos
108 of 173
Agentes baseados em Objetivos
Tipos de Objetivos:
Perform Goals: especifica ações a serem executadas.
Possı́veis estados:
Falha = nenhuma ação no plano pode ser executada
Em Andamento = um plano está em execução
Sucesso = um plano foi concluı́do
Exemplos:
Patrulhar ambiente
Cumprimentar agente
109 of 173
Agentes baseados em Objetivos
Tipos de Objetivos:
Achieve Goals: representa objetivos no sentido tradicional, ou seja, estados
futuros desejáveis.
É definido por uma target condition que indica quando
desejar o objetivo e uma failure condition que indica quando
desistir de um objetivo.
Exemplos:
Limpar a casa
110 of 173
target condition = casa está suja;
failure condition = nı́vel da bateria baixo
Agentes baseados em Objetivos
Tipos de Objetivos:
Query Goals: usado para verificar informação sobre um tema especı́fico.
Tı́pica ação em um plano para consulta é “coletar informação
sobre. . . ”
Exemplos:
Quanta bateria me resta?
Onde fica o cesto de lixo mais próximo?
111 of 173
Agentes baseados em Objetivos
Tipos de Objetivos:
Maintain Goals: tenta manter o agente em uma dada condição desejada.
Diferente dos outros objetivos, o objetivo manutenção assume
apenas dois estados:
Inerte quando a condição desejada é válida
Ativo caso contrário.
Não existe falha.
Exemplos:
Manter carga da bateria acima de 20
112 of 173
Agentes baseados em Objetivos
113 of 173
Agentes baseados em Utilidade
114 of 173
Agentes baseados em Utilidade
Utilidade significa associar valor a coisas.
O que vale mais: procurar comida ou fugir de predadores?
utility (objeto) = valor
Maximum Expected Utility
MEU(opcoes) = escolha
Onde utilizar o critério da MEU?
Escolha do melhor objetivo a seguir
Escolha do melhor plano para atingir um objetivo
Problema! utility-based agents podem (se muito complexos) demorar para
avaliar o melhor plano a seguir, até lá o ambiente pode já ter mudado e a
escolha se tornar inaplicável.
115 of 173
Agentes Qualquer Tempo
116 of 173
Agentes Deliberativos
Arquiteturas
117 of 173
Agentes Deliberativos
Agentes Deliberativos (ou cognitivos) se baseiam no fato de que
consideram aspectos da cognição humana (metáforas computacionais) no
processo de decisão
Processo deliberativo:
Percepção detecção de informações do mundo e/ou do próprio agente
Atitudes Mentais (em substituição à inferência + seleção) representa um
conjunto de etapas intermediárias formuladas pelo agente,
responsável por construir uma metáfora computacional ao
processo do raciocı́nio simbólico
Ação execução de ações que afetam tanto o agente em si,
quanto o ambiente no qual ele está inserido.
118 of 173
Agentes Deliberativos
119 of 173
Agentes Deliberativos
Atitudes Mentais são o conjunto de modelos computacionais que
pretendem modelar metáforas computacionais para determinados
aspectos da cognição humana, livremente inspirados nas teorias da
Psicologia Computacional
120 of 173
Agentes Deliberativos - Exemplos
Personalidade padrões de pensamento, atitudes e comportamentos que são
permanentes ou, ao menos, variam muito lentamente
Emoção reações psico-fisiológicas resultantes da avaliação do contexto
Tomada de Decisão define processos/critérios para avaliação de situações,
riscos e consequências para definição de estados mais
adequados a um objetivo especı́fico
Aprendizagem modelos para incorporação de novos conhecimentos à base de
conhecimento do agente. Tipos: supervionada,
não-supervisiona e por reforço
Memória modelos para armazenamento/recuperação do conhecimento
do agente. Tipos: episódica, semântica e procedimental
121 of 173
Agentes BDI
Um exemplo de agente deliberativo que se baseia na composição de três
atitides mentais:
Crenças (Beliefs) representa o conjunto de informações
armazenadas pelo agente acerca do ambiente e do
problema sendo resolvido
Desejos (Desires) representa o conjunto de estados-objetivos
(goals) que motivam o agente a agir de uma forma
especı́fica
Intenções (Intentions) representa o conjunto de ações (deliberações)
produzidas pelo agente afim de alcançar determinados
objetivos (com base no seu conjunto atual de crenças)
122 of 173
Agentes BDI - Crenças
Representa um conjunto de estados e/ou eventos que descrevem o
ambiente (em um dado momento) no qual o agente está inserido
Este conjunto apresenta uma correlação direta com os percepts
provenientes das rotinas de percepção (tanto externas quanto internas)
Crenças são subdividas em três tipos:
Objetos descreve caracterı́sticas e/ou estados de um objeto
Agentes descreve caracterı́sticas e/ou estados de um agente (que
pode ser self)
Eventos detecta a ocorrência de um evento
Exemplos de crenças:
Nı́vel de energia da bateria é igual a 28
Última posição conhecida do objeto bola é (5, 0, 0)
O agente ’policial’ entrou na delegacia
Foi detectado o acionar de um alarme no ambiente
123 of 173
Agentes BDI - Desejos
Funciona de forma análoga aos agentes baseados em objetivos
(goal-based agents) vistos anteriormente
Um desejo é um estado especial ao qual o agente ’deseja’ alcançar e para
tal, pode vir a definir um plano de ações
Importante: não existe a obrigatoriedade de satisfazer todos os desejos de
um agente
Desejos também podem ser classificados em: achieve, perform, query e
maintain
Exemplos de desejos:
Ir para a sala de televisão
Conversar com o agente ’policial’
Pegar o objeto bola no chão
Manter o nı́vel de energia acima de 100
124 of 173
Agentes BDI - Intenções
São estados especiais do agente aos quais (devido a algum processo
deliberativo) ele se compromete a alcançar
Intenções são o resultado da combinação das crenças atuais do agente
com seus desejos
Inew = B × D × Icurrent
Uma abordagem clássica é representar o processo deliberativo como uma
árvore de decisão, onde os estados internos representam as crenças do
agente e as folha representam seus objetivos. Nessa estrutura, o ramo
selecionado da árvore representa uma intenção a ser executada
Importante: a cada objetivo está associado um (ou até mais) planos de
ações
125 of 173
Agentes BDI - Algoritmo
1
2
3
4
5
6
7
8
9
10
11
initialize state ()
repeat
options = options−generation(event queue)
selected options = deliberate (options)
update intentions ( selected options )
execute()
get new external events ()
drop successfull attitudes ()
drop impossible attitudes ()
end−repeat
126 of 173
Agentes BDI - Exercı́cio
Construir um programa (em Blender3D) sobre um agente ’Pessoa’
vivendo em uma vila
A vila é composta por:
Casa
Restaurante
Praça
Cinema
local
local
local
local
onde o agente vai para descansar e/ou procurar abrigo
o agente vai para se alimentar
onde o agente passa seu tempo para se divertir
alternativo onde o agente vai para se divertir
O agente possui os seguintes desejos: ’divertir-se’, ’alimentar-se’,
’descansar’, ’estar protegido’
Repertório sugerido de ações2 : ’caminhar na praça’, ’entrar no
restaurante’, ’comer’, ’entrar no cinema’, ’assistir filme’, ’entrar em casa’
O ambiente controla: dia/noite (intervalos regulares), sol/chuva
(intervalos aleatórios)
2 Novas
127 of 173
ações podem ser sugeridas pelo aluno se necessário
Agentes BDI - Exercı́cio - Ontologia
1. Lista de crenças - B
2. Lista de desejos - D
3. Lista de intenções - I
4. Descrição comportamental
128 of 173
Agentes BDI - Exercı́cio - Ontologia
1. Lista de crenças - B
1.1
1.2
1.3
1.4
1.5
O agente está cansado
O agente está com fome
O agente está entediado
Está chovendo?
É dia
2. Lista de desejos - D
3. Lista de intenções - I
4. Descrição comportamental
129 of 173
Agentes BDI - Exercı́cio - Ontologia
1. Lista de crenças - B
1.1
1.2
1.3
1.4
O agente está cansado
O agente está com fome
O agente está entediado
Está chovendo?
1.5 É dia
2. Lista de desejos - D
2.1
2.2
2.3
2.4
Estar descansado
Estar seguro
Estar saciado
Não estar entediado
3. Lista de intenções - I
4. Descrição comportamental
130 of 173
Agentes BDI - Exercı́cio - Ontologia
1. Lista de crenças - B
1.1
1.2
1.3
1.4
O agente está cansado
O agente está com fome
O agente está entediado
Está chovendo?
1.5 É dia
2. Lista de desejos - D
2.1 Estar descansado
2.2 Estar seguro
2.3 Estar saciado
2.4 Não estar entediado
3. Lista de intenções - I
3.1
3.2
3.3
3.4
O
O
O
O
agente
agente
agente
agente
vai
vai
vai
vai
descansar
se proteger
comer
se divertir
4. Descrição comportamental
131 of 173
Agentes BDI - Exercı́cio - Ontologia
1. Lista de crenças - B
1.1
1.2
1.3
1.4
O agente está cansado
O agente está com fome
O agente está entediado
Está chovendo?
1.5 É dia
2. Lista de desejos - D
2.1 Estar descansado
2.2 Estar seguro
2.3 Estar saciado
2.4 Não estar entediado
3. Lista de intenções - I
3.1 O agente vai descansar
3.2 O agente vai se proteger
3.3 O agente vai comer
3.4 O agente vai se divertir
4. Descrição comportamental
4.1 I1 → D1 ∧ ((B1 ∧ ∼ B2 )∨ ∼ B5 )
4.2 I2 → D2 ∧ (B4 ∨ ∼ B5 )
4.3 I3 → D3 ∧ B2
4.4 I4 → D4 ∧ (∼ B1 ∧ ∼ B2 ∧ B3 )
132 of 173
Agentes EBDI
Uma limitação aos agentes BDI é o fato de apenas considerar o aspecto
decisório, desconsiderando por completo outras atitudes mentais naturais
da cognição humana.
Um exemplo são as emoções
Os agentes EBDI representam um melhoramento aos agentes BDI, dado
que incorporam emoções ao modelo já estudado.
Emoções são reações cognitivas para situações familiares ao agente.
Podem ser classificadas em dois grupos:
Emoções Primárias emoções reativas que agem como “filtros” ajustando
a prioridade das crenças do agente
Emoções Secundárias são as emoções que resultam de processos mais
elaborados de avaliação cognitiva, onde experiências
prévias do agente, bem como atitudes mentais de mais
alta ordem (como personalidade) são consideradas
133 of 173
Agentes EBDI
1
2
3
4
5
6
7
8
9
10
11
12
13
14
15
16
17
18
19
20
21
E = E0
B = B0
I = I0
// initial emotions
// initial beliefs
// initial intentions
while true
Bp = brf−see( Environment )
Bm = brf−msg( Content )
E = euf1( E, I , Bp + Bm )
B = brf−in( E, I , B + Bp + Bm )
D = options( B, I )
I = filter ( E, B, D, I )
E’ = E
E = euf2( E, I , B )
if time permits and E != E’ then
B = brf−in( E, I , B )
D = options( B, I )
I = filter ( E, B, D, I )
end−if
P = plan( I , Ac )
execute( P )
end−while
134 of 173
Agentes EBDI
brf-see mapeia as percepções provenientes do ambientes em crenças
brf-msg mapeia mensagens de comunicação recebidas pelo agentes em
crenças
euf1 define as emoções primárias com base nas crenças produzidas
anteriormente
brf-in função de revisão da base de crenças iniciais em relação às
novas atitudes mentais produzidas
options relaciona as crenças com as intenções para definir novos
desejos a serem alcançados
filter filtra a base de regras de intenções em função das atitudes
mentais atualizadas
euf2 define as emoções secundárias
plan constroi um plano de ações com base nas intenções ativas e
no repertório de ações (Ac) do agente
execute executa as ações no plano ativo
135 of 173
Abordagens Multi-Agentes
136 of 173
Sistemas Multi-Agentes
Problemas complexos geralmente demandam a execução de um grande
número de passos, envolvendo a aplicação de uma grande diversidade de
conhecimentos especı́ficos.
Sistemas multi-agentes (SMA) trabalham através da coordenação de
múltiplos agentes criados para resolver problemas especı́ficos ⇒ “Role
playing strategy”
Duas grandes abordagens
1. SMA descentralizado
2. SMA centralizado
137 of 173
SMA Descentralizado
Cada agente é capaz de comunicar-se com outros agentes próximos
através de um protocolo de comunicação previamente estabelecido.
138 of 173
SMA Centralizado
Agem colaborativamente através do compartilhamento de recursos
Memória: todos os agentes apresentam um único modelo mental do
ambiente.
Modelo deliberativo: a deliberação de ações é feita ou por um agente
central ou por um processo colaborativo.
139 of 173
SMA Centralizado - Blackboard
Analogia a um quadro negro = ‘o que um escreve, todos vêem’
Cada agente tem seu conjunto de sensores do ambiente, porém,
compartilham uma memória relativamente ao processo cognitivo
Deliberação única a partir da composição dos percepts de todos
140 of 173
SMA Centralizado - Deliberador Central
Implementa o conceito de ‘agente chefe’
Cada agente tem seu conjunto de sensores que (quando requisitados)
alimentam o modelo mental de um agente centralizador que delibera para
o grupo
O agente centralizador também pode ter seu próprio conjunto de sensores
141 of 173
SMA Centralizado - Leilão
Uma variante ao modelo de deliberação central onde todos os agentes
podem ‘dar um lance’
Cada agente tem seu conjunto de sensores e modelos mentais
O agente centralizador é responsável por propor planos alternativos e
contabilizar os lances dados e definir o ‘vencedor’
142 of 173
SMA Centralizado - Votação
Nesta abordagem a deliberação é descentralizada.
Cada agente pode sugerir um plano de ação a ser tomado pelo grupo
Todos os agentes ‘votam’ nos planos
O agente centralizador é responsável por contabilizar os votos dados e
definir o ‘vencedor’
143 of 173
Aplicação de Estudo
Storytelling Interativo
144 of 173
Psicologia Computacional
Emoção
Personalidade
Tomada de Decisão
Representação de Conhecimento
145 of 173
O que é Psicologia Computacional?
É uma nova área interdisciplinar de pesquisa que envolve estudar os
modelos das ‘ciências cognitivas’: filosofia, psicologia experimental,
linguı́stica, antropologia, neurociência e aplicá-los a áreas da computação
como inteligência artificial
Envolve aspectos amplos como:
Paradigmas da Modelagem Cognitiva Conexionista, Modelos Bayesianos,
Sistemas Dinâmicos, Modelos Declarativos (baseados em
lógica), Restrições
Modelos Cognitivos Memória Episódica, Memória Semântica, Categorização,
Tomada de Decisão, Raciocı́nio Indutivo,
Raciocı́nio Dedutivo (atitudes mentais), Competências e
Habilidades, Modelos de Aprendizagem Implı́cita, Modelos de
Atenção e Foco, Psicologia do Desenvolvimento,
Psico-linguı́stica, Personalidade e Desenvolvimento Social,
Processamento da Informação Visual, Controle Motor, etc.
146 of 173
Emoções
Computação Afetiva é definida como “a parte da computação que se relaciona
com, surge das, ou deliberadamente influencia as emoções”
Emoção reação fisiológica/cognitiva à interpretação de estı́mulos externos
(fisiologia vs cognição)
Agentes Afetivos são agentes capazes de manter um conjunto de estados internos
(chamados emoções) a partir da interpretação/avaliação de
situações
Estados internos não são perceptı́veis externamente; estes porém,
afetam a fisiologia dos agentes de forma a exteriorizá-los
Emoções vs Sentimentos alguns autores fazem a distinção, sugerindo que
sentimentos estão apenas relacionados com reações fisiológicas,
mesmo quando nenhuma cognição está envolvida: dor, fome,
cansaço, etc.
147 of 173
Emoções
Teoria Primitiva origens na Filosofia do final do século XIX e inı́cio do século XX com Darwin,
McDougall e outros
Teoria Fenomenológica como o nome sugere, estuda o ‘fenômeno’ da emoção, ao invés de tentar
definı́-la
Teoria Comportamentalista se baseia no estudo do comportamento emocional, ou seja, aquilo que
pode ser observado e medido
Teoria Fisiológica estudo das reações fisiológicas que ocorrem no corpo humano quando um indivı́duo
está experimentando emoções
Teoria Cognitiva estudo das relações entre o processo emocional e as faculdades cognitivas do
indivı́duo
Teoria Ambiciosas engloba um conjunto de autores que tentaram desenvolver ‘modelos completos’
com o intuito de explicar emoções
Teorias das Emoções Especı́ficas a ideia aqui é tentar explicar cada emoção separadamente por uma
teoria própria
Teoria Desenvolvimentalista teoriza que emoções são o resultado do processo natural do
desenvolvimento humano
Teoria Social alega que emoções são fruto de relações sociais, ou seja, reações ao convı́vio com
outros indivı́duos
Teoria Clı́nica estuda emoções sob o ponto de vista das psicopatias e terapias
Teoria do Indivı́duo, Ambiente e Cultura é uma teoria que tenta separar as reações emocionais como
tendo um de três possı́veis origens
Teorias fora da Psicologia com origens na Filosofia, História, Antropologia, Sociologia, Cultura, etc.
148 of 173
Metáforas Computacionais para Emoções
Appraisal representam a classe de arquiteturas que consideram que
emoções resultam da avaliação cognitiva da situação corrente
comparativamente as experiência prévias do indivı́duo
Dimensional são as arquiteturas que modelam emoções como um espaço
de dimensões (2 ou 3) contı́nuas
Anatômicas se baseiam nas teorias fisiológicas da Psicologia
Racional usa um modelo inspirado no comportamento emocional ao
invés de tentar apresentar ‘detalhes de implementação’
computacional
149 of 173
Metáforas Computacionais para Emoções
150 of 173
Modelo OCC
O modelo proposto por Ortony, Clore & Collins se tornou um dos
modelos mais populares entre os pesquisadores da computação
O OCC se baseia em cinco passos:
1 Classificação avalia a situação corrente (evento, agente ou objeto)
especificando a qual categoria emocional este afeta
2 Quantificação determina a intensidade de emoção sendo experimentada
3 Interação valida as relações da nova percepção com o estado
emocional corrente do indivı́duo
4 Mapeamento inicialmente o OCC categoriza 22 possı́veis emoções às
quais podem ser mapeadas em um conjunto menor se
necessário
5 Expressão é a realização da emoção sob a forma de um
comportamento fı́sico (p.ex. expressão facial)
151 of 173
Modelo OCC
152 of 173
Modelo OCC - Classificação
A fim de permitir que uma situação corrente seja apropriadamente
avaliada em estados emocionais, o agente faz uso de três bases de
conhecimento:
Attitudes descreve as relações emocionais do agente com os objetos.
P.ex.: o agente 007 gosta de frutas
Standards desvreve as relações sociais do agente com outros agentes.
P.ex.: o agente 007 é amigo da agente M
Goals descreve os objetivos do agente no ambiente. P.ex.: não
passar fome
Qual a reação emocional do agente 007 ao receber um pacote de maçãs
da agente M ?
153 of 173
Modelo OCC - Classificação
A fim de permitir que uma situação corrente seja apropriadamente avaliada em
estados emocionais, o agente faz uso de três bases de conhecimento:
Attitudes descreve as relações emocionais do agente com os objetos.
P.ex.: o agente 007 gosta de frutas
Standards desvreve as relações sociais do agente com outros agentes.
P.ex.: o agente 007 é amigo da agente M
Goals descreve os objetivos do agente no ambiente. P.ex.: não passar
fome
Qual a reação emocional do agente 007 ao receber um pacote de maçãs da
agente M ?
Avaliando as consequência do evento para outros: Pena (pity) com relação
ao agente M (que agora não tem mais o pacote de maçãs)
Avaliando as consequências do evento para si: satisfação (satisfaction) por
ter recebido as frutas
Em seguida, o agente avalia as ações do agente, resultando em: admiração
(admiration)
E por fim, avalia aspectos do objeto, resultando em amor (love)
154 of 173
Modelo OCC - Quantificação
O cálculo da intensidade dos estados emocionais é realizado
separadamente para eventos, agentes e objetos
Para eventos: é determinado em função do quanto o agente deseja que
aquele evento ocorra (desirability)
Para ações de agentes: é determinado em função do quanto o agente
valoriza aquela ação(praiseworthiness)
Para objetos: é determinado em função do quanto aquele objeto atrai a
atenção do agente (appealingness)
155 of 173
Modelo OCC - Interação
A avaliação do novo estado emocional do agente deve levar em
considerações seu estado emocional corrente. Por exemplo:
Imagine que o agente está irritado por não ter conseguido realizar uma
ação num passado recente
De repente, alguém lhe oferece uma fruta
Tal evento não deve fazer o agente mudar para o estado ‘contente’
porém certamente deveria fazê-lo diminuir a intensidade de seu estado
corrente ‘irritado’
156 of 173
Modelo OCC - Mapeamento
Muito frequentemente o agente possui mais estados emocionais do que
sua capacidade fı́sica de expressá-los
Neste caso, estados emocionais ‘complexos’ devem ser mapeados para
outros estados (em função do repertório do agente)
Uma alternativa: usar o modelo das sete emoções básicas de Paul Ekman
(raiva, nojo, desprezo, alegria, tristeza, surpresa e medo)
Outro aspecto a considerar: emoções ‘positivas’ e ‘negativas’
157 of 173
Modelo OCC - Expressão
Por definição, cada agente possui um conjunto de atuadores
O processo de expressão, consiste em utilizar esses atuadores para
representar ações que serão interpretadas como reações emocionais
Exemplo: animação de expressões faciais (FACS)
Outro exemplo: comportamento da postura corporal
A lista de possı́veis comportamentos depende das capacidade do agente
em si e deve ser considerada caso por caso
158 of 173
Modelo OCC - Exercı́cio
Projetar e implementar um sistema de storytelling que contenha 2
personagens (herói e vilão)
Descrever o ambiente onde esses personagens habitam. Incluir prédios,
objetos, ações possı́veis e eventos externos
Implementar cada agente para avaliar a situação (modelo EBDI) de
forma autônoma
159 of 173
Personalidade
Personalidade compreende certos padrões de comportamentos que são
permanentes ou que, pelo menos, variam muito lentamente
Teorias modernas defendem que uma definição de personalidade deve
considerar (pelo menos) os seguintes aspectos:
A forma como o indivı́duo é visto pela sociedade
Caracterı́sticas comportamentais estáveis e duradouras
Individualidade
Gênero e Etnia
Valores culturais e costumes
160 of 173
Personalidade
A descrição da personalidade deve responder a três perguntas básicas:
Descrição da Personalidade medidas de comparação entre diferenças
individuais. Abordagens: categorização, traços ou fatores.
Dinâmica da Personalidade descreve os mecanismos como uma
personalidade é expressa, com foco nas motivações para
um dado comportamento
Desenvolvimento da Personalidade descreve como e quando ocorrem
mudanças em uma personalidade
161 of 173
Personalidade - Teorias
Teoria Psicanalı́tica o inconsciente define processos mentais que determinam
o desenvolvimento da personalidade (ex.: Sigmund Freud)
Teoria Behaviorista a personalidade é o resultado de estı́mulos aprendidos.
Personalidade = Comportamento (ex.: Ivan Pavlov)
Teoria de Traços associam-se ‘adjetivos’ a indivı́duos como indicativos de
seu comportamento (ex.: Gordon Allport)
Teoria Humanista enfatiza personalidade como resultado de valores
aprendidos e de experiências positivas (em detrimento das
negativas) (ex.: Abraham Maslow)
Teoria Social-Cognitiva extensão da teoria behaviorista com a adição de
uma componente cognitiva (ex.: Alfred Bandura)
Teoria Biológica defende que ‘traços’ são o resultado de processos biológicos
(como a evolução natural) (ex.: Jean Piaget)
162 of 173
Personalidade - Modelos
Cognitive Styles “cada indivı́duo é capacidado com um conjunto único de qualidades
mentais para interagir com o mundo. Essas capacidades se manifestam
como comportamentos, maneirismos e produtos especı́ficos, que são
denominados coletivamente como estilo”. Os quatro estilo dominantes
são:
Concrete Sequential (CS) pontual, trabalhador pesado, um pouco rı́gido
Abstract Sequential (AS) aquele que ‘vive em sua mente’, distraı́do,
imaginativo
Abstract Random (AR) aquele que tem paixão por tudo o que faz,
religioso, com ‘conexões cósmicas’
Concrete Random (CR) criativo, centrado, muito intuitivo, divertido
163 of 173
Personalidade - Modelos
Modelo OCEAN defende a existência de cinco traços universais (Big Five):
Openness inventivo/curioso vs consistente/cauteloso
Conscientiousness eficiente/organizado vs
despreocupado/descuidado
Extraversion extrovertido/energético vs solitário/reservado
Agreeableness amigável/compassivo vs frio/rude
Neuroticism sensı́vel/nervoso vs seguro/confiante
http://www.outofservice.com/bigfive/
164 of 173
Personalidade - Modelos
16 Basic Desires Steven Reiss defende que o comportamento humano é motivado por 16
‘necessidades psicológicas’ (chamados de desejos básicos):
1.
2.
3.
4.
5.
6.
7.
8.
9.
10.
11.
12.
13.
14.
15.
16.
165 of 173
Power: desejo por liderança, influência, poder
Independence: desejo por liberdade e autoconfiança
Curiosity: desejo por conhecimento
Acceptance: desejo por uma auto-imagem positiva e auto-estima
Order: desejo por organização, ordem, limpeza, estabilidade
Saving: desejo de colecionar posses
Honor: desejo de apoiar valores morais, lealdade
Idealism: desejo por igualdade e justiça
Social Contact: desejo por amizades e diversão
Family: desejo de formar famı́lia, casar, ter filhos
Status: desejo por saúde, atenção, prêmios, tı́tulos
Vengeance: desejo por vencer, competir
Romance: desejo por afeição e sexo
Eating: desejo por comida, nutrição
Physical Exercise: desejo por estar em boa forma, saudável
Tranquility: desejo por relaxamento e segurança
Tomada de Decisão
Tomada de decisão autônoma envolve o processo de: (1) coleta de
informações acerca do problema; (2) elicitação de um conjunto de
soluções alternativas; (3) avaliação (mensuração da qualidade) de cada
possı́vel solução; (4) escolha de uma solução em particular e (5) execução
da solução.
Existem diversas teorias que permitem modelar tomada autônoma de
decisão. Algumas delas são:
166 of 173
Tomada de Decisão
Maximum Expected Utility permite modelar raciocı́nio sobre incerteza de maneira a
associar a cada opção o resultado de uma função de avaliação de
qualidade (chamada utilidade) E (U); onde U é a utilidade de uma opção
P
especı́fica, dada por N
i=1 U(Wi )pi , onde pi é a probabilidade de um
dado resultado i ocorrer e Wi é o valor dado pelo agente decisor caso o
resultado i seja realizado.
Prospect Theory é uma variante da MEU realizada em duas etapas:
1. na etapa de edição, uma lista de possibilidades é produzida através
de heurı́sticas, de forma a classificar cada possı́vel solução em
ganhos ou perdas
2. e então, na etapa de avaliação um clássico processo de utilidade é
executado
Fast & Frugal é um processo de tomada de decisão com incerteza, utilizando para isso
restrições na busca, conhecimento e tempo. A ideia aqui é imitar o
processo de tomada de decisão em processos crı́ticos (aqueles onde “o
pior que pode acontecer é não acontecer nada”, ou seja, qualquer
decisão, mesmo que incorreta ou imprecisa é melhor do que decisão
nenhuma).
São exemplos de processos crı́ticos: auxı́lio a controle de tráfego aéreo,
apoio a emergências médicas, etc.
167 of 173
Tomada de Decisão
168 of 173
Exercı́cio Final
Montar um agente capaz de:
1. Andar pelo cenário via comandos do usuário do tipo Faça:Nome da Ação
2. Enxergar objetos no chão
3. Enxergar outros agentes
4. Trocar mensagens com outros agentes:
Está ocorrendo algum evento?
Onde fica <objeto>?
169 of 173
Projeto Final
170 of 173
Projeto Final
Objetivo Fomentar a prática para fortalecer os conceitos teóricos
aprendidos
Descrição Implementar um SMA com base em algum dos modelos
vistos durante o semestre
Projetar um ambiente dinâmico, virtual, persistente, povoado
por múltiplos agentes que co-habitam e respondem de forma
inteligente a estı́mulos coletados no ambiente
O ambiente pode ser modificado pelos próprios agentes (ao
executarem ações) ou por comandos externos provenientes do
usuário
O resultado deve ser apresentado na forma de uma animação
interativa 3D
171 of 173
Projeto Final
Equipes de 2 alunos
O projeto deverá ser entregue em duas etapas:
1. Especificação textual/gráfica do ambiente, agentes e objetivos da simulação
(Design)
2. Protótipo que valida a especificação proposta na fase anterior
(Implementação)
A fase de design deverá ser entregue no dia 28/05/2014 com
apresentação em sala de aula e corresponderá a 15% da nota do Projeto
Final
A fase de implementação deverá ser entregue no dia 25/06/2014 com
apresentação em sala de aula e corresponderá a 85% da nota do Projeto
Final
172 of 173
Projeto Final
Sugestões de Temas:
cada agente precisa atender suas necessidades básicas (alimentação,
abrigo, reprodução) e devem lidar com estı́mulos externos (chuva, frio,
calor)
Savana Virtual diversos tipos de animais co-existem num ambiente (plantas, herbı́voros,
carnı́voros, etc.);
Residência uma famı́lia de agentes deve conviver em uma residência cumprindo as tarefas
usuais do dia-a-dia (pai, mãe, filhos, pets, etc.)
Praça Pública pessoas convivendo em ambiente público (cliente, vendedor, funcionário banco,
etc.)
Mars Rover conjunto de robôs treinados para exploração de minérios em um planeta distante
(explorador, escavador, coletor, etc.)
Conto de Fadas conjunto de personagens fictı́cios cooperam com o usuário para a contação de
estórias animadas (prı́ncipe, princesa, bruxa, ogro, etc.)
173 of 173