Laboratorio: Anotaciones para Sistemas Expertos
Objetivo: Crear anotaciones personalizadas para definir reglas y propiedades dentro de
un sistema experto simulado.
Pasos:
1. Crear el Proyecto:
o Abre tu IDE y crea un nuevo proyecto Java (si no tienes uno ya abierto).
Nómbralo, por ejemplo, SistemaExpertoAnotaciones.
2. Definir Anotaciones:
o Vamos a crear algunas anotaciones que podrían representar conceptos en
un sistema experto:
a. @Regla: Para marcar métodos que representan reglas del sistema
experto.
Crea una nueva interfaz Java llamada `Regla`:
```java
package tu.paquete.experto; // Reemplaza con tu paquete
import java.lang.annotation.ElementType;
import java.lang.annotation.Retention;
import java.lang.annotation.RetentionPolicy;
import java.lang.annotation.Target;
@Retention(RetentionPolicy.RUNTIME)
@Target(ElementType.METHOD)
public @interface Regla {
String nombre();
String descripcion() default "";
int prioridad() default 5; // Un valor por defecto
para la prioridad
}
```
* `@Retention(RetentionPolicy.RUNTIME)`: Indica que la
anotación estará disponible en tiempo de ejecución (para
poderla leer con Reflection).
* `@Target(ElementType.METHOD)`: Indica que esta
anotación solo se puede aplicar a métodos.
b. @Hecho: Para marcar campos que representan hechos o conocimientos
base del sistema.
Crea una nueva interfaz Java llamada `Hecho`:
```java
package tu.paquete.experto; // Reemplaza con tu paquete
import java.lang.annotation.ElementType;
import java.lang.annotation.Retention;
import java.lang.annotation.RetentionPolicy;
import java.lang.annotation.Target;
@Retention(RetentionPolicy.RUNTIME)
@Target(ElementType.FIELD)
public @interface Hecho {
String nombre();
String descripcion() default "";
}
```
* `@Target(ElementType.FIELD)`: Indica que esta
anotación solo se puede aplicar a campos (variables de
instancia).
3. Crear una Clase de Sistema Experto Simulado:
o Crea una clase Java llamada MotorInferencia. Esta clase contendrá los
hechos y las reglas, anotados con nuestras nuevas anotaciones.
Java
package tu.paquete.experto; // Reemplaza con tu paquete
public class MotorInferencia {
@Hecho(nombre = "temperatura_alta", descripcion = "La
temperatura del paciente es alta.")
public boolean temperaturaAlta = true;
@Hecho(nombre = "tos_presente", descripcion = "El paciente
tiene tos.")
public boolean tosPresente = true;
@Regla(nombre = "sospecha_gripe", descripcion = "Si la
temperatura es alta y hay tos, sospechar gripe.", prioridad =
10)
public void evaluarSospechaGripe() {
if (temperaturaAlta && tosPresente) {
System.out.println("REGla 'sospecha_gripe' se
cumple: Posible gripe.");
}
}
@Regla(nombre = "recomendar_descanso", descripcion = "Si se
sospecha gripe, recomendar descanso.", prioridad = 5)
public void recomendarDescanso() {
// Esta regla se activaría si la regla 'sospecha_gripe'
se cumplió (en un motor de inferencia real).
// Aquí solo lo simulamos.
if (temperaturaAlta && tosPresente) {
System.out.println("RECOMENDACIÓN: Se recomienda
descanso.");
}
}
public static void main(String[] args) {
MotorInferencia motor = new MotorInferencia();
// En un sistema experto real, aquí iría la lógica para
evaluar las reglas
// basándose en los hechos. Para este laboratorio, las
reglas se ejecutan directamente.
motor.evaluarSospechaGripe();
motor.recomendarDescanso();
}
}
4. Procesar las Anotaciones (Opcional para este laboratorio básico):
o Para un sistema experto real, necesitarías código que inspeccione las
clases en busca de las anotaciones @Hecho y @Regla y luego utilice esta
información para la inferencia. Esto se haría usando Reflection, similar a
como lo hicimos en el laboratorio anterior.
Conclusión del Laboratorio de Sistemas Expertos con Anotaciones:
Hemos creado dos anotaciones personalizadas (@Regla y @Hecho) que nos permiten
añadir metadatos semánticos relacionados con un sistema experto directamente en
nuestro código Java. Esto podría facilitar la organización y el procesamiento de las
reglas y los hechos en un motor de inferencia más complejo.
En un sistema experto real, un motor de inferencia examinaría las clases anotadas,
extraería la información de las reglas y los hechos, y luego utilizaría un algoritmo
(como encadenamiento hacia adelante o hacia atrás) para llegar a conclusiones.
