1 / 20

Introduction to Stream Logic Programming for Multi-Agent Systems

This seminar introduces the advantages of Stream Logic Programming (SLP) for MAS, proposing new languages like PLACA and MAIL, and using more general languages like OBCP (Object Based Concurrent Programming).

moesha
Télécharger la présentation

Introduction to Stream Logic Programming for Multi-Agent Systems

An Image/Link below is provided (as is) to download presentation Download Policy: Content on the Website is provided to you AS IS for your information and personal use and may not be sold / licensed / shared on other websites without getting consent from its author. Content is provided to you AS IS for your information and personal use only. Download presentation by click this link. While downloading, if for some reason you are not able to download a presentation, the publisher may have deleted the file from their server. During download, if you can't get a presentation, the file might be deleted by the publisher.

E N D

Presentation Transcript

  1. How Agents Do It In Stream Logic Programming Huntbach,M.M; Jennings,N.R.; Ringwood,G.A(ICMAS-95) Seminário apresentado na disciplina PCS-5740 - Fundamentos Lógicos de IA Prof: Jaime S. Sichman 1o. Quadrimestre de 1999 Simone G D Prado

  2. Introdução • Objetivo: mostrar as vantagens da SLP (Stream Logic Programming) • Problema: trabalhar com MAS (Multi Agent System) necessita de ferramentas e técnicas próprias • Soluções: • construir linguagens novas (PLACA e MAIL) • usar linguages mais gerais (OBCP - Object Based Concurrent Programming) Simone G D Prado

  3. Introdução (cont...) • OBCP em MAS: • vantagem: se sai bem na complexidade de executar grandes programas em sistemas distribuídos • desvantagem: restringe os agentes deixando-os muito inflexíveis • Exemplo de OBCP: ACTORS e ABCL Simone G D Prado

  4. Características do SLP • Sintaxe: • ACTORS - LISP • SLP - PROLOG • SLP consiste de um conjunto de comportamentos nomeados • Classe (LOO) • conjunto de clausulas (L Lógica) • vetor de slot de recepção de mensagens • slot => variáveis do Prolog Simone G D Prado

  5. Seleção de mensagens • Forma geral: • <guard> <- <behaviour> act(X,Y):- X=m <- ..... + act(X,Y):- X = n <- ..... • + representa as alternativas • Mensagem = termo da lógica de predicados • Objeto fica suspenso até chegar m/0 ou n/0 Simone G D Prado

  6. Seleção de mensagens (cont...) • Pode-se acrescentar: + act(X,Y):- X/=m & X/=n <- ..... • Existe prioridade - ordenação de cláusulas act(m,Y) <-.... + act(m,Y) <- .... + act(X,Y) <- .... Simone G D Prado

  7. Seleção de mensagens (cont...) • Pode-se requerer duas mensagens: max(I,J):- I > J <- .... + max(I,J): I=<J <- .... • As restrições não podem ser executadas enquanto não receberem a(s) mensagem(ns). Enquanto isso a cláusula fica suspensa. Simone G D Prado

  8. Metas como objetos pouco ativos • Objeto - meta em Prog Lógica, um comportamento com um nro de slots • Em SLP os slots são explícitos e podem ser manuseados. Pode-se ter lista de objetos: <- A << m|act(A,B)|bct(B,C)|... O envio da mensagem é assíncrono Simone G D Prado

  9. Metas (cont...) • Uma classe pode receber mensagens e enviar respostas: act(m,Y) <- Y << q + act(n,Y) <- Y << r bct (q,Y) <- done { nenhuma troca } <- A<<m | act(A,B)|bct(B,C)|.... <- act(m,B)|bct(B,C)|.... <- B<<q|bct(B,C)|.... <-bct(q,C)|.... <- .... Simone G D Prado

  10. Objetos de vida longa e Fluxo • Os slots podem receber mensagens. • As mensagens são termos. • Termos podem ter slots • Portanto: act(m(X),Y) <- Y << q(Z)|cct(X,Y) +act(n(X),Y) <- Y << r(Z)|dct(X,Y) os objetos cct/2 e dct/2 tratam dos termos que tem slot Simone G D Prado

  11. Objetos .... (cont...) • As mensagens podem ser multicast: <- X<<m|act(X,...)|bct(...,X,...)|cct(...,X) • Podem ser reincarnadas: bct(q(X),Y) <- bct(X,Y) • Reincarnadas recursivas: bct(q(X),Y) <- Z << r(X)|bct(Z,Y) {ou} bct(q(X),Y) <- bct(r(X),Y) envia uma mensagem para si mesmo Simone G D Prado

  12. Objetos... (cont...) • Quando várias mensagens são recebidas no mesmo fluxo: bct(s(t(X)),Y) <- bct(X,Y) bct(s:t:X,Y) <- bct(X,Y) bct([s,t|X],Y) <- bct(X,Y) bct([s|[t|X]],Y) <- bct(X,Y) Simone G D Prado

  13. Agentes Simples //vendedor(Preço_corrente,Proposta,Limite_min) vendedor(Perg,Prop:Cont,Limite):- Prop > Limite <- Cont << aceita(Prop)|vendedor(Perg,Cont,Limite) +vendedor(Perg,Prop:Cont,Limite):- Prop < Limite & Nova_P := (Perg+Prop)/2 & Nova_P > Limite <- Cont << Nova_P:Novo_C | vendedor(Nova_P,Novo_C,Limite) +vendedor(Perg,Prop:Cont,Limite):- Prop < Limite & Nova_Perg := (Perg+Prop)/2 & Nova_P < Limite <- Cont << rejeita(Prop) | vendedor(Perg,Cont,Limite) Simone G D Prado

  14. Agentes Simples (cont...) //comprador(Proposta_corrente,Pergunats,Limite_max) comprador(Prop,Perg:Cont,Limite):- Perg < Limite <- Cont << aceita(Perg)|comprador(Prop,Cont,Limite) +comprador(Prop,Perg:Cont,Limite):- Perg > Limite & Nova_P := (Perg+Prop)/2 & Nova_P < Limite <- Cont << Nova_P:Novo_C | comprador(Nova_P,Novo_C,Limite) +comprador(Prop,Perg:Cont,Limite):- Perg > Limite & Nova_Prop := (Perg+Prop)/2 & Nova_P > Limite <- Cont << rejeita(Perg) | comprador(Prop,Cont,Limite) Simone G D Prado

  15. Agente simples (cont...) <- vendedor(100,C,75)|comprador(40,100:C,80)(100+40)/2=70 <- vendedor(100,C,75)|C<<70:C1|comprador(70,C1,80) <- vendedor(100,70:C1,75)|comprador(70,C1,80) (100+70)/2=85 <- vendedor(85,C2,75)|C1<<85:C2|comprador(70,C1,80) <- vendedor(85,C2,75)|comprador(70,85:C2,80)(85+70)/2=77.5 <- vendedor(85,C2,75)|C2<<77.5:C3|comprador(77.5,C3,80) <- vendedor(85,77.5:C3,75)|comprador(77.5,C3,80) <- vendedor(85,C3,75)|C3<<aceita(77.5)|comprador(77.5,C3,80) <- vendedor(85,aceita(77.5),75)|comprador(77.5,aceita(77.5),80) Simone G D Prado

  16. Agentes submissos • Co-operação cliente-servidor // server(Pedido:Mais_Pedido, BcoDados) server(P:Ps,BD) <- transaction(P,BD,BDN)|server(Ps,BDN) 1o. Arg: fluxo da transação 2o. Arg: mensagem com o estado do servidor //cliente(Estado, Pedidos,Retorno) cliente(N,Ps,done):- N1:=N+1 <- Ps << do(N,Retorno):Ts|Cliente(N1,Ts,Retorno) Simone G D Prado

  17. Agentes submissos (cont...) • O servidor pode ser forçado a esperar até que a transação seja completada: server1(P:Ps,data(BD)) <- transaction(P,BD,BDN)|server1(Ps,BDN) • Para simplificar assume-se que o estado do servidor pe um registro de pedidos processados: transaction(do(Job,Reply),D,D1) <- D1<<data(Job:D)|Reply<<done. transaction1(do(Job,Reply),D,D1)<-Reply<<done;(D1<<data(Job:D)) Simone G D Prado

  18. Agentes sofisticados • Arquiteturas reflexivas ou meta nível são usadas pelos MAS. • Vanilla interpreter: // exec(Fila_de_metas) exec(done) <- done exec(user(Meta)|Rest_Metas) <- clause(user(Meta),Corpo)| exec(Corpo)|exec(Rest_Metas) clause(user(Head),Tail):- C1&...&Cn <- Tail << (user(b1)|...|user(bn)|done) Simone G D Prado

  19. Agentes inteligentes // agent0(Mensagem_Fluxo,Estado_Mental) agent0(Mens:Fluxo, EMental):- < condições mens e est mental> <- exec(Mens,EMental,Novo_EMental)| agent0(Fluxo,Novo_EMental) • O comportamento de exec/3 pode envolver envio de mensagens e/ou atualização de estado mental (crença, crenças comuns) • Enviar uma mensagem informal a um agente: // inform(Time, Agetn, Fact) inform(time_up, Agent,Fact) <- Agent << inform(Fact) Simone G D Prado

  20. Conclusões • O SLP • é potente para o MAS • pode modelar redes neurais • vetor de slots de mensagens receptores • uma mensagem pode conter slot • possibilita escolha entre comportamentos • tem sido usado para implementar sistema operacional distribuído Simone G D Prado

More Related