Changeset 1518


Ignore:
Timestamp:
02/16/2012 09:42:23 AM (7 years ago)
Author:
myl
Message:

Re-added the SACondition

Location:
AgentMind/branches/FAtiMA-Modular/FAtiMA.AdvancedMemory/src/FAtiMA/AdvancedMemory
Files:
2 added
3 edited

Legend:

Unmodified
Added
Removed
  • AgentMind/branches/FAtiMA-Modular/FAtiMA.AdvancedMemory/src/FAtiMA/AdvancedMemory/AdvancedMemoryComponent.java

    r1468 r1518  
    6666        public static final String FILENAME = "XMLMemoryAdvanced"; 
    6767 
    68         private static final String NAME = "AdvancedMemory"; 
     68        public static final String NAME = "AdvancedMemory"; 
    6969 
    7070        private static final String SA_MEMORY = "SA-MEMORY"; 
     
    7777 
    7878        private String locationOntologyFilename; 
     79        private boolean resultStorage; 
    7980 
    8081        private ArrayList<Object> results; // CompoundCue, SpreadingActivation, Generalisation 
     
    155156        @Override 
    156157        public ReflectXMLHandler getActionsParser(AgentModel am) { 
    157                 return null; 
     158                return new ActionsLoaderHandler(am); 
    158159        } 
    159160 
     
    408409                        // 
    409410 
     411                        System.out.println(perception); 
     412                        SpreadingActivation spreadingActivation = new SpreadingActivation();             
     413 
     414                        this.processSAPerception(perception, spreadingActivation); 
     415                         
     416                        if (resultStorage) { 
     417                                // add to results 
     418                                results.add(spreadingActivation); 
     419                                setResultsUpdated(true); 
     420                        } 
     421                         
     422                        // return result 
     423                        String result = AdvancedMemoryWriter.getUnformattedXML(spreadingActivation); 
     424                        am.getRemoteAgent().ReportMemoryResult(result); 
     425 
     426                } else if (msgType.equals(G_MEMORY)) { 
     427 
     428                        // perception format: 
     429 
     430                        // different parameters are separated by $ 
     431                        // <attribute names>$<minimum coverage>$<filter attributes>$ 
     432                        //   <time ontology parameters>$<target ontology parameters>$ 
     433                        //   <object ontology parameters>$<location ontology parameters>$ 
     434                        //   <result storage> 
     435                        // note: multiple successive $ are recognised as only one separator  
     436                        //       use * between $ to indicate an empty parameter 
     437 
     438                        // attribute names are separated by * 
     439                        // <attributes names> = <attribute name>*<attribute name>*... 
     440 
     441                        // filter attributes are separated by * 
     442                        // <filter attributes> = <filter attribute>*<filter attribute>*... 
     443                        // name and value of a filter attribute are separated by a space 
     444                        // <filterAttribute> = <name> <value> 
     445 
     446                        // <time ontology parameters> = <time abstraction mode> 
     447                        // values for time abstraction mode are defined in TimeOntology 
     448 
     449                        // <target ontology parameters> = <maximum depth> 
     450 
     451                        // <object ontology parameters> = <maximum depth> 
     452 
     453                        // <location ontology parameters> = <maximum depth> 
     454 
     455                        // <result storage> = true | false 
     456                        // true = store result, false = do not store result                      
     457 
     458                        //  
     459 
     460                        // usage examples: 
     461                        // G-MEMORY subject*action*$3 
     462                        // G-MEMORY subject*action*target*time$1$subject SELF*action greet*target Amol*time Morning$0 
     463                        // G-MEMORY subject*action*target*time$3$subject SELF*time Afternoon$0 
     464                        // G-MEMORY subject*target*time$5$time Tuesday$1$1 
     465                        // G-MEMORY target$1$*$*$*$*$*$true 
     466 
     467                        //  
     468 
    410469                        // parse perception 
    411470                        StringTokenizer stringTokenizer = new StringTokenizer(perception, "$"); 
    412                         String targetAttributeName = null; 
    413                         try { 
    414                                 targetAttributeName = stringTokenizer.nextToken(); 
    415                         } catch (Exception e) { 
    416                                 // no target attribute name given 
    417                                 System.err.println("No Target Attribute Name given!"); 
     471                        String attributeNamesStr = null; 
     472                        try { 
     473                                attributeNamesStr = stringTokenizer.nextToken(); 
     474                        } catch (Exception e) { 
     475                                // no attribute names given 
     476                                System.err.println("No Attribute Names given!"); 
    418477                                return; 
    419478                        } 
     479                        String minimumCoverageStr = null; 
     480                        try { 
     481                                minimumCoverageStr = stringTokenizer.nextToken(); 
     482                        } catch (Exception e) { 
     483                                // no minimum coverage given, use minimum coverage 1 
     484                                minimumCoverageStr = "1"; 
     485                        } 
    420486                        String filterAttributesStr = null; 
    421487                        try { 
     
    453519                        } catch (Exception e) { 
    454520                                // no result storage given 
     521                        } 
     522 
     523                        // parse minimum coverage 
     524                        Integer minimumCoverage = null; 
     525                        try { 
     526                                minimumCoverage = Integer.valueOf(minimumCoverageStr); 
     527                        } catch (Exception e) { 
     528                                System.err.println("Error while parsing Minimum Coverage!"); 
     529                                return; 
    455530                        } 
    456531 
     
    515590                        boolean resultStorage = Boolean.valueOf(resultStorageStr); 
    516591 
    517                         // execute Spreading Activation mechanism 
    518                         SpreadingActivation spreadingActivation = new SpreadingActivation(); 
    519                         spreadingActivation.spreadActivation(memory.getEpisodicMemory(), filterAttributesStr, targetAttributeName, timeOntology, targetOntology, objectOntology, locationOntology); 
    520  
    521                         if (resultStorage) { 
    522                                 // add to results 
    523                                 results.add(spreadingActivation); 
    524                                 setResultsUpdated(true); 
    525                         } 
    526  
    527                         // return result 
    528                         String result = AdvancedMemoryWriter.getUnformattedXML(spreadingActivation); 
    529                         am.getRemoteAgent().ReportMemoryResult(result); 
    530  
    531                 } else if (msgType.equals(G_MEMORY)) { 
    532  
    533                         // perception format: 
    534  
    535                         // different parameters are separated by $ 
    536                         // <attribute names>$<minimum coverage>$<filter attributes>$ 
    537                         //   <time ontology parameters>$<target ontology parameters>$ 
    538                         //   <object ontology parameters>$<location ontology parameters>$ 
    539                         //   <result storage> 
    540                         // note: multiple successive $ are recognised as only one separator  
    541                         //       use * between $ to indicate an empty parameter 
    542  
    543                         // attribute names are separated by * 
    544                         // <attributes names> = <attribute name>*<attribute name>*... 
    545  
    546                         // filter attributes are separated by * 
    547                         // <filter attributes> = <filter attribute>*<filter attribute>*... 
    548                         // name and value of a filter attribute are separated by a space 
    549                         // <filterAttribute> = <name> <value> 
    550  
    551                         // <time ontology parameters> = <time abstraction mode> 
    552                         // values for time abstraction mode are defined in TimeOntology 
    553  
    554                         // <target ontology parameters> = <maximum depth> 
    555  
    556                         // <object ontology parameters> = <maximum depth> 
    557  
    558                         // <location ontology parameters> = <maximum depth> 
    559  
    560                         // <result storage> = true | false 
    561                         // true = store result, false = do not store result                      
    562  
    563                         //  
    564  
    565                         // usage examples: 
    566                         // G-MEMORY subject*action*$3 
    567                         // G-MEMORY subject*action*target*time$1$subject SELF*action greet*target Amol*time Morning$0 
    568                         // G-MEMORY subject*action*target*time$3$subject SELF*time Afternoon$0 
    569                         // G-MEMORY subject*target*time$5$time Tuesday$1$1 
    570                         // G-MEMORY target$1$*$*$*$*$*$true 
    571  
    572                         //  
    573  
    574                         // parse perception 
    575                         StringTokenizer stringTokenizer = new StringTokenizer(perception, "$"); 
    576                         String attributeNamesStr = null; 
    577                         try { 
    578                                 attributeNamesStr = stringTokenizer.nextToken(); 
    579                         } catch (Exception e) { 
    580                                 // no attribute names given 
    581                                 System.err.println("No Attribute Names given!"); 
    582                                 return; 
    583                         } 
    584                         String minimumCoverageStr = null; 
    585                         try { 
    586                                 minimumCoverageStr = stringTokenizer.nextToken(); 
    587                         } catch (Exception e) { 
    588                                 // no minimum coverage given, use minimum coverage 1 
    589                                 minimumCoverageStr = "1"; 
    590                         } 
    591                         String filterAttributesStr = null; 
    592                         try { 
    593                                 filterAttributesStr = stringTokenizer.nextToken(); 
    594                         } catch (Exception e) { 
    595                                 // no filter attributes given 
    596                         } 
    597                         String timeAbstractionModeStr = null; 
    598                         try { 
    599                                 timeAbstractionModeStr = stringTokenizer.nextToken(); 
    600                         } catch (Exception e) { 
    601                                 // no time abstraction mode given 
    602                         } 
    603                         String targetDepthMaxStr = null; 
    604                         try { 
    605                                 targetDepthMaxStr = stringTokenizer.nextToken(); 
    606                         } catch (Exception e) { 
    607                                 // no target ontology maximum depth given 
    608                         } 
    609                         String objectDepthMaxStr = null; 
    610                         try { 
    611                                 objectDepthMaxStr = stringTokenizer.nextToken(); 
    612                         } catch (Exception e) { 
    613                                 // no object ontology maximum depth given 
    614                         } 
    615                         String locationDepthMaxStr = null; 
    616                         try { 
    617                                 locationDepthMaxStr = stringTokenizer.nextToken(); 
    618                         } catch (Exception e) { 
    619                                 // no location ontology maximum depth given 
    620                         } 
    621                         String resultStorageStr = null; 
    622                         try { 
    623                                 resultStorageStr = stringTokenizer.nextToken(); 
    624                         } catch (Exception e) { 
    625                                 // no result storage given 
    626                         } 
    627  
    628                         // parse minimum coverage 
    629                         Integer minimumCoverage = null; 
    630                         try { 
    631                                 minimumCoverage = Integer.valueOf(minimumCoverageStr); 
    632                         } catch (Exception e) { 
    633                                 System.err.println("Error while parsing Minimum Coverage!"); 
    634                                 return; 
    635                         } 
    636  
    637                         // parse time ontology 
    638                         TimeOntology timeOntology = null; 
    639                         if (timeAbstractionModeStr != null) { 
    640                                 // parse time abstraction mode 
    641                                 Short timeAbstractionMode = null; 
    642                                 try { 
    643                                         timeAbstractionMode = Short.valueOf(timeAbstractionModeStr); 
    644                                         // create time ontology 
    645                                         timeOntology = new TimeOntology(); 
    646                                         timeOntology.setAbstractionMode(timeAbstractionMode); 
    647                                 } catch (Exception e) { 
    648                                         System.err.println("Error while parsing Time Abstraction Mode!"); 
    649                                 } 
    650                         } 
    651  
    652                         // parse target ontology 
    653                         NounOntology targetOntology = null; 
    654                         if (targetDepthMaxStr != null) { 
    655                                 // parse target ontology maximum depth 
    656                                 try { 
    657                                         Integer depthMax = Integer.valueOf(targetDepthMaxStr); 
    658                                         // create target ontology 
    659                                         targetOntology = new NounOntology(); 
    660                                         targetOntology.setDepthMax(depthMax); 
    661                                 } catch (Exception e) { 
    662                                         System.err.println("Error while parsing Target Ontology Maximum Depth!"); 
    663                                 } 
    664                         } 
    665  
    666                         // parse object ontology 
    667                         NounOntology objectOntology = null; 
    668                         if (objectDepthMaxStr != null) { 
    669                                 // parse object ontology maximum depth 
    670                                 try { 
    671                                         Integer depthMax = Integer.valueOf(objectDepthMaxStr); 
    672                                         // create object ontology 
    673                                         objectOntology = new NounOntology(); 
    674                                         objectOntology.setDepthMax(depthMax); 
    675                                 } catch (Exception e) { 
    676                                         System.err.println("Error while parsing Object Ontology Maximum Depth!"); 
    677                                 } 
    678                         } 
    679  
    680                         // parse location ontology 
    681                         TreeOntology locationOntology = null; 
    682                         if (locationDepthMaxStr != null) { 
    683                                 // parse location ontology maximum depth 
    684                                 try { 
    685                                         Integer depthMax = Integer.valueOf(locationDepthMaxStr); 
    686                                         // create location ontology 
    687                                         locationOntology = new TreeOntology(locationOntologyFilename); 
    688                                         locationOntology.setDepthMax(depthMax); 
    689                                 } catch (Exception e) { 
    690                                         System.err.println("Error while parsing Location Ontology Maximum Depth!"); 
    691                                 } 
    692                         } 
    693  
    694                         // parse result storage 
    695                         boolean resultStorage = Boolean.valueOf(resultStorageStr); 
    696  
    697592                        // execute Generalisation mechanism 
    698593                        Generalisation generalisation = new Generalisation(); 
     
    775670        } 
    776671 
     672        public Object processSAPerception(String perception, SpreadingActivation sa){ 
     673                // parse perception 
     674                StringTokenizer stringTokenizer = new StringTokenizer(perception, "$"); 
     675                String targetAttributeName = null; 
     676                try { 
     677                        targetAttributeName = stringTokenizer.nextToken(); 
     678                } catch (Exception e) { 
     679                        // no target attribute name given 
     680                        System.err.println("No Target Attribute Name given!"); 
     681                        return null; 
     682                } 
     683                String filterAttributesStr = null; 
     684                try { 
     685                        filterAttributesStr = stringTokenizer.nextToken(); 
     686                } catch (Exception e) { 
     687                        // no filter attributes given 
     688                } 
     689                String timeAbstractionModeStr = null; 
     690                try { 
     691                        timeAbstractionModeStr = stringTokenizer.nextToken(); 
     692                } catch (Exception e) { 
     693                        // no time abstraction mode given 
     694                } 
     695                String targetDepthMaxStr = null; 
     696                try { 
     697                        targetDepthMaxStr = stringTokenizer.nextToken(); 
     698                } catch (Exception e) { 
     699                        // no target ontology maximum depth given 
     700                } 
     701                String objectDepthMaxStr = null; 
     702                try { 
     703                        objectDepthMaxStr = stringTokenizer.nextToken(); 
     704                } catch (Exception e) { 
     705                        // no object ontology maximum depth given 
     706                } 
     707                String locationDepthMaxStr = null; 
     708                try { 
     709                        locationDepthMaxStr = stringTokenizer.nextToken(); 
     710                } catch (Exception e) { 
     711                        // no location ontology maximum depth given 
     712                } 
     713                String resultStorageStr = null; 
     714                try { 
     715                        resultStorageStr = stringTokenizer.nextToken(); 
     716                } catch (Exception e) { 
     717                        // no result storage given 
     718                } 
     719 
     720                // parse time ontology 
     721                TimeOntology timeOntology = null; 
     722                if (timeAbstractionModeStr != null) { 
     723                        // parse time abstraction mode 
     724                        Short timeAbstractionMode = null; 
     725                        try { 
     726                                timeAbstractionMode = Short.valueOf(timeAbstractionModeStr); 
     727                                // create time ontology 
     728                                timeOntology = new TimeOntology(); 
     729                                timeOntology.setAbstractionMode(timeAbstractionMode); 
     730                        } catch (Exception e) { 
     731                                System.err.println("Error while parsing Time Abstraction Mode!"); 
     732                        } 
     733                } 
     734 
     735                // parse target ontology 
     736                NounOntology targetOntology = null; 
     737                if (targetDepthMaxStr != null) { 
     738                        // parse target ontology maximum depth 
     739                        try { 
     740                                Integer depthMax = Integer.valueOf(targetDepthMaxStr); 
     741                                // create target ontology 
     742                                targetOntology = new NounOntology(); 
     743                                targetOntology.setDepthMax(depthMax); 
     744                        } catch (Exception e) { 
     745                                System.err.println("Error while parsing Target Ontology Maximum Depth!"); 
     746                        } 
     747                } 
     748 
     749                // parse object ontology 
     750                NounOntology objectOntology = null; 
     751                if (objectDepthMaxStr != null) { 
     752                        // parse object ontology maximum depth 
     753                        try { 
     754                                Integer depthMax = Integer.valueOf(objectDepthMaxStr); 
     755                                // create object ontology 
     756                                objectOntology = new NounOntology(); 
     757                                objectOntology.setDepthMax(depthMax); 
     758                        } catch (Exception e) { 
     759                                System.err.println("Error while parsing Object Ontology Maximum Depth!"); 
     760                        } 
     761                } 
     762 
     763                // parse location ontology 
     764                TreeOntology locationOntology = null; 
     765                if (locationDepthMaxStr != null) { 
     766                        // parse location ontology maximum depth 
     767                        try { 
     768                                Integer depthMax = Integer.valueOf(locationDepthMaxStr); 
     769                                // create location ontology 
     770                                locationOntology = new TreeOntology(locationOntologyFilename); 
     771                                locationOntology.setDepthMax(depthMax); 
     772                        } catch (Exception e) { 
     773                                System.err.println("Error while parsing Location Ontology Maximum Depth!"); 
     774                        } 
     775                } 
     776 
     777                // parse result storage 
     778                resultStorage = Boolean.valueOf(resultStorageStr); 
     779                 
     780                // execute Spreading Activation mechanism 
     781                return sa.spreadActivation(memory.getEpisodicMemory(), filterAttributesStr, targetAttributeName, timeOntology, targetOntology, objectOntology, locationOntology); 
     782        } 
    777783} 
  • AgentMind/branches/FAtiMA-Modular/FAtiMA.AdvancedMemory/src/FAtiMA/AdvancedMemory/AttributeItemSet.java

    r1454 r1518  
    139139                                                                        // add only the first common hypernym to set 
    140140                                                                        hypernymSet.add(nounsGeneralised.getFirst()); 
    141  
     141                                                                        //hypernymSet.addAll(nounsGeneralised); 
    142142                                                                } 
    143143 
  • AgentMind/branches/FAtiMA-Modular/FAtiMA.AdvancedMemory/src/FAtiMA/AdvancedMemory/SpreadingActivation.java

    r1465 r1518  
    490490                this.frequencies = frequencies; 
    491491 
     492                System.out.println("ValueMax " + valueMax); 
    492493                return valueMax; 
    493494        } 
Note: See TracChangeset for help on using the changeset viewer.