Tarea de memoria de trabajo 1-2-AX

La tarea de memoria de trabajo 1-2-AX es una prueba cognitiva que requiere la memoria de trabajo para resolverse.

Se puede utilizar como caso de prueba para algoritmos de aprendizaje con el fin de comprobar su capacidad para recordar datos antiguos. Esta tarea se puede utilizar para demostrar las capacidades de memoria de trabajo de algoritmos como PBWM o memoria a corto plazo a largo plazo . ^[1]

La entrada de la tarea es una secuencia de números/letras 1 , 2 , A , X , B e Y , y otras instancias distractoras de 3 , C y Z que deben ignorarse. Para cada carácter de la entrada en la secuencia, el sujeto debe responder con izquierda ( L ) o derecha ( R ).

Las dos secuencias objetivo que busca el sujeto son AX y BY . Cuando el sujeto encuentra un 1, debe cambiar a buscar AX y cuando encuentra un 2, debe cambiar a buscar BY .

Al buscar AX , si el sujeto encuentra una X habiendo visto una A previamente (y de manera similar para una Y mientras busca BY ), y donde esa letra anterior no era parte de una secuencia anterior, responde R para marcar el final de esa secuencia; su respuesta a todos los demás caracteres debe ser L. ^[2 ]

Para resolver esta tarea, un algoritmo debe poder recordar tanto el último número 1 o 2 como la última letra A o B de forma independiente. A esta memoria la llamamos memoria de trabajo . Esta memoria debe conservar todas las demás entradas. Además, el algoritmo debe poder eliminar e ignorar las letras C y Z.

Para los modelos informáticos tradicionales, ambos requisitos son fáciles de resolver. Aquí hay un código Python (una especie de pseudocódigo , pero funciona) donde la función next_output obtiene un solo número o letra como entrada y devuelve una letra o nada. next_outputs está ahí para facilitar la operación en una secuencia completa.

último_num  =  "" 
última_letra  =  ""

def  next_output ( next_input :  str )  ->  str  |  None : 
"""     Args:       next_input: Una cadena que contiene un solo carácter.    



    Devuelve: 
      Una cadena que contiene las letras "L", "R" o Ninguna.

    Ejemplo: 
      >>> next_output("2") 
      'L' 
    """ 
    global  último_número ,  última_letra 
    si  siguiente_entrada  en  [ "1" ,  "2" ]: 
        último_número  =  siguiente_entrada 
        última_letra  =  "" 
        devolver  "L" 
    elif  siguiente_entrada  en  [ "A" ,  "B" ]: 
        última_letra  =  siguiente_entrada 
        devolver  "L" 
    elif  siguiente_entrada  en  [ "X" ,  "Y" ]: 
        seq  =  último_número  +  última_letra  +  siguiente_entrada 
        última_letra  =  siguiente_entrada 
        si  seq  en  [ "1AX" ,  "2BY" ]: 
            devolver  "R" 
        devolver  "L" 
    devolver  Ninguno

def  next_outputs ( next_inputs :  str )  ->  lista [ str ]: 
"""     Argumentos:       next_input: Una cadena.    



    Devuelve: 
      Una lista de cadenas que contienen las letras "L" o "R".

    Ejemplo: 
      >>> next_outputs("21AAXBYAX") 
      ["L", "L", "L", "L", "R", "L", "L", "L", "R"] 
    """ 
    return  [ next_output ( c )  for  c  in  next_inputs ]

Ejemplo:

>>> next_outputs ( "21AAXBYAX" ) 
['L', 'L', 'L', 'L', 'R', 'L', 'L', 'L', 'R'] 
>>> next_outputs ( "12CBZY" ) 
['L', 'L', Ninguno, 'L', Ninguno, 'R']

De manera similar, esta tarea se puede resolver de manera sencilla mediante una máquina de estados finitos con 7 estados (llamémoslos --- , 1-- , 2-- , 1A- , 2B- , 1AX , 2BY ).

Esta tarea es mucho más difícil para las redes neuronales . Para las redes neuronales de propagación hacia adelante simples , esta tarea no se puede resolver porque las redes de propagación hacia adelante no tienen memoria de trabajo. Incluir memoria de trabajo en las redes neuronales es una tarea difícil. Existen varios enfoques, como PBWM o memoria a corto plazo a largo plazo , que tienen memoria de trabajo y ambos son capaces de resolverla.