Ejemplo

Tomemos como referencia un ejemplo sencillo de sistema basado en reglas, como el que vemos en la sección que acompaña.

A continuación indicamos los usos básicos de ProbLog para trabajar con este ejemplo, que incluyen:

• Ejecución online en el sitio web de problog.
• Mediante un terminal, pasando el nombre del fichero .pl al comando problog.
• Llamando a la shell de problog desde terminal, y en ella consultar archivos y lanzar preguntas.
• Desde código Python

A las preguntas planteadas, el sistema deberá responder como se muestra en los árboles de resolución mostrados.

Editor online

Basta con acudir al editor online, introducir el código correspondiente en el área de texto, dejar la opción Inference seleccionada en el desplegable de la derecha y lanzar la evaluación de las consultas planteadas al sistema mediante Evaluate.

En este enlace puede ver el ejemplo en cuestión, listo para probarlo.

Comando terminal

Si tenemos instalado ProbLog instalado en nuestro equipo, podemos escribir nuestra base de conocimientos (BC) en un fichero y pasarlo a problog como parámetro del comando. Basta con escribir en el terminal, asumiendo la existencia del fichero ejemplo_simple.pl en la ruta indicada::

C:\Users\...\Tema2>problog Ej01/ejemplo_simple.pl
s(a):   0
s(b):   1

Esta salida nos indica, como en el caso online, que a la luz de los hechos, tenemos que se cumple s(b) y no se cumple s(a).

Shell

A través de la shell de problog

Desde el terminal podemos abrir una shell de problog:

C:\Users\...\Tema2>problog shell
% Welcome to ProbLog 2.1 (version 2.1.0.39)
% Type 'help.' for more information.
?-

El signo de interrogación nos indica que está esperando que demos órdenes al núcleo de blog. Aquí podremos cargar una base de conocimientos (usando consult) y hacer las preguntas que requiramos (usando query):

?- consult('Ej01/ejemplo_simple.pl').
?- query(s(a)).
s(a):   0
?- query(s(b)).
s(b):   1

Como vemos, el mismo resultado anterior se sigue manteniendo.

Python

Podemos lanzar igualmente el proceso sobre la base de conocimiento, empleando el motor de inferencia de ProbLog, a través de la llamada desde código Python como el siguiente:

from problog.program import PrologString
from problog.core import ProbLog
from problog import get_evaluatable

p = PrologString("""
s(X) :- q(X), \+r(X).
q(X) :- p(X).

p(a).
p(b).
r(a).

query(s(a)).
query(s(b)).
""")

r = get_evaluatable().create_from(p).evaluate()
print(r)

Puede escribir este fragmento de código Python en un fichero ejemplo_simple.py y lanzarlo desde el terminal:

C:\Users\...\Tema2>python Ej01/ejemplo_simple.py
{s(a): 0.0, s(b): 1.0}

Como vemos, el resultado es el mismo que en los casos anteriores, confirmándonos que el predicado s se cumple sobre b, pero no así sobre a. Comprobamos así que todos estos métodos estarán a nuestro alcance, para distintos uso pero siempre empleando el mismo núcleo y obteniendo, por tanto, el mismo resultado.

Hechos y reglas

% Estableciendo relaciones entre conceptos, datos...

%%% HECHOS

docente(marta). % Marta es docente
docente(laura). % Laura es docente
docente(miguel). % Miguel es docente

estudiante(paco). % Paco es estudiante
estudiante(susana). % Paco es estudiante
estudiante(raquel). % Paco es estudiante

asignatura(satd). % SATD es una asignatura

matriculado(paco,satd). % Paco se ha matriculado en SATD.
matriculado(raquel,satd). % Susana se ha matriculado en SATD.

imparte(marta,satd). % Marta imparte la asignatura SATD.
imparte(miguel,satd). % Miguel también imparte la asignatura SATD.


%%% REGLAS

% Sabiendo quién imparte cada asignatura y quién está matriculado,
% podremos deducir la asociación entre profesores y alumnos, 
% asumiendo que existe únicamente un grupo.

da_clase(Prof,Estud) :- docente(Prof), estudiante(Estud), 
                        asignatura(X), matriculado(Estud,X), imparte(Prof,X).

% La regla nos dice literalmente:
% "Si Prof es un docente, Estud es un estudiante, y existe una asignatura X
%  tal que Estud la estudia y Prof la imparte, entonces sabemos que
%  Prof da clase a Estud."


% A partir de lo anterior, podemos preguntar al sistema quién da clase a quién:

query(da_clase(X,Y)).

% Al pasarle las variables X e Y, el sistema devolverá todas las parejas X e Y 
% tales que X da clase a Y.

% De forma similar, si dos estudiantes están matriculados en la misma asignatura
% podemos decir que comparten clase:

comparten_clase(Estud1,Estud2) :- asignatura(X), matriculado(Estud1,X), matriculado(Estud2, X).

% Veamos qué compañeros/as tiene Raquel:

query(comparten_clase(raquel,Comp)).

Aritmética básica

% En una determinada cafetería vegetariana hay tres posibles desayunos:
% café (1 euro), café y media (1.70), o café con media y zumo (2.20).

desayuno(nada).
desayuno(cafe).
desayuno(cafeymedia).
desayuno(cafeconmediayzumo).

cuesta(nada,0).
cuesta(cafe,1).
cuesta(cafeymedia,1.70).
cuesta(cafeconmediayzumo,2.20).

% Para que una determinada persona pueda comprar un desayuno,
% debe contar con saldo suficiente para pagarlo (mayor o igual a su coste) 
puededesayunar(Pers,D) :- saldo(Pers,X), desayuno(D), cuesta(D,Y), X >= Y.

% Literalmente:
% si una persona Pers tiene un saldo X, hay un desayuno D que cuesta Y,
% y X es mayor que Y, entonces Pers puede comprar Y.

% Hemos necesitado un operador de comparación (X>=Y), sobre dos elementos 
% previamente sustituidos en las relaciones anteriores.

% Luis tiene 2 euros
saldo(luis,2).

% ¿Qué puede comprar Luis?
query(puededesayunar(luis,Art)).

% Además, podemos enriquecer la regla anterior, en caso de estar interesados 
% en saber con cuánto dinero nos quedaríamos según lo que compremos.

% María tiene 6.5 euros:
saldo(maria,6.5).

% ¿Qué puede desayunar María?
%query(puededesayunar(maria,Art)).

% Creamos la regla que a lavez compruebe si podemos comprar un producto y
% nos diga lo que nos queda si lo compramos.

quedariasicompra(Pers,D,Restante) :- 
    saldo(Pers,X), desayuno(D), cuesta(D,Y), X >= Y, Restante is X-Y.

% Como podemos observar en la regla, para ver lo que nos quedaría 
% necesitamos ver que podemos comprarlo (comparación), y además calcular 
% la diferencia del saldo acual y lo que cuesta el producto. Esto me lleva 
% a un pequeño cálculo aritmético (X-Y) y una asignación (Restante is X-Y).

%¿Cuánto le quedaría a María si compra el desayuno com zumo?

% Vaya descomentando y comentando las preguntas que quiera lanzar
%query(quedariasicompra(maria,cafeconmediayzumo,Queda)).

%¿Y si prescinde del zumo?

%query(quedariasicompra(maria,cafeymedia,Queda)).

% La comida de menú cuesta 4.5 euros...

comida(menu).

cuesta(menu,4.5).

% Una persona podrá comer una determinada comida,
% si tras el desayuno le ha quedado bastante dinero,
% y desde luego no desayunar no será una opción,
% ¡que hay que tirar el resto del día!
puedecomer(Pers,Des,Com,Sobra) :- 
        saldo(Pers,X), quedariasicompra(Pers,Des,Queda), Des \= nada,
        comida(Com), cuesta(Com,Precio), Queda >= Precio,
        Sobra is Queda - Precio.

% ¿Qué puede hacer María para desayunar y comer con el saldo que ha traído?
% ¿Le sobrará algo?
%query(puedecomer(maria,Des,Com,Sobra)).

SBC sobre síntomas y enfermedades

En este enlace encontrará un primer ejemplo de una base de conocimiento basada en reglas haciendo uso de ProbLog.

En la misma puede distinguir varios elementos a destacar:

• Una serie de reglas que nos proporcionan hipótesis, diagnósticos tentativos, de modo que si un determinado Paciente tiene una serie de síntomas es posible que ese Paciente tenga la enfermedad indicada en la regla.
• Una conjunto de de hechos, situados tras las reglas, indicando que ha llegado Antonio con unos ciertos síntomas y María con otros.
• Un par de consultas, que trasladan al sistema basado en reglas la cuestión de qué posibles enfermedades pueden estar afectando a Antonio y a María, respectivamente.

Puede ver el código correspondiente en la sección Base de conocimiento que acompaña a esta pestaña. Como observará, los elementos esenciales que encontramos son:

• Los predicados sintoma e hipotesis.
• Una serie de constantes (en minúsculas) representando los distintos síntomas posibles, así como a los pacientes concretos Antonio y María (nótese de nuevo la representación usando minúsculas para maria y antonio, al tratarse de constantes, valores específicos.)
• Tres variables (en mayúsculas): la primera representando cualquier posible Paciente, que presente cierto conjunto de síntomas, que lleven a concluir como posibilidad un cierto conjunto de hipótesis; las otras dos, más que parte de la base de conocimientos, forman parte de la consulta a realizar, de modo que la variable Enfermedad1 pueda devolvernos un valor para cada posible enfermedad como diagnóstico tentativo de Antonio, y de forma equivalente con Enfermedad2 para María.

Podemos lanzarlo desde cualquiera de los métodos que hemos visto en la sección de Primer uso. En cualquiera de los casos, como vemos en la imagen, obtenemos como posibles diagnósticos para Antonio la varicela y la rubeola y para María las paperas.

Diferenciando roles

En el ejemplo inicial tenemos en el mismo archivo tres elementos distintos:

• Base de conocimiento general sobre la relación entre síntomas e hipótesis
• Información específica sobre pacientes (hechos que representan evidencias de pacientes concretos)
• Consultas a realizar al sistema.

Parece que una aproximación más realista sería contar con una base de conocimiento general, como la que se puede observar en la sección Mejora, y dada la presencia de un paciente concreto en consulta que ha llegado con unas evidencias determinadas (por ejemplo, María), se pueda introducir esa evidencia y posteriormente pedir al sistema hipótesis, sugerencias de diagnóstico.

Eche un vistazo a esta sesión con el shell de problog:

?- consult('Ej02/kb_sintoma_enfermedad_2.pl').
?- query(hipotesis(maria,Enf)).
No clauses found for 'sintoma/2' at 2:5 in .\Ej02/kb_sintoma_enfermedad_2.pl.
?- use_module(library(assert)).
?- assertz(sintoma(maria,ganglios_inflamados)), assertz(sintoma(maria,fiebre)).
p: 1.0;
---------------
?- assertz(sintoma(maria,malestar_general)), assertz(sintoma(maria,dolor_de_cabeza)).
p: 1.0;
---------------
?- query(hipotesis(maria,Enf)).
hipotesis(maria,paperas):       1

Como puede observar, tras cargar la base de conocimientos general, solicitamos hipótesis pero el sistema no encuentra ninguna evidencia para comenzar a trabajar, ningún síntoma.

Ahora bien, podemos cargar el módulo assert, y posteriormente hacer uso del mismo, con su función assertz, para introducir los hechos relacionados con la evidencia concreta del paciente, en este caso María. Como vemos al final, nos plantea como hipótesis las paperas.