Giter Club home page Giter Club logo

roboy_dialog's Introduction

Roboy Dialog System

Documentation Status

What is this Project

Roboy says hi!

This repository contains a dialog system developed for the humanoid robot Roboy. One can find more information about this project through its documentation.

Installation Guide

Requirements

  • Apache Maven
  • Java 8 (Oracle is preferred)
  • ruby (1.8.7 or 1.9 advised)
  • git
  • Neo4J
  • wget
  • make
  • zip
  • Working Internet Connection for downloading dependencies!

Make sure that you are using Java 1.8 both for java and javac ! You can check this by running

javac -version
java -version

Recommendations

  • Intellij IDEA
  • At least 8GB of RAM
  • At least 6GB of Disk Space
    • ~ 4GB for Maven Dependencies
    • ~ 500MB for Roboy_Dialog with all sub-modules and files generated via mvn clean install
    • Rest is a ballpark estimate for Neo4J, Redis, ROS and their dependencies
  • Ubuntu (or variation) 16.04 LTS or Mac OSX
    • Needed for ROS Kinetic
    • If you do not need ROS features, any version of Linux should do

Command Line Installation Instructions

Assumes you have already set up Neo4j.

# Install Maven, Java, Docker and other programs needed (installing openJDK because of simplicity)
sudo apt-get install maven openjdk-8-jdk git docker.io make wget zip ruby
# Download and Run Neo4J with Docker
sudo docker run --publish=7474:7474 --publish=7687:7687 --volume=$HOME/neo4j/data:/data --volume=$HOME/neo4j/logs:/logs neo4j:3.0
# Clone Dialog's Master Branch (replace master with devel for other branches)
git clone https://github.com/Roboy/roboy_dialog --recursive -b master
# Change Directory to your new clone
cd roboy_dialog
# Download Dependencies and Install
mvn clean install
# Use this to Start Dialog
./start.sh

Running Neo4J's Docker Image as Non-Root

See here for more information.

Installation without Neo4J Tests

If you do not require Neo4J, or otherwise wish to prevent Neo4J-dependent tests execute (ie. situations with no internet connection and only remote instance setup), you can have the Neo4J tests ignored, by simply appending -D neo4jtest=false to your maven command.

Example: mvn clean install -D neo4jtest=false, mvn test -D neo4jtest=false

This will disable roboy_memory's org.roboy.memory.util.Neo4jTest & dialog's roboy.memory.MemoryIntegrationTest, since both require an active Neo4J database instance.

IDE Installation Instructions

Clone the Dialog Manager repository either using your IDE's VCS Tools or using the command line. git clone --recursive https://github.com/Roboy/roboy_dialog

Attention: Make sure that the git sub-modules are initialized!

  1. Import Dialog System as a Maven project into the IDE
  2. Download the Maven Dependencies
  3. Execute roboy.dialog.ConversationManager as the main class.

Do not forget to start Neo4J!

Environment Variables

You need to set environment variables to tell roboy_dialog where Neo4j, ROS (optional) and Redis (optional) are located. In most cases, it will suffice just to set the Neo4J variables. Just add the export VARIABLE=value statements to your $HOME/.bashrc.

Since all of these dependencies are actually required by roboy_memory, you can find more detailed installation instructions in the memory docs.

Neo4j

The dialog system's memory module uses Neo4j, a graph database which stores relations between enttities observed by roboy (names, hobbies, locations etc.).Therefore, make sure to set the following environment variables to meaningful values:

export NEO4J_ADDRESS=bolt://NEO4J-ADDRESS-GOES-HERE:7687
export NEO4J_USERNAME=user
export NEO4J_PASSWORD=pass

If no remote development instance of Neo4j is available, just run Neo4j in a docker container. For more options and additional information, refer to docs/Usage in the memory module.

sudo docker run \
    --publish=7474:7474 --publish=7687:7687 \
    --volume=$HOME/neo4j/data:/data \
    --volume=$HOME/neo4j/logs:/logs \
    neo4j:3.0

ROS-master

Note: Running ROS is only necessary when running roboy_dialog within the Roboy architecture. Otherwise, you may also set ROS_ENABLED: false in config.properties.

Dialog is tied into the Roboy architecture as a ROS node. Therefore, make sure to set the following environment variables to meaningful values:

export ROS_HOSTNAME=local-hostname
export ROS_MASTER_URI=http://rosmaster:11311

If no remote development instance of ROS master is available, just run roscore in a docker container.

Redis

Redis is a software used for facial feature-storage on a remote server. In most cases, you can simply ignore this, as the average project does not need this.

export REDIS_URI="***"
export REDIS_PASSWORD="***"

Running the Dialog System

Once the Neo4j (and ROS) dependencies are satisfied, run the dialog system via ...

./start.sh

If everything is running and configured correctly, you should be able to have a basic conversation like following

Roboy says hi!

Running NLU only

java -Xmx6g -d64 -cp \
    nlu/parser/target/roboy-parser-2.0.0-jar-with-dependencies.jar \
    edu.stanford.nlp.sempre.roboy.SemanticAnalyzerInterface.java

Using the Google Word2Vec Model in NLU

For a more complete but also much more memory-intensive Word Vector model, the NLU module has the ability to parse the GoogleNews word vector collection, which can be retrieved from here.

In order to use it, store and extract it under resources_nlu/word2vec. Then just set WORD2VEC_GOOGLE: true in parser.properties.

Configuration of roboy_dialog

One is able to customize the modules that are enabled, when dialog starts. One does this by altering the options in config.properties. For more details, see the [detailed documentation page](https://roboydialog.readthedocs.io/en/devel/user_manual/2_configuration.html#configuration

Logging Levels

One can configure the amount of logging one gets from memory, dialog and parser individually. It is recommended that...

User Type Dialog Parser Memory
Developer DEBUG DEBUG FINE
Regular User INFO INFO INFO

If you wish to have more detailed information, please view the docs page.

Enabling External APIs

If you want to set external APIs, you will have to create an APIkeys.yml file containing all the keys. For more information, see the relevant documentation page

Troubleshooting

See the Troubleshooting Page

roboy_dialog's People

Contributors

aevyz avatar alexmoroz avatar byteofprash avatar delevio avatar emlozin avatar josephbirkner avatar l-laura avatar letrend avatar mireu avatar missxa avatar nbasargin avatar ninalovegood avatar pblohm avatar sezercan avatar subscriber01 avatar waguramu avatar

Stargazers

 avatar  avatar  avatar  avatar  avatar  avatar  avatar  avatar

Watchers

 avatar  avatar  avatar  avatar  avatar  avatar  avatar  avatar  avatar  avatar  avatar  avatar  avatar

roboy_dialog's Issues

New Nodes created when existing Data should be used

With the new Devel merging, Dialog creates new nodes instead of using existing nodes. This is obviously completely wrong. Bad! Roboy is confused and runs all the questions again. Sad!

Recreation Steps

  1. Hi
  2. Name: Jason (or someones name who currently exists)
  3. Now there are two Jason's in Memory

Expected Behavior

  1. Uses Existing nodes and updates existing node, or...
  2. Create new nodes only for nodes created via telegram

Current Behavior

New Node created, essentially invalidating the entire database. Every single question will have to be reasked

Questions are not parsed correctly

Example: "Could you play a game", semantic parser returns failure, object answer is the whole sentence

Expected: parser_result="SUCCESS", sem_triple=(subject:Roboy, predicate:ability, object:game), OBJ_ANSWER="game"

The user should be able to ask roboy if he can play a game, then he suggests possible games.

Exit akinator game on request

If the user gets bored and doesnt want to play a game anymore, it should be possible to exit the state at any point of conversation

Dialog hanging with no Internet connection

When having roboy.dialog.states.ordinaryStates.QuestionAnsweringState in the personality file (even is no transitions to it are defined) the conversation won't start if there's no internet connection, since apparently the state is trying to resolve some http host forever.

Fix 20 Question Game State from crashing setup when installed

Specifically this line appears not to work w/o Internet and crashes the whole setup.

private Akiwrapper aw = new AkiwrapperBuilder().setFilterProfanity(true).build();

This leads to:

Exception in thread "main" java.lang.RuntimeException: State with identifier GamingTwentyQuestionsState is missing!
	at roboy.dialog.DialogStateMachine.parseAndSetTransitionsAndFallbacks(DialogStateMachine.java:392)
	at roboy.dialog.DialogStateMachine.loadFromJSON(DialogStateMachine.java:315)
	at roboy.dialog.DialogStateMachine.loadFromFile(DialogStateMachine.java:262)
	at roboy.dialog.Conversation.<init>(Conversation.java:61)
	at roboy.dialog.ConversationManager.createConversation(ConversationManager.java:222)
	at roboy.dialog.ConversationManager.main(ConversationManager.java:118)

Things to Fix:

  • Launching State Exception No need for exception due to refactor
  • Optional: If connection lost, quit game Not possible

Future of Context

Context is used to store non-permanent or changing information like dialog intents or face coordinates. The current implementation is a singleton and was not designed to support multiple conversations (in a sequence or at the same time). This leads to some problems like:

  • states can not assume that context data comes from the current conversation
  • with concurrent conversations, one conversation can read and change data of another one
  • Context can be accesses from anywhere, even from code that shouldn't be allowed to touch it

We have to come up with a solution for those problems in order to support multiple conversations. A use case for multiple conversations is a chat bot for Telegram.

One of possible solutions would be to create a new Context for every conversation.

Update readme

Requirements for the readme on GitHub:

  • should explain all steps to get the system running
  • even an inexperienced student (2nd/3rd semester) should be able to understand and follow it
  • should not contain architecture description (this goes to readthedocs)
  • should contain a link to readthedocs

Following should be in the roboy_dialog readme:

  • Link to readthedocs
  • How much HDD space is required to install the complete system + dependencies?
  • What dependencies are optional (like ROS) and when do we really need them?
  • List of all commands I have to type into the terminal to get the dependencies (sudo apt install XXX)
  • List of steps needed to install Neo4J locally (or a link to another readme/readthedocs)
    • What type of installation is preferred (docker/native)?
    • How to install using docker?
    • How to get the docker container that contains an empty database?
    • How to get the docker container that contains a pre-filled database?
    • How to set all relevant environment variables?
  • What options are important and should be set in the config file?
  • What to expect when the system is running (long parser loading? tons of weird logging output? ...)
  • What OS is recommended (Ubuntu 16)?
  • How to run the dialog ...
    • ... from command line
    • ... from the IDE
  • What dependencies must be installed (like maven, ruby etc.)?
  • In which directory should the user type mvn clean install
    (surprise, "in the directory containing pom.xml" won't do, we have many poms)
  • How to correctly clone the roboy_dialog repo
    (surprise, just git clone won't do because of submodules)
  • What IDE is recommended (IntelliJ)?
  • How much RAM is needed to run the system?

AnswerAnalyzer returns capitalized tokens instead of lowercase tokens.

roboy.linguistics.sentenceanalysis.AnswerAnalyzer.analyze(sentence) returns capitalized attributes inside the interpretation.

Observed in: AnswerAnalyzerTest

Description: AnswerAnalyzerTest analyzes sentences through ->SimpleTokenizer->OpenNLPPPOSTagger->OpenNLPParser->AnswerAnalyzer and checks if specific attributes are equal to the expected outcomes of the analyze-operation. These are provided in capitalized form ('Robot') but should be provided in lowercase form ('robot').

roboy.linguistics.sentenceanalysis.DictionaryBasedSentenceTypeDetectorTest failing

Running roboy.linguistics.sentenceanalysis.DictionaryBasedSentenceTypeDetectorTest
Tests run: 1, Failures: 0, Errors: 1, Skipped: 0, Time elapsed: 0.001 sec <<< FAILURE! - in roboy.lin
guistics.sentenceanalysis.DictionaryBasedSentenceTypeDetectorTest
testWhatIs(roboy.linguistics.sentenceanalysis.DictionaryBasedSentenceTypeDetectorTest)  Time elapsed:
 0 sec  <<< ERROR!
java.lang.NullPointerException: null
        at roboy.linguistics.sentenceanalysis.DictionaryBasedSentenceTypeDetector.determineSentenceTy
pe(DictionaryBasedSentenceTypeDetector.java:22)
        at roboy.linguistics.sentenceanalysis.DictionaryBasedSentenceTypeDetector.analyze(DictionaryB
asedSentenceTypeDetector.java:16)
        at roboy.linguistics.sentenceanalysis.DictionaryBasedSentenceTypeDetectorTest.testWhatIs(DictionaryBasedSentenceTypeDetectorTest.java:16)

Akinator Null Point Exception at End

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

Create a way for Roboy to start a conversation again

Recreation:

  1. Hi
  2. Bye

Expected Behavior

Restart conversation automatically. Alternatively: Option to restart dialog

Current Behavior

No way to restart conversation. @Waguramu wants the behavior as before.

Bonus: Making the system loaded thing in one line would be nice :)

Logs

[INFO] Creating new conversation... --- roboy.dialog.ConversationManager (19:17:54)
[INFO] RosMainNode will be unavailable in DialogStateMachine (null was passed) --- roboy.dialog.DialogStateMachine (19:17:54)
[INFO]  -> The infoList path: resources/sentences/RoboyInfoList.json --- roboy.dialog.states.ordinaryStates.IntroductionState (19:17:54)
[INFO]  -> The QAList path: resources/sentences/QAList.json --- roboy.dialog.states.ordinaryStates.PersonalInformationFollowUpState (19:17:54)
[INFO]  -> The QAList path: resources/sentences/QAList.json --- roboy.dialog.states.ordinaryStates.PersonalInformationAskingState (19:17:54)
[INFO] Waiting for conversation to end. --- roboy.dialog.ConversationManager (19:17:54)
[INFO] ############# Conversation started ############ --- Conversation15 (19:17:54)
[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]: greetings
[Roboy]: What's your name?
[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-bye
[INFO] ####################################################
#                SYSTEM LOADED                     #
####################################################
 --- roboy.dialog.ConversationManager (19:18:14)

shi
Command not found. Currently supported commands: shutdown

Recommend Projects

  • React photo React

    A declarative, efficient, and flexible JavaScript library for building user interfaces.

  • Vue.js photo Vue.js

    ๐Ÿ–– Vue.js is a progressive, incrementally-adoptable JavaScript framework for building UI on the web.

  • Typescript photo Typescript

    TypeScript is a superset of JavaScript that compiles to clean JavaScript output.

  • TensorFlow photo TensorFlow

    An Open Source Machine Learning Framework for Everyone

  • Django photo Django

    The Web framework for perfectionists with deadlines.

  • D3 photo D3

    Bring data to life with SVG, Canvas and HTML. ๐Ÿ“Š๐Ÿ“ˆ๐ŸŽ‰

Recommend Topics

  • javascript

    JavaScript (JS) is a lightweight interpreted programming language with first-class functions.

  • web

    Some thing interesting about web. New door for the world.

  • server

    A server is a program made to process requests and deliver data to clients.

  • Machine learning

    Machine learning is a way of modeling and interpreting data that allows a piece of software to respond intelligently.

  • Game

    Some thing interesting about game, make everyone happy.

Recommend Org

  • Facebook photo Facebook

    We are working to build community through open source technology. NB: members must have two-factor auth.

  • Microsoft photo Microsoft

    Open source projects and samples from Microsoft.

  • Google photo Google

    Google โค๏ธ Open Source for everyone.

  • D3 photo D3

    Data-Driven Documents codes.