Aula_01_Agentes

Prévia do material em texto

Inteligência Artificial
Aula 01 - Agentes Inteligentes
Rogério Pereira Junior
rogeriopereirajunior@gmail.com
5 de setembro de 2025
IES
Santa Catarina
São José
Definição de Agente
Artefato equipado de sensores com capacidade para perceber o ambiente e agir sobre ele
por meio de atuadores
Um agente é uma entidade que:
Percebe o ambiente através de sensores.
Toma decisões com base em um processo de raciocínio (regra, modelo ou aprendizado).
Age sobre o ambiente utilizando atuadores.
1 / 90
Analogia com o corpo humano
Sensores (Percepção):
Órgãos dos sentidos: olhos (visão),
ouvidos (audição), nariz (olfato), pele
(tato), língua (paladar).
Exemplo de IA: uma câmera, um
microfone, sensores de temperatura,
GPS
Atuadores (Ação)
Partes do corpo que realizam ações:
mãos, pernas, boca, cordas vocais.
Exemplo em IA: motores de um robô,
braços robóticos, sintetizador de voz.
Exemplifiquem sensores e atuadores para um Agente de Software
2 / 90
Exemplo prático de comparação
Humano:
Olhos veem uma bola ->
cérebro decide chutar -> pernas
chutam.
Agente IA (robô de futebol):
Câmera detecta a bola ->
algoritmo decide ação -> motor
da perna robótica chuta a bola.
3 / 90
Estrutura do Funcionamento de um Agente Inteligente
Sensores -> Percepção do
ambiente
Captam sinais (visão, som,
temperatura, etc.).
Exemplo: uma câmera detecta
um objeto na frente do robô.
Processamento -> Raciocínio /
tomada de decisão
O agente interpreta os sinais
recebidos.
Pode envolver algoritmos de IA
(regras, heurísticas,
aprendizado de máquina).
Exemplo: decidir se o objeto
detectado é um obstáculo ou
um alvo.
4 / 90
Estrutura do Funcionamento de um Agente Inteligente
Memória -> Histórico de
percepções
O agente não deve reagir
apenas ao presente, mas
também usar a sequência de
percepções passadas.
Exemplo: um aspirador
inteligente lembra por onde já
passou para não limpar o
mesmo lugar repetidamente.
Atuadores -> Ação no
ambiente
O agente executa sua decisão.
Exemplo: mover-se para a
esquerda para evitar o
obstáculo.
5 / 90
Exemplo Prático - Carro autônomo
Carro autônomo
Sensores: câmeras, radar, LIDAR.
Percepções: posição dos carros,
pedestres, sinais de trânsito.
Memória: trajetória percorrida, limites
de velocidade já lidos, padrões de
tráfego.
Processamento: interpretar a situação e
prever movimentos de outros veículos.
Ação: acelerar, frear ou desviar.
6 / 90
Mapeando percepções em ações
O comportamento de um agente é definido pela sua função.
A função agente tem o objetivo de mapear as possiveis ações por
meio das sequencias de percepções disponíveis no armazenamento
desse agente.
Formalmente, pode ser vista como:
f : P∗ → A
Onde:
P∗ = conjunto de todas as sequências possíveis de percepções;
A = conjunto de ações possíveis.
O programa do agente é uma implementação concreta da função
do agente
Agente = arquitetura + programa
7 / 90
Exemplo: O mundo do aspirador de pó
Percepções: Local e Estado
[A, Sujo]
Ações: Esquerda, Direita, Aspirar, NoOp
8 / 90
Tabulação parcial da função do agente aspirador de pó
Um função de agente pode ser implementada por meio de uma tabela de possíveis ações
relacionadas a uma sequencia de percepções
9 / 90
Programa do agente aspirador de pó
10 / 90
Atividade 1
Faça uma implementação simples em python do agente aspirador de
pó
11 / 90
Atividade 1 - Gabarito
class Ambiente:
def __init__(self):
self.estado = {"A": "sujeira", "B": "limpo"}
class Aspirador:
def __init__(self):
self.local = "A"
def perceber(self, ambiente):
return ambiente.estado[self.local]
def agir(self, ambiente):
percepcao = self.perceber(ambiente)
if percepcao == "sujeira":
ambiente.estado[self.local] = "limpo"
print(f"Limpando posição {self.local}")
else:
self.local = "B" if self.local == "A" else "A"
print(f"Movendo para posição {self.local}")
# Teste
ambiente = Ambiente()
aspirador = Aspirador()
for _ in range(4):
aspirador.agir(ambiente)
12 / 90
Atividade 1 - Gabarito
class Ambiente:
def __init__(self):
self.estado = ["sujeira", "limpo"]
def mostrar(self):
print(f"Ambiente: {self.estado}")
class Aspirador:
def __init__(self):
self.posicao = 0 # Começa na posição A (índice 0)
def perceber(self, ambiente):
return ambiente.estado[self.posicao]
def agir(self, ambiente):
percepcao = self.perceber(ambiente)
if percepcao == "sujeira":
ambiente.estado[self.posicao] = "limpo"
print(f"Limpando posição {'A' if self.posicao == 0 else 'B'}")
else:
print(f"Nada para limpar em {'A' if self.posicao == 0 else 'B'}")
self.mover()
def mover(self):
self.posicao = 1 if self.posicao == 0 else 0
print(f"Movendo para posição {'A' if self.posicao == 0 else 'B'}")
ambiente = Ambiente()
aspirador = Aspirador()
print("Estado inicial:")
ambiente.mostrar()
for _ in range(4):
aspirador.agir(ambiente)
print("\nEstado final:")
ambiente.mostrar()
13 / 90
Exemplo de agentes com sequencia de percepções
Agente Com apenas percepção atual Com sequência de percepções (me-
mória)
Robô aspirador Fica preso em ciclos, limpando o
mesmo canto repetidamente.
Constrói um mapa mental da casa,
evita áreas já limpas e cobre todo o
ambiente.
Carro autônomo Só reage ao semáforo no momento,
podendo frear bruscamente ou errar a
rota.
Lembra estados anteriores (verde →
amarelo → vermelho), prevê rotas e
evita acidentes.
Assistente virtual de
voz
Interpreta “E amanhã?” sem contexto,
dando resposta incoerente.
Lembra a pergunta anterior sobre o
clima e responde corretamente sobre
“amanhã”.
Agente financeiro Compra/vende baseado no preço
atual, sem entender tendências.
Analisa histórico de preços, identifica
padrões de alta/queda e decide de
forma estratégica.
Robô de resgate Busca apenas onde o sensor aponta
agora, podendo revisitar áreas vazias.
Lembra áreas já exploradas e integra
sinais para prever riscos estruturais.
Tabela: Comparação entre agentes com e sem memória de percepções.
14 / 90
Dificuldade central
Dificuldade em definir e implementar funções de agente que
consigam lidar com ambientes de alta complexidade, onde:
As percepções são numerosas e variadas.
Espaço de ações possíveis é gigantesco.
O agente deve tomar decisões eficazes em tempo hábil.
Exemplo: Xadrez
Um agente inteligente dedicado ao jogo de xadrez deve ter sua função
de agente limitada, de modo que não leve milhões de anos para fazer
uma jogada e que tenha memoria suficiente para armazenar jogadas
possíveis, considerando um horizonte de poucas jogadas a frente
15 / 90
Dificuldade central - Exemplo Xadrez
Horizonte de busca limitado
O agente considera apenas um número
finito de jogadas à frente (por exemplo,
4 ou 6 movimentos).
Isso é chamado de profundidade de
busca.
Memória controlada
Em vez de armazenar todas as partidas
possíveis, o agente guarda apenas as
jogadas mais promissoras (heurísticas)
e posições já avaliadas (tabelas de
transposição);
16 / 90
Dificuldade central - Exemplo Xadrez
Agente inteligente
Assim, a função agente no xadrez é projetada para:
Limitar o horizonte de busca;
Reduzir a explosão combinatória;
Manter memória suficiente, mas não infinita;
Tomar decisões em tempo hábil (segundos ou milissegundos, não séculos).
17 / 90
Agentes Racionais
18 / 90
Racionalidade x Onisciência x Autonomia
Racionalidade -> faz o melhor possível com a informação que tem.
Onisciência -> teria toda a informação possível (utopia, usado só
como referência).
Autonomia -> capacidade de aprender e agir por conta própria, sem
depender de instruções externas.
19 / 90
Medida de Desempenho
PEAS
Ao projetar um agente, a primeira etapa deve ser sempre
especificar o ambiente de tarefa
Performance = Medida de Desempenho
Environment = Ambiente
Actuators = Atuadores
Sensors = Sensores
20 / 90
PEAS
Robô aspirador de pó
Medida de desempenho: uma pontuação para cada quadrado
limpo em um periodo de tempo (9 quadrados limpos a cada minuto)
O ambiente do robô é previamente conhecido, ainda que a sujeira
possa variar de quadro a quadro
As ações que o robô pode executar são: mover-seà esquerda,
mover-se à direita, aspirar e parar.
Percepções: o robô identifica o quadrado onde se encontra e
verifica se ele tem sujeira ou não
21 / 90
PEAS
Exemplo (Sala de aula)
Desempenho: Notas dos alunos;
Ambiente: Grupo de alunos;
Atuadores: Exercícios, avaliações, aparelhos eletrônicos;
Sensores: Sentidos.
22 / 90
Robô de seleção de peças
Medida de desempenho: ????
Ambiente: ????
Atuadores: ????
Sensores: ????
23 / 90
Robô de seleção de peças
Medida de desempenho: porcentagem de peças em bandejas
corretas
Ambiente: esteira transportadora com peças, bandejas
Atuadores: braço e mão articulados
Sensores: câmeras e sensores de posicionamento
24 / 90
Agente racional - Exemplos
25 / 90
Agente racional - Exemplos
26 / 90
Comprar Dólar
Agente
class Agente:
def __init__(self, estado=None, funcaoAgente=None):
self.estado = estado
self.funcaoAgente = funcaoAgente
self.historicoPercepcoes = []
def mostraEstado(self):
return str(self.estado)
def vivo(self):
return hasattr(self, 'vivo') and self.vivo
def percepcao(self):
entrada = input("Entre com dados: ") # Percepções
self.historicoPercepcoes.append(entrada)
def __str__(self):
return self.__class__.__name__
a = Agente()
a.percepcao()
a.historicoPercepcoes
27 / 90
Ambiente
class Ambiente:
def __init__(self, estadoInicial = None):
self.estado = estadoInicial
self.objetosNoAmbiente = []
self.agentes = []
def percepcao(self, agente):
# Define as percepções do agente
return None
def adicionaAgente(self, agente):
self.agentes.append(agente)
def adicionaObjeto(self, obj):
self.objetosNoAmbiente.append(obj)
am = Ambiente()
am.adicionaAgente(a)
28 / 90
Agente de compra e venda de dolares
# Caso pratico: Agente de compra e venda de dolares
serieHistoricoDolar = [] # São nossas percepções
with open('bcdata.sgs.10813.csv', encoding='utf−8') as arquivo:
linhas = arquivo.readlines()
for linha in linhas[1:]:
partes = linha.strip().split(';')
valor_str = partes[1].replace('"', '').replace(',', '.')
valor_float = float(valor_str)
serieHistoricoDolar.append(valor_float)
import matplotlib.pyplot as plt
x = [i for i in range(len(serieHistoricoDolar))]
y = list(reversed(serieHistoricoDolar))
plt.plot(x,y)
plt.xlabel('Periodo (dias)')
plt.ylabel('Valor do dolar em Reais')
plt.title('Variação do dolar de Jan−2023 a Jun−2023')
plt.show()
29 / 90
Média Móvel
Média móvel é uma técnica estatística usada para suavizar flutuações
em séries temporais e destacar tendências ao longo do tempo. Em vez
de olhar para cada ponto isoladamente, ela calcula uma média que se
"move"conforme novos dados são adicionados.
def mediasMoveis(serie):
medias = []
for i,v in enumerate(serie):
if i == 0:
m = v
medias.append(m)
else:
m = m + (v − m)/ (i +1)
medias.append(m)
return medias
plt.plot(x,y)
plt.plot(x, mediasMoveis(y), label = 'Média Móvel')
plt.xlabel('Periodo (dias)')
plt.ylabel('Valor do dolar em Reais')
plt.title('Variação do dolar de Dez−2024 a Jun−2025')
plt.show()
30 / 90
funcaoAgenteCompraDolar
NOSSO AGENTE INTELIGENTE VAI DECIDIR ENTRE COMPRAR E VENDER DÓLARES
AQUI ESTAMOS ENCAPSULANDO O CONHECIMENTO A RESPEITO DO ASSUNTO
def funcaoAgenteCompraDolar(media, valor):
## Regras/tabela de decisão
if valor >= media:
return False, valor, media
else:
return True, valor, media
31 / 90
Agente Cambio
class AgenteCambio(Agente):
def __init__(self, estadoInicial = None, funcaoAgente = None):
super().__init__(estadoInicial, funcaoAgente)
self.observacao = 0
self.mediaAtual = 0
self.medias = []
def atualizaEstado(self,valor):
self.observacao +=1
if self.observacao == 1:
self.mediaAtual = valor
else:
self.mediaAtual = self.mediaAtual + (valor − self.mediaAtual)/(self.observacao +1)
self.estado.append(valor) # seria as cotações
self.medias.append(self.mediaAtual)
def percepcao(self, valorAtual): # a partir de uam cotação fazer a analise
self.atualizaEstado(valorAtual)
def saida(self):
return self.funcaoAgente(self.medias[−1], self.estado[−1]) # A ultima
ac = AgenteCambio([], funcaoAgenteCompraDolar)
for i in y[:10]:
ac.percepcao(i)
print(ac.saida(), end=", ")
32 / 90
AgenteCambioDesempenho
Sera que podemos ganhar dinheiro com esse agente ?
Precisamos ter alguma medida de desempenho (qual lucro que estamos tendo?)
class AgenteCambioDesempenho(AgenteCambio):
def __init__(self, estadoInicial=None, funcaoAgente=None, saldoR = 0, saldoD = 0):
super().__init__(estadoInicial, funcaoAgente)
self.saldoReal = saldoR
self.saldoDolar = saldoD
self.evolucaoReal = []
def comprar(self): # Ação comprar
if self.saldoReal > 0:
self.saldoDolar += self.saldoReal/self.estado[−1]
self.saldoReal = 0
def vender(self):
if self.saldoDolar > 0:
self.saldoReal += self.saldoDolar ∗ self.estado[−1]
self.saldoDolar = 0
self.evolucaoReal.append(self.saldoReal)
def desempenho(self):
print("DESEMPENHO")
return self.evolucaoReal[−1] − self.evolucaoReal[0]
33 / 90
AmbienteFinanceiro
class AmbienteFinanceiro(Ambiente):
def __init__(self, estadoInicial):
super().__init__(estadoInicial)
# def percepcao(self, agente):
# for i in self.estado: # estado é a cotação do dollar
# for ag in agentes: # para cada agente vamos perceber o estado do ambiente
# ag.percebe(i)
# return
def executaAmbiente(self):
for gst in self.estado:
for ag in self.agentes:
ag.atualizaEstado(gst)
acaoComprar = ag.saida()
if acaoComprar[0] == True:
ag.comprar()
else:
ag.vender()
def desempenhoAgentes(self):
desempenho = []
for i, ag in enumerate(self.agentes):
desempenho.append((i,ag.desempenho()))
return desempenho
34 / 90
Botando nosso agente para trabalhar
# Botando nosso agente para trabalhar
ag = AgenteCambioDesempenho([], funcaoAgenteCompraDolar, 1000, 0) # considerando investimento de 1000
reais
amb = AmbienteFinanceiro(y)
amb.adicionaAgente(ag)
amb.executaAmbiente()
desempenho = amb.desempenhoAgentes()
print("Desempenho geral: (Agente, Lucro) ", desempenho)
# Evolução real
x2 = list(range(len(ag.evolucaoReal)))
plt.plot(x2, ag.evolucaoReal)
plt.xlabel("Transações Efetuadas")
plt.ylabel("Saldo em reais")
plt.title("Evolução do investimento no periodo")
plt.show()
35 / 90
Aspirador 2.0
Aspirador
36 / 90
Aspirador
37 / 90
Aspirador
38 / 90
Atividade 2
Aumentar número de posições (por exemplo, 5 ou 10) e adaptar o
movimento para esquerda/direita com limites.
Adicionar obstáculos ou posições inacessíveis.
Implementem um contador de energia que diminui a cada ação.
Criem um agente com memória que evita visitar posições já limpas.
39 / 90
Atividade 2
import random
class Ambiente:
def __init__(self, tamanho=10):
self.estado = []
for _ in range(tamanho):
# 70% chance de sujeira, 20% limpo, 10% obstáculo
valor = random.choices(["sujeira", "limpo", "obstáculo"], [0.7, 0.2, 0.1])[0]
self.estado.append(valor)
def mostrar(self):
print("Ambiente:")
for i, estado in enumerate(self.estado):
print(f"Posição {i}: {estado}")
40 / 90
Atividade 2
class Aspirador:
def __init__(self, tamanho_ambiente):
self.posicao = 0
self.energia = 20
self.memoria = set()
self.tamanho = tamanho_ambiente
def perceber(self, ambiente):
return ambiente.estado[self.posicao]
def agir(self, ambiente):
if self.energiaprint(f" Movendo para posição {self.posicao}")
else:
print(f" Movimento bloqueado. Mantendo posição {self.posicao}")
# Inicialização
ambiente = Ambiente(tamanho=10)
aspirador = Aspirador(tamanho_ambiente=10)
print(" Estado inicial do ambiente:")
ambiente.mostrar()
# Ciclo de ações
while aspirador.agir(ambiente):
pass
print("\n Estado final do ambiente:")
ambiente.mostrar()
42 / 90
Natureza dos ambientes
Natureza dos ambientes
Dificuldade para a construção de agentes inteligentes: quão
completa pode ser a descrição de seu comportamento
Como vimos anteriormente:
robô aspirador: função de agente bem delimitada
robô destinado a jogar xadrez: apresenta um desafio, pois a quantidade de jogadas possíveis
chega a valores astronômicos
A caracterização do ambiente onde o agente atuará vai determinar o
sucesso de sua execução.
43 / 90
Completamente Observável x Parcialmente Observável
Completamente observável: o agente tem acesso a todas as informações relevantes do
ambiente no momento da decisão.
Parcialmente observável: o agente só vê parte do ambiente, precisando estimar ou
lembrar o resto.
Completamente observável: Jogo de xadrez no computador (o tabuleiro inteiro é visível ao
jogador e ao agente).
Parcialmente observável: Games
44 / 90
Determinístico x estocástico
Determinístico: a ação do agente leva a um resultado sempre previsível.
Estocástico: existe incerteza no resultado da ação, mesmo que o agente saiba o que fez.
Determinístico: Jogo da velha (os movimentos têm efeito fixo)
Estocástico: Carro autônomo (mesmo com análise, há fatores aleatórios que influenciam o
resultado)
45 / 90
Episódico x sequencial
Episódico: cada decisão do agente é independente das anteriores.
Sequencial: as ações influenciam estados futuros e decisões seguintes.
Episódico: Braço Mecânico (colocar a peça agora não afeta a próxima vez em que aparecer
outra peça)
Sequencial: Jogo de tabuleiro (Cada jogada feita influencia diretamente as jogadas futuras).
46 / 90
Estático x dinâmico
Estático: o ambiente não muda enquanto o agente decide sua ação.
Dinâmico: o ambiente pode mudar durante o processo de decisão, exigindo reação rápida.
Estático: O estado do jogo só muda quando o jogador ou agente faz uma jogada. Não há
mudanças externas imprevisíveis.
Dinâmico: Jogos, transito em uma cidade ((o ambiente muda a cada segundo)
47 / 90
Discreto x Continuo
Discreto: estados, percepções e ações são finitos e contáveis.
Contínuo: há uma infinitude de valores possíveis, exigindo aproximações.
Discreto: Jogo de tabuleiro (número limitado de movimentos e casas no tabuleiro).
Contínuo: Robô que controla um braço mecânico (ângulos, forças e posições variam em
infinitas possibilidades).
48 / 90
Individual x Multiagente
Individual: o agente atua sozinho, sem outros agentes competindo ou cooperando.
Multiagente: há outros agentes no mesmo ambiente, podendo ser aliados ou adversários.
Individual: Aplicativo de aprendizado (apresenta tarefas, correções adequados para o
aluno)
Multiagente: Jogo de futebol de robôs, onde os agentes precisam cooperar com colegas e
competir contra adversários.
49 / 90
Natureza dos ambientes
Ambientes completamente observáveis,
determinísticos, estáticos, discretos,
episódicos e individuais -> fáceis de
projetar agentes.
Ambientes parcialmente observáveis,
estocásticos, dinâmicos, contínuos,
sequenciais e multiagente -> muito mais
desafiadores e exigem agentes
avançados (aprendizagem, raciocínio
probabilístico, cooperação).
50 / 90
Natureza dos ambientes
51 / 90
Estruturas de agentes
Estruturas de agentes
Até agora fizemos referência aos agentes descrevendo o comportamento – a ação
executada após qualquer sequência de percepções específica.
Agora, teremos de seguir em frente e descrever o funcionamento interno desses agentes.
agente = arquitetura + programa.
abordagem orientada a tabelas para construção de agentes está
condenada ao fracasso
52 / 90
Programas de agentes
Ex: Imagine um aspirador simples em uma sala com 2 quadrados
(Esquerda e Direita):
Se a casa tivesse N posições (digamos 100), seriam necessárias 2100
combinações possíveis
O desafio fundamental da IA é descobrir como escrever programas
que, na medida do possível, produzam um comportamento racional a
partir de um pequeno programa em vez de uma grande tabela.
53 / 90
Reativo Simples
Toma decisões com base apenas na percepção atual do ambiente
Resposta imediata: A ação é diretamente ligada à percepção atual.
54 / 90
Reativo Simples
Como funciona:
Baseia-se apenas na percepção atual,
sem considerar o passado.
Age de acordo com regras condicionais:
“SE condição ENTÃO ação”.
Vantagem: rápido e simples.
Limitação: pode se perder em situações
mais complexas (não tem memória).
Exemplo real:
Aspirador de pó que suga se encontrar
sujeira.
Sensor de luz que acende uma lâmpada
quando está escuro.
Motorista do táxi automatizado: se
carro-da-frente-está-freando então
começar-a-frear.
55 / 90
Reativo Simples
56 / 90
Reativo baseado emmodelo
Mantém um modelo interno do mundo (memória).
57 / 90
Reativo baseado emmodelo
Considera histórico de percepções para decidir.
Vantagem: mais inteligente que o reativo simples.
Limitação: precisa de um modelo correto.
Definição
Um agente que tem o conhecimento de “como o mundo funciona” apresenta o que se
denomina modelo do mundo.
58 / 90
Reativo baseado emmodelo
Exemplo real:
Aspirador que lembra onde já limpou
para não repetir.
Carro que registra se passou por uma
rua antes.
59 / 90
Baseado em Objetivos
O fato de um agente ter conhecimento do estado atual do ambiente não é condição
suficiente para que ele decida o que fazer.
é necessário que obtenha alguma informação quanto aos objetivos relacionados a
situações ou cenários desejáveis.
60 / 90
Baseado em Objetivos
Como funciona: Age em função de
objetivos definidos.
Ele decide quais ações aproximam do
estado desejado.
Exemplo real:
GPS que traça rota até o destino.
Jogo da velha: o agente tenta ganhar
(objetivo).
Aspirador
O objetivo desse robô é executar sua
tarefa considerando o custo de
operação e o consumo de energia.
No decorrer do tempo, ele pode calcular
a frequência com que as limpezas são
feitas e entrar em modo de economia
de energia durante os intervalos, a fim
de alcançar um resultado mais
satisfatório.
61 / 90
Baseados na Utilidade
Quantificar o mapeamento de um estado ou uma sequência de estados em um número
que descreve o grau de “felicidade” alcançado
62 / 90
Baseados na Utilidade
Como funciona: Além do objetivo,
escolhe a ação que maximiza utilidade
(preferências, custo/benefício).
Diferente do agente baseado em
objetivo, que só verifica se um estado
satisfaz ou não o objetivo, o agente de
utilidade consegue comparar diferentes
estados possíveis.
Exemplo real:
Carro autônomo que escolhe entre 2
rotas: mais curta ou mais segura.
Investimento que escolhe ação com
maior retorno esperado.
63 / 90
Diferença para o Baseado em Objetivo
Baseado em Objetivo:
Pergunta: “Isso me leva ao meu objetivo?”
Resposta: Sim / Não.
Exemplo: GPS quer só chegar ao destino (não importa o caminho).
Baseado em Utilidade:
Pergunta: “Quão bom é este caminho comparado a outros?”
Resposta: Escolhe o melhor entre vários.
Exemplo: GPS avalia rotas considerando tempo, eficiência do
combustível, pedágio, segurança, conforto.
64 / 90
Agentes com aprendizagem
Até agora: agentes criados
com conhecimento
previamente definido e fixo.
Seria possível imaginar uma situação em que o agente atuasse em um
ambiente inicialmente desconhecido e ao longo do tempo adquirisse
conhecimento?
65 / 90
Agentes com aprendizagem
Um agente com aprendizagem vai além do conhecimento inicial,
adquirindo experiência com o ambiente para melhorar seu
desempenho ao longo do tempo.
Exemplo real:
Aspirador robô que melhora rotas com o tempo.
Assistente virtual que entende cada vez melhor o usuário.
Agente de investimento que aprende recompensas
Citem outros exemplos
66 / 90Agentes com aprendizagem
“Um agente de aprendizado pode ser dividido em quatro componentes conceituais”
(Russell; Norvig, 2004, p. 51). Em suma, são eles:
1 Elemento de desempenho - é a parte considerada até agora sobre o estudo dos
agentes anteriores, que recebe as percepções e decide qual ação executar;
2 Elemento crítico -informa ao elemento de aprendizado como o agente está se
comportando em relação a um padrão fixo de desempenho;
3 Elemento de aprendizado -utiliza a informação proveniente do crítico para
modificar o elemento de desempenho para obtenção de um melhor
funcionamento no futuro;
4 Gerador de problemas - é o elemento responsável pela sugestão de novas
regras e ações que podem levar a novas experiências
67 / 90
Agentes com aprendizagem
68 / 90
Resumo
Reativo simples -> só reage.
Baseado emmodelo -> lembra estados passados.
Baseado em objetivo -> busca metas.
Baseado em utilidade -> escolhe a melhor meta/ação
considerando preferências.
Aprendizagem -> melhora sozinho ao longo do tempo.
69 / 90
Qual é a função da IA nos agentes
Ideia
A função da IA é projetar um programa agente que implemente a função de agente (o
mapeamento das percepções em ações)
A ideia é criar um algoritmo (ou programa) que, ao receber uma sequência de percepções
do ambiente, decida qual a próxima ação a ser tomada para atingir determinado objetivo.
Chamamos essa função de:
função de agente: percepção(s) -> ação
Mas, na prática, não programamos diretamente essa “função matemática”. Em vez disso:
Criamos um sistema de decisão (baseado em regras, lógica, aprendizado ou otimização);
Esse sistema implementa a função de agente, por meio de estruturas de controle, aprendizado,
planejamento etc.
70 / 90
Qual é a função da IA
Exemplo Prático
Imagine um agente que joga xadrez:
Percepção: o estado atual do tabuleiro.
Ação: o próximo movimento.
Função de agente: algoritmo que mapeia o estado do jogo em ummovimento ideal.
Isso pode ser feito via:
Árvores de busca com heurísticas (como o algoritmo minimax),
Ou redes neurais treinadas em milhões de partidas (como o AlphaZero da DeepMind).
71 / 90
Resumindo
Resumindo
Um agente é algo que percebe e age em um ambiente. A função do agente
especifica a ação executada pelo agente em resposta a qualquer sequência de
percepções.
A medida de desempenho avalia o comportamento do agente em um ambiente.
Um agente racional age para maximizar o valor esperado da medida de
desempenho, dada a sequência de percepções recebida até o momento.
Uma especificação de ambiente de tarefa inclui a medida de desempenho, o
ambiente externo, os atuadores e os sensores. Ao projetar um agente, o primeiro
passo sempre deve ser especificar o ambiente de tarefa da maneira mais
completa possível.
Os ambientes de tarefas variam ao longo de diversas dimensões significativas.
Eles podem ser completa ou parcialmente observáveis, agente único ou
multiagente, determinísticos ou não determinísticos (ou estocásticos), episódicos
ou sequenciais, estáticos ou dinâmicos, discretos ou contínuos e conhecidos ou
desconhecidos.
72 / 90
Resumindo
Em casos em que a medida de desempenho é desconhecida ou difícil de ser
especificada corretamente, existe um risco significativo de o agente otimizar o
objetivo errado. Nesses casos, o projeto do agente deverá refletir a incerteza
quanto ao objetivo verdadeiro.
O programa do agente implementa a função do agente. Existem diversos
projetos básicos de programas de agentes, refletindo o tipo de informação
explicitada e usada no processo decisório. Os projetos variam em eficiência,
síntese e flexibilidade. O projeto apropriado do programa do agente depende da
natureza do ambiente.
Agentes reativos simples respondem diretamente a percepções, enquanto
agentes reativos baseados em modelos mantêm o estado interno para monitorar
aspectos do mundo que não estão evidentes na percepção atual. Agentes
baseados em objetivos agem para alcançar seus objetivos, enquanto agentes
baseados em utilidade tentam maximizar sua própria “felicidade” esperada.
Todos os agentes podem melhorar seu desempenho por meio do aprendizado.
73 / 90
Questões para revisão
1 O que é um agente inteligente?
2 O que significa sensor e atuador?
3 . O que significa sequência de percepções?
4 De acordo com o que você estudou, defina função do agente.
5 Dê um exemplo de agente inteligente e caracterize-o de acordo com os
elementos que determinam um agente (percepção, ação, etc.).
6 Do que depende a racionalidade do agente inteligente?
7 Defina o ambiente de tarefa de um agente
8 Dê um exemplo de ambiente de tarefa e caracterize-o de acordo com suas
propriedades.
9 O que são agentes reativos simples?
10 O que são agentes reativos com base em modelo?
11 O que são agentes com base em objetivos?
12 O que são agentes com base na utilidade?
13 O que é agente de aprendizagem e quais são seus elementos conceituais?
74 / 90
Exemplo 1 - Agente que navega em uma grade
Implemente um agente que se move em uma grade 5x5 do ponto
(0,0) até (4,4). O agente deve:
Perceber sua posição atual.
Mover-se na direção do objetivo.
Evitar obstáculos definidos como uma lista de coordenadas.
75 / 90
Exemplo 1 - Agente que navega em uma grade
class AmbienteGrade:
def __init__(self, tamanho, objetivo, obstaculos):
self.tamanho = tamanho
self.objetivo = objetivo
self.obstaculos = obstaculos
def posicao_valida(self, pos):
x, y = pos
return (0rato = RatoAgente(labirinto, inicio)
rato.executar()
80 / 90
Exemplo 3 - Jogo de velha
Um agente que jogue jogo da velha com você
Percepção do ambiente (espaços vazios, espaços com pelas do
adversário)
Ação (movimentos)
Sensores (posição atual)
Atuadores (movimentação)
81 / 90
Exemplo 3 - Jogo da velha
import random
from google.colab import output
def print_tabuleiro(tabuleiro):
print(" 0 1 2") # Cabeçalho das colunas
for i, linha in enumerate(tabuleiro):
print(f"{i} {' | '.join(linha)}") # Adiciona o número da linha à esquerda
if i