From 33ecf7730f874dbad8212962e2dbf0db485782c1 Mon Sep 17 00:00:00 2001 From: jenzur Date: Sat, 6 Apr 2019 23:58:18 +0200 Subject: [PATCH] updated responsemessages to evaluate own prior responses to new selected responses based on the client --- .../main/java/FunctionLayer/Datahandler.java | 157 +++++++++++++++--- .../FunctionLayer/MessageResponseHandler.java | 14 +- .../PresentationLayer/DiscordHandler.java | 5 +- 3 files changed, 143 insertions(+), 33 deletions(-) diff --git a/ArtificialAutism/src/main/java/FunctionLayer/Datahandler.java b/ArtificialAutism/src/main/java/FunctionLayer/Datahandler.java index 084ba1e6..9557abc9 100644 --- a/ArtificialAutism/src/main/java/FunctionLayer/Datahandler.java +++ b/ArtificialAutism/src/main/java/FunctionLayer/Datahandler.java @@ -55,8 +55,12 @@ public class Datahandler { public static final long EXPIRE_TIME_IN_SECONDS1 = TimeUnit.SECONDS.convert(10, TimeUnit.HOURS); public static Datahandler instance = new Datahandler(); private static volatile Double minDistance; + private static Annotation strAnno; + private static Annotation strAnnoSentiment; + private static Annotation strAnnoJMWE; private volatile boolean refreshMatrixFromDB; private static volatile int secondaryIterator = 0; + private static volatile Double preRelationCounters = 0.0; private final ConcurrentMap stringCache; private static ConcurrentMap pipelineAnnotationCache; private static ConcurrentMap pipelineSentimentAnnotationCache; @@ -395,7 +399,7 @@ public class Datahandler { } } - public synchronized String getResponseMsg(String str) throws CustomError { + public synchronized String getResponseMsg(String str, String MostRecent) throws CustomError { str = str.trim(); if (str.startsWith("<@")) { str = str.substring(str.indexOf("> ") + 2); @@ -405,7 +409,7 @@ public class Datahandler { double Score = -10000; SimilarityMatrix SMXreturn = new SimilarityMatrix("", ""); System.out.println("pre mostSimilarSTR \n"); - String mostSimilarSTR = mostSimilar(str, strArrs); + String mostSimilarSTR = mostSimilar(str, strArrs, MostRecent); if (mostSimilarSTR != null) { LinkedHashMap orDefault = LHMSMXLocal.getOrDefault(mostSimilarSTR, null); if (orDefault != null) { @@ -438,24 +442,17 @@ public class Datahandler { } } System.out.println("none within 8 range"); - Annotation strAnno = new Annotation(str); - pipeline.annotate(strAnno); - Annotation strAnno2 = new Annotation(str); - pipelineSentiment.annotate(strAnno2); - List notactualList = new ArrayList(); - notactualList.add(str); - ConcurrentMap jmweAnnotation = PipelineJMWESingleton.INSTANCE.getJMWEAnnotation(notactualList); - final Annotation strAnno3 = jmweAnnotation.values().iterator().next(); ConcurrentMap strCache = stringCache; ConcurrentMap> futureslocal = new MapMaker().concurrencyLevel(2).makeMap(); ConcurrentMap futurereturn = new MapMaker().concurrencyLevel(2).makeMap(); String strF = str; + getSingularAnnotation(strF); strCache.values().parallelStream().forEach((str1) -> { if (!strF.equals(str1)) { SimilarityMatrix SMX = new SimilarityMatrix(strF, str1); Callable worker = new SentimentAnalyzerTest(strF, str1, SMX, - strAnno3, jmweAnnotationCache.get(str1), strAnno, - pipelineAnnotationCache.get(str1), strAnno2, + strAnnoJMWE, jmweAnnotationCache.get(str1), strAnno, + pipelineAnnotationCache.get(str1), strAnnoSentiment, pipelineSentimentAnnotationCache.get(str1)); futureslocal.put(futureslocal.size() + 1, executor.submit(worker)); } @@ -463,13 +460,50 @@ public class Datahandler { futureslocal.values().parallelStream().forEach((future) -> { SimilarityMatrix SMX = new SimilarityMatrix("", ""); try { - SMX = future.get(20, TimeUnit.SECONDS); + SMX = future.get(5, TimeUnit.SECONDS); futurereturn.put(futurereturn.size() + 1, SMX); } catch (InterruptedException | ExecutionException | TimeoutException ex) { System.out.println("ex getResponsemsg: " + ex.getMessage() + "\n"); } }); + ConcurrentMap smxUpdateReturn = new MapMaker().concurrencyLevel(2).makeMap(); for (SimilarityMatrix SMX : futurereturn.values()) { + Double scoreRelation = 500.0; + boolean foundmatch = false; + if (!MostRecent.isEmpty()) { + LinkedHashMap orDefault1 = lHMSMX.getOrDefault(MostRecent, null); + if (orDefault1 != null) { + Collection orDefaultstrs = orDefault1.keySet(); + for (String strs : orDefaultstrs) { + if (strs.equals(SMX.getSecondaryString())) { + scoreRelation = orDefault1.get(SMX.getSecondaryString()); + foundmatch = true; + break; + } + } + } + if (!foundmatch) { + orDefault1 = lHMSMX.getOrDefault(SMX.getSecondaryString(), null); + if (orDefault1 != null) { + Collection orDefaultstrs = orDefault1.keySet(); + for (String strs : orDefaultstrs) { + if (strs.equals(MostRecent)) { + scoreRelation = orDefault1.get(MostRecent); + foundmatch = true; + break; + } + } + } + } + } + if (!foundmatch) { + scoreRelation = getScoreRelationNewMsgToRecentMsg(SMX.getSecondaryString(), MostRecent); + } + if (scoreRelation > 500.0 + (25 * smxUpdateReturn.size())) { + smxUpdateReturn.put(smxUpdateReturn.size() + 1, SMX); + } + } + for (SimilarityMatrix SMX : smxUpdateReturn.values()) { double distance = SMX.getDistance(); if (distance > Score) { Score = distance; @@ -481,31 +515,103 @@ public class Datahandler { return SMXreturn.getSecondaryString(); } - public String mostSimilar(String toBeCompared, ConcurrentMap concurrentStrings) { + public void getSingularAnnotation(String str) { + strAnno = new Annotation(str); + pipeline.annotate(strAnno); + strAnnoSentiment = new Annotation(str); + pipelineSentiment.annotate(strAnnoSentiment); + List notactualList = new ArrayList(); + notactualList.add(str); + ConcurrentMap jmweAnnotation = PipelineJMWESingleton.INSTANCE.getJMWEAnnotation(notactualList); + strAnnoJMWE = jmweAnnotation.values().iterator().next(); + } + + private Double getScoreRelationNewMsgToRecentMsg(String str, String mostRecentMsg) { + SimilarityMatrix SMX = new SimilarityMatrix(str, mostRecentMsg); + Callable worker = new SentimentAnalyzerTest(str, mostRecentMsg, SMX, + jmweAnnotationCache.get(str), jmweAnnotationCache.get(mostRecentMsg), pipelineAnnotationCache.get(str), + pipelineAnnotationCache.get(mostRecentMsg), pipelineSentimentAnnotationCache.get(str), + pipelineSentimentAnnotationCache.get(mostRecentMsg)); + SimilarityMatrix callSMX = null; + try { + callSMX = worker.call(); + } catch (Exception ex) { + Logger.getLogger(Datahandler.class + .getName()).log(Level.SEVERE, null, ex); + } + if (callSMX != null) { + double smxDistance = callSMX.getDistance(); + return smxDistance; + } + return 0.0; + } + + public String mostSimilar(String toBeCompared, ConcurrentMap concurrentStrings, String MostRecent) { similar = ""; - minDistance = 12.5; + minDistance = 7.0; + preRelationCounters = 500.0; + ConcurrentMap similardistances = new MapMaker().concurrencyLevel(2).makeMap(); concurrentStrings.values().parallelStream().forEach((str) -> { LevenshteinDistance leven = new LevenshteinDistance(toBeCompared, str); double distance = leven.computeLevenshteinDistance(); - if (distance < minDistance) { + if (distance <= minDistance) { minDistance = distance; System.out.println("distance: " + distance + "\n"); - similar = str; + similardistances.put(similardistances.size() + 1, str); } }); - LinkedHashMap orDefault = lHMSMX.getOrDefault(similar, null); - if (orDefault == null) { + if (similardistances.isEmpty()) { return null; } Double maxDistance = 0.0; - for (Entry defaultEntry : orDefault.entrySet()) { - Double value = defaultEntry.getValue(); - if (value > maxDistance) { - maxDistance = value; - similar = defaultEntry.getKey(); + for (String str : similardistances.values()) { + LinkedHashMap orDefault = lHMSMX.getOrDefault(str, null); + if (orDefault != null) { + for (Entry defaultEntry : orDefault.entrySet()) { + Double value = defaultEntry.getValue(); + String key = defaultEntry.getKey(); + if (value > maxDistance) { + Double RelationScore = 500.0; + boolean foundmatch = false; + if (!MostRecent.isEmpty()) { + LinkedHashMap orDefault1 = lHMSMX.getOrDefault(MostRecent, null); + if (orDefault1 != null) { + Collection orDefaultstrs = orDefault1.keySet(); + for (String strs : orDefaultstrs) { + if (strs.equals(key)) { + RelationScore = orDefault1.get(key); + foundmatch = true; + break; + } + } + } + if (!foundmatch) { + orDefault1 = lHMSMX.getOrDefault(key, null); + if (orDefault1 != null) { + Collection orDefaultstrs = orDefault1.keySet(); + for (String strs : orDefaultstrs) { + if (strs.equals(MostRecent)) { + RelationScore = orDefault1.get(MostRecent); + foundmatch = true; + break; + } + } + } + } + } + if (!foundmatch) { + RelationScore = getScoreRelationNewMsgToRecentMsg(key, MostRecent); + } + if (RelationScore > preRelationCounters) { + maxDistance = value; + similar = defaultEntry.getKey(); + preRelationCounters = RelationScore; + } + } + } } } - return similar; + return similar.isEmpty() ? null : similar; } public static ConcurrentMap cutContent(ConcurrentMap str, boolean hlStatsMsg) { @@ -729,4 +835,5 @@ public class Datahandler { }); return strmap; } + } diff --git a/ArtificialAutism/src/main/java/FunctionLayer/MessageResponseHandler.java b/ArtificialAutism/src/main/java/FunctionLayer/MessageResponseHandler.java index 13e86ef6..40e0f292 100644 --- a/ArtificialAutism/src/main/java/FunctionLayer/MessageResponseHandler.java +++ b/ArtificialAutism/src/main/java/FunctionLayer/MessageResponseHandler.java @@ -15,17 +15,17 @@ import java.util.concurrent.ConcurrentMap; * @author install1 */ public class MessageResponseHandler { - + private static ConcurrentMap str = new MapMaker().concurrencyLevel(2).makeMap(); - + public static ConcurrentMap getStr() { return str; } - + public static void setStr(ConcurrentMap str) { MessageResponseHandler.str = str; } - + public static void getMessage(String message) { if (message != null && !message.isEmpty()) { message = message.replace("@", ""); @@ -38,8 +38,8 @@ public class MessageResponseHandler { str.put(str.size() + 1, message); } } - - public static String selectReponseMessage(String toString) throws CustomError { + + public synchronized static String selectReponseMessage(String toString, String mostRecentMsg) throws CustomError { ConcurrentMap str1 = new MapMaker().concurrencyLevel(2).makeMap(); str1.put(str1.size() + 1, toString); str1 = Datahandler.cutContent(str1, false); @@ -49,7 +49,7 @@ public class MessageResponseHandler { strreturn = str; } } - String getResponseMsg = Datahandler.instance.getResponseMsg(strreturn); + String getResponseMsg = Datahandler.instance.getResponseMsg(strreturn, mostRecentMsg); return getResponseMsg; } } diff --git a/ArtificialAutism/src/main/java/PresentationLayer/DiscordHandler.java b/ArtificialAutism/src/main/java/PresentationLayer/DiscordHandler.java index 9f537c3f..42b984cb 100644 --- a/ArtificialAutism/src/main/java/PresentationLayer/DiscordHandler.java +++ b/ArtificialAutism/src/main/java/PresentationLayer/DiscordHandler.java @@ -33,6 +33,8 @@ import org.javacord.api.entity.user.User; */ public class DiscordHandler { + private static String MostRecentMsg = "initial state"; + public static void main(String[] args) { System.setProperty("java.util.concurrent.ForkJoinPool.common.parallelism", "25"); try { @@ -92,10 +94,11 @@ public class DiscordHandler { || event.getServerTextChannel().get().toString().contains("general-autism")) { String ResponseStr; try { - ResponseStr = MessageResponseHandler.selectReponseMessage(event.getMessage().toString()); + ResponseStr = MessageResponseHandler.selectReponseMessage(event.getMessage().toString(), MostRecentMsg); if (!ResponseStr.isEmpty()) { System.out.print("\nResponseStr3: " + ResponseStr + "\n"); event.getChannel().sendMessage(ResponseStr); + MostRecentMsg = ResponseStr; } new Thread(() -> { try {