Frames: Implementación en AgentSpeak

RESUMEN
La representación del conoocimiento de una manera sencilla y adecuada es uno
de los mayores desafíos de la Inteligencia Aritificial.

Una de las primeras representaciones estandarizados fueron las redes

semánticas, grados dirigidos que representan conceptos y sus relaciones. A
partir de éstas surgen los Frames: un método similar con mayor potencial
expresivo.

Para ello, se tomará como ejemplo, las relaciones entre alumnos, profesores y la
asignatura impartida .Esta implementación utilizará el lenguaje AgentSpeak,
usando adicionalmente artefactos Cartago para crear el entorno donde se
producen las relaciones.

INTRODUCCIÓN

Representación del conocimiento

Según Randall Davis(1), una Representación del Conocimiento (RC) se puede comprender en 5
roles:

1. Sustituto: del objeto/sujeto que deseamos representar.

2. Compromiso ontológico: que percibimos y como lo hacemos.
3. Teoría fragmentada de Razonamiento Inteligente (TFRI): Que significa razonar
inteligentemente y que podemos inferir de lo que sabemos.
4. Medio de computación eficiente: Preguntas sobre como diseñar nuestro razonamiento a
nivel de programación.
5. Medio de expresión humana: Como de bien funciona como medio de comunicación. Que
fácil nos es hablar en ese lenguaje.

Es decir, cada RC enfatizará ciertos roles dado que algunos roles no son compatibles (e.g. TFRI
vs Computación eficiente).

Representación por Frames

Un frame (Fig1) se define como una representación estructurada de un objeto (es decir, una
instancia) o de clases de objetos (es decir, una clase). Está idea de objeto será similar a la usada
en Programación Orientada a Objetos (POO).

Asignatura
Alumnos

Max_Alumnos

Fig1. Ejemplo de frame con dos slots

Por tanto, un sistema de frames será un conjunto de frames unidos mediante relaciones (Fig2).
Éstas serán mayoritariamente generalizaciones (Tobi es un perro), agregaciones (Tobi tiene una
cola) o asociaciones (Perro persigue a Gato). Por lo general, las instancias de un frame serán
generalizaciones mientras que las relaciones entre frames de clase serán asociaciones.

Asignatura
Alumnos

Max_Alumnos

Parte de

EntregaGrupo
Nota
Viewer does not support full SVG 1.1

Fig2. Ejemplo de relación entre dos Frames

Cada frame tendrá uno o varios slots, a los que se le asignarán valores. Estos representarán
descripciones de los atributos de la clase o instancia.

Para la notación de frames de instancia usaremos minúsculas , mientras que los frames generales
empezarán cada término con maýusculas (e.g. CiudadEspañola).

RESOLUCIÓN DE PROBLEMA

Enunciado
Explicar en que consisten los Frames mediante el ejemplo de las relaciones mostrado con la
Universidad de Vigo utilizado para construir una simulación en la que un profesor solicita a un
grupo de alumnos la realización de un trabajo que constará de dos entregas diferentes: una
memoria y un vídeo, que serán calificados por separado con un peso diferente (seguro que os
suena)

Planteamiento
Dada la información y contexto (o falta de) recibidos, se ha propuesto lo siguiente:

• Frames y slots: se emplearán 6 frames de clase en total, según lo que se observa en las
Fig3-8. Los slots marcados con un asterisco representarán la falta de valor por defecto en
cada frame instancia de un frame clase.
 Alumno Profesor
*Nombre *Nombre

*Nota Entrega1 Asignatura

*Nota Entrega2
Entrega Grupo
*Nota total Tipo Max_miembros

*Grupo Ponderación *Miembros

EntregaGrupo
Nota

Fig3-8. Frame empleados en la resolución del problema

• Relaciones (FigN): El diseño final utilizado será el mostrado en la Fig 7.

Profesor Alumno
*Nombre *Nombre

Asignatura *Nota Entrega1

Matriculado en
Imparte *Nota Entrega2

*Nota total

Asignatura *Grupo

Alumnos
Propone
Max_Alumnos
Parte de
Pertenece a
Parte de

Parte de

Entrega Parte de Grupo

EntregaGrupo
Tipo Hace Max_miembros
Nota
Ponderación *Miembros
Viewer does not support full SVG 1.1

Fig1-6. Frame empleados en la resolución del problema

Con este diseño se busca representar:

• El unirse a la asignatura.
• El comienzo de la asignatura.
• La creación e incorporación de miembros a un grupo.
• La entrega propuesta por el profesor y su lectura por parte del alumno.
• El proceso del trabajo del grupo.
• La corrección y “subida” de notas.
Implementación mediante AgentSpeak

Para su implementación en Jason, se han seguido los siguientes criterios:

• Se han creado 4 agentes que representarán 4 instancias diferentes del frame Alumno
(alumno1,alumno2,alumno3, alumno4). Uno de ellos, actuará como “lider” o portavoz del
grupo para evitar la aglomeración de mensajes.
• Se ha creado un agente que representa una instancia del frame Profesor (profesor).
• En vez de implementar el resto de frames como “pseudoagentes”, se integrarán en la
aplicación como artefactos usando Cartago.

A continuación, veremos las correspondencias entre los Frames y los agentes y Artefactos.

Artefactos:

➔ Asignatura
◦ Slot alumnos: Será una variable de clase que deberá asignar su valor inicial.
◦ Slot max_alumnos: Será una variable de clase con valor por defecto al inicio.

➔ Entrega
◦ Slot tipo: Será una variable de clase que deberá asignar su valor inicial. Este será
“memoria“ o “video”.
◦ Slot ponderación: Será una variable de clase que deberá asignar su valor inicial. Valores
admitidos: 0.1 a 0.9

➔ EntregaGrupo
◦ Slot nota: Será una variable de clase que deberá asignar su valor inicial. Valores admitidos:
0.0 a 10.0

➔ Grupo
◦ Slot miembros: Será una variable de clase que deberá asignar su valor inicial.
◦ Slot max_miembros: Será una variable de clase con valor por defecto al inicio.

Agentes:

➔ Profesor
◦ Slot Nombre: Equivaldrá a la acción interna “my_name”
◦ Slot Asignatura: Se adquirirá como creencia tras la acción inicial.

➔ Alumno
◦ Slot Nombre: Equivaldrá a la acción interna “my_name”
◦ Slot Nota1: Será una creencia adquirida.
◦ Slot Nota2: Será una creencia adquirida.
◦ Slot NotaFinal: Será una creencia adquirida.
◦ Slot Grupo: Será una creencia adquirida o creada (portavoz).
Ejecución del programa

El programa seguirá el siguiente recorrido:

1. El profesor comenzará la Asignatura si, avisando a los alumnos de ello.

2. Los alumnos reaccionarán uniéndose a la asignatura y formando los grupos de trabajo.
3. Al alcanzar el número máximo de alumnos y formarse los grupos, el artefacto Asignatura
mandará una señal al profesor.
4. El profesor entonces, subirá la entrega1 a la Asignatura si, notificando a los alumnos del
trabajo.
5. El portavoz de cada grupo, percibirá la Entrega, creará la EntregaGrupo correspondiente y
avisará a sus miembros del trabajo.
6. Los miembros de cada grupo colaborarán para completar la Entrega. Cuando es
completada, el portavoz del grupo se lo notificará al profesor.
7. El profesor entonces, corregirá la Entrega y calificará a los alumnos del grupo,
actualizando su percepción de la nota de dicha Entrega.
8. Cuando todos los grupos han sido evaluados, el profesor subirá la siguiente entrega. Se
volverán a recorrer los puntos 4 a 7 hasta que no haya más Entregas.
9. Al terminar todas las entregas, el profesor subirá la nota media del trabajo realizado y
actualizará las creencias de los alumnos sobre la nota final.

ANEXO: CÓDIGO AGENTSPEAK

Artefacto Grupo
package tools;
import cartago.*;
import cartago.tools.*;
import java.lang.Math;

public class Grupo extends Artifact {

private String[] Miembros; // Array de miembros

static final int max_miembros = 4; // Número maximo de miembros

// Constructor
void init(String c, String g){
defineObsProperty("miembros", 0);
Miembros = new String[max_miembros];
addMiembro(c,g);
}

// Añade un miembro y añade la creencia "grupo" en el alumno añadido.

@OPERATION
void addMiembro(String c, String g){
ObsProperty prop = getObsProperty("miembros");
int index = (int)prop.getValue();
if (index < max_miembros){
Miembros[index] = c;
prop.updateValue(index+1);
signal(c,"grupo",g);
}
}

// Comunica a todos los miembros la creencia "trabajoGrupo"

@OPERATION
void hacerEntrega(String E){
 signal("trabajoGrupo",E);
}

Artefacto Asignatura
package tools;
import cartago.*;
import cartago.tools.*;
import java.lang.Math;

@ARTIFACT_INFO(
outports = {
@OUTPORT(name = "E1G1"),
@OUTPORT(name = "E2G1")
}
)
public class Asignatura extends Artifact {

// Lista de alumnos
private String [] Alumnos;
// Alumnos maximos
public static int max_alumnos = 4;

private double [] nGrupo1;

void init(){
defineObsProperty("comienzo_curso", true);
defineObsProperty("al_inscritos",0);
defineObsProperty("al_nagrupados",4);
Alumnos = new String[max_alumnos];
nGrupo1 = new double[2];

@OPERATION
void addAlumno(String a){
ObsProperty prop = getObsProperty("al_inscritos");
int index = (int)prop.getValue();
Alumnos[index] = a;
prop.updateValue(index+1);
signal("apuntado",a);

if(index+1 == max_alumnos){
signal("alumnos_dentro");
}
}

@OPERATION
void addGrupo(int n){
ObsProperty prop = getObsProperty("al_nagrupados");
int agrup = (int)prop.getValue();
agrup=agrup-n;
prop.updateValue(agrup);
}

@OPERATION
void solicitarMiembro(String g){
signal("joinGrupo",g);
 }

@LINK
void avisoEntrega(String E,double p,String t){
signal("hayEntrega",E,p,t);
}

@OPERATION
void correccion(String e){

double min = 0.0;

double max = 9.0;

double nota = (Math.random()*(max-min)+1)+min;

if (e.equals("E1Grupo1")){
nGrupo1[0]=nota;
try{
execLinkedOp("E1G1","calificarEG",nota);
}
catch(Exception ex){
ex.printStackTrace();
}
signal("nota_decidida",e,nota,0.4);
}

if (e.equals("E2Grupo1")){
nGrupo1[1]=nota;
try{
execLinkedOp("E2G1","calificarEG",nota);
}
catch(Exception ex){
ex.printStackTrace();
}
signal("nota_decidida",e,nota,0.6);
}
}

@OPERATION
void evaluacion(double p1, double p2){
double nota_final = (nGrupo1[0]*p1) + (nGrupo1[1]*p2);
signal("nota_total",nota_final);
}

Artefacto Entrega
package tools;
import cartago.*;
import cartago.tools.*;

@ARTIFACT_INFO(
outports = {
@OUTPORT(name = "Primera"),
@OUTPORT(name = "Segunda")
}
)
public class Entrega extends Artifact {

private double ponderacion;

private String tipo;
 void init(double p,String t){
ponderacion = p;
tipo = t;
}

@OPERATION
void mostrarEntrega(String E){
if(E.equals("Entrega1")){
try{
execLinkedOp("Primera","avisoEntrega",E,ponderacion,tipo);
}
catch(Exception ex){
ex.printStackTrace();
}
}
if(E.equals("Entrega2")){
try{
execLinkedOp("Segunda","avisoEntrega",E,ponderacion,tipo);
}
catch(Exception ex){
ex.printStackTrace();
}
}
}

Artefacto EntregaGrupo

package tools;
import cartago.*;
import cartago.tools.*;

public class EntregaGrupo extends Artifact {

private double ponderacion; // Ponderación de la entrega sobre la nota

total
private String tipo; // Tipo de trabajo a entregar: memoria o video
private double nota; // Nota de la instancia EntregaGrupo

// Constructor
void init(double p,String t){

defineObsProperty("progreso", 0);
ponderacion = p;
tipo = t;
}

// Randomiza un valor que se emplea para actualizar la creencia "progreso"

// que representa como de completada está la entrega
@OPERATION
void actualizarProgreso() {

double max = 10.0;

double min = 1.0;

double porcentaje = (Math.random()*(max-min)+1)+min;

int porcentaje_int = (int)porcentaje;
ObsProperty prop = getObsProperty("progreso");
int valor_actual = porcentaje_int + (int)prop.getValue();
 if(valor_actual > 100){
valor_actual = 100;
}
prop.updateValue(valor_actual);
}

// Set a través de Asignatura

@LINK
void calificarEG(double n){
nota=n;
}

// Pone el valor de la creencia "progreso" a 0

@OPERATION
void resetearContador(){
ObsProperty prop = getObsProperty("progreso");
prop.updateValue(0);
}
}

Agente profesor

/* Plan inicial*/
!comenzar_curso.

/* Planes */

// Crea la asignatura, y avisa a los demás alumnos para que se anoten

+!comenzar_curso
<- makeArtifact("SI","tools.Asignatura",[],C);
focus(C);
.send([alumno1,alumno2,alumno3,alumno4],tell,comienzo_curso("SI")).

// Añade un grupo
+grupo(B)
<- println("- - - - - - - - - -");
println("Grupo creado");
println("- - - - - - - - - -");
addGrupo(B).

// Si no hay más alumnos que se puedan incorporar, empieza la primera entrega

+al_nagrupados(0) <- !describir_primera.

// Manda la primera entrega

+!describir_primera
<- lookupArtifact("SI",C);
makeArtifact("Entrega1","tools.Entrega",[0.4,"video"],D);
println("- - - - - - - - - -");
println("",D," Creada");
println("- - - - - - - - - -");
linkArtifacts(D,"Primera",C);
mostrarEntrega("Entrega1").

//Corrige una entrega

+entrega(E) <- println("",E," recibida, procedo a corregir");println("- - - - -
- - - - -");!corregir(E).

+!corregir(E) <- correccion(E).

//Manda la nota de la entrega corregida
+nota_decidida(E,N,P)
<- println("- - - - - - - - - -");
println("He decidido calificar ",E," con un ",N);
println("- - - - - - - - - -");
.send(["alumno1","alumno2","alumno3","alumno4"],tell,nota(E,N,P)).

// Segunda entrega
+entrega2 <- !describir_segunda.

+!describir_segunda
<- lookupArtifact("SI",C);
lookupArtifact("Entrega1",A);
disposeArtifact(A);
makeArtifact("Entrega2","tools.Entrega",[0.6,"informe"],E);
println("- - - - - - - - - -");
println("Entrega 2 creada");
println("- - - - - - - - - -");
linkArtifacts(E,"Segunda",C);
mostrarEntrega("Entrega2").

// Nota final
+final <- !evaluacion.

+!evaluacion <- evaluacion(0.4,0.6).

Agente alumno1

// El alumno espera a que el profesor comience la asignatura para anotarse en

ella
+comienzo_curso(C)[source(profesor)]: true
<- .wait(2000);!cursar(C).

// Acción de unirse a la asignatura con un método que avisará al profesor cuando

el número máximo de alumnos inscritos sea alcanzado
+!cursar(C)
<- lookupArtifact(C,E);
println("Empiezo Curso");
focus(E);
addAlumno("alumno1").

// Cuando el alumno "lider" actualiza sus creencias, y se percibe apuntado en la

asignatura, creará un grupo de trabajo
+apuntado("alumno1") <- println("Me he unido");!crear_grupo.

// Creación del grupo de trabajo, que añadirá al propio lider como miembro de
dicho grupo en su constructor
+!crear_grupo
<- lookupArtifact("SI",C);
makeArtifact("Grupo1","tools.Grupo",["alumno1","Grupo1"],D);
println("Grupo creado");
.wait(2000);
focus(D);
!add_miembros("Grupo1").

// Intención cuando el número de miembros máximo se haya alcanzado. Notifica al

profesor la creación del grupo y número de mimebros.
+!add_miembros(G): miembros(4) <-println("Grupo completado");println("- - - - -
- - - - -");.send(profesor,tell,grupo(4)).
// Intención cuando el número de miembros no es el máximo. Pregunta a todos los
alumnos si desean unirse.
+!add_miembros(G): not miembros(4) <- solicitarMiembro(G);.wait(4000); !
add_miembros(G).

// Si el alumno "lider" percibe que hay una entrega disponible, creará la

Entrega del Grupo1, y notificará a los miembros de la Entrega para su
realización
+hayEntrega("Entrega1",P,T)
<- lookupArtifact("SI",C);
makeArtifact("E1Grupo1","tools.EntregaGrupo",[P,T],D);
linkArtifacts(C,"E1G1",D);
println("Entrega 1, con ponderación ",P," y tipo ",T);
hacerEntrega("E1Grupo1").

+hayEntrega("Entrega2",P,T)
<- resetearContador;
lookupArtifact("SI",C);
makeArtifact("E2Grupo1","tools.EntregaGrupo",[P,T],D);
linkArtifacts(C,"E2G1",D);
println("Entrega 2, con ponderación ",P," y tipo ",T);
hacerEntrega("E2Grupo1").

// Percibe que el trabajo en grupo se inicia, ejecutando concurrentemente el

"proceso de desarrollo" del trabajo
+trabajoGrupo(A) <- lookupArtifact(A,B);focus(B);!desarrollar_entrega(A,B).

// Percepción del total completado del trabajo. Solo lo hará el "lider" para
evitar confusión y solapamiento de informaciones.
+progreso(C) <- println("Progreso: ",C,"%").

// Si el proceso no se ha completado, se sigue trabajando "actualizando" la

completitud de la entrega
+!desarrollar_entrega(A,B): not progreso(100) <-
actualizarProgreso[artifact_id(B)];.wait(1000);!desarrollar_entrega(A,B).

// Cuando la entrega se percibe completada, se enviará al profesor para su

correción
+!desarrollar_entrega(A,B): progreso(100) <- println("",B,"
terminada");.send(profesor,tell,entrega(A)).

// Creencias sobre las notas

+nota("E1Grupo1",N,P) <- println("La nota de Entrega1 es ",N,", con ponderación
",P);.send(profesor,tell,entrega2).

+nota("E2Grupo1",N,P) <- println("La nota de Entrega2 es ",N,", con ponderación

",P).send(profesor,tell,final).

+nota_total(N) <- println("La nota total es ",N).

Agentes alumno2, alumno3, alumno4

// El alumno espera a que el profesor comience la asignatura para anotarse en

ella
+comienzo_curso(C)[source(profesor)]: true
<- .wait(2000);!cursar(C).

//Deseo de unirse a la asignatura

+!cursar(C)
<- lookupArtifact(C,E);
println("Empiezo curso");
focus(E);
addAlumno("alumno2").

// Creencia de que el alumno se ha unido a la asignatura

+apuntado("alumno2") <- println("Me he unido").

// Si el alumno ya tiene grupo, notifica cual es su grupo

+joinGrupo(D): grupo(E) <- println("Ya tengo grupo, es el ",E).

//Si el alumno no tiene grupo se unirá a la primera petición entrante.

+joinGrupo(D) : not grupo(E)
<- lookupArtifact(D,C);
focus(C);
addMiembro("alumno2",D);
.wait(2000).

// Si el "lider" indica que debe hacerse una entrega, se desarrollará la entrega

+trabajoGrupo(A) <- lookupArtifact(A,B);focus(B);!desarrollar_entrega(A,B).

// Si el proceso no se ha completado, se sigue trabajando "actualizando" la

completitud de la entrega
+!desarrollar_entrega(A,B): not progreso(100) <-
actualizarProgreso[artifact_id(B)];.wait(1000);!desarrollar_entrega(A,B).

// Entrega completada
+!desarrollar_entrega(A,B): progreso(100) <- println("",B," terminada").

CONCLUSIÓN

La Representación del Conocimiento es un tema complicado, ya que debemos comprometer

algunos roles para emplear nuestro modelo de Representación. En el caso de los Frames, el rol
TFRI es comprometido en favor del Sustituto, del Medio de omputación eficiente y del Medio de
Expresión Humana. El compromiso ontológico también sería más limitado per se, ya que solo
percibimos frames de entidad y de clase, pero no interacciones entre instancias o entre clases.

Sin embargo, la implementación en Jason usando Cartago nos permite compensarlo ya que
podemos percibir propiedades observables en los Artefactos, que podrán alterar los deseo de un
agente. Este también solo habría sido un frame entidad, sin deseos o creencias; pero el empleo
de Jason evita eso.

La implementación podría haber sido más avanzada, pudiendo almacenar más grupos e
interacciones a la hora de formar los grupos o interactuar con el entorno/Artefacto Asignatura. Una
mayor investigación y desarrollo con Cartago podría haber conseguido esos objetivos.

En definitiva, Jason y Cartago son herramientas que permiten una capa adicional de expresión
para representaciones que se asemejan más a Bases de Datos o Modelos Entidad-Relación.

BIBLIOGRAFÍA

Coppin, Ben (2004) Artificial Intelligence Illuminated Ely, England, United Kingdom: Jones &
Bartlett
Fikes, Richard & Kehler, Tom (1985). The Role of Frame-Based Representation in Reasoning.
Communications of the ACM

Cibrán Rey De dios

[email protected]
Estudiante del Grado en Ingeniería Informática en la Universidad
de Vigo. Becario de Libre Acceso en la Facultad de Historia de
Ourense. Becario en EDISA. Fluente en Inglés.