Aula 13 - LIDA

Basic Agent Exercise 0

Esse exercício foi proposto com o intuito de explorar o ambiente do basicAgentExercises.

Essa é a estrutura do projeto no modo Project view do NetBeans

Essa é a estrutura do projeto no modo Files view do NetBeans

Basic Agent Exercise 1

Esse exercicio foi proposto para se familiarizar com a interface do framework.

O software pressiona o "botão 1" quando observa um quadrado vermelho ou o "botão 2" quando observa um circulo azul.

Abaixo uma imagem da interface do framework.

O printscreen abaixo mostra uma configuração de logging do ambiente registrando as atividades de seleção dos botões.

A tela abaixo mostra os ConfigurationsFiles.

Basic Agent Exercise 2

A tela abaixo mostra a configuração inicial para realizar este exercício. Utilizando esta configuração o agente não pressiona mais o botão 2.

A tela abaixo mostra o PerceptualBuffer.

A tela abaixo mostra o GlobalWorkspace

Foi alterado uma linha de código para:

csm = CSM,edu.memphis.ccrg.lida.framework.gui.panels.NodeStructurePanel,B,7,Y,Workspace.CurrentSituationalModel

A seguinte tela foi observada:

Basic Agent Exercise 3

Esse exercicio tem como objetivo realizar melhorias de funcionalidades do agente.

A tela abaixo mostra as configurações iniciais para realização deste exercício

O diagrama abaixo representa os elementos do Framework. As partes que estão marcadas com a linha pontilhada representa os elementos que serão adicionados no agente durante a realização deste exercício.

O arquivo "basicAgent_ex3.xml" utilizado vem como default faltando alguns elementos. Foi adicionado as partes que estavam faltando e outras novas, como a feature detector e attention codelet.

Foi adicionado no XML o seguinte trecho:

<module name="Environment">
            <class>emyagent.modules.ButtonEnvironment</class>
            <param name="height" type="int"> 10</param>
            <param name="width" type="int"> 10</param>
            <taskspawner>defaultTS</taskspawner>
        </module>

O agente detecta apenas quadrados vermelhos.

Depois foi adicionado no XML o seguinte trecho:

<listener>
            <listenertype>edu.memphis.ccrg.lida.pam.PamListener</listenertype>
            <modulename>PerceptualAssociativeMemory</modulename>
            <listenername>Workspace</listenername>
        </listener>

Agora o PercepturalBuffer do agente passa a mostar vermelho e azul quando ele percebe um "quadrado  vermelho" no ambiente.

Na sequencia foi implementando detectores para "blueDetector" e "circleDetector".

                <task name="blueDetector">
                    <tasktype>ColorDetector</tasktype>
                    <ticksperrun>3</ticksperrun>
                    <param name="color" type="int">-16776961</param>
                    <param name="node" type="string">blue</param>
                </task>
                <task name="circleDetector">
                    <tasktype>ShapeDetector</tasktype>
                    <ticksperrun>3</ticksperrun>
                    <param name="area" type="int">31</param>
                    <param name="backgroundColor" type="int">-1</param>
                    <param name="node" type="string">circle</param>
                </task>

Depois foi adicionado o seguinte trecho de código para que o agente possa ser capaz de acionar os botões "1" e "2", conforme a necessidade.

                 <task name="blueCircleCodelet">
                    <tasktype>BasicAttentionCodelet</tasktype>
                    <ticksperrun>5</ticksperrun>
                    <param name="nodes" type="string">blue,circle</param>
                    <param name="refractoryPeriod" type="int">30</param>
                    <param name="initialActivation" type="double">1.0</param>
                </task>

As funcionalidades que foram implementadas aqui de detecção de "shape" e "color" estão implementadas na seguinte classe em Java:

Advanced Exercise 1

Esse exercicio é usado para demonstrar como podemos rodar o framework do LIDA sem uma interface gráfica. Para isso, basta realizar a seguinte alteração no arquivo lidaConfig.properties e alterar a propriedade lida.gui.enable para false, conforme mostrado abaixo.

lida.gui.enable=false

O logging também pode ser gerado de forma opcional pelo via Console ou utilizando os mecanismos de logging do Java (java.util.logging).

Advanced Exercise 2

Esse exercicio é usado para demonstrar os efeitos do parametro ticksPerRun.

Primeiro foi setado o tickDuration para 10. Na simulação houve várias coalizões.

Na sequencia foram alterados o ticksperrun para 50 e o refractoryPeriod para 300, conforme mostrado abaixo:

                <task name="RedSquareCodelet">
                    <tasktype>BasicAttentionCodelet</tasktype>
                    <ticksperrun>50</ticksperrun>
                    <param name="nodes" type="string">red,square</param>
                    <param name="refractoryPeriod" type="int">300</param>
                    <param name="initialActivation" type="double">1.0</param>
                </task>

O número de coalizões observado no GlobalWorkspace foi reduzido assim como as coalizões que ocorrem em broadcast.

Advanced Exercise 3

Esse exercicio é proposto para criar uma feature para detectar quando a tela está branca.

Foi adicionado a seguinte Feature para detecção da Tela Branca:

public class WhiteScreenFeatureDetector extends BasicDetectionAlgorithm {
    
    public static final int TOLERANCE = 5;
    
    /*
     * Size of the shape in pixels.  
     */
    private int soughtArea = 1000;
    /*
     * The white background color should not be counted in determined the number of pixels in the shape
     */
    private int backgroundColor = 0xFFFFFFFF;

    private Map<String, Object> smParams = new HashMap<String, Object>();
    int white = 0xFFFFFFFF;
    
    /*
     * The square in the environment is 20x20 = 400 pixels.  Thus it takes up ~40% of the area.
     * The circle has radius = 10 so its area ~= 314 pixels.  Thus it takes up ~31% of the area.
     */
    @Override
    public void init() {
       super.init();
       smParams.put("mode","all");

       soughtArea = (Integer) getParam("area", 1000);
       backgroundColor = (Integer) getParam("backgroundColor", 0xFFFFFFFF);
       
    }

    @Override
    public double detect() {
        int[] layer = (int[]) sensoryMemory.getSensoryContent("visual",smParams);
        int area=0;
        for(int i=0;i<layer.length;i++){
            if(layer[i]== white){
                area++;
            }
        }
    
        area=(area*1000)/layer.length;
        if(Math.abs(area-soughtArea) < TOLERANCE){
            return 1.0;
        }
        return 0.0;
    }
}

Depois foi incluido a Task abaixo no arquivo factoryData.xml com um node "empty".

        <task name="WhiteScreenDetector">
            <class>myagent.featuredetectors.ShapeFeatureDetector</class>
            <ticksperrun>5</ticksperrun>
            <associatedmodule>SensoryMemory</associatedmodule>
            <associatedmodule>PerceptualAssociativeMemory</associatedmodule>
            <param name="area" type="int">40</param>
            <param name="backgroundColor" type="int">-1</param>
            <param name="node" type="string">empty</param>
        </task>

Foi adicionado na memoria procedural o seguinte código:

<param name="scheme.3">if empty, release press|(white,empty)()|action.releasePress|()()|0.01</param>

Depois disso foi removido o comentário da linha marcada abaixo:

module name="SensoryMotorMemory">
            <class>edu.memphis.ccrg.lida.sensorymotormemory.BasicSensoryMotorMemory</class>
            <associatedmodule>Environment</associatedmodule>
            <param name="smm.1">action.pressOne,algorithm.press1</param>
            <param name="smm.2">action.pressTwo,algorithm.press2</param>
            <param name="smm.3">action.releasePress,algorithm.releasePress</param>
            <taskspawner>defaultTS</taskspawner>                      <initializerclass>edu.memphis.ccrg.lida.sensorymotormemory.BasicSensoryMotorMemoryInitializer</initializerclass>
</module>

Como resultado, foi possível observar o acionamento na memória procedural

Tutorial Project II

Esse exercicio é realizado simulando um determinado mundo que está dividido em um grid de 10 x10.

Em cada célula pode existir um dos seguinte objetos ou agentes:

• Agente;
• Macaco;
• Hamburguer;
• Arvore;
• Pedra;

Os macacos podem ser mover de forma randômica pelo mapa.Se ele ficar na mesma célula do agente, irá tentar projudicá-lo.

As pedras ocupam uma célula inteira e não pode coexistir com outrao objetos dentro da célula.

O agente pode captar apenas os objetos que estão na mesma célula ou objeto que está na célula a sua frente. Ele também monitora o nível da sua propria saude.

O agente pode realizar as seguintes ações:

• mover para a proxima célula a sua frente;
• virar a esquerda ou direita;
• olhar em volta;
• comer;
• fugir;

O nível de saude do agente é decrementado para cada vez que ele toma uma ação. Ela também pode ser decrementada por um ataque de um macaco ou quando o agente tenta se mover para uma célula que contém uma pedra ou para fora do grid.

Se o agente comer um hamburguer, o nivel de saude é aumentado.

ALife Agent Exercise 1

a meta deste exercicio é explorar o agente funcional ALife.

A figura abaixo mostra o ambiente com os objetos inseridos nas céulas.

Quando comparado a GUI di alifeAgent com o basicAgent, a primeira coisa que é possivel observar são as ações e a interação do LIDA. No basicAgent, as ações eram acionar botões em função de determinadas percepções. Aqui, ocorre um processo mais elaborado de movimentação do agente e do macaco, além de controle de energia do agente.

A figura abaixo mostra um resumo das ações tomadas após cerca de 50000 interações.

ALife Agent Exercise 2

Nesse exercicio foi inicialmente alterada para zerar a quantidade de hamburgueres no ambiente.

#Agent properties
lida.agentdata=configs/alifeAgent_ex2.xml
lida.elementfactory.data=configs/factoryData.xml

trecho do código para alterar a quantidade de hamburgueres no ambiente para 0, conforme mostrado abaixo.

#name=QTY,x,y,iconId,size,health,className,[attributes]*
food=0,-1,-1,8,10,1.0,edu.memphis.ccrg.alife.elements.ALifeObjectImpl

Foi criado ainda  um monitor para o nível de saude para níveis abaixo de 0,33.

public class BadHealthDetector extends BasicDetectionAlgorithm {

    private final String modality = "";
    private Map<String, Object> detectorParams = new HashMap<String, Object>();

    @Override
    public void init() {
        super.init();
        detectorParams.put("mode", "health");
    }

    @Override
    public double detect() {
        double healthValue = (Double) sensoryMemory.getSensoryContent(modality, detectorParams);
        double activation = 0.0;
        if (healthValue <= 0.33) {
            activation = 1.0;
        }
        return activation;
    }
}

Dessa forma, quando a energia do agente decai abaixo de 0,33 ele não consegue mais se mover.

Abaixo foram realizadas algumas alterações de código para que o agente possa detectar a sua propria saude e detectar predadores a frente (na versão anterior ele só detectava se estive na mesma célula).

No arquivo factoryData.xml foi incluido a seguinte task:

         <task name="BadHealthDetector">
            <class>alifeagent.featuredetectors.BadHealthDetector</class>
            <ticksperrun>3</ticksperrun>
            <associatedmodule>SensoryMemory</associatedmodule>
            <associatedmodule>PerceptualAssociativeMemory</associatedmodule>
        </task>

Na sequencia foi realizada essa mesma alteração para o arquivo alifeAgent_ex2. xml, conforme mostrado abaixo:

                <task name="BadHealthDetector">
                    <tasktype>BadHealthDetector</tasktype>
                    <ticksperrun>3</ticksperrun>
                    <param name="node" type="string">badHealth</param>
                </task>

Depois foi adicionado o seguinte trecho:

                 <task name="predatorFrontDetector">
                    <tasktype>ObjectDetector</tasktype>
                    <ticksperrun>3</ticksperrun>
                    <param name="node" type="string">predatorOrigin</param>
                    <param name="object" type="string">predator</param>
                    <param name="position" type="int">1</param>
                </task>

Essas edições adicionaram mais possibilidades de comportamento na memória procedural do agente.

ALife Agent Exercise 3

Foram realizados os setups iniciais, conforme mostrado abaixo:

Quantidade de comida no mapa = 10

#name=QTY,x,y,iconId,size,health,className,[attributes]*
food=10,-1,-1,8,10,1.0,edu.memphis.ccrg.alife.elements.ALifeObjectImpl

#Agent properties
lida.agentdata=configs/alifeAgent_ex3.xml
lida.elementfactory.data=configs/factoryData.xml

Como o agente não possui codelets de atenção para o predador, ele não foge. Para resolver isso foi criado o seguinte codelet:

<task name="predatorAttentionCodelet">
                    <tasktype>NeighborhoodAttentionCodelet</tasktype>
                    <ticksperrun>5</ticksperrun>
                    <param name="nodes" type="string">predator</param>
                    <param name="refractoryPeriod" type="int">50</param>
                    <param name="initialActivation" type="double">1.0</param>
                </task>

Agora é possivel observar que o Agente consegue criar coalizões ao observar um predador.

Depois disso foi alterado o FoodAttentionCodelet para 0.01. Com essa alteração, a capacidade de reação a comida cai drasticamente.

Depois disso o initialActivation foi restaurado para 1.0 novamente e o tickduration foi alterado para 40.

Nessa simulação foi possivel observar que as coalizões contendo "goodHealth" tiveram um aumento.

ALife Agent Exercise 4

foi realizado as alterações do setup inicial do exercicio, conforme mostrado abaixo:

#Agent properties
lida.agentdata=configs/alifeAgent_ex4.xml
lida.elementfactory.data=configs/factoryData.xml

Nessa simulação, o agente passa a se mover apenas quando a energia dele decai abaixo de 0.66 ou existe um predador proximo.

Para corrigir isso, foi realizado essa alteração e o agente passou a agir de forma normal (good health)

<param name="scheme.10b">if emptyFront turn around|(emptyFront)()|action.moveAgent|()()  |0.1</param>    
            <taskspawner>defaultTS</taskspawner>                      
            <initializerclass>edu.memphis.ccrg.lida.proceduralmemory.BasicProceduralMemoryInitializer</initializerclass>

Depois disso foram realizadas alterações do código para que o agente pudesse utilizar elementos "non-default" para a estratégia. As seguintes alterações de codigos foram realizadas:

Alteração do parâmetro <initializerclass> dentro do módulo de PerceptualAssociativeMemory:

<initializerclass>alifeagent.initializers.CustomPamInitializer</initializerclass>

Depois disso o código foi alterado conforme indicado pelo exercicio:

public void initModule(FullyInitializable module, Agent agent, Map<String, ?> params) {
        super.initModule(module, agent, params);
        PerceptualAssociativeMemory pam = (PerceptualAssociativeMemory) module;

        // Obtains the ElementFactory
        ElementFactory factory = ElementFactory.getInstance();

        // Creates a new Node in PAM labeled 'object'
        Node objectNode = pam.addDefaultNode(factory.getNode("PamNodeImpl", "object"));

        // Obtains the 'rock' node from PAM
        Node child = pam.getNode("rock");

        //  Adds a Link in PAM from 'rock' to 'object' with link category PARENT
        pam.addDefaultLink(factory.getLink(child, objectNode, PerceptualAssociativeMemoryImpl.PARENT));

        // Obtain the 'food' node from PAM
        //  Add a Link in PAM from 'food' to 'object' with link category PARENT
        child = pam.getNode("food");        
        pam.addDefaultLink(factory.getLink(child, objectNode, PerceptualAssociativeMemoryImpl.PARENT));

        DecayStrategy decayStrategy = factory.getDecayStrategy("slowDecay");
        objectNode.setDecayStrategy(decayStrategy);
    }

O BasicPamInitializer lê os parâmetros "nodes" e "links" e cria conexões entre eles na memória de percepção associativa.

Advanced Exercise 1

O objetivo deste exercicio foi adicionar ao agente a capacidade de utilizar a arvore para se proteger de um predador. Para isso, quando ele está de frente com uma célula contendo uma arvore, ele move-se para esta célula.

Foi adicionado uma módulo de atenção para árvores e um novo esquema na memória procedural, conforme mostrado abaixo:

                <task name="TreeAttentionCodelet">
                    <tasktype>NeighborhoodAttentionCodelet</tasktype>
                    <ticksperrun>5</ticksperrun>
                    <param name="nodes" type="string">tree</param>
                    <param name="refractoryPeriod" type="int">50</param>
                    <param name="initialActivation" type="double">0.7</param>
                </task>

Abaixo o código que foi adicionado na memoria procedural:

            <param name="scheme.4">move to food|(foodFront)()|action.moveAgent|()()|0.1</param>
            <param name="scheme.5">eat food at origin|(foodOrigin)()|action.eat|()()|0.35</param>
            <param name="scheme.5a">move forward if treeFront|(treeFront)()|action.moveAgent|()()|0.1</param>         

Utilizando a aba Action Selection é possivel observar um momento em que a ação "move forward if treeFront" é selecionada.