diff --git a/ArtificialAutism/src/main/java/FunctionLayer/Datahandler.java b/ArtificialAutism/src/main/java/FunctionLayer/Datahandler.java index 381bf8b0..d239f202 100644 --- a/ArtificialAutism/src/main/java/FunctionLayer/Datahandler.java +++ b/ArtificialAutism/src/main/java/FunctionLayer/Datahandler.java @@ -56,7 +56,7 @@ public class Datahandler { private static Annotation strAnnoSentiment; private static Annotation strAnnoJMWE; private static CoreDocument coreDoc; - private static ConcurrentMap> sentenceRelationMap; + private static final ConcurrentMap> sentenceRelationMap = new MapMaker().concurrencyLevel(4).makeMap(); private static volatile Double preRelationCounters = 0.0; private static volatile Double preRelationUserCounters = 0.0; private static final ConcurrentMap stringCache = new MapMaker().concurrencyLevel(2).makeMap(); @@ -68,6 +68,8 @@ public class Datahandler { private static ConcurrentMap coreDocumentAnnotationCache; private static ConcurrentMap conversationMatchMap; private static ConcurrentMap conversationUserMatchMap; + private static final ConcurrentMap mapUdate = new MapMaker().concurrencyLevel(4).makeMap(); + private final static ConcurrentMap strmapreturn = new MapMaker().concurrencyLevel(4).makeMap(); private LinkedHashMap> lHMSMX = new LinkedHashMap(); private final Stopwatch stopwatch; private static final ForkJoinPool executor = instantiateExecutor(); @@ -94,13 +96,12 @@ public class Datahandler { public Datahandler() { this.stopwatch = Stopwatch.createUnstarted(); - this.jmweAnnotationCache = new MapMaker().concurrencyLevel(2).makeMap(); - this.pipelineAnnotationCache = new MapMaker().concurrencyLevel(2).makeMap(); - this.pipelineSentimentAnnotationCache = new MapMaker().concurrencyLevel(2).makeMap(); - this.coreDocumentAnnotationCache = new MapMaker().concurrencyLevel(2).makeMap(); - this.conversationMatchMap = new MapMaker().concurrencyLevel(2).makeMap(); - this.sentenceRelationMap = new MapMaker().concurrencyLevel(2).makeMap(); - this.conversationUserMatchMap = new MapMaker().concurrencyLevel(2).makeMap(); + this.jmweAnnotationCache = new MapMaker().concurrencyLevel(3).makeMap(); + this.pipelineAnnotationCache = new MapMaker().concurrencyLevel(4).makeMap(); + this.pipelineSentimentAnnotationCache = new MapMaker().concurrencyLevel(4).makeMap(); + this.coreDocumentAnnotationCache = new MapMaker().concurrencyLevel(5).makeMap(); + this.conversationMatchMap = new MapMaker().concurrencyLevel(4).makeMap(); + this.conversationUserMatchMap = new MapMaker().concurrencyLevel(4).makeMap(); } private static StanfordCoreNLP getPipeLineSetUp() { @@ -230,7 +231,7 @@ public class Datahandler { hlStatsMessages.put(str, hlStatsMessages.size()); } } - int capacity = 35000; + int capacity = 10000; hlStatsMessages.keySet().forEach(str -> { if (!str.startsWith("!") && MessageResponseHandler.getStr().values().size() < capacity) { String orElse = strCacheLocal.values().parallelStream().filter(e -> e.equals(str)).findAny().orElse(null); @@ -275,58 +276,41 @@ public class Datahandler { } } - private final static ConcurrentMap cachedReturnEvaluations(ConcurrentMap getMap, ConcurrentMap strmapreturn, String str) { - List dummy = new ArrayList(); - int relationCap = 20; - getMap.entrySet().parallelStream().forEach(mapValues -> { - if (!strmapreturn.values().contains(str) && dummy.isEmpty()) { - Double scoreRelationNewMsgToRecentMsg = mapValues.getValue(); - System.out.println("strmapreturn size: " + strmapreturn.size() + "\nscoreRelationNewMsgToRecentMsg: " - + scoreRelationNewMsgToRecentMsg + "\n"); - if (scoreRelationNewMsgToRecentMsg >= 4100.0) { - positiveRelationCounter++; - if (positiveRelationCounter > relationCap) { - strmapreturn.put(strmapreturn.size() + 1, str); - } - } else if (scoreRelationNewMsgToRecentMsg <= -5000.0) { - negativeRelationCounter++; - if (negativeRelationCounter > relationCap * 2) { - dummy.add(1); - } - } + private final static void futuresReturnOverallEvaluation(ConcurrentMap> futures, String str) { + + for (final Future future : futures.values()) { + final SimilarityMatrix getSMX = retrieveFutureSMX(future); + if (handleRetrievedSMX(getSMX, str)) { + break; } - }); - return strmapreturn; + } + sentenceRelationMap.put(str, mapUdate); } - private final static ConcurrentMap futuresReturnOverallEvaluation(ConcurrentMap> futures, ConcurrentMap strmapreturn, String str) { - int relationCap = 20; - final ConcurrentMap mapUdate = new MapMaker().concurrencyLevel(2).makeMap(); - final List dummy = new ArrayList(); - futures.values().parallelStream().forEach(future -> { - if (!strmapreturn.values().contains(str) && dummy.isEmpty()) { - final SimilarityMatrix getSMX = retrieveFutureSMX(future); - if (getSMX != null) { - Double scoreRelationNewMsgToRecentMsg = getSMX.getDistance(); - System.out.println("strmapreturn size: " + strmapreturn.size() + "\nscoreRelationNewMsgToRecentMsg: " - + scoreRelationNewMsgToRecentMsg + "\n"); - mapUdate.put(getSMX.getSecondaryString(), scoreRelationNewMsgToRecentMsg); - if (scoreRelationNewMsgToRecentMsg >= 4100.0) { - positiveRelationCounter++; - if (positiveRelationCounter > relationCap) { - strmapreturn.put(strmapreturn.size() + 1, str); - } - } else if (scoreRelationNewMsgToRecentMsg <= -5000.0) { - negativeRelationCounter++; - if (negativeRelationCounter > relationCap * 2) { - dummy.add(1); - } - } + private static final boolean handleRetrievedSMX(SimilarityMatrix getSMX, String str) { + final int relationCap = 20; + if (getSMX != null) { + final Double scoreRelationNewMsgToRecentMsg = getSMX.getDistance(); + System.out.println("scoreRelationNewMsgToRecentMsg: " + scoreRelationNewMsgToRecentMsg + "\n"); + mapUdate.put(getSMX.getSecondaryString(), scoreRelationNewMsgToRecentMsg); + System.out.println("getSMX primary: " + getSMX.getPrimaryString() + "\ngetSMX secodary: " + getSMX.getSecondaryString() + "\n"); + if (scoreRelationNewMsgToRecentMsg >= 200.0) { + positiveRelationCounter++; + if (positiveRelationCounter >= relationCap) { + System.out.println("added to strmapreturn str: " + str + "\n"); + strmapreturn.put(strmapreturn.size() + 1, str); + return true; } + } else if (scoreRelationNewMsgToRecentMsg <= -6000.0) { + negativeRelationCounter += 5; } - }); - sentenceRelationMap.put(str, mapUdate); - return strmapreturn; + } else { + negativeRelationCounter += 2; + } + if (negativeRelationCounter >= relationCap * 3) { + return true; + } + return false; } private final static ConcurrentMap> StrComparringNoSentenceRelationMap(ConcurrentMap strCacheLocal, @@ -349,32 +333,29 @@ public class Datahandler { pipelineSentimentAnnotationCache.get(str1), localCoreDocumentMap.get(str), coreDocumentAnnotationCache.get(str1)); } futures.put(futures.size() + 1, executor.submit(worker)); - System.out.println("futures.size(): " + futures.size() + "\nstrmap.values().size(): " + strmapSize + "\n"); } } return futures; } - private final static ConcurrentMap stringIteratorComparator(ConcurrentMap strmap, + private static ConcurrentMap stringIteratorComparator(ConcurrentMap strmap, ConcurrentMap strCacheLocal, ConcurrentMap localJMWEMap, ConcurrentMap localPipelineAnnotation, ConcurrentMap localPipelineSentimentAnnotation, ConcurrentMap localCoreDocumentMap) { - ConcurrentMap strmapreturn = new MapMaker().concurrencyLevel(4).makeMap(); + int i = 0; for (String str : strmap.values()) { - final ConcurrentMap getMap = sentenceRelationMap.get(str); positiveRelationCounter = 0; negativeRelationCounter = 0; - if (getMap == null) { - final ConcurrentMap> futures = StrComparringNoSentenceRelationMap(strCacheLocal, str, localJMWEMap, localPipelineAnnotation, localPipelineSentimentAnnotation, localCoreDocumentMap, strmap.size()); - strmapreturn = futuresReturnOverallEvaluation(futures, strmapreturn, str); - } else { - strmapreturn = cachedReturnEvaluations(getMap, strmapreturn, str); - } + final ConcurrentMap> futures = StrComparringNoSentenceRelationMap(strCacheLocal, str, localJMWEMap, localPipelineAnnotation, localPipelineSentimentAnnotation, localCoreDocumentMap, strmap.size()); + futuresReturnOverallEvaluation(futures, str); + System.out.println("overall advancement of future iterator: " + i + "\nstrmap size: " + strmap.values().size() + "\nstrmapreturn size: " + strmapreturn.size() + + "\n"); + i++; } return strmapreturn; } - private static ConcurrentMap removeNonSensicalStrings(ConcurrentMap strmap) { + private static final ConcurrentMap removeNonSensicalStrings(ConcurrentMap strmap) { final ConcurrentMap strCacheLocal = stringCache.size() < 150 ? strmap : stringCache; final ConcurrentMap localJMWEMap = getMultipleJMWEAnnotation(strmap.values()); final ConcurrentMap localPipelineAnnotation = getMultiplePipelineAnnotation(strmap.values()); @@ -384,7 +365,7 @@ public class Datahandler { return stringIteratorComparator(strmap, strCacheLocal, localJMWEMap, localPipelineAnnotation, localPipelineSentimentAnnotation, localCoreDocumentMap); } - private static SimilarityMatrix retrieveFutureSMX(Future future) { + private final static SimilarityMatrix retrieveFutureSMX(Future future) { try { return future.get(5, TimeUnit.SECONDS); } catch (InterruptedException | ExecutionException | TimeoutException ex) { diff --git a/ArtificialAutism/src/main/java/FunctionLayer/StanfordParser/SentimentAnalyzerTest.java b/ArtificialAutism/src/main/java/FunctionLayer/StanfordParser/SentimentAnalyzerTest.java index 382e0618..4adf54e8 100644 --- a/ArtificialAutism/src/main/java/FunctionLayer/StanfordParser/SentimentAnalyzerTest.java +++ b/ArtificialAutism/src/main/java/FunctionLayer/StanfordParser/SentimentAnalyzerTest.java @@ -1116,7 +1116,7 @@ public class SentimentAnalyzerTest implements Callable { } catch (Exception ex) { //System.out.println("SENTIMENT stacktrace Overall catch: " + ex.getMessage() + "\n"); } - System.out.println("Final current score: " + score + "\nSentence 1: " + str + "\nSentence 2: " + str1 + "\n"); + //System.out.println("Final current score: " + score + "\nSentence 1: " + str + "\nSentence 2: " + str1 + "\n"); smxParam.setDistance(score); return smxParam; }