Changeset 1285 for trunk/autoquest-core-tasktrees/src/main/java/de/ugoe/cs/autoquest/tasktrees/temporalrelation/TaskInstanceTrie.java

Timestamp:

07/30/13 09:44:39 (11 years ago)

Author:

pharms

Message:

• improved performance of task instance trie generation by using different symbol management strategies while creating the trie. This performance improvement is significant and allows to detect tasks now in a much faster manner.

File:

• trunk/autoquest-core-tasktrees/src/main/java/de/ugoe/cs/autoquest/tasktrees/temporalrelation/TaskInstanceTrie.java (modified) (9 diffs)

trunk/autoquest-core-tasktrees/src/main/java/de/ugoe/cs/autoquest/tasktrees/temporalrelation/TaskInstanceTrie.java

@@ -20 +20 @@
 import java.util.Map;
 
+import de.ugoe.cs.autoquest.tasktrees.treeifc.ITask;
 import de.ugoe.cs.autoquest.tasktrees.treeifc.ITaskInstance;
 import de.ugoe.cs.autoquest.tasktrees.treeifc.IUserSession;
@@ -33 +34 @@
  * @author Patrick Harms
  */
-public class TaskInstanceTrie extends Trie<ITaskInstance> {
+class TaskInstanceTrie extends Trie<ITaskInstance> {
 
     /**  */
@@ -43 +44 @@
      * </p>
      */
-    private TaskComparator comparator;
-
+    private TaskHandlingStrategy taskStrategy;
+    
     /**
      * <p>
@@ -52 +53 @@
      * @param taskComparator2
      */
-    public TaskInstanceTrie(TaskComparator taskComparator) {
-        super(taskComparator);
-        this.comparator = taskComparator;
+    public TaskInstanceTrie(TaskHandlingStrategy taskStrategy) {
+        super(taskStrategy);
+        this.taskStrategy = taskStrategy;
     }
 
@@ -65 +66 @@
         }
         
-        SymbolMap<ITaskInstance, List<ITaskInstance>> equalTaskInstancesMap =
-            new SymbolMap<ITaskInstance, List<ITaskInstance>>(comparator);
-        
-        Map<ITaskInstance, List<ITaskInstance>> taskInstancesMap =
-            new HashMap<ITaskInstance, List<ITaskInstance>>();
+        SymbolMap<ITaskInstance, Counter> equalTaskInstancesMap =
+            taskStrategy.createSymbolMap();
+        
+        Map<ITask, Counter> instanceCountMap = new HashMap<ITask, Counter>();
         
         System.out.println("preparing training");
+        int noOfTaskInstances = 0;
         for (IUserSession session : userSessions) {
             for (ITaskInstance taskInstance : session) {
-                List<ITaskInstance> equalTaskInstances =
-                    equalTaskInstancesMap.getValue(taskInstance);
-                
-                if (equalTaskInstances == null) {
-                    equalTaskInstances = new LinkedList<ITaskInstance>();
-                    equalTaskInstancesMap.addSymbol(taskInstance, equalTaskInstances);
+                Counter counter = equalTaskInstancesMap.getValue(taskInstance);
+                
+                if (counter == null) {
+                    counter = new Counter();
+                    equalTaskInstancesMap.addSymbol(taskInstance, counter);
                 }
                 
-                equalTaskInstances.add(taskInstance);
-                taskInstancesMap.put(taskInstance, equalTaskInstances);
-            }
-        }
-        
-        System.out.println("performing training");
+                counter.count++;
+                instanceCountMap.put(taskInstance.getTask(), counter);
+                
+                noOfTaskInstances++;
+            }
+        }
+        
+        System.out.println("performing training of " + noOfTaskInstances + " task instances");
+        Counter processedTaskInstances = new Counter();
+        int counterRecheckAt = noOfTaskInstances / 10; // recheck the maximum count after each
+                                                       // 10% of processed task instances
         for (IUserSession session : userSessions) {
-            train(session, maxOrder, taskInstancesMap);
+            train(session, maxOrder, instanceCountMap, processedTaskInstances, counterRecheckAt);
         }      
         
@@ -122 +127 @@
      * 
      */
-    private void train(IUserSession                            userSession,
-                       int                                     maxOrder,
-                       Map<ITaskInstance, List<ITaskInstance>> taskInstancesMap)
+    private void train(IUserSession        userSession,
+                       int                 maxOrder,
+                       Map<ITask, Counter> taskInstanceCountMap,
+                       Counter             processedTaskInstances,
+                       int                 counterRecheckAt)
     {
         List<ITaskInstance> executedTasks = userSession.getExecutedTasks();
@@ -130 +137 @@
         List<ITaskInstance> subsequence = new LinkedList<ITaskInstance>();
         
-        int numberOfTrainedSubsequences = 0;
         int sequenceMaxCount = 0;
         
         for (ITaskInstance currentTaskInstance : executedTasks) {
-            int occurrenceCount = taskInstancesMap.get(currentTaskInstance).size();
-            
-            if ((numberOfTrainedSubsequences % 10) == 0) {
+            
+            int occurrenceCount = taskInstanceCountMap.get(currentTaskInstance.getTask()).count;
+            
+            if (processedTaskInstances.count >= counterRecheckAt) {
                 sequenceMaxCount = getCurrentSequenceMaxCount();
+                processedTaskInstances.count = 0;
             }
             
@@ -158 +166 @@
                     add(subsequence);
                     subsequence.remove(0);
-
-                    numberOfTrainedSubsequences++;
                 }
             }
+            
+            processedTaskInstances.count++;
         }
         
@@ -219 +227 @@
     }
     
+    /**
+     * @author Patrick Harms
+     */
+    private static class Counter {
+        int count = 0;
+    }
+        
 }