Sistemas inteligentes y sus sociedades

Walter Fritz

Introducción
En el GL 3 todo se logra con conceptos y reglas de actuación. Un concepto es un patrón existente entre partes de entradas o partes de salidas.
Una regla de actuación es un patrón secuencial (temporal) entre la situación actual (Sit1) y la situación futura (FS). La Sit1 y la FS son parte de la regla. La Sit1 es la situación a la cual se puede aplicar la regla y la FS el la situación futura resultante; también llamada el objetivo. Ambos son expresados con conceptos.
La parte IntSit de una regla consiste de una situacion intermedia, también expresada con conceptos.

• Posiblemene, en el futuro, algunas reglas pueden representar conceptos en un pizarrón interno (que también es un concepto), y retrabajarlas o reagruparlas (esto es la imaginación). De esta manera debería poder aprender muchas de las actividades que las personas hacen con lápiz y papel, o piedritas, o palitos.
  El concepto ":pizzarón": puede mostrarse o no en la pantalla de la computadora, eligiéndolo con el menú. La pantalla muestra una planilla con lineas y columnas. Si es visible en la pantalla, y cambia a medida que hay cambios en el concepto pizarrón. El concepto "pizarrón" incluye los conceptos linea1, linea2 etc. El concepto linea 1 incluye los conceptos posición 1, posición2 etc.

Reglas externas toman información del entorno y actuan sobre el entorno. Reglas internas hacen el procesamiento dentro de la parte cerebro del GL 3. Esto incluye crear conceptos abstractos y compuestos, crear reglas, elegir una regla a hacer, olvidar, aprender por generalización etc. La calidad de las reglas internas determina la capacidad del cerebro. El programador provee un juego de reglas internas elementales.

Conceptos iniciales de situación interna

• 10005: AWAKE (despierto)
• 10006: WORDS (palabras)
• 10007: DRAWINGS (dibujos)
• 10008: EXTERN_SIT (situación externa creada)
• 10009: RUL_LEARNED (la regla está aprendida)
• 10010: RUL_CAND_LIST (lista de reglas aplicables hecha)
• 10011: RUL_WT_LIST (lista de valores correspondientes)
• 10012: SEL_RULE (regla seleccionada)
• 10013: ACTION (accion)
• 10014: ASLEEP (estado dormido)
• 10015: RULES_COMB (reglas fueron combinadas)
• 10016: CHRONO_EXT (lista cronológica de reglas externas usadas)
• 10017: CHRONO_INT (lista cronológica de reglas internas usadas)
• 10018: CONC_COMB (conceptos combinados hechos)
• 10019: CONC_ABSTR (conceptos abstractos hechos)
• 10020: SIT_GENERAL (la situacion fue generalizada y un nuevo concepto creado)
• 10021: DIR_REP (un cierto patrón hecho)
• 10022: REP_LAB (un cierto patrón hecho)
• 10023: PAT_OP (un cierto patrón hecho)

Reglas elementales
Reglas elementales son reglas que arrancan la correspondiente función de lenguaje C. Al principio el programador provee todas las reglas elementales internas. Vea una lista de reglas elementales en: Reglas elementales (Entre para leer de corrido, como un libro). Al arrancar el programa por primera vez, el GL3 combina reglas elementales a reglas combinadas. Despues, combina estas en reglas combinadas, mas y mas grandes, llegando finalmente a reglas de maximo nivel. Todas las demas reglas, que cumplen con las funciones del cerebro, son parte de aquellos.

Nota: Para poder usar una regla, la parte sit1 de una regla tiene que coincidir con la situación actual, y la parte FS de la regla tiene que coincidir con la situación futura deseada. La sit1 y la FS contienen conceptos concretos, combinados o abstractos.

El bucle principal
El bucle principal del programa tiene las siguientes partes (sub programas):

Evento principal
Aquí el programa maneja "eventos", o sea actividad del teclado y del ratón, pedidos hechos por menu y muestra ventanas.

Aprobación
El sub programa que detecta la aprobación o desaprobación hecha por la persona y que modifica las reglas afectadas.

Mantener las situaciones
En el estado despierto pone:
La situación inicial (sit1) a: AWAKE
La situación medida (IntSit) a: AWAKE, EXTERN_SIT, RUL_LEARNED
La situación final (FS) es la misma como la situación inicial.

En estado dormido pone:
La situación inicial (sit1) a: ASLEEP, CHRONO_EXT
La situación media (IntSit) a: ASLEEP, CHRONO_INT
La situación final (FS) es la misma como la situación inicial.

Nota:
CHRONO_EXT quiere decir que el programa está trabajando con la lista de reglas externas usadas.
CHRONO_INT quiere decir que el programa está trabajando con la lista de reglas internas usadas.

Elegir una regla
Elije una regla que puede llegar de la situación inicial a la situación media.

Hacer la regla
Ejecuta esta regla.

Elegir una regla
Elije una regla que puede llegar de la situación media a la situación final.

Hacer la regla
Ejecuta esta regla.

- - - - -

Aquí el bucle se repite.

Usando reglas
El programa selecciona una regla de su memoria que llega de la primera a la segunda situación. Una vez encontrada la regla se ejecuta descomponiendola. Esto quiere decir encontrar reglas de menor nivel que van de la sit1, situación inicial, a una situación intermedia y finalmente a la situación FS, la situación final. Si una de estas reglas de menor nivel es una regla elemental, el programa hace la función de lenguaje C correspondiente. Si no, se descompone la regla en sus reglas de menor nivel.
El GL 3 no puede actuar si no encuentra una regla. En ese caso avisa que no encontró una regla apropiada.

Cuando el GL 3 encuentra una regla abstracta, usa la regla concreta que tiene el mejor "valor".
Usa primero la regla que cubre la mayor parte de los conceptos de la sit1. Construye la acción a hacer. Después usa más reglas por conceptos de la sit1 no usados hasta allí y modifica la acción.

Parte central del programa en lenguaje C
(archivo: main.c)

int		main(void)
// El GL3 es similar al General Learner, pero la actividad del cerebro 
// esta hecho por conceptos y reglas en lugar de funciones de lenguaje C.
	{
	short		sit1[256], sit2[256], sit3[256];
	short		rule;
	
	gIsTimeSensitive = false; // haga esto verdadero cuando NO está en pruebas.
	
	InitializeProgram(); // inicializar el programa.

	// Leer la memoria de conceptos y reglas previamente aprendidos.
	ReadMemory();

	gMH.period++;  
	// otro periodo de vida. gMH.period varia entre 120 y 240.
	if (gMH.period LT (unsigned char)120)
		gMH.period = (unsigned char)120;
	if (gMH.period GT (unsigned char)240)
		gNeedForget = true;

	// solo la primera vez que arranca el programa.	
	if (gMH.fillC EQ 0)
		{
		FillInitConcepts();	// crea el concepto comodin y conceptos iniciales.
		CreateElemRules();	// crea la regla comodin y reglas iniciales.
		PutElemRulesIntoChrono();  
		WriteMem(); // guardar la memoria.
		}

	HandleNewStart();	// nuevo arranque.
	
	TryoutOfFunction();	// se usa para pruebas.

	// Bucle principal del programa.
	// Se corre una vez por "instante".  				
while (true) 
		{
		MainEvent();	// maneja "eventos" = teclado, ratón, menues y ventanas.
							
		if (gGotInput)	
			DoApproval();	// Maneja la aprobación y desaprobación.
			
  // pone las situaciones según el estado despierto o dormido
	// y maneja la ventana "dormido".
		MaintainIntSits(sit1, sit2, sit3);		

		if (gGotInput OR gSleepNow) // cualquier		entrada.
			{
			// primera regla
			rule = SelectRule(sit1, sit2);	

			if (rule NE NONE)
				DoRule(rule);
			else
				{
				NumNotice(NoRuleFound, 101, NONE, NONE);
				WaitWithMainEvent(180);		
				SysBeep(2);
				}
			
			// segunda regla
			rule = SelectRule(sit2, sit3);	

			if (rule NE NONE)
				DoRule(rule);
			else
				{
				NumNotice(NoRuleFound, 102, NONE, NONE);
				WaitWithMainEvent(180);
				SysBeep(2);
				}

			gGotInput = false;
			}
		}

	return 0;	// se precisa en lenguaje C.
	}

Nota:
DoRule( ) remplaza el BrainSensoryArea( ), CentralBrain( ), BrainMotorArea( ) y Sleep( ) del GL anterior. Hace la primera y segunda regla. Ellos despues buscan reglas de menor nivel, que hacen las acciones internas y externas.

Formato de conceptos en lenguaje C

typedef struct 
	{
	char		Type;	// BRANCH_Typ, WORD, OBJ, COMP, SOUND etc.
	char		Use;		// BRANCH_Use, ELEM, CONCUR, SEQU
	short	*pAddrP;	// BRANCH_P 
	// partes de este concepto. En tipo (Type) COMP hay solamente conceptos, 
	// en los demás, cualquieros números.  	
	// pAddrP siempre tiene que estar llenado, indica que el concepto existe.
	// Todo lo que sigue son reglas y conceptos relacionados:
	short	*pAddrT;	// BRANCH_T, los conceptos totales que incluyen este concepto.							 
	short	*pAddrA;	// BRANCH_A. conceptos abstractos que incluyen este concepto.			
	short	*pAddrC;	// BRANCH_C, los conceptos concretos de este concepto.	
	short	*pAddrS1r; // BRANCH_S1r, las reglas en las cuales se usa el concepto en la sit1.
	short	*pAddrFSr; //BRANCH_FS, las reglas en las cuales se usa el concepto en la FS.
	} DataC;

Formato de reglas en lenguaje C

typedef struct 
	{
	char		Type; // BRANCH_Typ, ELEM, COMB 
	char		From; // BRANCH_From, donde fue creado.
	unsigned char	LastUse; // BRANCH_LastUse, ultimo uso.
	short	value // BRANCH_value, valor de la regla para elegir entre reglas.
	char		mode // BRANCH_mode, en secuencia, al mismo tiempo o repetidas veces.							
	char 		rep; // BRANCH_rep, cantidad de repeticiones.
	short	*pAddrS1; // BRANCHRULS1, situación 1.			
		// pAddrS1 siempre tiene que ser llenado, indica la existencia de la regla.
	short	*pAddrW; // BRANCHRULW, valor de cada concepto de la sit 1.	
	short	*pAddrIntSits; // BRANCHRULIS situacion intermedia.		
	short	*pAddrFS;	// BRANCHRULFS la situación futura (después que la acción fue hecha.
	short	*pAddrT; // BRANCH_T, regla total que incluye esta regla.	
	short	*pAddrA; // BRANCH_A, regla abstracta que incluye esta regla como concreta.	
	} DataR;

Para leer de corrido, como un libro - continua aquí
Saltar al Contenido del libro electrónico / Investigación actual / al Inicio de esta página.