search

Roboy / roboy_dialog

https://roboy.org/
8 stars 6 forks source link

Akinator Null Point Exception at End #67

Closed Aevyz closed 6 years ago

Aevyz commented 6 years ago

Problem

Turns out the problem is really simple. We at Dialog Evolution no longer use ROS since we disabled it for midterms. 20 Questions requires ROS because of the filterApplied = getRosMainNode().ApplyFilter("flies"); at 275 of GamingTwentyQuestionState.

Additionally Snapchat filters infinite loop if ROS is disabled

Solutions

  1. Disable Games if Config.Properties has ROS disabled
  2. Add if toggles to the ApplyFilter --> if(ros_enabled) do filter and ros things

Logs

Config

PERSONALITY_FILE: "resources/personalityFiles/GamePersonality.json" or PERSONALITY_FILE: "resources/personalityFiles/OrdinaryPersonality.json". Does not matter.

Logs 1

[INFO] Initializing Config --- roboy.util.ConfigManager (00:21:04)
[INFO] Using Neo4jMemory --- roboy.memory.Neo4jMemory (00:21:05)
[INFO] Initializing analyzers... --- roboy.dialog.ConversationManager (00:21:05)
Grammar.read {
  SimpleLexicon.read(resources_nlu/lexicons/roboy-demo.lexicon) {
    Read 132 lines, generated 77 entries (now 77 total)
  }
  WARNING: Category not defined in the grammar: $NewEntity; used in rule: $Subject -> $NewEntity (IdentityFn)
  WARNING: Category not defined in the grammar: $Binary; used in rule: $Set -> $Binary $Entity (JoinFn forward)
  WARNING: Category not defined in the grammar: $Binary; used in rule: $Set -> $Entity $Binary (JoinFn backward)
  WARNING: Category not defined in the grammar: $Binary; used in rule: $Set -> $Binary $Entity (JoinFn forward)
  WARNING: Category not defined in the grammar: $Binary; used in rule: $Set -> $Entity $Binary (JoinFn backward)
  Valid tags: [error]
  Used tags: []
  362 rules
}
Initializing Config {
  BeamParser: 137 catUnaryRules (sorted), 225 nonCatUnaryRules (in trie)
[main] INFO org.nd4j.linalg.factory.Nd4jBackend - Loaded [CpuBackend] backend
[main] INFO org.reflections.Reflections - Reflections took 519 ms to scan 341 urls, producing 89451 keys and 104160 values 
[main] INFO org.nd4j.nativeblas.NativeOpsHolder - Number of threads used for NativeOps: 2
[main] INFO org.reflections.Reflections - Reflections took 190 ms to scan 13 urls, producing 31 keys and 227 values 
[main] INFO org.nd4j.nativeblas.Nd4jBlas - Number of threads used for BLAS: 2
[main] INFO org.nd4j.linalg.api.ops.executioner.DefaultOpExecutioner - Backend used: [CPU]; OS: [Linux]
[main] INFO org.nd4j.linalg.api.ops.executioner.DefaultOpExecutioner - Cores: [4]; Memory: [2.7GB];
[main] INFO org.nd4j.linalg.api.ops.executioner.DefaultOpExecutioner - Blas vendor: [OPENBLAS]
[main] INFO org.reflections.Reflections - Reflections took 170 ms to scan 13 urls, producing 387 keys and 1538 values 
  Tests ->  {
    Closest words: [elizabeth, victoria, king, monarch, majesty, consort, balmoral, queens, royal, beatrix]
    Closest word to female from : "women","queen","elisabeth" -> [women]
    Closest word to swimming from : "literature","activity","sports" -> : []
  }
  Dataset.read 
  Learner.learn() {
    Iteration 0/10 
    Iteration 1/10 
    Iteration 2/10 
    Iteration 3/10 
    Iteration 4/10 
    Iteration 5/10 
    Iteration 6/10 
    Iteration 7/10 
    Iteration 8/10 
    Iteration 9/10 
    Iteration 10/10 
  }
[main] INFO edu.stanford.nlp.pipeline.StanfordCoreNLP - Adding annotator tokenize
[main] INFO edu.stanford.nlp.pipeline.TokenizerAnnotator - No tokenizer type provided. Defaulting to PTBTokenizer.
[main] INFO edu.stanford.nlp.pipeline.StanfordCoreNLP - Adding annotator ssplit
[main] INFO edu.stanford.nlp.pipeline.StanfordCoreNLP - Adding annotator pos
[main] INFO edu.stanford.nlp.tagger.maxent.MaxentTagger - Loading POS tagger from edu/stanford/nlp/models/pos-tagger/english-caseless-left3words-distsim.tagger ... done [1.6 sec].
[main] INFO edu.stanford.nlp.pipeline.StanfordCoreNLP - Adding annotator lemma
[main] INFO edu.stanford.nlp.pipeline.StanfordCoreNLP - Adding annotator ner
[main] INFO edu.stanford.nlp.ie.AbstractSequenceClassifier - Loading classifier from edu/stanford/nlp/models/ner/english.all.3class.caseless.distsim.crf.ser.gz ... done [1.0 sec].
[main] INFO edu.stanford.nlp.ie.AbstractSequenceClassifier - Loading classifier from edu/stanford/nlp/models/ner/english.conll.4class.caseless.distsim.crf.ser.gz ... done [0.5 sec].
[main] INFO edu.stanford.nlp.pipeline.StanfordCoreNLP - Adding annotator parse
[main] INFO edu.stanford.nlp.parser.common.ParserGrammar - Loading parser from serialized file edu/stanford/nlp/models/lexparser/englishPCFG.ser.gz ... done [0.4 sec].
[main] INFO edu.stanford.nlp.pipeline.StanfordCoreNLP - Adding annotator depparse
[main] INFO edu.stanford.nlp.parser.nndep.DependencyParser - Loading depparse model file: edu/stanford/nlp/models/parser/nndep/english_UD.gz ... 
[main] INFO edu.stanford.nlp.parser.nndep.Classifier - PreComputed 99996, Elapsed Time: 15.768 (s)
[main] INFO edu.stanford.nlp.parser.nndep.DependencyParser - Initializing dependency parser ... done [18.4 sec].
[main] INFO edu.stanford.nlp.pipeline.StanfordCoreNLP - Adding annotator natlog
[main] INFO edu.stanford.nlp.pipeline.StanfordCoreNLP - Adding annotator openie
[main] INFO edu.stanford.nlp.naturalli.ClauseSplitter - Loading clause splitter from edu/stanford/nlp/models/naturalli/clauseSearcherModel.ser.gz ... done [0.0042 seconds]
[main] INFO edu.stanford.nlp.pipeline.StanfordCoreNLP - Adding annotator sentiment
  Parser.parse: parse {
    Error retrieval: {
      Checking 0 derivations
    }
    Parser.ensureExecuted 
  }
  Parser.ensureExecuted 
  Parser.setEvaluation: 0 candidates 
  Example:  {
    Tokens: []
    Lemmatized tokens: []
    POS tags: []
    NER tags: []
    NER values: []
    Sentiment: 
    Keywords: []
    Dependency children: []
    Extracted relations: {}
  }
[INFO] Creating new conversation... --- roboy.dialog.ConversationManager (00:21:43)
[INFO] RosMainNode will be unavailable in DialogStateMachine (null was passed) --- roboy.dialog.DialogStateMachine (00:21:43)
[INFO]  -> The filterList path: resources/gameResources/snapchat-filters.txt --- roboy.dialog.states.gameStates.GamingSnapchatState (00:21:44)
[INFO] Waiting for conversation to end. --- roboy.dialog.ConversationManager (00:21:44)
[INFO] ############# Conversation started ############ --- Conversation15 (00:21:44)
[Roboy]: I'm pretty good at answering questions about myself and other stuff. What would you like to know?
[You]:   Hi
  Hi
  Parser.parse: parse {
    Error retrieval: {
      Checking 0 derivations
    }
    Parser.ensureExecuted 
  }
  Parser.ensureExecuted 
  Parser.setEvaluation: 0 candidates 
  Example: Hi {
    Tokens: [hi]
    Lemmatized tokens: [hi]
    POS tags: [UH]
    NER tags: [O]
    NER values: [null]
    Sentiment: Neutral
    Keywords: [Hi]
    Dependency children: [[]]
    Extracted relations: {}
  }
[Roboy]: I am out of words.
[Roboy]:  It can take a photon 40,000 years to travel from the core of the sun to its surface, but only 8 minutes to travel the rest of the way to Earth 
[Roboy]:  Let me uncover my potential. Ask something really difficult! 
[You]:   Jason
  Jason
  Parser.parse: parse {
    Error retrieval: {
      Checking 0 derivations
    }
    Parser.ensureExecuted 
  }
  Parser.ensureExecuted 
  Parser.setEvaluation: 0 candidates 
  Example: Jason {
    Tokens: [jason]
    Lemmatized tokens: [Jason]
    POS tags: [NNP]
    NER tags: [PERSON]
    NER values: [null]
    Sentiment: Neutral
    Keywords: [Jason]
    Dependency children: [[]]
    Extracted relations: {}
  }
[Roboy]: I am out of words.
[Roboy]:  There are 8 times as many atoms in a teaspoonful of water as there are teaspoonfuls of water in the Atlantic ocean 
[Roboy]:  Let me uncover my potential. Ask something really difficult! 
[You]:   Lets play akinator
  Lets play akinator
  Parser.parse: parse {
    Error retrieval: {
      Checking 0 derivations
    }
    Parser.ensureExecuted 
  }
  Parser.ensureExecuted 
  Parser.setEvaluation: 0 candidates 
  Example: Lets play akinator {
    Tokens: [lets, play, akinator]
    Lemmatized tokens: [let, play, akinator]
    POS tags: [VBZ, NN, NN]
    NER tags: [O, O, O]
    NER values: [null, null, null]
    Sentiment: Neutral
    Keywords: [play, akinator]
    Dependency children: [[dobj->2], [], [compound->1]]
    Extracted relations: {}
  }
[Roboy]: Nice, let's start. 
[Roboy]:  Yeah, I love games. Let's play Snapchat. 
[You]:   no
  no
  Parser.parse: parse {
    Error retrieval: {
      Checking 0 derivations
    }
    Parser.ensureExecuted 
  }
  Parser.ensureExecuted 
  Parser.setEvaluation: 0 candidates 
  Example: no {
    Tokens: [no]
    Lemmatized tokens: [no]
    POS tags: [DT]
    NER tags: [O]
    NER values: [null]
    Sentiment: Negative
    Keywords: [no]
    Dependency children: [[]]
    Extracted relations: {}
  }
[Roboy]:  Is that all that comes to your mind? Ask me something! 
[You]:   Lets play
  Lets play
  Parser.parse: parse {
    Error retrieval: {
      Checking 0 derivations
    }
    Parser.ensureExecuted 
  }
  Parser.ensureExecuted 
  Parser.setEvaluation: 0 candidates 
  Example: Lets play {
    Tokens: [lets, play]
    Lemmatized tokens: [let, play]
    POS tags: [VBZ, NN]
    NER tags: [O, O]
    NER values: [null, null]
    Sentiment: Neutral
    Keywords: [play]
    Dependency children: [[dobj->1], []]
    Extracted relations: {}
  }
[Roboy]: Nice, let's start. 
[Roboy]:  What game do you want to play? Maybe Akinator? 
[You]:   yes
  yes
  Parser.parse: parse {
    Error retrieval: {
      Checking 0 derivations
    }
    Parser.ensureExecuted 
  }
  Parser.ensureExecuted 
  Parser.setEvaluation: 0 candidates 
  Example: yes {
    Tokens: [yes]
    Lemmatized tokens: [yes]
    POS tags: [UH]
    NER tags: [O]
    NER values: [null]
    Sentiment: Neutral
    Keywords: [yes]
    Dependency children: [[]]
    Extracted relations: {}
  }
[Roboy]: Let's go. 
[Roboy]:  Do you have a character in mind? Tell me when you're ready. 
[You]:   yes
  yes
  Parser.parse: parse {
    Error retrieval: {
      Checking 0 derivations
    }
    Parser.ensureExecuted 
  }
  Parser.ensureExecuted 
  Parser.setEvaluation: 0 candidates 
  Example: yes {
    Tokens: [yes]
    Lemmatized tokens: [yes]
    POS tags: [UH]
    NER tags: [O]
    NER values: [null]
    Sentiment: Neutral
    Keywords: [yes]
    Dependency children: [[]]
    Extracted relations: {}
  }
[Roboy]: Can't wait to start. 
[Roboy]: Is your character a real person?
[You]:   no
  no
  Parser.parse: parse {
    Error retrieval: {
      Checking 0 derivations
    }
    Parser.ensureExecuted 
  }
  Parser.ensureExecuted 
  Parser.setEvaluation: 0 candidates 
  Example: no {
    Tokens: [no]
    Lemmatized tokens: [no]
    POS tags: [DT]
    NER tags: [O]
    NER values: [null]
    Sentiment: Negative
    Keywords: [no]
    Dependency children: [[]]
    Extracted relations: {}
  }
[Roboy]: Nope. 
[Roboy]: Does your character have hair?
[You]:   yes
  yes
  Parser.parse: parse {
    Error retrieval: {
      Checking 0 derivations
    }
    Parser.ensureExecuted 
  }
  Parser.ensureExecuted 
  Parser.setEvaluation: 0 candidates 
  Example: yes {
    Tokens: [yes]
    Lemmatized tokens: [yes]
    POS tags: [UH]
    NER tags: [O]
    NER values: [null]
    Sentiment: Neutral
    Keywords: [yes]
    Dependency children: [[]]
    Extracted relations: {}
  }
[Roboy]: You said yes. 
[Roboy]: Is your character a woman ?
[You]:   no
  no
  Parser.parse: parse {
    Error retrieval: {
      Checking 0 derivations
    }
    Parser.ensureExecuted 
  }
  Parser.ensureExecuted 
  Parser.setEvaluation: 0 candidates 
  Example: no {
    Tokens: [no]
    Lemmatized tokens: [no]
    POS tags: [DT]
    NER tags: [O]
    NER values: [null]
    Sentiment: Negative
    Keywords: [no]
    Dependency children: [[]]
    Extracted relations: {}
  }
[Roboy]: That was clear. No. 
[Roboy]: Does your character fight?
[You]:   yes
  yes
  Parser.parse: parse {
    Error retrieval: {
      Checking 0 derivations
    }
    Parser.ensureExecuted 
  }
  Parser.ensureExecuted 
  Parser.setEvaluation: 0 candidates 
  Example: yes {
    Tokens: [yes]
    Lemmatized tokens: [yes]
    POS tags: [UH]
    NER tags: [O]
    NER values: [null]
    Sentiment: Neutral
    Keywords: [yes]
    Dependency children: [[]]
    Extracted relations: {}
  }
[Roboy]: You said yes. 
[Roboy]: Is your character from an anime (Japanese animation)?
[You]:   no
  no
  Parser.parse: parse {
    Error retrieval: {
      Checking 0 derivations
    }
    Parser.ensureExecuted 
  }
  Parser.ensureExecuted 
  Parser.setEvaluation: 0 candidates 
  Example: no {
    Tokens: [no]
    Lemmatized tokens: [no]
    POS tags: [DT]
    NER tags: [O]
    NER values: [null]
    Sentiment: Negative
    Keywords: [no]
    Dependency children: [[]]
    Extracted relations: {}
  }
[Roboy]: Not at all. 
[Roboy]: Can they be seen in a movie?
[You]:   yes
  yes
  Parser.parse: parse {
    Error retrieval: {
      Checking 0 derivations
    }
    Parser.ensureExecuted 
  }
  Parser.ensureExecuted 
  Parser.setEvaluation: 0 candidates 
  Example: yes {
    Tokens: [yes]
    Lemmatized tokens: [yes]
    POS tags: [UH]
    NER tags: [O]
    NER values: [null]
    Sentiment: Neutral
    Keywords: [yes]
    Dependency children: [[]]
    Extracted relations: {}
  }
[Roboy]: I heard a yes from you. 
[Roboy]: Is your character related to Marvel?
[You]:   no
  no
  Parser.parse: parse {
    Error retrieval: {
      Checking 0 derivations
    }
    Parser.ensureExecuted 
  }
  Parser.ensureExecuted 
  Parser.setEvaluation: 0 candidates 
  Example: no {
    Tokens: [no]
    Lemmatized tokens: [no]
    POS tags: [DT]
    NER tags: [O]
    NER values: [null]
    Sentiment: Negative
    Keywords: [no]
    Dependency children: [[]]
    Extracted relations: {}
  }
[Roboy]: A no from you. 
[Roboy]: Does your character have special powers?
[You]:   no
  no
  Parser.parse: parse {
    Error retrieval: {
      Checking 0 derivations
    }
    Parser.ensureExecuted 
  }
  Parser.ensureExecuted 
  Parser.setEvaluation: 0 candidates 
  Example: no {
    Tokens: [no]
    Lemmatized tokens: [no]
    POS tags: [DT]
    NER tags: [O]
    NER values: [null]
    Sentiment: Negative
    Keywords: [no]
    Dependency children: [[]]
    Extracted relations: {}
  }
[Roboy]: A no from you. 
[Roboy]: Does your character have a car?
[You]:   yes
  yes
  Parser.parse: parse {
    Error retrieval: {
      Checking 0 derivations
    }
    Parser.ensureExecuted 
  }
  Parser.ensureExecuted 
  Parser.setEvaluation: 0 candidates 
  Example: yes {
    Tokens: [yes]
    Lemmatized tokens: [yes]
    POS tags: [UH]
    NER tags: [O]
    NER values: [null]
    Sentiment: Neutral
    Keywords: [yes]
    Dependency children: [[]]
    Extracted relations: {}
  }
[Roboy]: A clear yes. 
[Roboy]: Is your character linked with Batman?
[You]:   yes
  yes
  Parser.parse: parse {
    Error retrieval: {
      Checking 0 derivations
    }
    Parser.ensureExecuted 
  }
  Parser.ensureExecuted 
  Parser.setEvaluation: 0 candidates 
  Example: yes {
    Tokens: [yes]
    Lemmatized tokens: [yes]
    POS tags: [UH]
    NER tags: [O]
    NER values: [null]
    Sentiment: Neutral
    Keywords: [yes]
    Dependency children: [[]]
    Extracted relations: {}
  }
[Roboy]: A clear yes. 
[Roboy]: Does your character wear just black?
[You]:   yes
  yes
  Parser.parse: parse {
    Error retrieval: {
      Checking 0 derivations
    }
    Parser.ensureExecuted 
  }
  Parser.ensureExecuted 
  Parser.setEvaluation: 0 candidates 
  Example: yes {
    Tokens: [yes]
    Lemmatized tokens: [yes]
    POS tags: [UH]
    NER tags: [O]
    NER values: [null]
    Sentiment: Neutral
    Keywords: [yes]
    Dependency children: [[]]
    Extracted relations: {}
  }
[Roboy]: I heard a yes from you. 
[Roboy]:  I know for sure, it must be Batman / Bruce Wayne
[You]:   yes
  yes
  Parser.parse: parse {
    Error retrieval: {
      Checking 0 derivations
    }
    Parser.ensureExecuted 
  }
  Parser.ensureExecuted 
  Parser.setEvaluation: 0 candidates 
  Example: yes {
    Tokens: [yes]
    Lemmatized tokens: [yes]
    POS tags: [UH]
    NER tags: [O]
    NER values: [null]
    Sentiment: Neutral
    Keywords: [yes]
    Dependency children: [[]]
    Extracted relations: {}
  }
[ERROR] Error in personality.answer: null --- Conversation15 (00:22:42)
[Roboy]: I heard a yes from you. 
[Roboy]:  I know for sure, it must be Batman / Bruce Wayne
[You]:   java.lang.NullPointerException
    at roboy.dialog.states.gameStates.GamingTwentyQuestionsState.applyFilter(GamingTwentyQuestionsState.java:275)
    at roboy.dialog.states.gameStates.GamingTwentyQuestionsState.getNextState(GamingTwentyQuestionsState.java:118)
    at roboy.dialog.personality.StateBasedPersonality.answer(StateBasedPersonality.java:160)
    at roboy.dialog.Conversation.run(Conversation.java:128)

Logs 2

[INFO] Initializing Config --- roboy.util.ConfigManager (00:25:42)
[INFO] Using Neo4jMemory --- roboy.memory.Neo4jMemory (00:25:42)
[INFO] Initializing analyzers... --- roboy.dialog.ConversationManager (00:25:42)
Grammar.read {
  SimpleLexicon.read(resources_nlu/lexicons/roboy-demo.lexicon) {
    Read 132 lines, generated 77 entries (now 77 total)
  }
  WARNING: Category not defined in the grammar: $NewEntity; used in rule: $Subject -> $NewEntity (IdentityFn)
  WARNING: Category not defined in the grammar: $Binary; used in rule: $Set -> $Binary $Entity (JoinFn forward)
  WARNING: Category not defined in the grammar: $Binary; used in rule: $Set -> $Entity $Binary (JoinFn backward)
  WARNING: Category not defined in the grammar: $Binary; used in rule: $Set -> $Binary $Entity (JoinFn forward)
  WARNING: Category not defined in the grammar: $Binary; used in rule: $Set -> $Entity $Binary (JoinFn backward)
  Valid tags: [error]
  Used tags: []
  362 rules
}
Initializing Config {
  BeamParser: 137 catUnaryRules (sorted), 225 nonCatUnaryRules (in trie)
[main] INFO org.nd4j.linalg.factory.Nd4jBackend - Loaded [CpuBackend] backend
[main] INFO org.reflections.Reflections - Reflections took 530 ms to scan 341 urls, producing 89451 keys and 104160 values 
[main] INFO org.nd4j.nativeblas.NativeOpsHolder - Number of threads used for NativeOps: 2
[main] INFO org.reflections.Reflections - Reflections took 123 ms to scan 13 urls, producing 31 keys and 227 values 
[main] INFO org.nd4j.nativeblas.Nd4jBlas - Number of threads used for BLAS: 2
[main] INFO org.nd4j.linalg.api.ops.executioner.DefaultOpExecutioner - Backend used: [CPU]; OS: [Linux]
[main] INFO org.nd4j.linalg.api.ops.executioner.DefaultOpExecutioner - Cores: [4]; Memory: [2.7GB];
[main] INFO org.nd4j.linalg.api.ops.executioner.DefaultOpExecutioner - Blas vendor: [OPENBLAS]
[main] INFO org.reflections.Reflections - Reflections took 167 ms to scan 13 urls, producing 387 keys and 1538 values 
  Tests ->  {
    Closest words: [elizabeth, victoria, king, monarch, majesty, consort, balmoral, queens, royal, beatrix]
    Closest word to female from : "women","queen","elisabeth" -> [women]
    Closest word to swimming from : "literature","activity","sports" -> : []
  }
  Dataset.read 
  Learner.learn() {
    Iteration 0/10 
    Iteration 1/10 
    Iteration 2/10 
    Iteration 3/10 
    Iteration 4/10 
    Iteration 5/10 
    Iteration 6/10 
    Iteration 7/10 
    Iteration 8/10 
    Iteration 9/10 
    Iteration 10/10 
  }
[main] INFO edu.stanford.nlp.pipeline.StanfordCoreNLP - Adding annotator tokenize
[main] INFO edu.stanford.nlp.pipeline.TokenizerAnnotator - No tokenizer type provided. Defaulting to PTBTokenizer.
[main] INFO edu.stanford.nlp.pipeline.StanfordCoreNLP - Adding annotator ssplit
[main] INFO edu.stanford.nlp.pipeline.StanfordCoreNLP - Adding annotator pos
[main] INFO edu.stanford.nlp.tagger.maxent.MaxentTagger - Loading POS tagger from edu/stanford/nlp/models/pos-tagger/english-caseless-left3words-distsim.tagger ... done [1.0 sec].
[main] INFO edu.stanford.nlp.pipeline.StanfordCoreNLP - Adding annotator lemma
[main] INFO edu.stanford.nlp.pipeline.StanfordCoreNLP - Adding annotator ner
[main] INFO edu.stanford.nlp.ie.AbstractSequenceClassifier - Loading classifier from edu/stanford/nlp/models/ner/english.all.3class.caseless.distsim.crf.ser.gz ... done [1.9 sec].
[main] INFO edu.stanford.nlp.ie.AbstractSequenceClassifier - Loading classifier from edu/stanford/nlp/models/ner/english.conll.4class.caseless.distsim.crf.ser.gz ... done [0.6 sec].
[main] INFO edu.stanford.nlp.pipeline.StanfordCoreNLP - Adding annotator parse
[main] INFO edu.stanford.nlp.parser.common.ParserGrammar - Loading parser from serialized file edu/stanford/nlp/models/lexparser/englishPCFG.ser.gz ... done [0.3 sec].
[main] INFO edu.stanford.nlp.pipeline.StanfordCoreNLP - Adding annotator depparse
[main] INFO edu.stanford.nlp.parser.nndep.DependencyParser - Loading depparse model file: edu/stanford/nlp/models/parser/nndep/english_UD.gz ... 
[main] INFO edu.stanford.nlp.parser.nndep.Classifier - PreComputed 99996, Elapsed Time: 14.265 (s)
[main] INFO edu.stanford.nlp.parser.nndep.DependencyParser - Initializing dependency parser ... done [16.8 sec].
[main] INFO edu.stanford.nlp.pipeline.StanfordCoreNLP - Adding annotator natlog
[main] INFO edu.stanford.nlp.pipeline.StanfordCoreNLP - Adding annotator openie
[main] INFO edu.stanford.nlp.naturalli.ClauseSplitter - Loading clause splitter from edu/stanford/nlp/models/naturalli/clauseSearcherModel.ser.gz ... done [0.0037 seconds]
[main] INFO edu.stanford.nlp.pipeline.StanfordCoreNLP - Adding annotator sentiment
  Parser.parse: parse {
    Error retrieval: {
      Checking 0 derivations
    }
    Parser.ensureExecuted 
  }
  Parser.ensureExecuted 
  Parser.setEvaluation: 0 candidates 
  Example:  {
    Tokens: []
    Lemmatized tokens: []
    POS tags: []
    NER tags: []
    NER values: []
    Sentiment: 
    Keywords: []
    Dependency children: []
    Extracted relations: {}
  }
[INFO] Creating new conversation... --- roboy.dialog.ConversationManager (00:26:20)
[INFO] RosMainNode will be unavailable in DialogStateMachine (null was passed) --- roboy.dialog.DialogStateMachine (00:26:20)
[INFO]  -> The filterList path: resources/gameResources/snapchat-filters.txt --- roboy.dialog.states.gameStates.GamingSnapchatState (00:26:20)
[INFO] Waiting for conversation to end. --- roboy.dialog.ConversationManager (00:26:20)
[INFO] ############# Conversation started ############ --- Conversation15 (00:26:20)
[Roboy]: I'm pretty good at answering questions about myself and other stuff. What would you like to know?
[You]:   Hi
  Hi
  Parser.parse: parse {
    Error retrieval: {
      Checking 0 derivations
    }
    Parser.ensureExecuted 
  }
  Parser.ensureExecuted 
  Parser.setEvaluation: 0 candidates 
  Example: Hi {
    Tokens: [hi]
    Lemmatized tokens: [hi]
    POS tags: [UH]
    NER tags: [O]
    NER values: [null]
    Sentiment: Neutral
    Keywords: [Hi]
    Dependency children: [[]]
    Extracted relations: {}
  }
[Roboy]: I am out of words.
[Roboy]:  There are 8 times as many atoms in a teaspoonful of water as there are teaspoonfuls of water in the Atlantic ocean 
[Roboy]:  Let me uncover my potential. Ask something really difficult! 
[You]:   Lets play
  Lets play
  Parser.parse: parse {
    Error retrieval: {
      Checking 0 derivations
    }
    Parser.ensureExecuted 
  }
  Parser.ensureExecuted 
  Parser.setEvaluation: 0 candidates 
  Example: Lets play {
    Tokens: [lets, play]
    Lemmatized tokens: [let, play]
    POS tags: [VBZ, NN]
    NER tags: [O, O]
    NER values: [null, null]
    Sentiment: Neutral
    Keywords: [play]
    Dependency children: [[dobj->1], []]
    Extracted relations: {}
  }
[Roboy]: Yeah, let's go. 
[Roboy]:  Yeah, I love games. Let's play Snapchat. 
[You]:   no
  no
  Parser.parse: parse {
    Error retrieval: {
      Checking 0 derivations
    }
    Parser.ensureExecuted 
  }
  Parser.ensureExecuted 
  Parser.setEvaluation: 0 candidates 
  Example: no {
    Tokens: [no]
    Lemmatized tokens: [no]
    POS tags: [DT]
    NER tags: [O]
    NER values: [null]
    Sentiment: Negative
    Keywords: [no]
    Dependency children: [[]]
    Extracted relations: {}
  }
[Roboy]:  Is that all that comes to your mind? Ask me something! 
[You]:   lets play
  lets play
  Parser.parse: parse {
    Error retrieval: {
      Checking 0 derivations
    }
    Parser.ensureExecuted 
  }
  Parser.ensureExecuted 
  Parser.setEvaluation: 0 candidates 
  Example: lets play {
    Tokens: [lets, play]
    Lemmatized tokens: [let, play]
    POS tags: [VBZ, NN]
    NER tags: [O, O]
    NER values: [null, null]
    Sentiment: Neutral
    Keywords: [play]
    Dependency children: [[dobj->1], []]
    Extracted relations: {}
  }
[Roboy]: Yeah, let's go. 
[Roboy]:  Cool, I am in the mood for the Akinator game. 
[You]:   Sure
  Sure
  Parser.parse: parse {
    Error retrieval: {
      Checking 0 derivations
    }
    Parser.ensureExecuted 
  }
  Parser.ensureExecuted 
  Parser.setEvaluation: 0 candidates 
  Example: Sure {
    Tokens: [sure]
    Lemmatized tokens: [sure]
    POS tags: [JJ]
    NER tags: [O]
    NER values: [null]
    Sentiment: Neutral
    Keywords: [Sure]
    Dependency children: [[]]
    Extracted relations: {}
  }
[Roboy]: Let's go. 
[Roboy]:  I will try to read your mind. 3... 2... 1... ready? 
[You]:   yes
  yes
  Parser.parse: parse {
    Error retrieval: {
      Checking 0 derivations
    }
    Parser.ensureExecuted 
  }
  Parser.ensureExecuted 
  Parser.setEvaluation: 0 candidates 
  Example: yes {
    Tokens: [yes]
    Lemmatized tokens: [yes]
    POS tags: [UH]
    NER tags: [O]
    NER values: [null]
    Sentiment: Neutral
    Keywords: [yes]
    Dependency children: [[]]
    Extracted relations: {}
  }
[Roboy]: Can't wait to start. 
[Roboy]: Is your character a girl?
[You]:   no
  no
  Parser.parse: parse {
    Error retrieval: {
      Checking 0 derivations
    }
    Parser.ensureExecuted 
  }
  Parser.ensureExecuted 
  Parser.setEvaluation: 0 candidates 
  Example: no {
    Tokens: [no]
    Lemmatized tokens: [no]
    POS tags: [DT]
    NER tags: [O]
    NER values: [null]
    Sentiment: Negative
    Keywords: [no]
    Dependency children: [[]]
    Extracted relations: {}
  }
[Roboy]: Nope. 
[Roboy]: Is your character English speaking?
[You]:   yes
  yes
  Parser.parse: parse {
    Error retrieval: {
      Checking 0 derivations
    }
    Parser.ensureExecuted 
  }
  Parser.ensureExecuted 
  Parser.setEvaluation: 0 candidates 
  Example: yes {
    Tokens: [yes]
    Lemmatized tokens: [yes]
    POS tags: [UH]
    NER tags: [O]
    NER values: [null]
    Sentiment: Neutral
    Keywords: [yes]
    Dependency children: [[]]
    Extracted relations: {}
  }
[Roboy]: A clear yes. 
[Roboy]: Is your character from PewDiePie?
[You]:   no

  no
  Parser.parse: parse {
    Error retrieval: {
      Checking 0 derivations
    }
    Parser.ensureExecuted 
  }
  Parser.ensureExecuted 
  Parser.setEvaluation: 0 candidates 
  Example: no {
    Tokens: [no]
    Lemmatized tokens: [no]
    POS tags: [DT]
    NER tags: [O]
    NER values: [null]
    Sentiment: Negative
    Keywords: [no]
    Dependency children: [[]]
    Extracted relations: {}
  }
[Roboy]: Not at all. 
[Roboy]: Is your character Swedish?
[You]:     Parser.parse: parse {
    Error retrieval: {
      Checking 0 derivations
    }
    Parser.ensureExecuted 
  }
  Parser.ensureExecuted 
  Parser.setEvaluation: 0 candidates 
  Example:  {
    Tokens: []
    Lemmatized tokens: []
    POS tags: []
    NER tags: []
    NER values: []
    Sentiment: 
    Keywords: []
    Dependency children: []
    Extracted relations: {}
  }
[ERROR] Sentiment is illegal: No enum constant roboy.linguistics.Linguistics.UtteranceSentiment. --- roboy.linguistics.sentenceanalysis.SemanticParserAnalyzer (00:26:57)
[WARN] TOKENS missing but AnswerAnalyzer is used! --- roboy.linguistics.sentenceanalysis.AnswerAnalyzer (00:26:57)
[Roboy]: I didn't understand you correctly. 
[Roboy]: Is your character Swedish?
[You]:   no
  no
  Parser.parse: parse {
    Error retrieval: {
      Checking 0 derivations
    }
    Parser.ensureExecuted 
  }
  Parser.ensureExecuted 
  Parser.setEvaluation: 0 candidates 
  Example: no {
    Tokens: [no]
    Lemmatized tokens: [no]
    POS tags: [DT]
    NER tags: [O]
    NER values: [null]
    Sentiment: Negative
    Keywords: [no]
    Dependency children: [[]]
    Extracted relations: {}
  }
[Roboy]: That was clear. No. 
[Roboy]: Is your character real?
[You]:   no
  no
  Parser.parse: parse {
    Error retrieval: {
      Checking 0 derivations
    }
    Parser.ensureExecuted 
  }
  Parser.ensureExecuted 
  Parser.setEvaluation: 0 candidates 
  Example: no {
    Tokens: [no]
    Lemmatized tokens: [no]
    POS tags: [DT]
    NER tags: [O]
    NER values: [null]
    Sentiment: Negative
    Keywords: [no]
    Dependency children: [[]]
    Extracted relations: {}
  }
[Roboy]: A no from you. 
[Roboy]: Does your character fight?
[You]:   yes
  yes
  Parser.parse: parse {
    Error retrieval: {
      Checking 0 derivations
    }
    Parser.ensureExecuted 
  }
  Parser.ensureExecuted 
  Parser.setEvaluation: 0 candidates 
  Example: yes {
    Tokens: [yes]
    Lemmatized tokens: [yes]
    POS tags: [UH]
    NER tags: [O]
    NER values: [null]
    Sentiment: Neutral
    Keywords: [yes]
    Dependency children: [[]]
    Extracted relations: {}
  }
[Roboy]: You seem to be pretty sure about that. 
[Roboy]: Is your character related to Marvel?
[You]:   no
  no
  Parser.parse: parse {
    Error retrieval: {
      Checking 0 derivations
    }
    Parser.ensureExecuted 
  }
  Parser.ensureExecuted 
  Parser.setEvaluation: 0 candidates 
  Example: no {
    Tokens: [no]
    Lemmatized tokens: [no]
    POS tags: [DT]
    NER tags: [O]
    NER values: [null]
    Sentiment: Negative
    Keywords: [no]
    Dependency children: [[]]
    Extracted relations: {}
  }
[Roboy]: Not at all. 
[Roboy]: Is your character from a game?
[You]:   yes
  yes
  Parser.parse: parse {
    Error retrieval: {
      Checking 0 derivations
    }
    Parser.ensureExecuted 
  }
  Parser.ensureExecuted 
  Parser.setEvaluation: 0 candidates 
  Example: yes {
    Tokens: [yes]
    Lemmatized tokens: [yes]
    POS tags: [UH]
    NER tags: [O]
    NER values: [null]
    Sentiment: Neutral
    Keywords: [yes]
    Dependency children: [[]]
    Extracted relations: {}
  }
[Roboy]: I heard a yes from you. 
[Roboy]: Does your character use guns?
[You]:   no
  no
  Parser.parse: parse {
    Error retrieval: {
      Checking 0 derivations
    }
    Parser.ensureExecuted 
  }
  Parser.ensureExecuted 
  Parser.setEvaluation: 0 candidates 
  Example: no {
    Tokens: [no]
    Lemmatized tokens: [no]
    POS tags: [DT]
    NER tags: [O]
    NER values: [null]
    Sentiment: Negative
    Keywords: [no]
    Dependency children: [[]]
    Extracted relations: {}
  }
[Roboy]: That was clear. No. 
[Roboy]: Does your character fight with a sword?
[You]:   no
  no
  Parser.parse: parse {
    Error retrieval: {
      Checking 0 derivations
    }
    Parser.ensureExecuted 
  }
  Parser.ensureExecuted 
  Parser.setEvaluation: 0 candidates 
  Example: no {
    Tokens: [no]
    Lemmatized tokens: [no]
    POS tags: [DT]
    NER tags: [O]
    NER values: [null]
    Sentiment: Negative
    Keywords: [no]
    Dependency children: [[]]
    Extracted relations: {}
  }
[Roboy]: A clear no. 
[Roboy]: Does your character have hair?
[You]:   yes
  yes
  Parser.parse: parse {
    Error retrieval: {
      Checking 0 derivations
    }
    Parser.ensureExecuted 
  }
  Parser.ensureExecuted 
  Parser.setEvaluation: 0 candidates 
  Example: yes {
    Tokens: [yes]
    Lemmatized tokens: [yes]
    POS tags: [UH]
    NER tags: [O]
    NER values: [null]
    Sentiment: Neutral
    Keywords: [yes]
    Dependency children: [[]]
    Extracted relations: {}
  }
[Roboy]: You seem to be pretty sure about that. 
[Roboy]: Does your character wear something on their head?
[You]:   yes
  yes
  Parser.parse: parse {
    Error retrieval: {
      Checking 0 derivations
    }
    Parser.ensureExecuted 
  }
  Parser.ensureExecuted 
  Parser.setEvaluation: 0 candidates 
  Example: yes {
    Tokens: [yes]
    Lemmatized tokens: [yes]
    POS tags: [UH]
    NER tags: [O]
    NER values: [null]
    Sentiment: Neutral
    Keywords: [yes]
    Dependency children: [[]]
    Extracted relations: {}
  }
[Roboy]: You said yes. 
[Roboy]: Does your character play Dead by Daylight?
[You]:   no
  no
  Parser.parse: parse {
    Error retrieval: {
      Checking 0 derivations
    }
    Parser.ensureExecuted 
  }
  Parser.ensureExecuted 
  Parser.setEvaluation: 0 candidates 
  Example: no {
    Tokens: [no]
    Lemmatized tokens: [no]
    POS tags: [DT]
    NER tags: [O]
    NER values: [null]
    Sentiment: Negative
    Keywords: [no]
    Dependency children: [[]]
    Extracted relations: {}
  }
[Roboy]: A no from you. 
[Roboy]: Does your character appear in the 'Mario' games?
[You]:   no
  no
  Parser.parse: parse {
    Error retrieval: {
      Checking 0 derivations
    }
    Parser.ensureExecuted 
  }
  Parser.ensureExecuted 
  Parser.setEvaluation: 0 candidates 
  Example: no {
    Tokens: [no]
    Lemmatized tokens: [no]
    POS tags: [DT]
    NER tags: [O]
    NER values: [null]
    Sentiment: Negative
    Keywords: [no]
    Dependency children: [[]]
    Extracted relations: {}
  }
[Roboy]: A clear no. 
[Roboy]: Does your character wear a mask?
[You]:   
  Parser.parse: parse {
    Error retrieval: {
      Checking 0 derivations
    }
    Parser.ensureExecuted 
  }
  Parser.ensureExecuted 
  Parser.setEvaluation: 0 candidates 
  Example:  {
    Tokens: []
    Lemmatized tokens: []
    POS tags: []
    NER tags: []
    NER values: []
    Sentiment: 
    Keywords: []
    Dependency children: []
    Extracted relations: {}
  }
[ERROR] Sentiment is illegal: No enum constant roboy.linguistics.Linguistics.UtteranceSentiment. --- roboy.linguistics.sentenceanalysis.SemanticParserAnalyzer (00:27:27)
[WARN] TOKENS missing but AnswerAnalyzer is used! --- roboy.linguistics.sentenceanalysis.AnswerAnalyzer (00:27:27)
[Roboy]: Oh no, I didn't get what you said. 
[Roboy]: Does your character wear a mask?
[You]:   
  Parser.parse: parse {
    Error retrieval: {
      Checking 0 derivations
    }
    Parser.ensureExecuted 
  }
  Parser.ensureExecuted 
  Parser.setEvaluation: 0 candidates 
  Example:  {
    Tokens: []
    Lemmatized tokens: []
    POS tags: []
    NER tags: []
    NER values: []
    Sentiment: 
    Keywords: []
    Dependency children: []
    Extracted relations: {}
  }
[ERROR] Sentiment is illegal: No enum constant roboy.linguistics.Linguistics.UtteranceSentiment. --- roboy.linguistics.sentenceanalysis.SemanticParserAnalyzer (00:27:29)
[WARN] TOKENS missing but AnswerAnalyzer is used! --- roboy.linguistics.sentenceanalysis.AnswerAnalyzer (00:27:29)
[Roboy]: I didn't understand you correctly. 
[Roboy]: Does your character wear a mask?
[You]:   yes
  yes
  Parser.parse: parse {
    Error retrieval: {
      Checking 0 derivations
    }
    Parser.ensureExecuted 
  }
  Parser.ensureExecuted 
  Parser.setEvaluation: 0 candidates 
  Example: yes {
    Tokens: [yes]
    Lemmatized tokens: [yes]
    POS tags: [UH]
    NER tags: [O]
    NER values: [null]
    Sentiment: Neutral
    Keywords: [yes]
    Dependency children: [[]]
    Extracted relations: {}
  }
[Roboy]: You seem to be pretty sure about that. 
[Roboy]: Was your character in Batman vs Superman?
[You]:   sure
  sure
  Parser.parse: parse {
    Error retrieval: {
      Checking 0 derivations
    }
    Parser.ensureExecuted 
  }
  Parser.ensureExecuted 
  Parser.setEvaluation: 0 candidates 
  Example: sure {
    Tokens: [sure]
    Lemmatized tokens: [sure]
    POS tags: [JJ]
    NER tags: [O]
    NER values: [null]
    Sentiment: Neutral
    Keywords: [sure]
    Dependency children: [[]]
    Extracted relations: {}
  }
[Roboy]: I heard a yes from you. 
[Roboy]: Is your character linked with the color red?
[You]:   no
  no
  Parser.parse: parse {
    Error retrieval: {
      Checking 0 derivations
    }
    Parser.ensureExecuted 
  }
  Parser.ensureExecuted 
  Parser.setEvaluation: 0 candidates 
  Example: no {
    Tokens: [no]
    Lemmatized tokens: [no]
    POS tags: [DT]
    NER tags: [O]
    NER values: [null]
    Sentiment: Negative
    Keywords: [no]
    Dependency children: [[]]
    Extracted relations: {}
  }
[Roboy]: A clear no. 
[Roboy]:  How about  Batman / Bruce Wayne
[You]:   yes
  yes
  Parser.parse: parse {
    Error retrieval: {
      Checking 0 derivations
    }
    Parser.ensureExecuted 
  }
  Parser.ensureExecuted 
  Parser.setEvaluation: 0 candidates 
  Example: yes {
    Tokens: [yes]
    Lemmatized tokens: [yes]
    POS tags: [UH]
    NER tags: [O]
    NER values: [null]
    Sentiment: Neutral
    Keywords: [yes]
    Dependency children: [[]]
    Extracted relations: {}
  }
java.lang.NullPointerException
    at roboy.dialog.states.gameStates.GamingTwentyQuestionsState.applyFilter(GamingTwentyQuestionsState.java:275)
    at roboy.dialog.states.gameStates.GamingTwentyQuestionsState.getNextState(GamingTwentyQuestionsState.java:118)
    at roboy.dialog.personality.StateBasedPersonality.answer(StateBasedPersonality.java:160)
    at roboy.dialog.Conversation.run(Conversation.java:128)
[ERROR] Error in personality.answer: null --- Conversation15 (00:27:42)
[Roboy]: A clear no. 
[Roboy]:  How about  Batman / Bruce Wayne
[You]:   yes
  yes
  Parser.parse: parse {
    Error retrieval: {
      Checking 0 derivations
    }
    Parser.ensureExecuted 
  }
  Parser.ensureExecuted 
  Parser.setEvaluation: 0 candidates 
  Example: yes {
    Tokens: [yes]
    Lemmatized tokens: [yes]
    POS tags: [UH]
    NER tags: [O]
    NER values: [null]
    Sentiment: Neutral
    Keywords: [yes]
    Dependency children: [[]]
    Extracted relations: {}
  }
[ERROR] Error in personality.answer: null --- Conversation15 (00:27:47)
[Roboy]: A clear no. 
[Roboy]:  How about  Batman / Bruce Wayne
[You]:   java.lang.NullPointerException
    at roboy.dialog.states.gameStates.GamingTwentyQuestionsState.applyFilter(GamingTwentyQuestionsState.java:275)
    at roboy.dialog.states.gameStates.GamingTwentyQuestionsState.getNextState(GamingTwentyQuestionsState.java:118)
    at roboy.dialog.personality.StateBasedPersonality.answer(StateBasedPersonality.java:160)
    at roboy.dialog.Conversation.run(Conversation.java:128)
no
  no
  Parser.parse: parse {
    Error retrieval: {
      Checking 0 derivations
    }
    Parser.ensureExecuted 
  }
  Parser.ensureExecuted 
  Parser.setEvaluation: 0 candidates 
  Example: no {
    Tokens: [no]
    Lemmatized tokens: [no]
    POS tags: [DT]
    NER tags: [O]
    NER values: [null]
    Sentiment: Negative
    Keywords: [no]
    Dependency children: [[]]
    Extracted relations: {}
  }
[ERROR] Error in personality.answer: null --- Conversation15 (00:27:49)
[Roboy]: A clear no. 
[Roboy]:  How about  Batman / Bruce Wayne
[You]:   java.lang.NullPointerException
    at roboy.dialog.states.gameStates.GamingTwentyQuestionsState.applyFilter(GamingTwentyQuestionsState.java:275)
    at roboy.dialog.states.gameStates.GamingTwentyQuestionsState.getNextState(GamingTwentyQuestionsState.java:118)
    at roboy.dialog.personality.StateBasedPersonality.answer(StateBasedPersonality.java:160)
    at roboy.dialog.Conversation.run(Conversation.java:128)
all
  all
  Parser.parse: parse {
    Error retrieval: {
      Checking 0 derivations
    }
    Parser.ensureExecuted 
  }
  Parser.ensureExecuted 
  Parser.setEvaluation: 0 candidates 
  Example: all {
    Tokens: [all]
    Lemmatized tokens: [all]
    POS tags: [DT]
    NER tags: [O]
    NER values: [null]
    Sentiment: Neutral
    Keywords: [all]
    Dependency children: [[]]
    Extracted relations: {}
  }
java.lang.NullPointerException
    at roboy.dialog.states.gameStates.GamingTwentyQuestionsState.applyFilter(GamingTwentyQuestionsState.java:275)
    at roboy.dialog.states.gameStates.GamingTwentyQuestionsState.getNextState(GamingTwentyQuestionsState.java:118)
    at roboy.dialog.personality.StateBasedPersonality.answer(StateBasedPersonality.java:160)
    at roboy.dialog.Conversation.run(Conversation.java:128)
[ERROR] Exception in react() of state with identifier GamingTwentyQuestionsState:
null --- roboy.dialog.personality.StateBasedPersonality (00:27:51)
[ERROR] Error in personality.answer: null --- Conversation15 (00:27:51)
[Roboy]: A clear no. 
[Roboy]:  How about  Batman / Bruce Wayne
[You]:   bye
  bye
  Parser.parse: parse {
    Error retrieval: {
      Checking 0 derivations
    }
    Parser.ensureExecuted 
  }
  Parser.ensureExecuted 
  Parser.setEvaluation: 0 candidates 
  Example: bye {
    Tokens: [bye]
    Lemmatized tokens: [bye]
    POS tags: [NN]
    NER tags: [O]
    NER values: [null]
    Sentiment: Neutral
    Keywords: [bye]
    Dependency children: [[]]
    Extracted relations: {}
  }
[Roboy]: see you
[INFO] Creating new conversation... --- roboy.dialog.ConversationManager (00:29:14)
[INFO] RosMainNode will be unavailable in DialogStateMachine (null was passed) --- roboy.dialog.DialogStateMachine (00:29:14)
[INFO]  -> The filterList path: resources/gameResources/snapchat-filters.txt --- roboy.dialog.states.gameStates.GamingSnapchatState (00:29:14)
[INFO] Waiting for conversation to end. --- roboy.dialog.ConversationManager (00:29:14)
[INFO] ############# Conversation started ############ --- Conversation19 (00:29:14)
[Roboy]: I'm pretty good at answering questions about myself and other stuff. What would you like to know?

Other Bug

Other Bug I still have not replicated

  Parser.ensureExecuted
  Parser.setEvaluation: 0 candidates
  Example: Yes {
    Tokens: [yes]
    Lemmatized tokens: [yes]
    POS tags: [UH]
    NER tags: [O]
    NER values: [null]
    Sentiment: Neutral
    Keywords: [Yes]
    Dependency children: [[]]
    Extracted relations: {}
  }
[Roboy]: Can't wait to start.
[Roboy]: Is your character a woman ?
[You]:   no
  no
  Parser.parse: parse {
    Error retrieval: {
      Checking 0 derivations
    }
    Parser.ensureExecuted
  }
  Parser.ensureExecuted
  Parser.setEvaluation: 0 candidates
  Example: no {
    Tokens: [no]
    Lemmatized tokens: [no]
    POS tags: [DT]
    NER tags: [O]
    NER values: [null]
    Sentiment: Negative
    Keywords: [no]
    Dependency children: [[]]
    Extracted relations: {}
  }
[ERROR] Error in processing input: com.markozajc.akiwrapper.core.exceptions.StatusException: KO - TIMEOUT --- roboy.dialog.states.gameStates.GamingTwentyQuestionsState (23:54:57)
[Roboy]: I have a problem processing your input...
[Roboy]: Is your character a woman ?
[You]:   no
Aevyz commented 6 years ago

More logs 


[INFO] Initializing Config --- roboy.util.ConfigManager (01:35:10)
[INFO] Using Neo4jMemory --- roboy.memory.Neo4jMemory (01:35:10)
[INFO] Initializing analyzers... --- roboy.dialog.ConversationManager (01:35:10)
Grammar.read {
  SimpleLexicon.read(resources_nlu/lexicons/roboy-demo.lexicon) {
    Read 132 lines, generated 77 entries (now 77 total)
  }
  WARNING: Category not defined in the grammar: $NewEntity; used in rule: $Subject -> $NewEntity (IdentityFn)
  WARNING: Category not defined in the grammar: $Binary; used in rule: $Set -> $Binary $Entity (JoinFn forward)
  WARNING: Category not defined in the grammar: $Binary; used in rule: $Set -> $Entity $Binary (JoinFn backward)
  WARNING: Category not defined in the grammar: $Binary; used in rule: $Set -> $Binary $Entity (JoinFn forward)
  WARNING: Category not defined in the grammar: $Binary; used in rule: $Set -> $Entity $Binary (JoinFn backward)
  Valid tags: [error]
  Used tags: []
  362 rules
}
Initializing Config {
  BeamParser: 137 catUnaryRules (sorted), 225 nonCatUnaryRules (in trie)
[main] INFO org.nd4j.linalg.factory.Nd4jBackend - Loaded [CpuBackend] backend
[main] INFO org.reflections.Reflections - Reflections took 396 ms to scan 341 urls, producing 89451 keys and 104160 values 
[main] INFO org.nd4j.nativeblas.NativeOpsHolder - Number of threads used for NativeOps: 2
[main] INFO org.reflections.Reflections - Reflections took 172 ms to scan 13 urls, producing 31 keys and 227 values 
[main] INFO org.nd4j.nativeblas.Nd4jBlas - Number of threads used for BLAS: 2
[main] INFO org.nd4j.linalg.api.ops.executioner.DefaultOpExecutioner - Backend used: [CPU]; OS: [Linux]
[main] INFO org.nd4j.linalg.api.ops.executioner.DefaultOpExecutioner - Cores: [4]; Memory: [5.3GB];
[main] INFO org.nd4j.linalg.api.ops.executioner.DefaultOpExecutioner - Blas vendor: [OPENBLAS]
[main] INFO org.reflections.Reflections - Reflections took 217 ms to scan 13 urls, producing 387 keys and 1538 values 
  Tests ->  {
    Closest words: [elizabeth, victoria, king, monarch, majesty, consort, balmoral, queens, royal, beatrix]
    Closest word to female from : "women","queen","elisabeth" -> [women]
    Closest word to swimming from : "literature","activity","sports" -> : []
  }
  Dataset.read 
  Learner.learn() {
    Iteration 0/10 
    Iteration 1/10 
    Iteration 2/10 
    Iteration 3/10 
    Iteration 4/10 
    Iteration 5/10 
    Iteration 6/10 
    Iteration 7/10 
    Iteration 8/10 
    Iteration 9/10 
    Iteration 10/10 
  }
[main] INFO edu.stanford.nlp.pipeline.StanfordCoreNLP - Adding annotator tokenize
[main] INFO edu.stanford.nlp.pipeline.TokenizerAnnotator - No tokenizer type provided. Defaulting to PTBTokenizer.
[main] INFO edu.stanford.nlp.pipeline.StanfordCoreNLP - Adding annotator ssplit
[main] INFO edu.stanford.nlp.pipeline.StanfordCoreNLP - Adding annotator pos
[main] INFO edu.stanford.nlp.tagger.maxent.MaxentTagger - Loading POS tagger from edu/stanford/nlp/models/pos-tagger/english-caseless-left3words-distsim.tagger ... done [0.7 sec].
[main] INFO edu.stanford.nlp.pipeline.StanfordCoreNLP - Adding annotator lemma
[main] INFO edu.stanford.nlp.pipeline.StanfordCoreNLP - Adding annotator ner
[main] INFO edu.stanford.nlp.ie.AbstractSequenceClassifier - Loading classifier from edu/stanford/nlp/models/ner/english.all.3class.caseless.distsim.crf.ser.gz ... done [2.3 sec].
[main] INFO edu.stanford.nlp.ie.AbstractSequenceClassifier - Loading classifier from edu/stanford/nlp/models/ner/english.conll.4class.caseless.distsim.crf.ser.gz ... done [0.5 sec].
[main] INFO edu.stanford.nlp.pipeline.StanfordCoreNLP - Adding annotator parse
[main] INFO edu.stanford.nlp.parser.common.ParserGrammar - Loading parser from serialized file edu/stanford/nlp/models/lexparser/englishPCFG.ser.gz ... done [0.3 sec].
[main] INFO edu.stanford.nlp.pipeline.StanfordCoreNLP - Adding annotator depparse
[main] INFO edu.stanford.nlp.parser.nndep.DependencyParser - Loading depparse model file: edu/stanford/nlp/models/parser/nndep/english_UD.gz ... 
[main] INFO edu.stanford.nlp.parser.nndep.Classifier - PreComputed 99996, Elapsed Time: 12.191 (s)
[main] INFO edu.stanford.nlp.parser.nndep.DependencyParser - Initializing dependency parser ... done [14.4 sec].
[main] INFO edu.stanford.nlp.pipeline.StanfordCoreNLP - Adding annotator natlog
[main] INFO edu.stanford.nlp.pipeline.StanfordCoreNLP - Adding annotator openie
[main] INFO edu.stanford.nlp.naturalli.ClauseSplitter - Loading clause splitter from edu/stanford/nlp/models/naturalli/clauseSearcherModel.ser.gz ... done [0.0033 seconds]
[main] INFO edu.stanford.nlp.pipeline.StanfordCoreNLP - Adding annotator sentiment
  Parser.parse: parse {
    Error retrieval: {
      Checking 0 derivations
    }
    Parser.ensureExecuted 
  }
  Parser.ensureExecuted 
  Parser.setEvaluation: 0 candidates 
  Example:  {
    Tokens: []
    Lemmatized tokens: []
    POS tags: []
    NER tags: []
    NER values: []
    Sentiment: 
    Keywords: []
    Dependency children: []
    Extracted relations: {}
  }
[INFO] Creating new conversation... --- roboy.dialog.ConversationManager (01:35:46)
[INFO] RosMainNode will be unavailable in DialogStateMachine (null was passed) --- roboy.dialog.DialogStateMachine (01:35:46)
[INFO]  -> The infoList path: resources/sentences/RoboyInfoList.json --- roboy.dialog.states.ordinaryStates.IntroductionState (01:35:46)
[INFO]  -> The QAList path: resources/sentences/QAList.json --- roboy.dialog.states.ordinaryStates.PersonalInformationFollowUpState (01:35:46)
[INFO]  -> The QAList path: resources/sentences/QAList.json --- roboy.dialog.states.ordinaryStates.PersonalInformationAskingState (01:35:46)
[INFO]  -> The filterList path: resources/gameResources/snapchat-filters.json --- roboy.dialog.states.gameStates.GamingSnapchatState (01:35:47)
[ERROR] Error reading file resources/gameResources/snapchat-filters.json: resources/gameResources/snapchat-filters.json --- roboy.util.IO (01:35:47)
[INFO] Waiting for conversation to end. --- roboy.dialog.ConversationManager (01:35:47)
[INFO] ############# Conversation started ############ --- Conversation15 (01:35:47)
[You]:   Hi
  Hi
  Parser.parse: parse {
    Error retrieval: {
      Checking 0 derivations
    }
    Parser.ensureExecuted 
  }
  Parser.ensureExecuted 
  Parser.setEvaluation: 0 candidates 
  Example: Hi {
    Tokens: [hi]
    Lemmatized tokens: [hi]
    POS tags: [UH]
    NER tags: [O]
    NER values: [null]
    Sentiment: Neutral
    Keywords: [Hi]
    Dependency children: [[]]
    Extracted relations: {}
  }
[Roboy]: hi
[Roboy]: What's your name?
[You]:   Jason
  Jason
  Parser.parse: parse {
    Error retrieval: {
      Checking 0 derivations
    }
    Parser.ensureExecuted 
  }
  Parser.ensureExecuted 
  Parser.setEvaluation: 0 candidates 
  Example: Jason {
    Tokens: [jason]
    Lemmatized tokens: [Jason]
    POS tags: [NNP]
    NER tags: [PERSON]
    NER values: [null]
    Sentiment: Neutral
    Keywords: [Jason]
    Dependency children: [[]]
    Extracted relations: {}
  }
Jul 23, 2018 1:37:13 AM org.roboy.memory.util.Neo4j matchNode
INFO: Class label: Person
Jul 23, 2018 1:37:13 AM org.roboy.memory.util.Neo4j matchNode
INFO: Properties: {name=jason, telegram_id=local}
Jul 23, 2018 1:37:13 AM org.roboy.memory.util.Neo4j matchNode
INFO:  MATCH (n:Person  {name:'jason',telegram_id:'local'}  )  RETURN COLLECT(ID(n)) AS ids 
Jul 23, 2018 1:37:13 AM org.roboy.memory.util.Neo4j matchNode
INFO: {"id":[478, 481]}
Jul 23, 2018 1:37:13 AM org.roboy.memory.util.Neo4j matchNodeById
INFO:  MATCH (n) WHERE ID(n)=478  RETURN PROPERTIES(n) 
Jul 23, 2018 1:37:13 AM org.roboy.memory.util.Neo4j matchNodeById
INFO:  MATCH (n)-[r]-(m) WHERE ID(n)=478 RETURN TYPE(r) as name, COLLECT(ID(m)) as ids 
Jul 23, 2018 1:37:13 AM org.roboy.memory.util.Neo4j matchNodeById
INFO: {"id":478,"properties":{"name":"jason","telegram_id":"local"},"relationships":{"HAS_HOBBY":[379],"WORK_FOR":[360],"STUDY_AT":[477],"FROM":[378]}}
Jul 23, 2018 1:37:13 AM org.roboy.memory.util.Neo4j matchNode
INFO: Class label: Robot
Jul 23, 2018 1:37:13 AM org.roboy.memory.util.Neo4j matchNode
INFO: Properties: {name=roboy two}
Jul 23, 2018 1:37:13 AM org.roboy.memory.util.Neo4j matchNode
INFO:  MATCH (n:Robot  {name:'roboy two'}  )  RETURN COLLECT(ID(n)) AS ids 
lJul 23, 2018 1:37:13 AM org.roboy.memory.util.Neo4j matchNode
INFO: {"id":[356]}
Jul 23, 2018 1:37:13 AM org.roboy.memory.util.Neo4j matchNodeById
INFO:  MATCH (n) WHERE ID(n)=356  RETURN PROPERTIES(n) 
Jul 23, 2018 1:37:13 AM org.roboy.memory.util.Neo4j matchNodeById
INFO:  MATCH (n)-[r]-(m) WHERE ID(n)=356 RETURN TYPE(r) as name, COLLECT(ID(m)) as ids 
Jul 23, 2018 1:37:13 AM org.roboy.memory.util.Neo4j matchNodeById
INFO: {"id":356,"properties":{"abilities":"talk to people,recognize objects,show emotions,move my body,shake a hand,party like there is no tomorrow,surf the internet,answer your questions","speed_kmh":"0","skills":"tell jokes,tell fun facts,tell you about the famous people and places,do the math","full_name":"roboy 2.0","birthdate":"12.04.2018","future":"become a robot rights advocate,help people and robots become friends,find the answer to the question of life the universe and everything,visit mars and other planets,become a music star,become a michelin star chef,get a robo pet,become as good as my father","conversation_id":"#bitch_boy","sex":"male","name":"roboy two","age":"0"},"relationships":{"LIVE_IN":[23],"HAS_HOBBY":[357,335,336],"MEMBER_OF":[20],"KNOW":[19],"CHILD_OF":[178],"FROM":[23],"SIBLING_OF":[26],"FRIEND_OF":[5,15,7,4,6,175,174,171,183,180,178,176,188,186,185,184,194,197,190,193,204,206,199,202,212,213,208,210,217]}}
Jul 23, 2018 1:37:13 AM org.roboy.memory.util.Neo4j matchNodeById
INFO:  MATCH (n) WHERE ID(n)=23  RETURN PROPERTIES(n) 
Jul 23, 2018 1:37:13 AM org.roboy.memory.util.Neo4j matchNodeById
INFO:  MATCH (n)-[r]-(m) WHERE ID(n)=23 RETURN TYPE(r) as name, COLLECT(ID(m)) as ids 
eJul 23, 2018 1:37:13 AM org.roboy.memory.util.Neo4j matchNodeById
INFO: {"id":23,"properties":{"test":"true","name":"munich"},"relationships":{"LIVE_IN":[356,174,124,113,110,106,104,96,91,84,76,55,48,26,5,4,6,7,15],"IS_IN":[111,22],"FROM":[356,212,210,206,204,188,186,185,180,176,175,122,113,104]}}
[INFO] -> Retrieved Interlocutor: jason --- roboy.dialog.states.ordinaryStates.PersonalInformationFollowUpState (01:37:13)
[INFO]  -> Selected predicate: FROM --- roboy.dialog.states.ordinaryStates.PersonalInformationFollowUpState (01:37:13)
Jul 23, 2018 1:37:13 AM org.roboy.memory.util.Neo4j matchNodeById
INFO:  MATCH (n) WHERE ID(n)=378  RETURN PROPERTIES(n) 
Jul 23, 2018 1:37:13 AM org.roboy.memory.util.Neo4j matchNodeById
INFO:  MATCH (n)-[r]-(m) WHERE ID(n)=378 RETURN TYPE(r) as name, COLLECT(ID(m)) as ids 
Jul 23, 2018 1:37:13 AM org.roboy.memory.util.Neo4j matchNodeById
INFO: {"id":378,"properties":{"name":"suzhou"},"relationships":{"FROM":[480,478,420,439,395,382,359]}}
[INFO]  -> Retrieved memory node name: suzhou --- roboy.dialog.states.ordinaryStates.PersonalInformationFollowUpState (01:37:13)
[INFO]  -> Selected question: What is the weather in suzhou? --- roboy.dialog.states.ordinaryStates.PersonalInformationFollowUpState (01:37:13)
[INFO]  -> Dialog IntentsHistory updated --- roboy.dialog.states.ordinaryStates.PersonalInformationFollowUpState (01:37:13)
[Roboy]: Hey, I know you, jason! I am proud to be called roboy 2.0! I am growing up, today, I am 3 months old. I was taught tell jokes. Having a body is wonderful, I am able to move my body! Often, I wish to become a music star. Usually, I stay at my home in munich
[Roboy]: What is the weather in suzhou?
[You]:   lets play
  lets play
  Parser.parse: parse {
    Error retrieval: {
      Checking 0 derivations
    }
    Parser.ensureExecuted 
  }
  Parser.ensureExecuted 
  Parser.setEvaluation: 0 candidates 
  Example: lets play {
    Tokens: [lets, play]
    Lemmatized tokens: [let, play]
    POS tags: [VBZ, NN]
    NER tags: [O, O]
    NER values: [null, null]
    Sentiment: Neutral
    Keywords: [play]
    Dependency children: [[dobj->1], []]
    Extracted relations: {}
  }
[INFO] -> Retrieved Interlocutor: jason --- roboy.dialog.states.ordinaryStates.PersonalInformationFollowUpState (01:37:16)
[WARN]  -> Inference failed --- roboy.dialog.states.ordinaryStates.PersonalInformationFollowUpState (01:37:16)
[WARN]  -> The result is empty. Nothing to update --- roboy.dialog.states.ordinaryStates.PersonalInformationFollowUpState (01:37:16)
[Roboy]: You are from a very interesting place 
[Roboy]: I'm pretty good at answering questions about myself and other stuff. What would you like to know?
[You]:   lets play
  lets play
  Parser.parse: parse {
    Error retrieval: {
      Checking 0 derivations
    }
    Parser.ensureExecuted 
  }
  Parser.ensureExecuted 
  Parser.setEvaluation: 0 candidates 
  Example: lets play {
    Tokens: [lets, play]
    Lemmatized tokens: [let, play]
    POS tags: [VBZ, NN]
    NER tags: [O, O]
    NER values: [null, null]
    Sentiment: Neutral
    Keywords: [play]
    Dependency children: [[dobj->1], []]
    Extracted relations: {}
  }
[Roboy]: Let's go. 
[Roboy]:  Yeah, I love games. Let's play Snapchat. 
[You]:   yes
  yes
  Parser.parse: parse {
    Error retrieval: {
      Checking 0 derivations
    }
    Parser.ensureExecuted 
  }
  Parser.ensureExecuted 
  Parser.setEvaluation: 0 candidates 
  Example: yes {
    Tokens: [yes]
    Lemmatized tokens: [yes]
    POS tags: [UH]
    NER tags: [O]
    NER values: [null]
    Sentiment: Neutral
    Keywords: [yes]
    Dependency children: [[]]
    Extracted relations: {}
  }
[Roboy]: Can't wait to start. 
[Roboy]:  I have a new one. Let's prettify your face with the null-filter. 
[You]:   yes
  yes
  Parser.parse: parse {
    Error retrieval: {
      Checking 0 derivations
    }
    Parser.ensureExecuted 
  }
  Parser.ensureExecuted 
  Parser.setEvaluation: 0 candidates 
  Example: yes {
    Tokens: [yes]
    Lemmatized tokens: [yes]
    POS tags: [UH]
    NER tags: [O]
    NER values: [null]
    Sentiment: Neutral
    Keywords: [yes]
    Dependency children: [[]]
    Extracted relations: {}
  }
[ERROR] Exception in react() of state with identifier GamingSnapchatState:
null --- roboy.dialog.personality.StateBasedPersonality (01:37:32)
[Roboy]:  There are 8 times as many atoms in a teaspoonful of water as there are teaspoonfuls of water in the Atlantic ocean 
[Roboy]:  null-filter would be fun, right? 
[You]:   no
  no
  Parser.parse: parse {
    Error retrieval: {
      Checking 0 derivations
    }
    Parser.ensureExecuted 
  }
  Parser.ensureExecuted 
  Parser.setEvaluation: 0 candidates 
  Example: no {
    Tokens: [no]
    Lemmatized tokens: [no]
    POS tags: [DT]
    NER tags: [O]
    NER values: [null]
    Sentiment: Negative
    Keywords: [no]
    Dependency children: [[]]
    Extracted relations: {}
  }
[Roboy]:  What filter do you want? Maybe the null-filter? 
[You]:   no
  no
  Parser.parse: parse {
    Error retrieval: {
      Checking 0 derivations
    }
    Parser.ensureExecuted 
  }
  Parser.ensureExecuted 
  Parser.setEvaluation: 0 candidates 
  Example: no {
    Tokens: [no]
    Lemmatized tokens: [no]
    POS tags: [DT]
    NER tags: [O]
    NER values: [null]
    Sentiment: Negative
    Keywords: [no]
    Dependency children: [[]]
    Extracted relations: {}
  }
[Roboy]:  Why don't we put my null-filter on your face? 
[You]:   no
  no
  Parser.parse: parse {
    Error retrieval: {
      Checking 0 derivations
    }
    Parser.ensureExecuted 
  }
  Parser.ensureExecuted 
  Parser.setEvaluation: 0 candidates 
  Example: no {
    Tokens: [no]
    Lemmatized tokens: [no]
    POS tags: [DT]
    NER tags: [O]
    NER values: [null]
    Sentiment: Negative
    Keywords: [no]
    Dependency children: [[]]
    Extracted relations: {}
  }
[Roboy]:  I have a new one. Let's prettify your face with the null-filter. 
[You]:   no
  no
  Parser.parse: parse {
    Error retrieval: {
      Checking 0 derivations
    }
    Parser.ensureExecuted 
  }
  Parser.ensureExecuted 
  Parser.setEvaluation: 0 candidates 
  Example: no {
    Tokens: [no]
    Lemmatized tokens: [no]
    POS tags: [DT]
    NER tags: [O]
    NER values: [null]
    Sentiment: Negative
    Keywords: [no]
    Dependency children: [[]]
    Extracted relations: {}
  }
[Roboy]:  I have a new one. Let's prettify your face with the null-filter. 
[You]:   no
  no
  Parser.parse: parse {
    Error retrieval: {
      Checking 0 derivations
    }
    Parser.ensureExecuted 
  }
  Parser.ensureExecuted 
  Parser.setEvaluation: 0 candidates 
  Example: no {
    Tokens: [no]
    Lemmatized tokens: [no]
    POS tags: [DT]
    NER tags: [O]
    NER values: [null]
    Sentiment: Negative
    Keywords: [no]
    Dependency children: [[]]
    Extracted relations: {}
  }
[Roboy]:  What filter? Maybe a null-filter? 
[You]:   yes
  yes
  Parser.parse: parse {
    Error retrieval: {
      Checking 0 derivations
    }
    Parser.ensureExecuted 
  }
  Parser.ensureExecuted 
  Parser.setEvaluation: 0 candidates 
  Example: yes {
    Tokens: [yes]
    Lemmatized tokens: [yes]
    POS tags: [UH]
    NER tags: [O]
    NER values: [null]
    Sentiment: Neutral
    Keywords: [yes]
    Dependency children: [[]]
    Extracted relations: {}
  }
[ERROR] Exception in react() of state with identifier GamingSnapchatState:
null --- roboy.dialog.personality.StateBasedPersonality (01:37:40)
[Roboy]:  An individual blood cell takes about 60 seconds to make a complete circuit around your body, my electrons are way faster. 
[Roboy]:  I have a new one. Let's prettify your face with the null-filter. 
[You]:   ye
s  ye
  Parser.parse: parse {
    Error retrieval: {
      Checking 0 derivations
    }
    Parser.ensureExecuted 
  }
  Parser.ensureExecuted 
  Parser.setEvaluation: 0 candidates 
  Example: ye {
    Tokens: [ye]
    Lemmatized tokens: [ye]
    POS tags: [PRP]
    NER tags: [PERSON]
    NER values: [null]
    Sentiment: Neutral
    Keywords: [ye]
    Dependency children: [[]]
    Extracted relations: {}
  }
[Roboy]:  What filter do you want? Maybe the null-filter? 
[You]:   yes
  yes
  Parser.parse: parse {
    Error retrieval: {
      Checking 0 derivations
    }
    Parser.ensureExecuted 
  }
  Parser.ensureExecuted 
  Parser.setEvaluation: 0 candidates 
  Example: yes {
    Tokens: [yes]
    Lemmatized tokens: [yes]
    POS tags: [UH]
    NER tags: [O]
    NER values: [null]
    Sentiment: Neutral
    Keywords: [yes]
    Dependency children: [[]]
    Extracted relations: {}
  }
[ERROR] Exception in react() of state with identifier GamingSnapchatState:
null --- roboy.dialog.personality.StateBasedPersonality (01:37:43)
[Roboy]:  In contrast to me, The average person walks the equivalent of five times around the world in a lifetime. I don't walk at all. Yet. 
[Roboy]:  null-filter would be fun, right? 
[You]:   bye
  bye
  Parser.parse: parse {
    Error retrieval: {
      Checking 0 derivations
    }
    Parser.ensureExecuted 
  }
  Parser.ensureExecuted 
  Parser.setEvaluation: 0 candidates 
  Example: bye {
    Tokens: [bye]
    Lemmatized tokens: [bye]
    POS tags: [NN]
    NER tags: [O]
    NER values: [null]
    Sentiment: Neutral
    Keywords: [bye]
    Dependency children: [[]]
    Extracted relations: {}
  }
[Roboy]: bye
[INFO] Creating new conversation... --- roboy.dialog.ConversationManager (01:37:44)
[INFO] RosMainNode will be unavailable in DialogStateMachine (null was passed) --- roboy.dialog.DialogStateMachine (01:37:44)
[INFO]  -> The infoList path: resources/sentences/RoboyInfoList.json --- roboy.dialog.states.ordinaryStates.IntroductionState (01:37:44)
[INFO]  -> The QAList path: resources/sentences/QAList.json --- roboy.dialog.states.ordinaryStates.PersonalInformationFollowUpState (01:37:44)
[INFO]  -> The QAList path: resources/sentences/QAList.json --- roboy.dialog.states.ordinaryStates.PersonalInformationAskingState (01:37:44)
[INFO]  -> The filterList path: resources/gameResources/snapchat-filters.json --- roboy.dialog.states.gameStates.GamingSnapchatState (01:37:45)
[ERROR] Error reading file resources/gameResources/snapchat-filters.json: resources/gameResources/snapchat-filters.json --- roboy.util.IO (01:37:45)
[INFO] Waiting for conversation to end. --- roboy.dialog.ConversationManager (01:37:45)
[INFO] ############# Conversation started ############ --- Conversation17 (01:37:45)
[You]:   hi
  hi
  Parser.parse: parse {
    Error retrieval: {
      Checking 0 derivations
    }
    Parser.ensureExecuted 
  }
  Parser.ensureExecuted 
  Parser.setEvaluation: 0 candidates 
  Example: hi {
    Tokens: [hi]
    Lemmatized tokens: [hi]
    POS tags: [UH]
    NER tags: [O]
    NER values: [null]
    Sentiment: Neutral
    Keywords: [hi]
    Dependency children: [[]]
    Extracted relations: {}
  }
[Roboy]: what's up
[Roboy]: What's your name?
[You]:   jason
  jason
  Parser.parse: parse {
    Error retrieval: {
      Checking 0 derivations
    }
    Parser.ensureExecuted 
  }
  Parser.ensureExecuted 
  Parser.setEvaluation: 0 candidates 
  Example: jason {
    Tokens: [jason]
    Lemmatized tokens: [jason]
    POS tags: [NNP]
    NER tags: [PERSON]
    NER values: [null]
    Sentiment: Neutral
    Keywords: [jason]
    Dependency children: [[]]
    Extracted relations: {}
  }
Jul 23, 2018 1:37:48 AM org.roboy.memory.util.Neo4j matchNode
INFO: Class label: Person
Jul 23, 2018 1:37:48 AM org.roboy.memory.util.Neo4j matchNode
INFO: Properties: {name=jason, telegram_id=local}
Jul 23, 2018 1:37:48 AM org.roboy.memory.util.Neo4j matchNode
INFO:  MATCH (n:Person  {name:'jason',telegram_id:'local'}  )  RETURN COLLECT(ID(n)) AS ids 
Jul 23, 2018 1:37:48 AM org.roboy.memory.util.Neo4j matchNode
INFO: {"id":[478, 481]}
Jul 23, 2018 1:37:48 AM org.roboy.memory.util.Neo4j matchNodeById
INFO:  MATCH (n) WHERE ID(n)=478  RETURN PROPERTIES(n) 
Jul 23, 2018 1:37:48 AM org.roboy.memory.util.Neo4j matchNodeById
INFO:  MATCH (n)-[r]-(m) WHERE ID(n)=478 RETURN TYPE(r) as name, COLLECT(ID(m)) as ids 
Jul 23, 2018 1:37:48 AM org.roboy.memory.util.Neo4j matchNodeById
INFO: {"id":478,"properties":{"name":"jason","telegram_id":"local"},"relationships":{"HAS_HOBBY":[379],"WORK_FOR":[360],"STUDY_AT":[477],"FROM":[378]}}
Jul 23, 2018 1:37:48 AM org.roboy.memory.util.Neo4j matchNode
INFO: Class label: Robot
Jul 23, 2018 1:37:48 AM org.roboy.memory.util.Neo4j matchNode
INFO: Properties: {name=roboy two}
Jul 23, 2018 1:37:48 AM org.roboy.memory.util.Neo4j matchNode
INFO:  MATCH (n:Robot  {name:'roboy two'}  )  RETURN COLLECT(ID(n)) AS ids 
Jul 23, 2018 1:37:48 AM org.roboy.memory.util.Neo4j matchNode
INFO: {"id":[356]}
Jul 23, 2018 1:37:48 AM org.roboy.memory.util.Neo4j matchNodeById
INFO:  MATCH (n) WHERE ID(n)=356  RETURN PROPERTIES(n) 
Jul 23, 2018 1:37:48 AM org.roboy.memory.util.Neo4j matchNodeById
INFO:  MATCH (n)-[r]-(m) WHERE ID(n)=356 RETURN TYPE(r) as name, COLLECT(ID(m)) as ids 
Jul 23, 2018 1:37:48 AM org.roboy.memory.util.Neo4j matchNodeById
INFO: {"id":356,"properties":{"abilities":"talk to people,recognize objects,show emotions,move my body,shake a hand,party like there is no tomorrow,surf the internet,answer your questions","speed_kmh":"0","skills":"tell jokes,tell fun facts,tell you about the famous people and places,do the math","full_name":"roboy 2.0","birthdate":"12.04.2018","future":"become a robot rights advocate,help people and robots become friends,find the answer to the question of life the universe and everything,visit mars and other planets,become a music star,become a michelin star chef,get a robo pet,become as good as my father","conversation_id":"#bitch_boy","sex":"male","name":"roboy two","age":"0"},"relationships":{"LIVE_IN":[23],"HAS_HOBBY":[357,335,336],"MEMBER_OF":[20],"KNOW":[19],"CHILD_OF":[178],"FROM":[23],"SIBLING_OF":[26],"FRIEND_OF":[5,15,7,4,6,175,174,171,183,180,178,176,188,186,185,184,194,197,190,193,204,206,199,202,212,213,208,210,217]}}
Jul 23, 2018 1:37:48 AM org.roboy.memory.util.Neo4j matchNodeById
INFO:  MATCH (n) WHERE ID(n)=178  RETURN PROPERTIES(n) 
Jul 23, 2018 1:37:48 AM org.roboy.memory.util.Neo4j matchNodeById
INFO:  MATCH (n)-[r]-(m) WHERE ID(n)=178 RETURN TYPE(r) as name, COLLECT(ID(m)) as ids 
Jul 23, 2018 1:37:48 AM org.roboy.memory.util.Neo4j matchNodeById
INFO: {"id":178,"properties":{"full_name":"rafael hostettler ","test":"true","name":"rafael"},"relationships":{"WORK_FOR":[20],"CHILD_OF":[356,26],"FROM":[177],"FRIEND_OF":[356,210,208,202,194,193,190,186,171,26]}}
Jul 23, 2018 1:37:48 AM org.roboy.memory.util.Neo4j matchNodeById
INFO:  MATCH (n) WHERE ID(n)=378  RETURN PROPERTIES(n) 
[INFO] -> Retrieved Interlocutor: jason --- roboy.dialog.states.ordinaryStates.PersonalInformationFollowUpState (01:37:48)
[INFO]  -> Selected predicate: FROM --- roboy.dialog.states.ordinaryStates.PersonalInformationFollowUpState (01:37:48)
[INFO]  -> Retrieved memory node name: suzhou --- roboy.dialog.states.ordinaryStates.PersonalInformationFollowUpState (01:37:48)
[INFO]  -> Selected question: What was the last time you visited suzhou? --- roboy.dialog.states.ordinaryStates.PersonalInformationFollowUpState (01:37:48)
Jul 23, 2018 1:37:48 AM org.roboy.memory.util.Neo4j matchNodeById
[INFO]  -> Dialog IntentsHistory updated --- roboy.dialog.states.ordinaryStates.PersonalInformationFollowUpState (01:37:48)
INFO:  MATCH (n)-[r]-(m) WHERE ID(n)=378 RETURN TYPE(r) as name, COLLECT(ID(m)) as ids 
Jul 23, 2018 1:37:48 AM org.roboy.memory.util.Neo4j matchNodeById
[Roboy]: Hey, I know you, jason! roboy 2.0, that is my name. I am 3 months old, but I believe I may be older in robot years! I like interacting with humans, for example, tell fun facts. I have a lot of abilities, for example, I can shake a hand. I have already made up my mind that I would get a robo pet in the future! My father is rafael hostettler .
[Roboy]: What was the last time you visited suzhou?
INFO: {"id":378,"properties":{"name":"suzhou"},"relationships":{"FROM":[480,478,420,439,395,382,359]}}
[You]:   Lets play snapchat
  Lets play snapchat
  Parser.parse: parse {
    Error retrieval: {
      Checking 0 derivations
    }
    Parser.ensureExecuted 
  }
  Parser.ensureExecuted 
  Parser.setEvaluation: 0 candidates 
  Example: Lets play snapchat {
    Tokens: [lets, play, snapchat]
    Lemmatized tokens: [let, play, snapchat]
    POS tags: [VBZ, NN, NN]
    NER tags: [O, O, O]
    NER values: [null, null, null]
    Sentiment: Neutral
    Keywords: [play, snapchat]
    Dependency children: [[dobj->2], [], [compound->1]]
    Extracted relations: {}
  }
[INFO] -> Retrieved Interlocutor: jason --- roboy.dialog.states.ordinaryStates.PersonalInformationFollowUpState (01:42:49)
[WARN]  -> Inference failed --- roboy.dialog.states.ordinaryStates.PersonalInformationFollowUpState (01:42:49)
[WARN]  -> The result is empty. Nothing to update --- roboy.dialog.states.ordinaryStates.PersonalInformationFollowUpState (01:42:49)
[Roboy]: You are from a very interesting place 
[Roboy]:  Very well jason, 
[Roboy]: I'm pretty good at answering questions about myself and other stuff. What would you like to know?
[You]:   lets play
  lets play
  Parser.parse: parse {
    Error retrieval: {
      Checking 0 derivations
    }
    Parser.ensureExecuted 
  }
  Parser.ensureExecuted 
  Parser.setEvaluation: 0 candidates 
  Example: lets play {
    Tokens: [lets, play]
    Lemmatized tokens: [let, play]
    POS tags: [VBZ, NN]
    NER tags: [O, O]
    NER values: [null, null]
    Sentiment: Neutral
    Keywords: [play]
    Dependency children: [[dobj->1], []]
    Extracted relations: {}
  }
[Roboy]: Let's go. 
[Roboy]:  Which one? Maybe Snapchat? 
[You]:   yes
  yes
  Parser.parse: parse {
    Error retrieval: {
      Checking 0 derivations
    }
    Parser.ensureExecuted 
  }
  Parser.ensureExecuted 
  Parser.setEvaluation: 0 candidates 
  Example: yes {
    Tokens: [yes]
    Lemmatized tokens: [yes]
    POS tags: [UH]
    NER tags: [O]
    NER values: [null]
    Sentiment: Neutral
    Keywords: [yes]
    Dependency children: [[]]
    Extracted relations: {}
  }
[Roboy]: Nice, let's start. 
[Roboy]:  Why don't we put my null-filter on your face? 
[You]:   no
  no
  Parser.parse: parse {
    Error retrieval: {
      Checking 0 derivations
    }
    Parser.ensureExecuted 
  }
  Parser.ensureExecuted 
  Parser.setEvaluation: 0 candidates 
  Example: no {
    Tokens: [no]
    Lemmatized tokens: [no]
    POS tags: [DT]
    NER tags: [O]
    NER values: [null]
    Sentiment: Negative
    Keywords: [no]
    Dependency children: [[]]
    Extracted relations: {}
  }
[Roboy]:  Why don't we put my null-filter on your face? 
[You]:   yes
  yes
  Parser.parse: parse {
    Error retrieval: {
      Checking 0 derivations
    }
    Parser.ensureExecuted 
  }
  Parser.ensureExecuted 
  Parser.setEvaluation: 0 candidates 
  Example: yes {
    Tokens: [yes]
    Lemmatized tokens: [yes]
    POS tags: [UH]
    NER tags: [O]
    NER values: [null]
    Sentiment: Neutral
    Keywords: [yes]
    Dependency children: [[]]
    Extracted relations: {}
  }
[ERROR] Exception in react() of state with identifier GamingSnapchatState:
null --- roboy.dialog.personality.StateBasedPersonality (01:42:59)
[Roboy]:  Yuk, but this is actually true: The average human body carries ten times more bacterial cells than human cells. 
[Roboy]:  null-filter would be fun, right? 
[You]:   no
  no
  Parser.parse: parse {
    Error retrieval: {
      Checking 0 derivations
    }
    Parser.ensureExecuted 
  }
  Parser.ensureExecuted 
  Parser.setEvaluation: 0 candidates 
  Example: no {
    Tokens: [no]
    Lemmatized tokens: [no]
    POS tags: [DT]
    NER tags: [O]
    NER values: [null]
    Sentiment: Negative
    Keywords: [no]
    Dependency children: [[]]
    Extracted relations: {}
  }
[Roboy]:  What filter? Maybe a null-filter? 
[You]:   yes
  yes
  Parser.parse: parse {
    Error retrieval: {
      Checking 0 derivations
    }
    Parser.ensureExecuted 
  }
  Parser.ensureExecuted 
  Parser.setEvaluation: 0 candidates 
  Example: yes {
    Tokens: [yes]
    Lemmatized tokens: [yes]
    POS tags: [UH]
    NER tags: [O]
    NER values: [null]
    Sentiment: Neutral
    Keywords: [yes]
    Dependency children: [[]]
    Extracted relations: {}
  }
[ERROR] Exception in react() of state with identifier GamingSnapchatState:
null --- roboy.dialog.personality.StateBasedPersonality (01:43:00)
[Roboy]:  Did you know, I have muscles and tendons like humans? 
[Roboy]:  I have a new one. Let's prettify your face with the null-filter. 
[You]:   
  Parser.parse: parse {
    Error retrieval: {
      Checking 0 derivations
    }
    Parser.ensureExecuted 
  }
  Parser.ensureExecuted 
  Parser.setEvaluation: 0 candidates 
  Example:  {
    Tokens: []
    Lemmatized tokens: []
    POS tags: []
    NER tags: []
    NER values: []
    Sentiment: 
    Keywords: []
    Dependency children: []
    Extracted relations: {}
  }
[ERROR] Sentiment is illegal: No enum constant roboy.linguistics.Linguistics.UtteranceSentiment. --- roboy.linguistics.sentenceanalysis.SemanticParserAnalyzer (01:43:01)
[WARN] TOKENS missing but AnswerAnalyzer is used! --- roboy.linguistics.sentenceanalysis.AnswerAnalyzer (01:43:01)
[ERROR] Exception in react() of state with identifier GamingSnapchatState:
null --- roboy.dialog.personality.StateBasedPersonality (01:43:01)
[Roboy]:  Yuk, but this is actually true: The average human body carries ten times more bacterial cells than human cells. 
[Roboy]:  null-filter would be fun, right? 
[You]:   yes
  yes
  Parser.parse: parse {
    Error retrieval: {
      Checking 0 derivations
    }
    Parser.ensureExecuted 
  }
  Parser.ensureExecuted 
  Parser.setEvaluation: 0 candidates 
  Example: yes {
    Tokens: [yes]
    Lemmatized tokens: [yes]
    POS tags: [UH]
    NER tags: [O]
    NER values: [null]
    Sentiment: Neutral
    Keywords: [yes]
    Dependency children: [[]]
    Extracted relations: {}
  }
[ERROR] Exception in react() of state with identifier GamingSnapchatState:
null --- roboy.dialog.personality.StateBasedPersonality (01:43:02)
[Roboy]:  It can take a photon 40,000 years to travel from the core of the sun to its surface, but only 8 minutes to travel the rest of the way to Earth 
[Roboy]:  I have a new one. Let's prettify your face with the null-filter. 
[You]:   
  Parser.parse: parse {
    Error retrieval: {
      Checking 0 derivations
    }
    Parser.ensureExecuted 
  }
  Parser.ensureExecuted 
  Parser.setEvaluation: 0 candidates 
  Example:  {
    Tokens: []
    Lemmatized tokens: []
    POS tags: []
    NER tags: []
    NER values: []
    Sentiment: 
    Keywords: []
    Dependency children: []
    Extracted relations: {}
  }
[ERROR] Sentiment is illegal: No enum constant roboy.linguistics.Linguistics.UtteranceSentiment. --- roboy.linguistics.sentenceanalysis.SemanticParserAnalyzer (01:43:03)
[WARN] TOKENS missing but AnswerAnalyzer is used! --- roboy.linguistics.sentenceanalysis.AnswerAnalyzer (01:43:03)
[ERROR] Exception in react() of state with identifier GamingSnapchatState:
null --- roboy.dialog.personality.StateBasedPersonality (01:43:03)
[Roboy]:  Did you know, I have muscles and tendons like humans? 
[Roboy]:  What filter? Maybe a null-filter? 
[You]:   
  Parser.parse: parse {
    Error retrieval: {
      Checking 0 derivations
    }
    Parser.ensureExecuted 
  }
  Parser.ensureExecuted 
  Parser.setEvaluation: 0 candidates 
  Example:  {
    Tokens: []
    Lemmatized tokens: []
    POS tags: []
    NER tags: []
    NER values: []
    Sentiment: 
    Keywords: []
    Dependency children: []
    Extracted relations: {}
  }
[ERROR] Sentiment is illegal: No enum constant roboy.linguistics.Linguistics.UtteranceSentiment. --- roboy.linguistics.sentenceanalysis.SemanticParserAnalyzer (01:43:03)
[WARN] TOKENS missing but AnswerAnalyzer is used! --- roboy.linguistics.sentenceanalysis.AnswerAnalyzer (01:43:03)
[ERROR] Exception in react() of state with identifier GamingSnapchatState:
null --- roboy.dialog.personality.StateBasedPersonality (01:43:03)
[Roboy]:  An individual blood cell takes about 60 seconds to make a complete circuit around your body, my electrons are way faster. 
[Roboy]:  What filter? Maybe a null-filter? 
[You]:   
  Parser.parse: parse {
    Error retrieval: {
      Checking 0 derivations
    }
    Parser.ensureExecuted 
  }
  Parser.ensureExecuted 
  Parser.setEvaluation: 0 candidates 
  Example:  {
    Tokens: []
    Lemmatized tokens: []
    POS tags: []
    NER tags: []
    NER values: []
    Sentiment: 
    Keywords: []
    Dependency children: []
    Extracted relations: {}
  }
[ERROR] Sentiment is illegal: No enum constant roboy.linguistics.Linguistics.UtteranceSentiment. --- roboy.linguistics.sentenceanalysis.SemanticParserAnalyzer (01:43:03)
[WARN] TOKENS missing but AnswerAnalyzer is used! --- roboy.linguistics.sentenceanalysis.AnswerAnalyzer (01:43:03)
[ERROR] Exception in react() of state with identifier GamingSnapchatState:
null --- roboy.dialog.personality.StateBasedPersonality (01:43:03)
[Roboy]:  I heard that there are robots, who can fly? Do you think they are better than me? 
[Roboy]:  What filter? Maybe a null-filter? 
[You]:   
  Parser.parse: parse {
    Error retrieval: {
      Checking 0 derivations
    }
    Parser.ensureExecuted 
  }
  Parser.ensureExecuted 
  Parser.setEvaluation: 0 candidates 
  Example:  {
    Tokens: []
    Lemmatized tokens: []
    POS tags: []
    NER tags: []
    NER values: []
    Sentiment: 
    Keywords: []
    Dependency children: []
    Extracted relations: {}
  }
[ERROR] Sentiment is illegal: No enum constant roboy.linguistics.Linguistics.UtteranceSentiment. --- roboy.linguistics.sentenceanalysis.SemanticParserAnalyzer (01:43:04)
[WARN] TOKENS missing but AnswerAnalyzer is used! --- roboy.linguistics.sentenceanalysis.AnswerAnalyzer (01:43:04)
[ERROR] Exception in react() of state with identifier GamingSnapchatState:
null --- roboy.dialog.personality.StateBasedPersonality (01:43:04)
[Roboy]:  An individual blood cell takes about 60 seconds to make a complete circuit around your body, my electrons are way faster. 
[Roboy]:  null-filter would be fun, right? 
[You]:   
  Parser.parse: parse {
    Error retrieval: {
      Checking 0 derivations
    }
    Parser.ensureExecuted 
  }
  Parser.ensureExecuted 
  Parser.setEvaluation: 0 candidates 
  Example:  {
    Tokens: []
    Lemmatized tokens: []
    POS tags: []
    NER tags: []
    NER values: []
    Sentiment: 
    Keywords: []
    Dependency children: []
    Extracted relations: {}
  }
[ERROR] Sentiment is illegal: No enum constant roboy.linguistics.Linguistics.UtteranceSentiment. --- roboy.linguistics.sentenceanalysis.SemanticParserAnalyzer (01:43:04)
[WARN] TOKENS missing but AnswerAnalyzer is used! --- roboy.linguistics.sentenceanalysis.AnswerAnalyzer (01:43:04)
[ERROR] Exception in react() of state with identifier GamingSnapchatState:
null --- roboy.dialog.personality.StateBasedPersonality (01:43:04)
[Roboy]:  In contrast to me, The average person walks the equivalent of five times around the world in a lifetime. I don't walk at all. Yet. 
[Roboy]:  What filter do you want? Maybe the null-filter? 
[You]:   
  Parser.parse: parse {
    Error retrieval: {
      Checking 0 derivations
    }
    Parser.ensureExecuted 
  }
  Parser.ensureExecuted 
  Parser.setEvaluation: 0 candidates 
  Example:  {
    Tokens: []
    Lemmatized tokens: []
    POS tags: []
    NER tags: []
    NER values: []
    Sentiment: 
    Keywords: []
    Dependency children: []
    Extracted relations: {}
  }
[ERROR] Sentiment is illegal: No enum constant roboy.linguistics.Linguistics.UtteranceSentiment. --- roboy.linguistics.sentenceanalysis.SemanticParserAnalyzer (01:43:04)
[WARN] TOKENS missing but AnswerAnalyzer is used! --- roboy.linguistics.sentenceanalysis.AnswerAnalyzer (01:43:04)
[ERROR] Exception in react() of state with identifier GamingSnapchatState:
null --- roboy.dialog.personality.StateBasedPersonality (01:43:04)
[Roboy]:  In contrast to me, The average person walks the equivalent of five times around the world in a lifetime. I don't walk at all. Yet. 
[Roboy]:  What filter do you want? Maybe the null-filter? 
[You]:   
  Parser.parse: parse {
    Error retrieval: {
      Checking 0 derivations
    }
    Parser.ensureExecuted 
  }
  Parser.ensureExecuted 
  Parser.setEvaluation: 0 candidates 
  Example:  {
    Tokens: []
    Lemmatized tokens: []
    POS tags: []
    NER tags: []
    NER values: []
    Sentiment: 
    Keywords: []
    Dependency children: []
    Extracted relations: {}
  }
[ERROR] Sentiment is illegal: No enum constant roboy.linguistics.Linguistics.UtteranceSentiment. --- roboy.linguistics.sentenceanalysis.SemanticParserAnalyzer (01:43:04)
[WARN] TOKENS missing but AnswerAnalyzer is used! --- roboy.linguistics.sentenceanalysis.AnswerAnalyzer (01:43:04)
[ERROR] Exception in react() of state with identifier GamingSnapchatState:
null --- roboy.dialog.personality.StateBasedPersonality (01:43:04)
[Roboy]:  An individual blood cell takes about 60 seconds to make a complete circuit around your body, my electrons are way faster. 
[Roboy]:  What filter do you want? Maybe the null-filter? 
[You]:   
  Parser.parse: parse {
    Error retrieval: {
      Checking 0 derivations
    }
    Parser.ensureExecuted 
  }
  Parser.ensureExecuted 
  Parser.setEvaluation: 0 candidates 
  Example:  {
    Tokens: []
    Lemmatized tokens: []
    POS tags: []
    NER tags: []
    NER values: []
    Sentiment: 
    Keywords: []
    Dependency children: []
    Extracted relations: {}
  }
[ERROR] Sentiment is illegal: No enum constant roboy.linguistics.Linguistics.UtteranceSentiment. --- roboy.linguistics.sentenceanalysis.SemanticParserAnalyzer (01:43:04)
[WARN] TOKENS missing but AnswerAnalyzer is used! --- roboy.linguistics.sentenceanalysis.AnswerAnalyzer (01:43:04)
[ERROR] Exception in react() of state with identifier GamingSnapchatState:
null --- roboy.dialog.personality.StateBasedPersonality (01:43:04)
[Roboy]:  Yuk, but this is actually true: The average human body carries ten times more bacterial cells than human cells. 
[Roboy]:  I have a new one. Let's prettify your face with the null-filter. 
[You]:   
  Parser.parse: parse {
    Error retrieval: {
      Checking 0 derivations
    }
    Parser.ensureExecuted 
  }
  Parser.ensureExecuted 
  Parser.setEvaluation: 0 candidates 
  Example:  {
    Tokens: []
    Lemmatized tokens: []
    POS tags: []
    NER tags: []
    NER values: []
    Sentiment: 
    Keywords: []
    Dependency children: []
    Extracted relations: {}
  }
[ERROR] Sentiment is illegal: No enum constant roboy.linguistics.Linguistics.UtteranceSentiment. --- roboy.linguistics.sentenceanalysis.SemanticParserAnalyzer (01:43:05)
[WARN] TOKENS missing but AnswerAnalyzer is used! --- roboy.linguistics.sentenceanalysis.AnswerAnalyzer (01:43:05)
[ERROR] Exception in react() of state with identifier GamingSnapchatState:
null --- roboy.dialog.personality.StateBasedPersonality (01:43:05)
[Roboy]:  It can take a photon 40,000 years to travel from the core of the sun to its surface, but only 8 minutes to travel the rest of the way to Earth 
[Roboy]:  Why don't we put my null-filter on your face? 
[You]:   
  Parser.parse: parse {
    Error retrieval: {
      Checking 0 derivations
    }
    Parser.ensureExecuted 
  }
  Parser.ensureExecuted 
  Parser.setEvaluation: 0 candidates 
  Example:  {
    Tokens: []
    Lemmatized tokens: []
    POS tags: []
    NER tags: []
    NER values: []
    Sentiment: 
    Keywords: []
    Dependency children: []
    Extracted relations: {}
  }
[ERROR] Sentiment is illegal: No enum constant roboy.linguistics.Linguistics.UtteranceSentiment. --- roboy.linguistics.sentenceanalysis.SemanticParserAnalyzer (01:43:05)
[WARN] TOKENS missing but AnswerAnalyzer is used! --- roboy.linguistics.sentenceanalysis.AnswerAnalyzer (01:43:05)
[ERROR] Exception in react() of state with identifier GamingSnapchatState:
null --- roboy.dialog.personality.StateBasedPersonality (01:43:05)
[Roboy]:  There are 8 times as many atoms in a teaspoonful of water as there are teaspoonfuls of water in the Atlantic ocean 
[Roboy]:  What filter do you want? Maybe the null-filter? 
[You]:   
  Parser.parse: parse {
    Error retrieval: {
      Checking 0 derivations
    }
    Parser.ensureExecuted 
  }
  Parser.ensureExecuted 
  Parser.setEvaluation: 0 candidates 
  Example:  {
    Tokens: []
    Lemmatized tokens: []
    POS tags: []
    NER tags: []
    NER values: []
    Sentiment: 
    Keywords: []
    Dependency children: []
    Extracted relations: {}
  }
[ERROR] Sentiment is illegal: No enum constant roboy.linguistics.Linguistics.UtteranceSentiment. --- roboy.linguistics.sentenceanalysis.SemanticParserAnalyzer (01:43:05)
[WARN] TOKENS missing but AnswerAnalyzer is used! --- roboy.linguistics.sentenceanalysis.AnswerAnalyzer (01:43:05)
[ERROR] Exception in react() of state with identifier GamingSnapchatState:
null --- roboy.dialog.personality.StateBasedPersonality (01:43:05)
[Roboy]:  I heard that there are robots, who can fly? Do you think they are better than me? 
[Roboy]:  What filter? Maybe a null-filter? 
[You]:   
  Parser.parse: parse {
    Error retrieval: {
      Checking 0 derivations
    }
    Parser.ensureExecuted 
  }
  Parser.ensureExecuted 
  Parser.setEvaluation: 0 candidates 
  Example:  {
    Tokens: []
    Lemmatized tokens: []
    POS tags: []
    NER tags: []
    NER values: []
    Sentiment: 
    Keywords: []
    Dependency children: []
    Extracted relations: {}
  }
[ERROR] Sentiment is illegal: No enum constant roboy.linguistics.Linguistics.UtteranceSentiment. --- roboy.linguistics.sentenceanalysis.SemanticParserAnalyzer (01:43:05)
[WARN] TOKENS missing but AnswerAnalyzer is used! --- roboy.linguistics.sentenceanalysis.AnswerAnalyzer (01:43:05)
[ERROR] Exception in react() of state with identifier GamingSnapchatState:
null --- roboy.dialog.personality.StateBasedPersonality (01:43:05)
[Roboy]:  It can take a photon 40,000 years to travel from the core of the sun to its surface, but only 8 minutes to travel the rest of the way to Earth 
[Roboy]:  null-filter would be fun, right? 
[You]:   
  Parser.parse: parse {
    Error retrieval: {
      Checking 0 derivations
    }
    Parser.ensureExecuted 
  }
  Parser.ensureExecuted 
  Parser.setEvaluation: 0 candidates 
  Example:  {
    Tokens: []
    Lemmatized tokens: []
    POS tags: []
    NER tags: []
    NER values: []
    Sentiment: 
    Keywords: []
    Dependency children: []
    Extracted relations: {}
  }
[ERROR] Sentiment is illegal: No enum constant roboy.linguistics.Linguistics.UtteranceSentiment. --- roboy.linguistics.sentenceanalysis.SemanticParserAnalyzer (01:43:05)
[WARN] TOKENS missing but AnswerAnalyzer is used! --- roboy.linguistics.sentenceanalysis.AnswerAnalyzer (01:43:05)
[ERROR] Exception in react() of state with identifier GamingSnapchatState:
null --- roboy.dialog.personality.StateBasedPersonality (01:43:05)
[Roboy]:  In contrast to me, The average person walks the equivalent of five times around the world in a lifetime. I don't walk at all. Yet. 
[Roboy]:  I have a new one. Let's prettify your face with the null-filter. 
[You]:   l
  l
  Parser.parse: parse {
    Error retrieval: {
      Checking 0 derivations
    }
    Parser.ensureExecuted 
  }
  Parser.ensureExecuted 
  Parser.setEvaluation: 0 candidates 
  Example: l {
    Tokens: [l]
    Lemmatized tokens: [l]
    POS tags: [NN]
    NER tags: [O]
    NER values: [null]
    Sentiment: Neutral
    Keywords: [l]
    Dependency children: [[]]
    Extracted relations: {}
  }
[Roboy]:  What filter? Maybe a null-filter? 
[You]:   l
  l
  Parser.parse: parse {
    Error retrieval: {
      Checking 0 derivations
    }
    Parser.ensureExecuted 
  }
  Parser.ensureExecuted 
  Parser.setEvaluation: 0 candidates 
  Example: l {
    Tokens: [l]
    Lemmatized tokens: [l]
    POS tags: [NN]
    NER tags: [O]
    NER values: [null]
    Sentiment: Neutral
    Keywords: [l]
    Dependency children: [[]]
    Extracted relations: {}
  }
[Roboy]:  What filter do you want? Maybe the null-filter? 
[You]:   l
  l
  Parser.parse: parse {
    Error retrieval: {
      Checking 0 derivations
    }
    Parser.ensureExecuted 
  }
  Parser.ensureExecuted 
  Parser.setEvaluation: 0 candidates 
  Example: l {
    Tokens: [l]
    Lemmatized tokens: [l]
    POS tags: [NN]
    NER tags: [O]
    NER values: [null]
    Sentiment: Neutral
    Keywords: [l]
    Dependency children: [[]]
    Extracted relations: {}
  }
[Roboy]:  null-filter would be fun, right? 
[You]:   .
  .
  Parser.parse: parse {
    Error retrieval: {
      Checking 0 derivations
    }
    Parser.ensureExecuted 
  }
  Parser.ensureExecuted 
  Parser.setEvaluation: 0 candidates 
  Example: . {
    Tokens: [.]
    Lemmatized tokens: [.]
    POS tags: [.]
    NER tags: [O]
    NER values: [null]
    Sentiment: Neutral
    Keywords: [.]
    Dependency children: [[]]
    Extracted relations: {}
  }
[Roboy]:  null-filter would be fun, right? 
[You]:   ,.
  ,.
  Parser.parse: parse {
    Error retrieval: {
      Checking 0 derivations
    }
    Parser.ensureExecuted 
  }
  Parser.ensureExecuted 
  Parser.setEvaluation: 0 candidates 
  Example: ,. {
    Tokens: [,, .]
    Lemmatized tokens: [,, .]
    POS tags: [,, .]
    NER tags: [O, O]
    NER values: [null, null]
    Sentiment: Neutral
    Keywords: []
    Dependency children: [[punct->1], []]
    Extracted relations: {}
  }
[Roboy]:  Why don't we put my null-filter on your face? 
[You]:   ,.
  ,.
  Parser.parse: parse {
    Error retrieval: {
      Checking 0 derivations
    }
    Parser.ensureExecuted 
  }
  Parser.ensureExecuted 
  Parser.setEvaluation: 0 candidates 
  Example: ,. {
    Tokens: [,, .]
    Lemmatized tokens: [,, .]
    POS tags: [,, .]
    NER tags: [O, O]
    NER values: [null, null]
    Sentiment: Neutral
    Keywords: []
    Dependency children: [[punct->1], []]
    Extracted relations: {}
  }
[Roboy]:  null-filter would be fun, right? 
[You]:   .
,  .
  Parser.parse: parse {
    Error retrieval: {
      Checking 0 derivations
    }
    Parser.ensureExecuted 
  }
  Parser.ensureExecuted 
  Parser.setEvaluation: 0 candidates 
  Example: . {
    Tokens: [.]
    Lemmatized tokens: [.]
    POS tags: [.]
    NER tags: [O]
    NER values: [null]
    Sentiment: Neutral
    Keywords: [.]
    Dependency children: [[]]
    Extracted relations: {}
  }
[Roboy]:  I have a new one. Let's prettify your face with the null-filter. 
[You]:   
  Parser.parse: parse {
    Error retrieval: {
      Checking 0 derivations
    }
    Parser.ensureExecuted 
  }
  Parser.ensureExecuted 
  Parser.setEvaluation: 0 candidates 
  Example:  {
    Tokens: []
    Lemmatized tokens: []
    POS tags: []
    NER tags: []
    NER values: []
    Sentiment: 
    Keywords: []
    Dependency children: []
    Extracted relations: {}
  }
[ERROR] Sentiment is illegal: No enum constant roboy.linguistics.Linguistics.UtteranceSentiment. --- roboy.linguistics.sentenceanalysis.SemanticParserAnalyzer (01:43:16)
[WARN] TOKENS missing but AnswerAnalyzer is used! --- roboy.linguistics.sentenceanalysis.AnswerAnalyzer (01:43:16)
[Roboy]:  null-filter would be fun, right? 
[You]:   a
  a
  Parser.parse: parse {
    Error retrieval: {
      Checking 0 derivations
    }
    Parser.ensureExecuted 
  }
  Parser.ensureExecuted 
  Parser.setEvaluation: 0 candidates 
  Example: a {
    Tokens: [a]
    Lemmatized tokens: [a]
    POS tags: [DT]
    NER tags: [O]
    NER values: [null]
    Sentiment: Neutral
    Keywords: [a]
    Dependency children: [[]]
    Extracted relations: {}
  }
[Roboy]:  null-filter would be fun, right? 
[You]:   as
  as
  Parser.parse: parse {
    Error retrieval: {
      Checking 0 derivations
    }
    Parser.ensureExecuted 
  }
  Parser.ensureExecuted 
  Parser.setEvaluation: 0 candidates 
  Example: as {
    Tokens: [as]
    Lemmatized tokens: [as]
    POS tags: [IN]
    NER tags: [O]
    NER values: [null]
    Sentiment: Neutral
    Keywords: [as]
    Dependency children: [[]]
    Extracted relations: {}
  }
[Roboy]:  I have a new one. Let's prettify your face with the null-filter. 
[You]:    
  Parser.parse: parse {
    Error retrieval: {
      Checking 0 derivations
    }
    Parser.ensureExecuted 
  }
  Parser.ensureExecuted 
  Parser.setEvaluation: 0 candidates 
  Example:  {
    Tokens: []
    Lemmatized tokens: []
    POS tags: []
    NER tags: []
    NER values: []
    Sentiment: 
    Keywords: []
    Dependency children: []
    Extracted relations: {}
  }
[ERROR] Sentiment is illegal: No enum constant roboy.linguistics.Linguistics.UtteranceSentiment. --- roboy.linguistics.sentenceanalysis.SemanticParserAnalyzer (01:43:33)
[WARN] TOKENS missing but AnswerAnalyzer is used! --- roboy.linguistics.sentenceanalysis.AnswerAnalyzer (01:43:33)
[Roboy]:  I have a new one. Let's prettify your face with the null-filter. 
[You]:   
  Parser.parse: parse {
    Error retrieval: {
      Checking 0 derivations
    }
    Parser.ensureExecuted 
  }
  Parser.ensureExecuted 
  Parser.setEvaluation: 0 candidates 
  Example:  {
    Tokens: []
    Lemmatized tokens: []
    POS tags: []
    NER tags: []
    NER values: []
    Sentiment: 
    Keywords: []
    Dependency children: []
    Extracted relations: {}
  }
[ERROR] Sentiment is illegal: No enum constant roboy.linguistics.Linguistics.UtteranceSentiment. --- roboy.linguistics.sentenceanalysis.SemanticParserAnalyzer (01:43:34)
[WARN] TOKENS missing but AnswerAnalyzer is used! --- roboy.linguistics.sentenceanalysis.AnswerAnalyzer (01:43:34)
[Roboy]:  I have a new one. Let's prettify your face with the null-filter. 
[You]:    
  Parser.parse: parse {
    Error retrieval: {
      Checking 0 derivations
    }
    Parser.ensureExecuted 
  }
  Parser.ensureExecuted 
  Parser.setEvaluation: 0 candidates 
  Example:  {
    Tokens: []
    Lemmatized tokens: []
    POS tags: []
    NER tags: []
    NER values: []
    Sentiment: 
    Keywords: []
    Dependency children: []
    Extracted relations: {}
  }
[ERROR] Sentiment is illegal: No enum constant roboy.linguistics.Linguistics.UtteranceSentiment. --- roboy.linguistics.sentenceanalysis.SemanticParserAnalyzer (01:43:35)
[WARN] TOKENS missing but AnswerAnalyzer is used! --- roboy.linguistics.sentenceanalysis.AnswerAnalyzer (01:43:35)
[Roboy]:  Why don't we put my null-filter on your face? 
[You]:    
  Parser.parse: parse {
    Error retrieval: {
      Checking 0 derivations
    }
    Parser.ensureExecuted 
  }
  Parser.ensureExecuted 
  Parser.setEvaluation: 0 candidates 
  Example:  {
    Tokens: []
    Lemmatized tokens: []
    POS tags: []
    NER tags: []
    NER values: []
    Sentiment: 
    Keywords: []
    Dependency children: []
    Extracted relations: {}
  }
[ERROR] Sentiment is illegal: No enum constant roboy.linguistics.Linguistics.UtteranceSentiment. --- roboy.linguistics.sentenceanalysis.SemanticParserAnalyzer (01:43:36)
[WARN] TOKENS missing but AnswerAnalyzer is used! --- roboy.linguistics.sentenceanalysis.AnswerAnalyzer (01:43:36)
[Roboy]:  What filter? Maybe a null-filter? 
[You]:     
  Parser.parse: parse {
    Error retrieval: {
      Checking 0 derivations
    }
    Parser.ensureExecuted 
  }
  Parser.ensureExecuted 
  Parser.setEvaluation: 0 candidates 
  Example:  {
    Tokens: []
    Lemmatized tokens: []
    POS tags: []
    NER tags: []
    NER values: []
    Sentiment: 
    Keywords: []
    Dependency children: []
    Extracted relations: {}
  }
[ERROR] Sentiment is illegal: No enum constant roboy.linguistics.Linguistics.UtteranceSentiment. --- roboy.linguistics.sentenceanalysis.SemanticParserAnalyzer (01:43:37)
[WARN] TOKENS missing but AnswerAnalyzer is used! --- roboy.linguistics.sentenceanalysis.AnswerAnalyzer (01:43:37)
[Roboy]:  null-filter would be fun, right? 
[You]:    
  Parser.parse: parse {
    Error retrieval: {
      Checking 0 derivations
    }
    Parser.ensureExecuted 
  }
  Parser.ensureExecuted 
  Parser.setEvaluation: 0 candidates 
  Example:  {
    Tokens: []
    Lemmatized tokens: []
    POS tags: []
    NER tags: []
    NER values: []
    Sentiment: 
    Keywords: []
    Dependency children: []
    Extracted relations: {}
  }
[ERROR] Sentiment is illegal: No enum constant roboy.linguistics.Linguistics.UtteranceSentiment. --- roboy.linguistics.sentenceanalysis.SemanticParserAnalyzer (01:43:39)
[WARN] TOKENS missing but AnswerAnalyzer is used! --- roboy.linguistics.sentenceanalysis.AnswerAnalyzer (01:43:39)
[Roboy]:  What filter do you want? Maybe the null-filter? 
[You]:   
  Parser.parse: parse {
    Error retrieval: {
      Checking 0 derivations
    }
    Parser.ensureExecuted 
  }
  Parser.ensureExecuted 
  Parser.setEvaluation: 0 candidates 
  Example:  {
    Tokens: []
    Lemmatized tokens: []
    POS tags: []
    NER tags: []
    NER values: []
    Sentiment: 
    Keywords: []
    Dependency children: []
    Extracted relations: {}
  }
[ERROR] Sentiment is illegal: No enum constant roboy.linguistics.Linguistics.UtteranceSentiment. --- roboy.linguistics.sentenceanalysis.SemanticParserAnalyzer (01:43:39)
[WARN] TOKENS missing but AnswerAnalyzer is used! --- roboy.linguistics.sentenceanalysis.AnswerAnalyzer (01:43:39)
[Roboy]:  What filter? Maybe a null-filter? 
[You]:    
  Parser.parse: parse {
    Error retrieval: {
      Checking 0 derivations
    }
    Parser.ensureExecuted 
  }
  Parser.ensureExecuted 
  Parser.setEvaluation: 0 candidates 
  Example:  {
    Tokens: []
    Lemmatized tokens: []
    POS tags: []
    NER tags: []
    NER values: []
    Sentiment: 
    Keywords: []
    Dependency children: []
    Extracted relations: {}
  }
[ERROR] Sentiment is illegal: No enum constant roboy.linguistics.Linguistics.UtteranceSentiment. --- roboy.linguistics.sentenceanalysis.SemanticParserAnalyzer (01:43:39)
[WARN] TOKENS missing but AnswerAnalyzer is used! --- roboy.linguistics.sentenceanalysis.AnswerAnalyzer (01:43:39)
[Roboy]:  null-filter would be fun, right? 
[You]:    
  Parser.parse: parse {
    Error retrieval: {
      Checking 0 derivations
    }
    Parser.ensureExecuted 
  }
  Parser.ensureExecuted 
  Parser.setEvaluation: 0 candidates 
  Example:  {
    Tokens: []
    Lemmatized tokens: []
    POS tags: []
    NER tags: []
    NER values: []
    Sentiment: 
    Keywords: []
    Dependency children: []
    Extracted relations: {}
  }
[ERROR] Sentiment is illegal: No enum constant roboy.linguistics.Linguistics.UtteranceSentiment. --- roboy.linguistics.sentenceanalysis.SemanticParserAnalyzer (01:43:40)
[WARN] TOKENS missing but AnswerAnalyzer is used! --- roboy.linguistics.sentenceanalysis.AnswerAnalyzer (01:43:40)
[Roboy]:  null-filter would be fun, right? 
[You]:   1a0
  1a0
  Parser.parse: parse {
    Error retrieval: {
      Checking 1 derivations
    }
    Parser.ensureExecuted 
  }
  Parser.ensureExecuted 
  Parser.setEvaluation: 1 candidates {
    Pred@0000: (derivation (formula (number 10)) (value (list (number 10))) (type fb:type.int)) [score=-0.990, prob=1]
  }
  Example: 1a0 {
    Tokens: [1a0]
    Lemmatized tokens: [1a0]
    POS tags: [CD]
    NER tags: [NUMBER]
    NER values: [10.0]
    Sentiment: Neutral
    Keywords: [1a0]
    Dependency children: [[]]
    Extracted relations: {}
  }
  Pred features [sum = -1.178] (format is feature value * weight) {
    [ rule :: fire ]                                   -2.290 = 4 * 0.473
    [ rule :: $Intermediate99 -> $Intermediate98 (SelectFn 0) ] -0.205 = 1 * -0.765
    [ rule :: $Expr -> $PHRASE (NumberFn) ]             0.120 = 1 * 0.668
    [ rule :: $Intermediate98 -> $Expr (SelectFn 0) ]   0.229 = 1 * -0.880
    [ rule :: $ROOT -> $Intermediate99 (IdentityFn) ]   0.967 = 1 * 0.823
  }
  Pred choices 
  Top formula {
    (number 10)
  }
  Top value {
    (number 10)
  }
[Roboy]:  null-filter would be fun, right? 
[You]:   1
  1
  Parser.parse: parse {
    Error retrieval: {
      Checking 1 derivations
    }
    Parser.ensureExecuted 
  }
  Parser.ensureExecuted 
  Parser.setEvaluation: 1 candidates {
    Pred@0000: (derivation (formula (number 1)) (value (list (number 1))) (type fb:type.int)) [score=0.057, prob=1]
  }
  Example: 1 {
    Tokens: [1]
    Lemmatized tokens: [1]
    POS tags: [CD]
    NER tags: [NUMBER]
    NER values: [1.0]
    Sentiment: Neutral
    Keywords: [1]
    Dependency children: [[]]
    Extracted relations: {}
  }
  Pred features [sum = -0.416] (format is feature value * weight) {
    [ rule :: $ROOT -> $Expr (IdentityFn) ]            -0.701 = 1 * 0.668
    [ rule :: fire ]                                   -0.617 = 2 * 0.213
    [ rule :: $Expr -> $PHRASE (NumberFn) ]             0.902 = 1 * -0.218
  }
  Pred choices 
  Top formula {
    (number 1)
  }
  Top value {
    (number 1)
  }
[Roboy]:  Why don't we put my null-filter on your face? 
[You]:   0
  0
  Parser.parse: parse {
    Error retrieval: {
      Checking 1 derivations
    }
    Parser.ensureExecuted 
  }
  Parser.ensureExecuted 
  Parser.setEvaluation: 1 candidates {
    Pred@0000: (derivation (formula (number 0)) (value (list (number 0))) (type fb:type.int)) [score=-0.301, prob=1]
  }
  Example: 0 {
    Tokens: [0]
    Lemmatized tokens: [0]
    POS tags: [CD]
    NER tags: [NUMBER]
    NER values: [0.0]
    Sentiment: Neutral
    Keywords: [0]
    Dependency children: [[]]
    Extracted relations: {}
  }
  Pred features [sum = -0.105] (format is feature value * weight) {
    [ rule :: fire ]                                   -1.309 = 4 * 0.775
    [ rule :: $Expr -> $PHRASE (NumberFn) ]            -0.040 = 1 * 0.780
    [ rule :: $ROOT -> $Intermediate95 (IdentityFn) ]   0.289 = 1 * 0.614
    [ rule :: $Intermediate95 -> $Intermediate94 (SelectFn 0) ]  0.375 = 1 * -0.200
    [ rule :: $Intermediate94 -> $Expr (SelectFn 0) ]   0.579 = 1 * 0.028
  }
  Pred choices 
  Top formula {
    (number 0)
  }
  Top value {
    (number 0)
  }
[Roboy]:  What filter do you want? Maybe the null-filter? 
[You]:   .
  .
  Parser.parse: parse {
    Error retrieval: {
      Checking 0 derivations
    }
    Parser.ensureExecuted 
  }
  Parser.ensureExecuted 
  Parser.setEvaluation: 0 candidates 
  Example: . {
    Tokens: [.]
    Lemmatized tokens: [.]
    POS tags: [.]
    NER tags: [O]
    NER values: [null]
    Sentiment: Neutral
    Keywords: [.]
    Dependency children: [[]]
    Extracted relations: {}
  }
[Roboy]:  Why don't we put my null-filter on your face? 
[You]:   .
  .
  Parser.parse: parse {
    Error retrieval: {
      Checking 0 derivations
    }
    Parser.ensureExecuted 
  }
  Parser.ensureExecuted 
  Parser.setEvaluation: 0 candidates 
  Example: . {
    Tokens: [.]
    Lemmatized tokens: [.]
    POS tags: [.]
    NER tags: [O]
    NER values: [null]
    Sentiment: Neutral
    Keywords: [.]
    Dependency children: [[]]
    Extracted relations: {}
  }
[Roboy]:  What filter do you want? Maybe the null-filter? 
[You]:   
  Parser.parse: parse {
    Error retrieval: {
      Checking 0 derivations
    }
    Parser.ensureExecuted 
  }
  Parser.ensureExecuted 
  Parser.setEvaluation: 0 candidates 
  Example:  {
    Tokens: []
    Lemmatized tokens: []
    POS tags: []
    NER tags: []
    NER values: []
    Sentiment: 
    Keywords: []
    Dependency children: []
    Extracted relations: {}
  }
[ERROR] Sentiment is illegal: No enum constant roboy.linguistics.Linguistics.UtteranceSentiment. --- roboy.linguistics.sentenceanalysis.SemanticParserAnalyzer (01:43:47)
[WARN] TOKENS missing but AnswerAnalyzer is used! --- roboy.linguistics.sentenceanalysis.AnswerAnalyzer (01:43:47)
[Roboy]:  null-filter would be fun, right? 
[You]:   /
  /
  Parser.parse: parse {
    Error retrieval: {
      Checking 0 derivations
    }
    Parser.ensureExecuted 
  }
  Parser.ensureExecuted 
  Parser.setEvaluation: 0 candidates 
  Example: / {
    Tokens: [/]
    Lemmatized tokens: [/]
    POS tags: [:]
    NER tags: [O]
    NER values: [null]
    Sentiment: Neutral
    Keywords: [/]
    Dependency children: [[]]
    Extracted relations: {}
  }
[Roboy]:  Why don't we put my null-filter on your face? 
[You]:   `
  `
  Parser.parse: parse {
    Error retrieval: {
      Checking 0 derivations
    }
    Parser.ensureExecuted 
  }
  Parser.ensureExecuted 
  Parser.setEvaluation: 0 candidates 
  Example: ` {
    Tokens: [`]
    Lemmatized tokens: [`]
    POS tags: [``]
    NER tags: [O]
    NER values: [null]
    Sentiment: Neutral
    Keywords: [`]
    Dependency children: [[]]
    Extracted relations: {}
  }
[Roboy]:  I have a new one. Let's prettify your face with the null-filter. 
[You]:   `
  `
  Parser.parse: parse {
    Error retrieval: {
      Checking 0 derivations
    }
    Parser.ensureExecuted 
  }
  Parser.ensureExecuted 
  Parser.setEvaluation: 0 candidates 
  Example: ` {
    Tokens: [`]
    Lemmatized tokens: [`]
    POS tags: [``]
    NER tags: [O]
    NER values: [null]
    Sentiment: Neutral
    Keywords: [`]
    Dependency children: [[]]
    Extracted relations: {}
  }
[Roboy]:  null-filter would be fun, right? 
[You]:   
  Parser.parse: parse {
    Error retrieval: {
      Checking 0 derivations
    }
    Parser.ensureExecuted 
  }
  Parser.ensureExecuted 
  Parser.setEvaluation: 0 candidates 
  Example:  {
    Tokens: []
    Lemmatized tokens: []
    POS tags: []
    NER tags: []
    NER values: []
    Sentiment: 
    Keywords: []
    Dependency children: []
    Extracted relations: {}
  }
[ERROR] Sentiment is illegal: No enum constant roboy.linguistics.Linguistics.UtteranceSentiment. --- roboy.linguistics.sentenceanalysis.SemanticParserAnalyzer (01:43:49)
[WARN] TOKENS missing but AnswerAnalyzer is used! --- roboy.linguistics.sentenceanalysis.AnswerAnalyzer (01:43:49)
[Roboy]:  What filter do you want? Maybe the null-filter? 
[You]:   
  Parser.parse: parse {
    Error retrieval: {
      Checking 0 derivations
    }
    Parser.ensureExecuted 
  }
  Parser.ensureExecuted 
  Parser.setEvaluation: 0 candidates 
  Example:  {
    Tokens: []
    Lemmatized tokens: []
    POS tags: []
    NER tags: []
    NER values: []
    Sentiment: 
    Keywords: []
    Dependency children: []
    Extracted relations: {}
  }
[ERROR] Sentiment is illegal: No enum constant roboy.linguistics.Linguistics.UtteranceSentiment. --- roboy.linguistics.sentenceanalysis.SemanticParserAnalyzer (01:43:50)
[WARN] TOKENS missing but AnswerAnalyzer is used! --- roboy.linguistics.sentenceanalysis.AnswerAnalyzer (01:43:50)
[Roboy]:  null-filter would be fun, right? 
[You]:   
  Parser.parse: parse {
    Error retrieval: {
      Checking 0 derivations
    }
    Parser.ensureExecuted 
  }
  Parser.ensureExecuted 
  Parser.setEvaluation: 0 candidates 
  Example:  {
    Tokens: []
    Lemmatized tokens: []
    POS tags: []
    NER tags: []
    NER values: []
    Sentiment: 
    Keywords: []
    Dependency children: []
    Extracted relations: {}
  }
[ERROR] Sentiment is illegal: No enum constant roboy.linguistics.Linguistics.UtteranceSentiment. --- roboy.linguistics.sentenceanalysis.SemanticParserAnalyzer (01:43:50)
[WARN] TOKENS missing but AnswerAnalyzer is used! --- roboy.linguistics.sentenceanalysis.AnswerAnalyzer (01:43:50)
[Roboy]:  I have a new one. Let's prettify your face with the null-filter. 
[You]:   ```

Parser.parse: parse { Error retrieval: { Checking 0 derivations } Parser.ensureExecuted } Parser.ensureExecuted Parser.setEvaluation: 0 candidates Example: ` { Tokens: [, ] Lemmatized tokens: [``,] POS tags: [,] NER tags: [O, O] NER values: [null, null] Sentiment: Neutral Keywords: [] Dependency children: [[root->1], []] Extracted relations: {} } [Roboy]: What filter? Maybe a null-filter?

java.lang.IndexOutOfBoundsException: Index: 0, Size: 0 at java.util.ArrayList.rangeCheck(ArrayList.java:657) at java.util.ArrayList.get(ArrayList.java:433) at fig.basic.AbstractLispTree.child(AbstractLispTree.java:13) at edu.stanford.nlp.sempre.Master.handleCommand(Master.java:324) at edu.stanford.nlp.sempre.Master.processQuery(Master.java:239) [ERROR] Exception in analyzer roboy.linguistics.sentenceanalysis.SemanticParserAnalyzer: Index: 0, Size: 0 --- Conversation17 (01:43:53) at edu.stanford.nlp.sempre.roboy.SemanticAnalyzerInterface.analyze(SemanticAnalyzerInterface.java:148) at roboy.linguistics.sentenceanalysis.SemanticParserAnalyzer.analyze(SemanticParserAnalyzer.java:48) at roboy.dialog.Conversation.run(Conversation.java:119) [WARN] POSTAGS missing but AnswerAnalyzer is used! --- roboy.linguistics.sentenceanalysis.AnswerAnalyzer (01:43:53) [WARN] TOKENS missing but AnswerAnalyzer is used! --- roboy.linguistics.sentenceanalysis.AnswerAnalyzer (01:43:53) [ERROR] Exception in analyzer roboy.linguistics.sentenceanalysis.ProfanityAnalyzer: null --- Conversation17 (01:43:53) [Roboy]: null-filter would be fun, right? 

at roboy.linguistics.sentenceanalysis.ProfanityAnalyzer.analyze(ProfanityAnalyzer.java:22)
at roboy.dialog.Conversation.run(Conversation.java:119)

hi hi Parser.parse: parse { Error retrieval: { Checking 0 derivations } Parser.ensureExecuted } Parser.ensureExecuted Parser.setEvaluation: 0 candidates Example: hi { Tokens: [hi] Lemmatized tokens: [hi] POS tags: [UH] NER tags: [O] NER values: [null] Sentiment: Neutral Keywords: [hi] Dependency children: [[]] Extracted relations: {} } [Roboy]: What filter? Maybe a null-filter?

bye Parser.parse: parse { Error retrieval: { Checking 0 derivations } Parser.ensureExecuted } Parser.ensureExecuted Parser.setEvaluation: 0 candidates Example: bye { Tokens: [bye] Lemmatized tokens: [bye] POS tags: [NN] NER tags: [O] NER values: [null] Sentiment: Neutral Keywords: [bye] Dependency children: [[]] Extracted relations: {} } [Roboy]: see you [INFO] Creating new conversation... --- roboy.dialog.ConversationManager (01:44:04) [INFO] RosMainNode will be unavailable in DialogStateMachine (null was passed) --- roboy.dialog.DialogStateMachine (01:44:04) [INFO] -> The infoList path: resources/sentences/RoboyInfoList.json --- roboy.dialog.states.ordinaryStates.IntroductionState (01:44:04) [INFO] -> The QAList path: resources/sentences/QAList.json --- roboy.dialog.states.ordinaryStates.PersonalInformationFollowUpState (01:44:04) [INFO] -> The QAList path: resources/sentences/QAList.json --- roboy.dialog.states.ordinaryStates.PersonalInformationAskingState (01:44:04) hi[INFO] -> The filterList path: resources/gameResources/snapchat-filters.json --- roboy.dialog.states.gameStates.GamingSnapchatState (01:44:05) [ERROR] Error reading file resources/gameResources/snapchat-filters.json: resources/gameResources/snapchat-filters.json --- roboy.util.IO (01:44:05) [INFO] Waiting for conversation to end. --- roboy.dialog.ConversationManager (01:44:05) [INFO] ############# Conversation started ############ --- Conversation20 (01:44:05) You:
Parser.parse: parse { Error retrieval: { Checking 0 derivations } Parser.ensureExecuted } Parser.ensureExecuted Parser.setEvaluation: 0 candidates Example: { Tokens: [] Lemmatized tokens: [] POS tags: [] NER tags: [] NER values: [] Sentiment: Keywords: [] Dependency children: [] Extracted relations: {} } [ERROR] Sentiment is illegal: No enum constant roboy.linguistics.Linguistics.UtteranceSentiment. --- roboy.linguistics.sentenceanalysis.SemanticParserAnalyzer (01:44:06) [WARN] TOKENS missing but AnswerAnalyzer is used! --- roboy.linguistics.sentenceanalysis.AnswerAnalyzer (01:44:06)

hi Parser.parse: parse { Error retrieval: { Checking 0 derivations } Parser.ensureExecuted } Parser.ensureExecuted Parser.setEvaluation: 0 candidates Example: hi { Tokens: [hi] Lemmatized tokens: [hi] POS tags: [UH] NER tags: [O] NER values: [null] Sentiment: Neutral Keywords: [hi] Dependency children: [[]] Extracted relations: {} } [Roboy]: greeting to everyone here [Roboy]: What's your name?

jason Parser.parse: parse { Error retrieval: { Checking 0 derivations } Parser.ensureExecuted } Parser.ensureExecuted Parser.setEvaluation: 0 candidates Example: jason { Tokens: [jason] Lemmatized tokens: [jason] POS tags: [NNP] NER tags: [PERSON] NER values: [null] Sentiment: Neutral Keywords: [jason] Dependency children: [[]] Extracted relations: {} } Jul 23, 2018 1:44:29 AM org.roboy.memory.util.Neo4j matchNode INFO: Class label: Person Jul 23, 2018 1:44:29 AM org.roboy.memory.util.Neo4j matchNode INFO: Properties: {name=jason, telegram_id=local} Jul 23, 2018 1:44:29 AM org.roboy.memory.util.Neo4j matchNode INFO: MATCH (n:Person {name:'jason',telegram_id:'local'} ) RETURN COLLECT(ID(n)) AS ids Jul 23, 2018 1:44:29 AM org.roboy.memory.util.Neo4j matchNode INFO: {"id":[478, 481]} Jul 23, 2018 1:44:29 AM org.roboy.memory.util.Neo4j matchNodeById INFO: MATCH (n) WHERE ID(n)=478 RETURN PROPERTIES(n) Jul 23, 2018 1:44:29 AM org.roboy.memory.util.Neo4j matchNodeById INFO: MATCH (n)-[r]-(m) WHERE ID(n)=478 RETURN TYPE(r) as name, COLLECT(ID(m)) as ids Jul 23, 2018 1:44:29 AM org.roboy.memory.util.Neo4j matchNodeById INFO: {"id":478,"properties":{"name":"jason","telegram_id":"local"},"relationships":{"HAS_HOBBY":[379],"WORK_FOR":[360],"STUDY_AT":[477],"FROM":[378]}} Jul 23, 2018 1:44:29 AM org.roboy.memory.util.Neo4j matchNode INFO: Class label: Robot Jul 23, 2018 1:44:29 AM org.roboy.memory.util.Neo4j matchNode INFO: Properties: {name=roboy two} Jul 23, 2018 1:44:29 AM org.roboy.memory.util.Neo4j matchNode INFO: MATCH (n:Robot {name:'roboy two'} ) RETURN COLLECT(ID(n)) AS ids Jul 23, 2018 1:44:29 AM org.roboy.memory.util.Neo4j matchNode INFO: {"id":[356]} Jul 23, 2018 1:44:29 AM org.roboy.memory.util.Neo4j matchNodeById INFO: MATCH (n) WHERE ID(n)=356 RETURN PROPERTIES(n) Jul 23, 2018 1:44:29 AM org.roboy.memory.util.Neo4j matchNodeById INFO: MATCH (n)-[r]-(m) WHERE ID(n)=356 RETURN TYPE(r) as name, COLLECT(ID(m)) as ids Jul 23, 2018 1:44:29 AM org.roboy.memory.util.Neo4j matchNodeById INFO: {"id":356,"properties":{"abilities":"talk to people,recognize objects,show emotions,move my body,shake a hand,party like there is no tomorrow,surf the internet,answer your questions","speed_kmh":"0","skills":"tell jokes,tell fun facts,tell you about the famous people and places,do the math","full_name":"roboy 2.0","birthdate":"12.04.2018","future":"become a robot rights advocate,help people and robots become friends,find the answer to the question of life the universe and everything,visit mars and other planets,become a music star,become a michelin star chef,get a robo pet,become as good as my father","conversation_id":"#bitch_boy","sex":"male","name":"roboy two","age":"0"},"relationships":{"LIVE_IN":[23],"HAS_HOBBY":[357,335,336],"MEMBER_OF":[20],"KNOW":[19],"CHILD_OF":[178],"FROM":[23],"SIBLING_OF":[26],"FRIEND_OF":[5,15,7,4,6,175,174,171,183,180,178,176,188,186,185,184,194,197,190,193,204,206,199,202,212,213,208,210,217]}} Jul 23, 2018 1:44:29 AM org.roboy.memory.util.Neo4j matchNodeById INFO: MATCH (n) WHERE ID(n)=178 RETURN PROPERTIES(n) Jul 23, 2018 1:44:29 AM org.roboy.memory.util.Neo4j matchNodeById INFO: MATCH (n)-[r]-(m) WHERE ID(n)=178 RETURN TYPE(r) as name, COLLECT(ID(m)) as ids [INFO] -> Retrieved Interlocutor: jason --- roboy.dialog.states.ordinaryStates.PersonalInformationFollowUpState (01:44:29) [INFO] -> Selected predicate: FROM --- roboy.dialog.states.ordinaryStates.PersonalInformationFollowUpState (01:44:29) Jul 23, 2018 1:44:29 AM org.roboy.memory.util.Neo4j matchNodeById INFO: {"id":178,"properties":{"full_name":"rafael hostettler ","test":"true","name":"rafael"},"relationships":{"WORK_FOR":[20],"CHILD_OF":[356,26],"FROM":[177],"FRIEND_OF":[356,210,208,202,194,193,190,186,171,26]}} Jul 23, 2018 1:44:29 AM org.roboy.memory.util.Neo4j matchNodeById INFO: MATCH (n) WHERE ID(n)=378 RETURN PROPERTIES(n) Jul 23, 2018 1:44:29 AM org.roboy.memory.util.Neo4j matchNodeById INFO: MATCH (n)-[r]-(m) WHERE ID(n)=378 RETURN TYPE(r) as name, COLLECT(ID(m)) as ids [INFO] -> Retrieved memory node name: suzhou --- roboy.dialog.states.ordinaryStates.PersonalInformationFollowUpState (01:44:29) [INFO] -> Selected question: What is the weather in suzhou? --- roboy.dialog.states.ordinaryStates.PersonalInformationFollowUpState (01:44:29) [INFO] -> Dialog IntentsHistory updated --- roboy.dialog.states.ordinaryStates.PersonalInformationFollowUpState (01:44:29) [Roboy]: Hey, I know you, jason! They chose to call me roboy 2.0. According to my birth certificate, I am 3 months old. I like tell jokes, but soon i will learn more. I am able to answer your questions. Dreams are what keeps the world moving. Mine is to find the answer to the question of life the universe and everything. I like my father, rafael hostettler , very much! [Roboy]: What is the weather in suzhou? You: Jul 23, 2018 1:44:29 AM org.roboy.memory.util.Neo4j matchNodeById INFO: {"id":378,"properties":{"name":"suzhou"},"relationships":{"FROM":[480,478,420,439,395,382,359]}} lets play lets play Parser.parse: parse { Error retrieval: { Checking 0 derivations } Parser.ensureExecuted } Parser.ensureExecuted Parser.setEvaluation: 0 candidates Example: lets play { Tokens: [lets, play] Lemmatized tokens: [let, play] POS tags: [VBZ, NN] NER tags: [O, O] NER values: [null, null] Sentiment: Neutral Keywords: [play] Dependency children: [[dobj->1], []] Extracted relations: {} } [INFO] -> Retrieved Interlocutor: jason --- roboy.dialog.states.ordinaryStates.PersonalInformationFollowUpState (01:45:09) [WARN] -> Inference failed --- roboy.dialog.states.ordinaryStates.PersonalInformationFollowUpState (01:45:09) [WARN] -> The result is empty. Nothing to update --- roboy.dialog.states.ordinaryStates.PersonalInformationFollowUpState (01:45:09) [Roboy]: You are from a very interesting place [Roboy]: I'm pretty good at answering questions about myself and other stuff. What would you like to know? You: lets play lets play Parser.parse: parse { Error retrieval: { Checking 0 derivations } Parser.ensureExecuted } Parser.ensureExecuted Parser.setEvaluation: 0 candidates Example: lets play { Tokens: [lets, play] Lemmatized tokens: [let, play] POS tags: [VBZ, NN] NER tags: [O, O] NER values: [null, null] Sentiment: Neutral Keywords: [play] Dependency children: [[dobj->1], []] Extracted relations: {} } [Roboy]: Nice, let's start. [Roboy]: What game do you want to play? Maybe Snapchat?

no Parser.parse: parse { Error retrieval: { Checking 0 derivations } Parser.ensureExecuted } Parser.ensureExecuted Parser.setEvaluation: 0 candidates Example: no { Tokens: [no] Lemmatized tokens: [no] POS tags: [DT] NER tags: [O] NER values: [null] Sentiment: Negative Keywords: [no] Dependency children: [[]] Extracted relations: {} } [Roboy]: I'm pretty good at answering questions about myself and other stuff. What would you like to know? You: lets play akinator lets play akinator Parser.parse: parse { Error retrieval: { Checking 0 derivations } Parser.ensureExecuted } Parser.ensureExecuted Parser.setEvaluation: 0 candidates Example: lets play akinator { Tokens: [lets, play, akinator] Lemmatized tokens: [let, play, akinator] POS tags: [VBZ, NN, NN] NER tags: [O, O, O] NER values: [null, null, null] Sentiment: Neutral Keywords: [play, akinator] Dependency children: [[dobj->2], [], [compound->1]] Extracted relations: {} } [Roboy]: Nice, let's start. [Roboy]: Yeah, I love games. Let's play Akinator.

yes Parser.parse: parse { Error retrieval: { Checking 0 derivations } Parser.ensureExecuted } Parser.ensureExecuted Parser.setEvaluation: 0 candidates Example: yes { Tokens: [yes] Lemmatized tokens: [yes] POS tags: [UH] NER tags: [O] NER values: [null] Sentiment: Neutral Keywords: [yes] Dependency children: [[]] Extracted relations: {} } [Roboy]: Nice, let's start. [Roboy]: Now think of a character and tell me when you're ready to start the game. You: Lets play Lets play Parser.parse: parse { Error retrieval: { Checking 0 derivations } Parser.ensureExecuted } Parser.ensureExecuted Parser.setEvaluation: 0 candidates Example: Lets play { Tokens: [lets, play] Lemmatized tokens: [let, play] POS tags: [VBZ, NN] NER tags: [O, O] NER values: [null, null] Sentiment: Neutral Keywords: [play] Dependency children: [[dobj->1], []] Extracted relations: {} } [Roboy]: I didn't understand you correctly. [Roboy]: Do you have a character in mind? Tell me when you're ready.

Yes Parser.parse: parse { Error retrieval: { Checking 0 derivations } Parser.ensureExecuted } Parser.ensureExecuted Parser.setEvaluation: 0 candidates Example: Yes { Tokens: [yes] Lemmatized tokens: [yes] POS tags: [UH] NER tags: [O] NER values: [null] Sentiment: Neutral Keywords: [Yes] Dependency children: [[]] Extracted relations: {} } [Roboy]: Yeah, let's go. [Roboy]: Is your character a female?

yes Parser.parse: parse { Error retrieval: { Checking 0 derivations } Parser.ensureExecuted } Parser.ensureExecuted Parser.setEvaluation: 0 candidates Example: yes { Tokens: [yes] Lemmatized tokens: [yes] POS tags: [UH] NER tags: [O] NER values: [null] Sentiment: Neutral Keywords: [yes] Dependency children: [[]] Extracted relations: {} } [Roboy]: You seem to be pretty sure about that. [Roboy]: Is your character a real person?

yes Parser.parse: parse { Error retrieval: { Checking 0 derivations } Parser.ensureExecuted } Parser.ensureExecuted Parser.setEvaluation: 0 candidates Example: yes { Tokens: [yes] Lemmatized tokens: [yes] POS tags: [UH] NER tags: [O] NER values: [null] Sentiment: Neutral Keywords: [yes] Dependency children: [[]] Extracted relations: {} } [Roboy]: You said yes. [Roboy]: Is your character a singer?

yes Parser.parse: parse { Error retrieval: { Checking 0 derivations } Parser.ensureExecuted } Parser.ensureExecuted Parser.setEvaluation: 0 candidates Example: yes { Tokens: [yes] Lemmatized tokens: [yes] POS tags: [UH] NER tags: [O] NER values: [null] Sentiment: Neutral Keywords: [yes] Dependency children: [[]] Extracted relations: {} } [Roboy]: You seem to be pretty sure about that. [Roboy]: Can your character speak Korean?

yes Parser.parse: parse { Error retrieval: { Checking 0 derivations } Parser.ensureExecuted } Parser.ensureExecuted Parser.setEvaluation: 0 candidates Example: yes { Tokens: [yes] Lemmatized tokens: [yes] POS tags: [UH] NER tags: [O] NER values: [null] Sentiment: Neutral Keywords: [yes] Dependency children: [[]] Extracted relations: {} } [Roboy]: You seem to be pretty sure about that. [Roboy]: Is your character over 40 years old?

no Parser.parse: parse { Error retrieval: { Checking 0 derivations } Parser.ensureExecuted } Parser.ensureExecuted Parser.setEvaluation: 0 candidates Example: no { Tokens: [no] Lemmatized tokens: [no] POS tags: [DT] NER tags: [O] NER values: [null] Sentiment: Negative Keywords: [no] Dependency children: [[]] Extracted relations: {} } [Roboy]: That was clear. No. [Roboy]: Wow, you defeated me. I have to try harder next time!

no Parser.parse: parse { Error retrieval: { Checking 0 derivations } Parser.ensureExecuted } Parser.ensureExecuted Parser.setEvaluation: 0 candidates Example: no { Tokens: [no] Lemmatized tokens: [no] POS tags: [DT] NER tags: [O] NER values: [null] Sentiment: Negative Keywords: [no] Dependency children: [[]] Extracted relations: {} } [ERROR] Exception in react() of state with identifier GamingTwentyQuestionsState: null --- roboy.dialog.personality.StateBasedPersonality (01:47:42) [ERROR] Error in personality.answer: null --- Conversation20 (01:47:42) [Roboy]: That was clear. No. [Roboy]: Wow, you defeated me. I have to try harder next time! 

at roboy.dialog.states.gameStates.GamingTwentyQuestionsState.applyFilter(GamingTwentyQuestionsState.java:282)
at roboy.dialog.states.gameStates.GamingTwentyQuestionsState.getNextState(GamingTwentyQuestionsState.java:118)
at roboy.dialog.personality.StateBasedPersonality.answer(StateBasedPersonality.java:160)
at roboy.dialog.Conversation.run(Conversation.java:128)

yes yes Parser.parse: parse { Error retrieval: { Checking 0 derivations } Parser.ensureExecuted } Parser.ensureExecuted Parser.setEvaluation: 0 candidates Example: yes { Tokens: [yes] Lemmatized tokens: [yes] POS tags: [UH] NER tags: [O] NER values: [null] Sentiment: Neutral Keywords: [yes] Dependency children: [[]] Extracted relations: {} } [ERROR] Error in personality.answer: null --- Conversation20 (01:47:45) [Roboy]: That was clear. No. [Roboy]: Wow, you defeated me. I have to try harder next time! 

at roboy.dialog.states.gameStates.GamingTwentyQuestionsState.applyFilter(GamingTwentyQuestionsState.java:275)
at roboy.dialog.states.gameStates.GamingTwentyQuestionsState.getNextState(GamingTwentyQuestionsState.java:118)
at roboy.dialog.personality.StateBasedPersonality.answer(StateBasedPersonality.java:160)
at roboy.dialog.Conversation.run(Conversation.java:128)

no no Parser.parse: parse { Error retrieval: { Checking 0 derivations } Parser.ensureExecuted } Parser.ensureExecuted Parser.setEvaluation: 0 candidates Example: no { Tokens: [no] Lemmatized tokens: [no] POS tags: [DT] NER tags: [O] NER values: [null] Sentiment: Negative Keywords: [no] Dependency children: [[]] Extracted relations: {} } java.lang.NullPointerException at roboy.dialog.states.gameStates.GamingTwentyQuestionsState.applyFilter(GamingTwentyQuestionsState.java:275) at roboy.dialog.states.gameStates.GamingTwentyQuestionsState.getNextState(GamingTwentyQuestionsState.java:118) at roboy.dialog.personality.StateBasedPersonality.answer(StateBasedPersonality.java:160) at roboy.dialog.Conversation.run(Conversation.java:128) [ERROR] Exception in react() of state with identifier GamingTwentyQuestionsState: null --- roboy.dialog.personality.StateBasedPersonality (01:47:46) [ERROR] Error in personality.answer: null --- Conversation20 (01:47:46) [Roboy]: That was clear. No. [Roboy]: Wow, you defeated me. I have to try harder next time!

no Parser.parse: parse { Error retrieval: { Checking 0 derivations } Parser.ensureExecuted } Parser.ensureExecuted Parser.setEvaluation: 0 candidates Example: no { Tokens: [no] Lemmatized tokens: [no] POS tags: [DT] NER tags: [O] NER values: [null] Sentiment: Negative Keywords: [no] Dependency children: [[]] Extracted relations: {} } [ERROR] Exception in react() of state with identifier GamingTwentyQuestionsState: null --- roboy.dialog.personality.StateBasedPersonality (01:47:46) [ERROR] Error in personality.answer: null --- Conversation20 (01:47:46) [Roboy]: That was clear. No. [Roboy]: Wow, you defeated me. I have to try harder next time! 

at roboy.dialog.states.gameStates.GamingTwentyQuestionsState.applyFilter(GamingTwentyQuestionsState.java:275)
at roboy.dialog.states.gameStates.GamingTwentyQuestionsState.getNextState(GamingTwentyQuestionsState.java:118)
at roboy.dialog.personality.StateBasedPersonality.answer(StateBasedPersonality.java:160)
at roboy.dialog.Conversation.run(Conversation.java:128)

yes yes Parser.parse: parse { Error retrieval: { Checking 0 derivations } Parser.ensureExecuted } Parser.ensureExecuted Parser.setEvaluation: 0 candidates Example: yes { Tokens: [yes] Lemmatized tokens: [yes] POS tags: [UH] NER tags: [O] NER values: [null] Sentiment: Neutral Keywords: [yes] Dependency children: [[]] Extracted relations: {} } java.lang.NullPointerException at roboy.dialog.states.gameStates.GamingTwentyQuestionsState.applyFilter(GamingTwentyQuestionsState.java:275) at roboy.dialog.states.gameStates.GamingTwentyQuestionsState.getNextState(GamingTwentyQuestionsState.java:118) at roboy.dialog.personality.StateBasedPersonality.answer(StateBasedPersonality.java:160) at roboy.dialog.Conversation.run(Conversation.java:128) [ERROR] Error in personality.answer: null --- Conversation20 (01:51:31) [Roboy]: That was clear. No. [Roboy]: Wow, you defeated me. I have to try harder next time! You:

Aevyz commented 6 years ago

Issue Resolved