Copy disabled (too large)
Download .txt
Showing preview only (24,778K chars total). Download the full file to get everything.
Repository: afader/oqa
Branch: master
Commit: c59161c7bd0f
Files: 1065
Total size: 249.1 MB
Directory structure:
gitextract_8frwjrok/
├── README.md
├── oqa-core/
│ ├── README.md
│ ├── build.sbt
│ ├── models/
│ │ └── full.txt
│ ├── questions.txt
│ └── src/
│ └── main/
│ ├── resources/
│ │ ├── application.conf
│ │ ├── edu/
│ │ │ └── knowitall/
│ │ │ ├── execution/
│ │ │ │ ├── stoplist.txt
│ │ │ │ └── stopregex.txt
│ │ │ ├── paraphrasing/
│ │ │ │ ├── rules/
│ │ │ │ │ └── rules.txt
│ │ │ │ └── template/
│ │ │ │ └── templatesStops.txt
│ │ │ ├── parsing/
│ │ │ │ └── cg/
│ │ │ │ ├── argFilters.txt
│ │ │ │ ├── lexicon.txt
│ │ │ │ ├── macros.txt
│ │ │ │ └── relFilters.txt
│ │ │ └── search/
│ │ │ └── qa/
│ │ │ ├── isa.txt
│ │ │ └── tupleFeatures.txt
│ │ ├── log4j.properties
│ │ └── logback.xml
│ └── scala/
│ └── edu/
│ └── knowitall/
│ ├── eval/
│ │ ├── Oracle.scala
│ │ ├── OutputRecord.scala
│ │ ├── SystemOutput.scala
│ │ └── qa/
│ │ ├── QAOutputRecord.scala
│ │ ├── QASystemOutput.scala
│ │ └── QASystemRunner.scala
│ ├── execution/
│ │ ├── AnswerFilter.scala
│ │ ├── ConjunctiveQuery.scala
│ │ ├── JoinPlanner.scala
│ │ ├── QueryExecutor.scala
│ │ ├── RelationalAlgebra.scala
│ │ └── StopwordExecutor.scala
│ ├── learning/
│ │ ├── CorrectnessModel.scala
│ │ ├── FeatureFunction.scala
│ │ ├── HiddenVariableModel.scala
│ │ ├── InteractiveOracle.scala
│ │ ├── LabeledDataOracle.scala
│ │ ├── MemoryInteractiveOracle.scala
│ │ ├── Perceptron.scala
│ │ ├── QATrainer.scala
│ │ ├── QueryTupleSimilarity.scala
│ │ └── SparseVector.scala
│ ├── lm/
│ │ └── LanguageModel.scala
│ ├── model/
│ │ ├── Derivation.scala
│ │ └── QaModel.scala
│ ├── paraphrasing/
│ │ ├── Paraphrase.scala
│ │ ├── ParaphraseDerivation.scala
│ │ ├── Paraphraser.scala
│ │ ├── rules/
│ │ │ ├── ParaphraseRule.scala
│ │ │ └── ParaphraseRuleSet.scala
│ │ └── template/
│ │ ├── LmParaphraseScorer.scala
│ │ ├── ParaphraseScorer.scala
│ │ ├── PmiLmParaphraseScorer.scala
│ │ ├── PmiParaphraseScorer.scala
│ │ ├── Template.scala
│ │ ├── TemplateIndexer.scala
│ │ ├── TemplateParaphraseGenerator.scala
│ │ └── TemplateParaphraser.scala
│ ├── parsing/
│ │ └── cg/
│ │ ├── CKY.scala
│ │ ├── Categories.scala
│ │ ├── CategoryPattern.scala
│ │ ├── CgParser.scala
│ │ ├── Combinators.scala
│ │ ├── LexicalRule.scala
│ │ ├── LexiconPreprocessor.scala
│ │ ├── ParserFieldFilter.scala
│ │ ├── PatternExtractor.scala
│ │ └── SentencePattern.scala
│ ├── relsyn/
│ │ ├── IsaRelSynClient.scala
│ │ ├── ListRelSynClient.scala
│ │ ├── RelSynClient.scala
│ │ ├── RelSynRule.scala
│ │ └── SolrRelSynClient.scala
│ ├── search/
│ │ ├── Beam.scala
│ │ ├── BeamSearch.scala
│ │ ├── BestFirstSearch.scala
│ │ ├── SearchAlgorithm.scala
│ │ ├── SearchProblem.scala
│ │ ├── Transition.scala
│ │ └── qa/
│ │ ├── AbstractArgTransition.scala
│ │ ├── AbstractedArgState.scala
│ │ ├── AnswerState.scala
│ │ ├── CgParseTransition.scala
│ │ ├── DropQueryStopsTransition.scala
│ │ ├── ExecutionTransition.scala
│ │ ├── ParaphraseRuleTransition.scala
│ │ ├── ProjectionTransition.scala
│ │ ├── QaAction.scala
│ │ ├── QaBeamSearch.scala
│ │ ├── QaCostModel.scala
│ │ ├── QaFeatures.scala
│ │ ├── QaLayeredSearch.scala
│ │ ├── QaSearchProblem.scala
│ │ ├── QaState.scala
│ │ ├── QaStateComparator.scala
│ │ ├── QaStep.scala
│ │ ├── QaTransitionModel.scala
│ │ ├── QueryState.scala
│ │ ├── QuestionState.scala
│ │ ├── RelSynTransition.scala
│ │ ├── TemplateTransition.scala
│ │ ├── TupleFeatureTemplate.scala
│ │ └── TupleState.scala
│ ├── triplestore/
│ │ ├── IsaClient.scala
│ │ └── TriplestoreClient.scala
│ └── util/
│ ├── AlignedWordProcessor.scala
│ ├── Counter.scala
│ ├── DummyChunker.scala
│ ├── HadoopUtils.scala
│ ├── MathUtils.scala
│ ├── NlpTools.scala
│ ├── NlpUtils.scala
│ ├── PPDBParser.scala
│ ├── ResourceUtils.scala
│ ├── StringUtils.scala
│ ├── TimingUtils.scala
│ ├── TuplePrinter.scala
│ └── WikiAnswersSampler.scala
├── oqa-data/
│ ├── README.md
│ ├── predictions/
│ │ ├── README.md
│ │ ├── oqa-trec.txt
│ │ ├── oqa-webquestions.txt
│ │ ├── oqa-wikianswers.txt
│ │ ├── paralex-trec.txt
│ │ ├── paralex-webquestions.txt
│ │ ├── paralex-wikianswers.txt
│ │ ├── sempre-trec.txt
│ │ ├── sempre-webquestions.txt
│ │ └── sempre-wikianswers.txt
│ └── src/
│ └── main/
│ └── scripts/
│ └── download-oqa-data.sh
├── oqa-lm/
│ ├── README.md
│ └── src/
│ └── main/
│ └── scripts/
│ ├── build-lm.sh
│ ├── install-kenlm.sh
│ ├── server.py
│ ├── start.sh
│ └── stop.sh
└── oqa-solr/
├── README.md
├── paraphrase/
│ ├── README.txt
│ ├── cloud-scripts/
│ │ ├── zkcli.bat
│ │ └── zkcli.sh
│ ├── contexts/
│ │ └── solr-jetty-context.xml
│ ├── etc/
│ │ ├── create-solrtest.keystore.sh
│ │ ├── jetty.xml
│ │ ├── logging.properties
│ │ ├── solrtest.keystore
│ │ └── webdefault.xml
│ ├── example-DIH/
│ │ ├── README.txt
│ │ ├── hsqldb/
│ │ │ ├── ex.backup
│ │ │ ├── ex.data
│ │ │ ├── ex.log
│ │ │ ├── ex.properties
│ │ │ └── ex.script
│ │ └── solr/
│ │ ├── db/
│ │ │ ├── conf/
│ │ │ │ ├── admin-extra.html
│ │ │ │ ├── admin-extra.menu-bottom.html
│ │ │ │ ├── admin-extra.menu-top.html
│ │ │ │ ├── db-data-config.xml
│ │ │ │ ├── elevate.xml
│ │ │ │ ├── protwords.txt
│ │ │ │ ├── schema.xml
│ │ │ │ ├── scripts.conf
│ │ │ │ ├── solrconfig.xml
│ │ │ │ ├── stopwords.txt
│ │ │ │ ├── synonyms.txt
│ │ │ │ └── xslt/
│ │ │ │ ├── example.xsl
│ │ │ │ ├── example_atom.xsl
│ │ │ │ ├── example_rss.xsl
│ │ │ │ └── luke.xsl
│ │ │ └── lib/
│ │ │ ├── derby-10.9.1.0.jar
│ │ │ └── hsqldb-1.8.0.10.jar
│ │ ├── mail/
│ │ │ └── conf/
│ │ │ ├── admin-extra.html
│ │ │ ├── admin-extra.menu-bottom.html
│ │ │ ├── admin-extra.menu-top.html
│ │ │ ├── data-config.xml
│ │ │ ├── protwords.txt
│ │ │ ├── schema.xml
│ │ │ ├── solrconfig.xml
│ │ │ ├── stopwords.txt
│ │ │ └── synonyms.txt
│ │ ├── rss/
│ │ │ └── conf/
│ │ │ ├── admin-extra.html
│ │ │ ├── admin-extra.menu-bottom.html
│ │ │ ├── admin-extra.menu-top.html
│ │ │ ├── elevate.xml
│ │ │ ├── protwords.txt
│ │ │ ├── rss-data-config.xml
│ │ │ ├── schema.xml
│ │ │ ├── scripts.conf
│ │ │ ├── solrconfig.xml
│ │ │ ├── stopwords.txt
│ │ │ └── synonyms.txt
│ │ ├── solr/
│ │ │ └── conf/
│ │ │ ├── admin-extra.html
│ │ │ ├── admin-extra.menu-bottom.html
│ │ │ ├── admin-extra.menu-top.html
│ │ │ ├── elevate.xml
│ │ │ ├── protwords.txt
│ │ │ ├── schema.xml
│ │ │ ├── scripts.conf
│ │ │ ├── solr-data-config.xml
│ │ │ ├── solrconfig.xml
│ │ │ ├── stopwords.txt
│ │ │ └── synonyms.txt
│ │ ├── solr.xml
│ │ └── tika/
│ │ └── conf/
│ │ ├── admin-extra.html
│ │ ├── admin-extra.menu-bottom.html
│ │ ├── admin-extra.menu-top.html
│ │ ├── schema.xml
│ │ ├── solrconfig.xml
│ │ └── tika-data-config.xml
│ ├── exampledocs/
│ │ ├── books.csv
│ │ ├── books.json
│ │ ├── gb18030-example.xml
│ │ ├── hd.xml
│ │ ├── ipod_other.xml
│ │ ├── ipod_video.xml
│ │ ├── manufacturers.xml
│ │ ├── mem.xml
│ │ ├── money.xml
│ │ ├── monitor.xml
│ │ ├── monitor2.xml
│ │ ├── mp500.xml
│ │ ├── post.jar
│ │ ├── post.sh
│ │ ├── sd500.xml
│ │ ├── solr.xml
│ │ ├── test_utf8.sh
│ │ ├── utf8-example.xml
│ │ └── vidcard.xml
│ ├── lib/
│ │ ├── ext/
│ │ │ ├── jcl-over-slf4j-1.6.6.jar
│ │ │ ├── jul-to-slf4j-1.6.6.jar
│ │ │ ├── log4j-1.2.16.jar
│ │ │ ├── slf4j-api-1.6.6.jar
│ │ │ └── slf4j-log4j12-1.6.6.jar
│ │ ├── jetty-continuation-8.1.8.v20121106.jar
│ │ ├── jetty-deploy-8.1.8.v20121106.jar
│ │ ├── jetty-http-8.1.8.v20121106.jar
│ │ ├── jetty-io-8.1.8.v20121106.jar
│ │ ├── jetty-jmx-8.1.8.v20121106.jar
│ │ ├── jetty-security-8.1.8.v20121106.jar
│ │ ├── jetty-server-8.1.8.v20121106.jar
│ │ ├── jetty-servlet-8.1.8.v20121106.jar
│ │ ├── jetty-util-8.1.8.v20121106.jar
│ │ ├── jetty-webapp-8.1.8.v20121106.jar
│ │ ├── jetty-xml-8.1.8.v20121106.jar
│ │ └── servlet-api-3.0.jar
│ ├── multicore/
│ │ ├── README.txt
│ │ ├── core0/
│ │ │ └── conf/
│ │ │ ├── schema.xml
│ │ │ └── solrconfig.xml
│ │ ├── core1/
│ │ │ └── conf/
│ │ │ ├── schema.xml
│ │ │ └── solrconfig.xml
│ │ ├── exampledocs/
│ │ │ ├── ipod_other.xml
│ │ │ └── ipod_video.xml
│ │ ├── solr.xml
│ │ └── zoo.cfg
│ ├── resources/
│ │ └── log4j.properties
│ ├── solr/
│ │ ├── README.txt
│ │ ├── paraphrase/
│ │ │ ├── README.txt
│ │ │ ├── conf/
│ │ │ │ ├── admin-extra.html
│ │ │ │ ├── admin-extra.menu-bottom.html
│ │ │ │ ├── admin-extra.menu-top.html
│ │ │ │ ├── currency.xml
│ │ │ │ ├── elevate.xml
│ │ │ │ ├── lang/
│ │ │ │ │ ├── contractions_ca.txt
│ │ │ │ │ ├── contractions_fr.txt
│ │ │ │ │ ├── contractions_ga.txt
│ │ │ │ │ ├── contractions_it.txt
│ │ │ │ │ ├── hyphenations_ga.txt
│ │ │ │ │ ├── stemdict_nl.txt
│ │ │ │ │ ├── stoptags_ja.txt
│ │ │ │ │ ├── stopwords_ar.txt
│ │ │ │ │ ├── stopwords_bg.txt
│ │ │ │ │ ├── stopwords_ca.txt
│ │ │ │ │ ├── stopwords_cz.txt
│ │ │ │ │ ├── stopwords_da.txt
│ │ │ │ │ ├── stopwords_de.txt
│ │ │ │ │ ├── stopwords_el.txt
│ │ │ │ │ ├── stopwords_en.txt
│ │ │ │ │ ├── stopwords_es.txt
│ │ │ │ │ ├── stopwords_eu.txt
│ │ │ │ │ ├── stopwords_fa.txt
│ │ │ │ │ ├── stopwords_fi.txt
│ │ │ │ │ ├── stopwords_fr.txt
│ │ │ │ │ ├── stopwords_ga.txt
│ │ │ │ │ ├── stopwords_gl.txt
│ │ │ │ │ ├── stopwords_hi.txt
│ │ │ │ │ ├── stopwords_hu.txt
│ │ │ │ │ ├── stopwords_hy.txt
│ │ │ │ │ ├── stopwords_id.txt
│ │ │ │ │ ├── stopwords_it.txt
│ │ │ │ │ ├── stopwords_ja.txt
│ │ │ │ │ ├── stopwords_lv.txt
│ │ │ │ │ ├── stopwords_nl.txt
│ │ │ │ │ ├── stopwords_no.txt
│ │ │ │ │ ├── stopwords_pt.txt
│ │ │ │ │ ├── stopwords_ro.txt
│ │ │ │ │ ├── stopwords_ru.txt
│ │ │ │ │ ├── stopwords_sv.txt
│ │ │ │ │ ├── stopwords_th.txt
│ │ │ │ │ ├── stopwords_tr.txt
│ │ │ │ │ └── userdict_ja.txt
│ │ │ │ ├── mapping-FoldToASCII.txt
│ │ │ │ ├── mapping-ISOLatin1Accent.txt
│ │ │ │ ├── protwords.txt
│ │ │ │ ├── schema.xml
│ │ │ │ ├── scripts.conf
│ │ │ │ ├── solrconfig.xml
│ │ │ │ ├── spellings.txt
│ │ │ │ ├── stopwords.txt
│ │ │ │ ├── synonyms.txt
│ │ │ │ ├── update-script.js
│ │ │ │ ├── velocity/
│ │ │ │ │ ├── VM_global_library.vm
│ │ │ │ │ ├── browse.vm
│ │ │ │ │ ├── cluster.vm
│ │ │ │ │ ├── clusterResults.vm
│ │ │ │ │ ├── debug.vm
│ │ │ │ │ ├── did_you_mean.vm
│ │ │ │ │ ├── facet_fields.vm
│ │ │ │ │ ├── facet_pivot.vm
│ │ │ │ │ ├── facet_queries.vm
│ │ │ │ │ ├── facet_ranges.vm
│ │ │ │ │ ├── facets.vm
│ │ │ │ │ ├── footer.vm
│ │ │ │ │ ├── head.vm
│ │ │ │ │ ├── header.vm
│ │ │ │ │ ├── hit.vm
│ │ │ │ │ ├── hitGrouped.vm
│ │ │ │ │ ├── join-doc.vm
│ │ │ │ │ ├── jquery.autocomplete.css
│ │ │ │ │ ├── jquery.autocomplete.js
│ │ │ │ │ ├── layout.vm
│ │ │ │ │ ├── main.css
│ │ │ │ │ ├── product-doc.vm
│ │ │ │ │ ├── query.vm
│ │ │ │ │ ├── queryGroup.vm
│ │ │ │ │ ├── querySpatial.vm
│ │ │ │ │ ├── richtext-doc.vm
│ │ │ │ │ ├── suggest.vm
│ │ │ │ │ └── tabs.vm
│ │ │ │ └── xslt/
│ │ │ │ ├── example.xsl
│ │ │ │ ├── example_atom.xsl
│ │ │ │ ├── example_rss.xsl
│ │ │ │ ├── luke.xsl
│ │ │ │ └── updateXml.xsl
│ │ │ └── lib/
│ │ │ └── triplestore-lemmatizer-assembly-0.1.jar
│ │ ├── solr.xml
│ │ └── zoo.cfg
│ ├── solr-webapp/
│ │ └── webapp/
│ │ ├── META-INF/
│ │ │ ├── LICENSE.txt
│ │ │ ├── MANIFEST.MF
│ │ │ └── NOTICE.txt
│ │ ├── WEB-INF/
│ │ │ ├── lib/
│ │ │ │ ├── commons-cli-1.2.jar
│ │ │ │ ├── commons-codec-1.7.jar
│ │ │ │ ├── commons-fileupload-1.2.1.jar
│ │ │ │ ├── commons-io-2.1.jar
│ │ │ │ ├── commons-lang-2.6.jar
│ │ │ │ ├── guava-13.0.1.jar
│ │ │ │ ├── httpclient-4.2.3.jar
│ │ │ │ ├── httpcore-4.2.2.jar
│ │ │ │ ├── httpmime-4.2.3.jar
│ │ │ │ ├── lucene-analyzers-common-4.3.0.jar
│ │ │ │ ├── lucene-analyzers-kuromoji-4.3.0.jar
│ │ │ │ ├── lucene-analyzers-phonetic-4.3.0.jar
│ │ │ │ ├── lucene-codecs-4.3.0.jar
│ │ │ │ ├── lucene-core-4.3.0.jar
│ │ │ │ ├── lucene-grouping-4.3.0.jar
│ │ │ │ ├── lucene-highlighter-4.3.0.jar
│ │ │ │ ├── lucene-memory-4.3.0.jar
│ │ │ │ ├── lucene-misc-4.3.0.jar
│ │ │ │ ├── lucene-queries-4.3.0.jar
│ │ │ │ ├── lucene-queryparser-4.3.0.jar
│ │ │ │ ├── lucene-spatial-4.3.0.jar
│ │ │ │ ├── lucene-suggest-4.3.0.jar
│ │ │ │ ├── noggit-0.5.jar
│ │ │ │ ├── org.restlet-2.1.1.jar
│ │ │ │ ├── org.restlet.ext.servlet-2.1.1.jar
│ │ │ │ ├── solr-core-4.3.0.jar
│ │ │ │ ├── solr-solrj-4.3.0.jar
│ │ │ │ ├── spatial4j-0.3.jar
│ │ │ │ ├── wstx-asl-3.2.7.jar
│ │ │ │ └── zookeeper-3.4.5.jar
│ │ │ ├── web.xml
│ │ │ └── weblogic.xml
│ │ ├── admin.html
│ │ ├── css/
│ │ │ ├── chosen.css
│ │ │ └── styles/
│ │ │ ├── analysis.css
│ │ │ ├── cloud.css
│ │ │ ├── common.css
│ │ │ ├── cores.css
│ │ │ ├── dashboard.css
│ │ │ ├── dataimport.css
│ │ │ ├── index.css
│ │ │ ├── java-properties.css
│ │ │ ├── logging.css
│ │ │ ├── menu.css
│ │ │ ├── plugins.css
│ │ │ ├── query.css
│ │ │ ├── replication.css
│ │ │ ├── schema-browser.css
│ │ │ └── threads.css
│ │ ├── img/
│ │ │ ├── ZeroClipboard.swf
│ │ │ └── filetypes/
│ │ │ └── README
│ │ ├── js/
│ │ │ ├── lib/
│ │ │ │ ├── ZeroClipboard.js
│ │ │ │ ├── chosen.js
│ │ │ │ ├── console.js
│ │ │ │ ├── d3.js
│ │ │ │ ├── highlight.js
│ │ │ │ ├── jquery.autogrow.js
│ │ │ │ ├── jquery.blockUI.js
│ │ │ │ ├── jquery.cookie.js
│ │ │ │ ├── jquery.form.js
│ │ │ │ ├── jquery.jstree.js
│ │ │ │ ├── jquery.sammy.js
│ │ │ │ ├── jquery.timeago.js
│ │ │ │ ├── linker.js
│ │ │ │ └── order.js
│ │ │ ├── main.js
│ │ │ ├── require.js
│ │ │ └── scripts/
│ │ │ ├── analysis.js
│ │ │ ├── app.js
│ │ │ ├── cloud.js
│ │ │ ├── cores.js
│ │ │ ├── dashboard.js
│ │ │ ├── dataimport.js
│ │ │ ├── file.js
│ │ │ ├── index.js
│ │ │ ├── java-properties.js
│ │ │ ├── logging.js
│ │ │ ├── ping.js
│ │ │ ├── plugins.js
│ │ │ ├── query.js
│ │ │ ├── replication.js
│ │ │ ├── schema-browser.js
│ │ │ └── threads.js
│ │ └── tpl/
│ │ ├── analysis.html
│ │ ├── cloud.html
│ │ ├── cores.html
│ │ ├── dashboard.html
│ │ ├── dataimport.html
│ │ ├── index.html
│ │ ├── logging.html
│ │ ├── plugins.html
│ │ ├── query.html
│ │ ├── replication.html
│ │ ├── schema-browser.html
│ │ └── threads.html
│ ├── start.jar
│ └── webapps/
│ └── solr.war
├── relsyn/
│ ├── README.txt
│ ├── cloud-scripts/
│ │ ├── zkcli.bat
│ │ └── zkcli.sh
│ ├── contexts/
│ │ └── solr-jetty-context.xml
│ ├── etc/
│ │ ├── create-solrtest.keystore.sh
│ │ ├── jetty.xml
│ │ ├── logging.properties
│ │ ├── solrtest.keystore
│ │ └── webdefault.xml
│ ├── example-DIH/
│ │ ├── README.txt
│ │ ├── hsqldb/
│ │ │ ├── ex.backup
│ │ │ ├── ex.data
│ │ │ ├── ex.log
│ │ │ ├── ex.properties
│ │ │ └── ex.script
│ │ └── solr/
│ │ ├── db/
│ │ │ ├── conf/
│ │ │ │ ├── admin-extra.html
│ │ │ │ ├── admin-extra.menu-bottom.html
│ │ │ │ ├── admin-extra.menu-top.html
│ │ │ │ ├── db-data-config.xml
│ │ │ │ ├── elevate.xml
│ │ │ │ ├── protwords.txt
│ │ │ │ ├── schema.xml
│ │ │ │ ├── scripts.conf
│ │ │ │ ├── solrconfig.xml
│ │ │ │ ├── stopwords.txt
│ │ │ │ ├── synonyms.txt
│ │ │ │ └── xslt/
│ │ │ │ ├── example.xsl
│ │ │ │ ├── example_atom.xsl
│ │ │ │ ├── example_rss.xsl
│ │ │ │ └── luke.xsl
│ │ │ └── lib/
│ │ │ ├── derby-10.9.1.0.jar
│ │ │ └── hsqldb-1.8.0.10.jar
│ │ ├── mail/
│ │ │ └── conf/
│ │ │ ├── admin-extra.html
│ │ │ ├── admin-extra.menu-bottom.html
│ │ │ ├── admin-extra.menu-top.html
│ │ │ ├── data-config.xml
│ │ │ ├── protwords.txt
│ │ │ ├── schema.xml
│ │ │ ├── solrconfig.xml
│ │ │ ├── stopwords.txt
│ │ │ └── synonyms.txt
│ │ ├── rss/
│ │ │ └── conf/
│ │ │ ├── admin-extra.html
│ │ │ ├── admin-extra.menu-bottom.html
│ │ │ ├── admin-extra.menu-top.html
│ │ │ ├── elevate.xml
│ │ │ ├── protwords.txt
│ │ │ ├── rss-data-config.xml
│ │ │ ├── schema.xml
│ │ │ ├── scripts.conf
│ │ │ ├── solrconfig.xml
│ │ │ ├── stopwords.txt
│ │ │ └── synonyms.txt
│ │ ├── solr/
│ │ │ └── conf/
│ │ │ ├── admin-extra.html
│ │ │ ├── admin-extra.menu-bottom.html
│ │ │ ├── admin-extra.menu-top.html
│ │ │ ├── elevate.xml
│ │ │ ├── protwords.txt
│ │ │ ├── schema.xml
│ │ │ ├── scripts.conf
│ │ │ ├── solr-data-config.xml
│ │ │ ├── solrconfig.xml
│ │ │ ├── stopwords.txt
│ │ │ └── synonyms.txt
│ │ ├── solr.xml
│ │ └── tika/
│ │ └── conf/
│ │ ├── admin-extra.html
│ │ ├── admin-extra.menu-bottom.html
│ │ ├── admin-extra.menu-top.html
│ │ ├── schema.xml
│ │ ├── solrconfig.xml
│ │ └── tika-data-config.xml
│ ├── exampledocs/
│ │ ├── books.csv
│ │ ├── books.json
│ │ ├── gb18030-example.xml
│ │ ├── hd.xml
│ │ ├── ipod_other.xml
│ │ ├── ipod_video.xml
│ │ ├── manufacturers.xml
│ │ ├── mem.xml
│ │ ├── money.xml
│ │ ├── monitor.xml
│ │ ├── monitor2.xml
│ │ ├── mp500.xml
│ │ ├── post.jar
│ │ ├── post.sh
│ │ ├── sd500.xml
│ │ ├── solr.xml
│ │ ├── test_utf8.sh
│ │ ├── utf8-example.xml
│ │ └── vidcard.xml
│ ├── lib/
│ │ ├── ext/
│ │ │ ├── jcl-over-slf4j-1.6.6.jar
│ │ │ ├── jul-to-slf4j-1.6.6.jar
│ │ │ ├── log4j-1.2.16.jar
│ │ │ ├── slf4j-api-1.6.6.jar
│ │ │ └── slf4j-log4j12-1.6.6.jar
│ │ ├── jetty-continuation-8.1.8.v20121106.jar
│ │ ├── jetty-deploy-8.1.8.v20121106.jar
│ │ ├── jetty-http-8.1.8.v20121106.jar
│ │ ├── jetty-io-8.1.8.v20121106.jar
│ │ ├── jetty-jmx-8.1.8.v20121106.jar
│ │ ├── jetty-security-8.1.8.v20121106.jar
│ │ ├── jetty-server-8.1.8.v20121106.jar
│ │ ├── jetty-servlet-8.1.8.v20121106.jar
│ │ ├── jetty-util-8.1.8.v20121106.jar
│ │ ├── jetty-webapp-8.1.8.v20121106.jar
│ │ ├── jetty-xml-8.1.8.v20121106.jar
│ │ └── servlet-api-3.0.jar
│ ├── multicore/
│ │ ├── README.txt
│ │ ├── core0/
│ │ │ └── conf/
│ │ │ ├── schema.xml
│ │ │ └── solrconfig.xml
│ │ ├── core1/
│ │ │ └── conf/
│ │ │ ├── schema.xml
│ │ │ └── solrconfig.xml
│ │ ├── exampledocs/
│ │ │ ├── ipod_other.xml
│ │ │ └── ipod_video.xml
│ │ ├── solr.xml
│ │ └── zoo.cfg
│ ├── resources/
│ │ └── log4j.properties
│ ├── solr/
│ │ ├── README.txt
│ │ ├── relsyn/
│ │ │ ├── README.txt
│ │ │ ├── conf/
│ │ │ │ ├── admin-extra.html
│ │ │ │ ├── admin-extra.menu-bottom.html
│ │ │ │ ├── admin-extra.menu-top.html
│ │ │ │ ├── currency.xml
│ │ │ │ ├── elevate.xml
│ │ │ │ ├── lang/
│ │ │ │ │ ├── contractions_ca.txt
│ │ │ │ │ ├── contractions_fr.txt
│ │ │ │ │ ├── contractions_ga.txt
│ │ │ │ │ ├── contractions_it.txt
│ │ │ │ │ ├── hyphenations_ga.txt
│ │ │ │ │ ├── stemdict_nl.txt
│ │ │ │ │ ├── stoptags_ja.txt
│ │ │ │ │ ├── stopwords_ar.txt
│ │ │ │ │ ├── stopwords_bg.txt
│ │ │ │ │ ├── stopwords_ca.txt
│ │ │ │ │ ├── stopwords_cz.txt
│ │ │ │ │ ├── stopwords_da.txt
│ │ │ │ │ ├── stopwords_de.txt
│ │ │ │ │ ├── stopwords_el.txt
│ │ │ │ │ ├── stopwords_en.txt
│ │ │ │ │ ├── stopwords_es.txt
│ │ │ │ │ ├── stopwords_eu.txt
│ │ │ │ │ ├── stopwords_fa.txt
│ │ │ │ │ ├── stopwords_fi.txt
│ │ │ │ │ ├── stopwords_fr.txt
│ │ │ │ │ ├── stopwords_ga.txt
│ │ │ │ │ ├── stopwords_gl.txt
│ │ │ │ │ ├── stopwords_hi.txt
│ │ │ │ │ ├── stopwords_hu.txt
│ │ │ │ │ ├── stopwords_hy.txt
│ │ │ │ │ ├── stopwords_id.txt
│ │ │ │ │ ├── stopwords_it.txt
│ │ │ │ │ ├── stopwords_ja.txt
│ │ │ │ │ ├── stopwords_lv.txt
│ │ │ │ │ ├── stopwords_nl.txt
│ │ │ │ │ ├── stopwords_no.txt
│ │ │ │ │ ├── stopwords_pt.txt
│ │ │ │ │ ├── stopwords_ro.txt
│ │ │ │ │ ├── stopwords_ru.txt
│ │ │ │ │ ├── stopwords_sv.txt
│ │ │ │ │ ├── stopwords_th.txt
│ │ │ │ │ ├── stopwords_tr.txt
│ │ │ │ │ └── userdict_ja.txt
│ │ │ │ ├── mapping-FoldToASCII.txt
│ │ │ │ ├── mapping-ISOLatin1Accent.txt
│ │ │ │ ├── protwords.txt
│ │ │ │ ├── schema.xml
│ │ │ │ ├── scripts.conf
│ │ │ │ ├── solrconfig.xml
│ │ │ │ ├── spellings.txt
│ │ │ │ ├── stopwords.txt
│ │ │ │ ├── synonyms.txt
│ │ │ │ ├── update-script.js
│ │ │ │ ├── velocity/
│ │ │ │ │ ├── VM_global_library.vm
│ │ │ │ │ ├── browse.vm
│ │ │ │ │ ├── cluster.vm
│ │ │ │ │ ├── clusterResults.vm
│ │ │ │ │ ├── debug.vm
│ │ │ │ │ ├── did_you_mean.vm
│ │ │ │ │ ├── facet_fields.vm
│ │ │ │ │ ├── facet_pivot.vm
│ │ │ │ │ ├── facet_queries.vm
│ │ │ │ │ ├── facet_ranges.vm
│ │ │ │ │ ├── facets.vm
│ │ │ │ │ ├── footer.vm
│ │ │ │ │ ├── head.vm
│ │ │ │ │ ├── header.vm
│ │ │ │ │ ├── hit.vm
│ │ │ │ │ ├── hitGrouped.vm
│ │ │ │ │ ├── join-doc.vm
│ │ │ │ │ ├── jquery.autocomplete.css
│ │ │ │ │ ├── jquery.autocomplete.js
│ │ │ │ │ ├── layout.vm
│ │ │ │ │ ├── main.css
│ │ │ │ │ ├── product-doc.vm
│ │ │ │ │ ├── query.vm
│ │ │ │ │ ├── queryGroup.vm
│ │ │ │ │ ├── querySpatial.vm
│ │ │ │ │ ├── richtext-doc.vm
│ │ │ │ │ ├── suggest.vm
│ │ │ │ │ └── tabs.vm
│ │ │ │ └── xslt/
│ │ │ │ ├── example.xsl
│ │ │ │ ├── example_atom.xsl
│ │ │ │ ├── example_rss.xsl
│ │ │ │ ├── luke.xsl
│ │ │ │ └── updateXml.xsl
│ │ │ └── lib/
│ │ │ └── triplestore-lemmatizer-assembly-0.1.jar
│ │ ├── solr.xml
│ │ └── zoo.cfg
│ ├── solr-webapp/
│ │ └── webapp/
│ │ ├── META-INF/
│ │ │ ├── LICENSE.txt
│ │ │ ├── MANIFEST.MF
│ │ │ └── NOTICE.txt
│ │ ├── WEB-INF/
│ │ │ ├── lib/
│ │ │ │ ├── commons-cli-1.2.jar
│ │ │ │ ├── commons-codec-1.7.jar
│ │ │ │ ├── commons-fileupload-1.2.1.jar
│ │ │ │ ├── commons-io-2.1.jar
│ │ │ │ ├── commons-lang-2.6.jar
│ │ │ │ ├── guava-13.0.1.jar
│ │ │ │ ├── httpclient-4.2.3.jar
│ │ │ │ ├── httpcore-4.2.2.jar
│ │ │ │ ├── httpmime-4.2.3.jar
│ │ │ │ ├── lucene-analyzers-common-4.3.0.jar
│ │ │ │ ├── lucene-analyzers-kuromoji-4.3.0.jar
│ │ │ │ ├── lucene-analyzers-phonetic-4.3.0.jar
│ │ │ │ ├── lucene-codecs-4.3.0.jar
│ │ │ │ ├── lucene-core-4.3.0.jar
│ │ │ │ ├── lucene-grouping-4.3.0.jar
│ │ │ │ ├── lucene-highlighter-4.3.0.jar
│ │ │ │ ├── lucene-memory-4.3.0.jar
│ │ │ │ ├── lucene-misc-4.3.0.jar
│ │ │ │ ├── lucene-queries-4.3.0.jar
│ │ │ │ ├── lucene-queryparser-4.3.0.jar
│ │ │ │ ├── lucene-spatial-4.3.0.jar
│ │ │ │ ├── lucene-suggest-4.3.0.jar
│ │ │ │ ├── noggit-0.5.jar
│ │ │ │ ├── org.restlet-2.1.1.jar
│ │ │ │ ├── org.restlet.ext.servlet-2.1.1.jar
│ │ │ │ ├── solr-core-4.3.0.jar
│ │ │ │ ├── solr-solrj-4.3.0.jar
│ │ │ │ ├── spatial4j-0.3.jar
│ │ │ │ ├── wstx-asl-3.2.7.jar
│ │ │ │ └── zookeeper-3.4.5.jar
│ │ │ ├── web.xml
│ │ │ └── weblogic.xml
│ │ ├── admin.html
│ │ ├── css/
│ │ │ ├── chosen.css
│ │ │ └── styles/
│ │ │ ├── analysis.css
│ │ │ ├── cloud.css
│ │ │ ├── common.css
│ │ │ ├── cores.css
│ │ │ ├── dashboard.css
│ │ │ ├── dataimport.css
│ │ │ ├── index.css
│ │ │ ├── java-properties.css
│ │ │ ├── logging.css
│ │ │ ├── menu.css
│ │ │ ├── plugins.css
│ │ │ ├── query.css
│ │ │ ├── replication.css
│ │ │ ├── schema-browser.css
│ │ │ └── threads.css
│ │ ├── img/
│ │ │ ├── ZeroClipboard.swf
│ │ │ └── filetypes/
│ │ │ └── README
│ │ ├── js/
│ │ │ ├── lib/
│ │ │ │ ├── ZeroClipboard.js
│ │ │ │ ├── chosen.js
│ │ │ │ ├── console.js
│ │ │ │ ├── d3.js
│ │ │ │ ├── highlight.js
│ │ │ │ ├── jquery.autogrow.js
│ │ │ │ ├── jquery.blockUI.js
│ │ │ │ ├── jquery.cookie.js
│ │ │ │ ├── jquery.form.js
│ │ │ │ ├── jquery.jstree.js
│ │ │ │ ├── jquery.sammy.js
│ │ │ │ ├── jquery.timeago.js
│ │ │ │ ├── linker.js
│ │ │ │ └── order.js
│ │ │ ├── main.js
│ │ │ ├── require.js
│ │ │ └── scripts/
│ │ │ ├── analysis.js
│ │ │ ├── app.js
│ │ │ ├── cloud.js
│ │ │ ├── cores.js
│ │ │ ├── dashboard.js
│ │ │ ├── dataimport.js
│ │ │ ├── file.js
│ │ │ ├── index.js
│ │ │ ├── java-properties.js
│ │ │ ├── logging.js
│ │ │ ├── ping.js
│ │ │ ├── plugins.js
│ │ │ ├── query.js
│ │ │ ├── replication.js
│ │ │ ├── schema-browser.js
│ │ │ └── threads.js
│ │ └── tpl/
│ │ ├── analysis.html
│ │ ├── cloud.html
│ │ ├── cores.html
│ │ ├── dashboard.html
│ │ ├── dataimport.html
│ │ ├── index.html
│ │ ├── logging.html
│ │ ├── plugins.html
│ │ ├── query.html
│ │ ├── replication.html
│ │ ├── schema-browser.html
│ │ └── threads.html
│ ├── start.jar
│ └── webapps/
│ └── solr.war
├── src/
│ └── main/
│ └── scripts/
│ ├── create-indexes-small.sh
│ ├── create-indexes.sh
│ ├── index-relsyn.py
│ ├── index.py
│ ├── start-all.sh
│ ├── start.sh
│ ├── stop-all.sh
│ ├── stop.sh
│ └── utils.py
└── triplestore/
├── README.txt
├── cloud-scripts/
│ ├── zkcli.bat
│ └── zkcli.sh
├── contexts/
│ └── solr-jetty-context.xml
├── etc/
│ ├── create-solrtest.keystore.sh
│ ├── jetty.xml
│ ├── logging.properties
│ ├── solrtest.keystore
│ └── webdefault.xml
├── example-DIH/
│ ├── README.txt
│ ├── hsqldb/
│ │ ├── ex.backup
│ │ ├── ex.data
│ │ ├── ex.log
│ │ ├── ex.properties
│ │ └── ex.script
│ └── solr/
│ ├── db/
│ │ ├── conf/
│ │ │ ├── admin-extra.html
│ │ │ ├── admin-extra.menu-bottom.html
│ │ │ ├── admin-extra.menu-top.html
│ │ │ ├── db-data-config.xml
│ │ │ ├── elevate.xml
│ │ │ ├── protwords.txt
│ │ │ ├── schema.xml
│ │ │ ├── scripts.conf
│ │ │ ├── solrconfig.xml
│ │ │ ├── stopwords.txt
│ │ │ ├── synonyms.txt
│ │ │ └── xslt/
│ │ │ ├── example.xsl
│ │ │ ├── example_atom.xsl
│ │ │ ├── example_rss.xsl
│ │ │ └── luke.xsl
│ │ └── lib/
│ │ ├── derby-10.9.1.0.jar
│ │ └── hsqldb-1.8.0.10.jar
│ ├── mail/
│ │ └── conf/
│ │ ├── admin-extra.html
│ │ ├── admin-extra.menu-bottom.html
│ │ ├── admin-extra.menu-top.html
│ │ ├── data-config.xml
│ │ ├── protwords.txt
│ │ ├── schema.xml
│ │ ├── solrconfig.xml
│ │ ├── stopwords.txt
│ │ └── synonyms.txt
│ ├── rss/
│ │ └── conf/
│ │ ├── admin-extra.html
│ │ ├── admin-extra.menu-bottom.html
│ │ ├── admin-extra.menu-top.html
│ │ ├── elevate.xml
│ │ ├── protwords.txt
│ │ ├── rss-data-config.xml
│ │ ├── schema.xml
│ │ ├── scripts.conf
│ │ ├── solrconfig.xml
│ │ ├── stopwords.txt
│ │ └── synonyms.txt
│ ├── solr/
│ │ └── conf/
│ │ ├── admin-extra.html
│ │ ├── admin-extra.menu-bottom.html
│ │ ├── admin-extra.menu-top.html
│ │ ├── elevate.xml
│ │ ├── protwords.txt
│ │ ├── schema.xml
│ │ ├── scripts.conf
│ │ ├── solr-data-config.xml
│ │ ├── solrconfig.xml
│ │ ├── stopwords.txt
│ │ └── synonyms.txt
│ ├── solr.xml
│ └── tika/
│ └── conf/
│ ├── admin-extra.html
│ ├── admin-extra.menu-bottom.html
│ ├── admin-extra.menu-top.html
│ ├── schema.xml
│ ├── solrconfig.xml
│ └── tika-data-config.xml
├── exampledocs/
│ ├── books.csv
│ ├── books.json
│ ├── gb18030-example.xml
│ ├── hd.xml
│ ├── ipod_other.xml
│ ├── ipod_video.xml
│ ├── manufacturers.xml
│ ├── mem.xml
│ ├── money.xml
│ ├── monitor.xml
│ ├── monitor2.xml
│ ├── mp500.xml
│ ├── post.jar
│ ├── post.sh
│ ├── sd500.xml
│ ├── solr.xml
│ ├── test_utf8.sh
│ ├── utf8-example.xml
│ └── vidcard.xml
├── lib/
│ ├── ext/
│ │ ├── jcl-over-slf4j-1.6.6.jar
│ │ ├── jul-to-slf4j-1.6.6.jar
│ │ ├── log4j-1.2.16.jar
│ │ ├── slf4j-api-1.6.6.jar
│ │ └── slf4j-log4j12-1.6.6.jar
│ ├── jetty-continuation-8.1.8.v20121106.jar
│ ├── jetty-deploy-8.1.8.v20121106.jar
│ ├── jetty-http-8.1.8.v20121106.jar
│ ├── jetty-io-8.1.8.v20121106.jar
│ ├── jetty-jmx-8.1.8.v20121106.jar
│ ├── jetty-security-8.1.8.v20121106.jar
│ ├── jetty-server-8.1.8.v20121106.jar
│ ├── jetty-servlet-8.1.8.v20121106.jar
│ ├── jetty-util-8.1.8.v20121106.jar
│ ├── jetty-webapp-8.1.8.v20121106.jar
│ ├── jetty-xml-8.1.8.v20121106.jar
│ └── servlet-api-3.0.jar
├── multicore/
│ ├── README.txt
│ ├── core0/
│ │ └── conf/
│ │ ├── schema.xml
│ │ └── solrconfig.xml
│ ├── core1/
│ │ └── conf/
│ │ ├── schema.xml
│ │ └── solrconfig.xml
│ ├── exampledocs/
│ │ ├── ipod_other.xml
│ │ └── ipod_video.xml
│ ├── solr.xml
│ └── zoo.cfg
├── resources/
│ └── log4j.properties
├── solr/
│ ├── README.txt
│ ├── solr.xml
│ ├── triplestore/
│ │ ├── README.txt
│ │ ├── conf/
│ │ │ ├── admin-extra.html
│ │ │ ├── admin-extra.menu-bottom.html
│ │ │ ├── admin-extra.menu-top.html
│ │ │ ├── currency.xml
│ │ │ ├── elevate.xml
│ │ │ ├── lang/
│ │ │ │ ├── contractions_ca.txt
│ │ │ │ ├── contractions_fr.txt
│ │ │ │ ├── contractions_ga.txt
│ │ │ │ ├── contractions_it.txt
│ │ │ │ ├── hyphenations_ga.txt
│ │ │ │ ├── stemdict_nl.txt
│ │ │ │ ├── stoptags_ja.txt
│ │ │ │ ├── stopwords_ar.txt
│ │ │ │ ├── stopwords_bg.txt
│ │ │ │ ├── stopwords_ca.txt
│ │ │ │ ├── stopwords_cz.txt
│ │ │ │ ├── stopwords_da.txt
│ │ │ │ ├── stopwords_de.txt
│ │ │ │ ├── stopwords_el.txt
│ │ │ │ ├── stopwords_en.txt
│ │ │ │ ├── stopwords_es.txt
│ │ │ │ ├── stopwords_eu.txt
│ │ │ │ ├── stopwords_fa.txt
│ │ │ │ ├── stopwords_fi.txt
│ │ │ │ ├── stopwords_fr.txt
│ │ │ │ ├── stopwords_ga.txt
│ │ │ │ ├── stopwords_gl.txt
│ │ │ │ ├── stopwords_hi.txt
│ │ │ │ ├── stopwords_hu.txt
│ │ │ │ ├── stopwords_hy.txt
│ │ │ │ ├── stopwords_id.txt
│ │ │ │ ├── stopwords_it.txt
│ │ │ │ ├── stopwords_ja.txt
│ │ │ │ ├── stopwords_lv.txt
│ │ │ │ ├── stopwords_nl.txt
│ │ │ │ ├── stopwords_no.txt
│ │ │ │ ├── stopwords_pt.txt
│ │ │ │ ├── stopwords_ro.txt
│ │ │ │ ├── stopwords_ru.txt
│ │ │ │ ├── stopwords_sv.txt
│ │ │ │ ├── stopwords_th.txt
│ │ │ │ ├── stopwords_tr.txt
│ │ │ │ └── userdict_ja.txt
│ │ │ ├── mapping-FoldToASCII.txt
│ │ │ ├── mapping-ISOLatin1Accent.txt
│ │ │ ├── protwords.txt
│ │ │ ├── schema.xml
│ │ │ ├── scripts.conf
│ │ │ ├── solrconfig.xml
│ │ │ ├── spellings.txt
│ │ │ ├── stopwords.txt
│ │ │ ├── synonyms.txt
│ │ │ ├── update-script.js
│ │ │ ├── velocity/
│ │ │ │ ├── VM_global_library.vm
│ │ │ │ ├── browse.vm
│ │ │ │ ├── cluster.vm
│ │ │ │ ├── clusterResults.vm
│ │ │ │ ├── debug.vm
│ │ │ │ ├── did_you_mean.vm
│ │ │ │ ├── facet_fields.vm
│ │ │ │ ├── facet_pivot.vm
│ │ │ │ ├── facet_queries.vm
│ │ │ │ ├── facet_ranges.vm
│ │ │ │ ├── facets.vm
│ │ │ │ ├── footer.vm
│ │ │ │ ├── head.vm
│ │ │ │ ├── header.vm
│ │ │ │ ├── hit.vm
│ │ │ │ ├── hitGrouped.vm
│ │ │ │ ├── join-doc.vm
│ │ │ │ ├── jquery.autocomplete.css
│ │ │ │ ├── jquery.autocomplete.js
│ │ │ │ ├── layout.vm
│ │ │ │ ├── main.css
│ │ │ │ ├── product-doc.vm
│ │ │ │ ├── query.vm
│ │ │ │ ├── queryGroup.vm
│ │ │ │ ├── querySpatial.vm
│ │ │ │ ├── richtext-doc.vm
│ │ │ │ ├── suggest.vm
│ │ │ │ └── tabs.vm
│ │ │ └── xslt/
│ │ │ ├── example.xsl
│ │ │ ├── example_atom.xsl
│ │ │ ├── example_rss.xsl
│ │ │ ├── luke.xsl
│ │ │ └── updateXml.xsl
│ │ └── lib/
│ │ └── triplestore-lemmatizer-assembly-0.1.jar
│ └── zoo.cfg
├── solr-webapp/
│ └── webapp/
│ ├── META-INF/
│ │ ├── LICENSE.txt
│ │ ├── MANIFEST.MF
│ │ └── NOTICE.txt
│ ├── WEB-INF/
│ │ ├── lib/
│ │ │ ├── commons-cli-1.2.jar
│ │ │ ├── commons-codec-1.7.jar
│ │ │ ├── commons-fileupload-1.2.1.jar
│ │ │ ├── commons-io-2.1.jar
│ │ │ ├── commons-lang-2.6.jar
│ │ │ ├── guava-13.0.1.jar
│ │ │ ├── httpclient-4.2.3.jar
│ │ │ ├── httpcore-4.2.2.jar
│ │ │ ├── httpmime-4.2.3.jar
│ │ │ ├── lucene-analyzers-common-4.3.0.jar
│ │ │ ├── lucene-analyzers-kuromoji-4.3.0.jar
│ │ │ ├── lucene-analyzers-phonetic-4.3.0.jar
│ │ │ ├── lucene-codecs-4.3.0.jar
│ │ │ ├── lucene-core-4.3.0.jar
│ │ │ ├── lucene-grouping-4.3.0.jar
│ │ │ ├── lucene-highlighter-4.3.0.jar
│ │ │ ├── lucene-memory-4.3.0.jar
│ │ │ ├── lucene-misc-4.3.0.jar
│ │ │ ├── lucene-queries-4.3.0.jar
│ │ │ ├── lucene-queryparser-4.3.0.jar
│ │ │ ├── lucene-spatial-4.3.0.jar
│ │ │ ├── lucene-suggest-4.3.0.jar
│ │ │ ├── noggit-0.5.jar
│ │ │ ├── org.restlet-2.1.1.jar
│ │ │ ├── org.restlet.ext.servlet-2.1.1.jar
│ │ │ ├── solr-core-4.3.0.jar
│ │ │ ├── solr-solrj-4.3.0.jar
│ │ │ ├── spatial4j-0.3.jar
│ │ │ ├── wstx-asl-3.2.7.jar
│ │ │ └── zookeeper-3.4.5.jar
│ │ ├── web.xml
│ │ └── weblogic.xml
│ ├── admin.html
│ ├── css/
│ │ ├── chosen.css
│ │ └── styles/
│ │ ├── analysis.css
│ │ ├── cloud.css
│ │ ├── common.css
│ │ ├── cores.css
│ │ ├── dashboard.css
│ │ ├── dataimport.css
│ │ ├── index.css
│ │ ├── java-properties.css
│ │ ├── logging.css
│ │ ├── menu.css
│ │ ├── plugins.css
│ │ ├── query.css
│ │ ├── replication.css
│ │ ├── schema-browser.css
│ │ └── threads.css
│ ├── img/
│ │ ├── ZeroClipboard.swf
│ │ └── filetypes/
│ │ └── README
│ ├── js/
│ │ ├── lib/
│ │ │ ├── ZeroClipboard.js
│ │ │ ├── chosen.js
│ │ │ ├── console.js
│ │ │ ├── d3.js
│ │ │ ├── highlight.js
│ │ │ ├── jquery.autogrow.js
│ │ │ ├── jquery.blockUI.js
│ │ │ ├── jquery.cookie.js
│ │ │ ├── jquery.form.js
│ │ │ ├── jquery.jstree.js
│ │ │ ├── jquery.sammy.js
│ │ │ ├── jquery.timeago.js
│ │ │ ├── linker.js
│ │ │ └── order.js
│ │ ├── main.js
│ │ ├── require.js
│ │ └── scripts/
│ │ ├── analysis.js
│ │ ├── app.js
│ │ ├── cloud.js
│ │ ├── cores.js
│ │ ├── dashboard.js
│ │ ├── dataimport.js
│ │ ├── file.js
│ │ ├── index.js
│ │ ├── java-properties.js
│ │ ├── logging.js
│ │ ├── ping.js
│ │ ├── plugins.js
│ │ ├── query.js
│ │ ├── replication.js
│ │ ├── schema-browser.js
│ │ └── threads.js
│ └── tpl/
│ ├── analysis.html
│ ├── cloud.html
│ ├── cores.html
│ ├── dashboard.html
│ ├── dataimport.html
│ ├── index.html
│ ├── logging.html
│ ├── plugins.html
│ ├── query.html
│ ├── replication.html
│ ├── schema-browser.html
│ └── threads.html
├── start.jar
└── webapps/
└── solr.war
================================================
FILE CONTENTS
================================================
================================================
FILE: README.md
================================================
This is a repository for the code and data from the paper _Open Question
Answering Over Curated and Extracted Knowledge Bases_ from KDD 2014. If you use
any of these resources in a published paper, please use the following citation:
@inproceedings{Fader14,
author = {Anthony Fader and Luke Zettlemoyer and Oren Etzioni},
title = {{Open Question Answering Over Curated and Extracted
Knowledge Bases}},
booktitle = {KDD},
year = {2014}
}
Code
===
Warning: This project has lots of moving parts. It will probably take quite a
bit of effort to get it running. I would recommend playing with the data
before trying to run the code.
## Dependencies
Below are the dependencies used for OQA. Version numbers are what I have used,
but other versions may be compatible.
* sbt (0.13)
* java (1.8.0)
* scala (2.10)
* Boost C++ libraries (1.5.7)
* Python (2.7.8)
* wget (1.15)
## Code Structure
OQA consists of the following components:
* Solr indexes (used for storing triples, paraphrases, and query rewrites).
* Language model (used for scoring answer derivation steps)
* Question answering code (used for inference and learning)
Getting the code running involves completing these steps in order:
1. [Downloading the data](oqa-data/) in `oqa-data/`
2. [Creating the indexes](oqa-solr/) in `oqa-solr/`
3. [Building the language model](oqa-lm/) in `oqa-lm/`
4. [Running the code](oqa-core/) in `oqa-core/`
Please follow the above links to the individual README files. Each README
will walk you through the steps.
Data
===
Below is a description of the data included with OQA.
## Knowledge Base (KB) Data
You can download the KB data at this url:
http://knowitall.cs.washington.edu/oqa/data/kb. The KB is divided into 20
gzip-compressed files. The total compressed filesize is approximately 20GB; the
total decompressed filesize is approximately 50GB.
Each file contains a newline-separated list of KB
records. Each record is a tab-separated list of (field name, field value) pairs.
For example, here is a record corresponding to a Freebase assertion (with tabs
replaced by newlines):
arg1
1,2-Benzoquinone
rel
Notable types
arg2
Chemical Compound
arg1_fbid_s
08s9rd
id
fb-179681780
namespace
freebase
The following fields names appear in the data:
| Field Name | Description | Required? |
| --------------------------|-------------------------------|-----------|
| `arg1` | Argument 1 of the triple | Yes |
| `rel` | Relation phrase of the triple | Yes |
| `arg2` | Argument 1 of the triple | Yes |
| `id` | Unique ID for the triple | Yes |
| `namespace` | The source of this triple | Yes |
| `arg1_fbid_s` | Arg1 Freebase ID | No |
| `arg2_fbid_s` | Arg2 Freebase ID | No |
| `num_extrs_i` | Extraction redundancy | No |
| `conf_f` | Extractor confidence | No |
| `corpora_ss` | Extractor corpus | No |
| `zipfSlope_f` | Probase statistic | No |
| `entitySize_i` | Probase statistic | No |
| `entityFrequency_i` | Probase statistic | No |
| `popularity_i` | Probase statistic | No |
| `freq_i` | Probase statistic | No |
| `zipfPearsonCoefficient_f`| Probase statistic | No |
| `conceptVagueness_f` | Probase statistic | No |
| `prob_f` | Probase statistic | No |
| `conceptSize_i` | Probase statistic | No |
There is a total of 930 million records in the data. The distribution the
different `namespace` values is:
| Namespace | Count |
|-------------------|----------:|
| Total |930,143,872|
| ReVerb |391,345,565|
| Freebase |299,370,817|
| Probase |170,278,429|
| Open IE 4.0 | 67,221,551|
| NELL | 1,927,510|
## WikiAnswers Corpus
The WikiAnswers corpus contains clusters of questions tagged by WikiAnswers
users as paraphrases. Each cluster optionally contains an answer provided by
WikiAnswers users. There are 30,370,994 clusters containing an average of 25
questions per cluster. 3,386,256 (11%) of the clusters have an answer.
The data can be downloaded from:
http://knowitall.cs.washington.edu/oqa/data/wikianswers/. The corpus is split
into 40 gzip-compressed files. The total compressed filesize is 8GB; the total
decompressed filesize is 40GB. Each file contains one cluster per line. Each
cluster is a tab-separated list of questions and answers. Questions are prefixed
by `q:` and answers are prefixed by `a:`. Here is an example cluster (tabs
replaced with newlines):
q:How many muslims make up indias 1 billion population?
q:How many of india's population are muslim?
q:How many populations of muslims in india?
q:What is population of muslims in india?
a:Over 160 million Muslims per Pew Forum Study as of October 2009.
This corpus is different than the data used in the Paralex system (see
http://knowitall.cs.washington.edu/paralex). First, it contains more questions
resulting from a longer crawl of WikiAnswers. Second, it groups questions into
clusters, instead of enumerating all pairs of paraphrases. Third, it contains
the answers, while the Paralex data does not.
We also provide a hierarchical clustering of the lowercased tokens in the
WikiAnswers corpus. We used [Percy Liang's implementation of the Brown
Clustering Algorithm](https://github.com/percyliang/brown-cluster) with
1000 clusters (i.e. `--c 1000`). The raw output is available [here](https://s3-us-west-2.amazonaws.com/ai2-oqa/wikianswers-brown-clusters-c1000.txt.gz).
You can browse the clusters [here](https://s3-us-west-2.amazonaws.com/ai2-oqa/wikianswers-cluster-viewer/cluster_viewer.html).
We did not use these in the OQA system, but we probably should have.
## Paraphrase Template Data
The paraphrase templates used in OQA are available for download at
http://knowitall.cs.washington.edu/oqa/data/paraphrase-templates.txt.gz. The
file is 90M compressed and 900M decompressed. Each line in the file contains a
paraphrase template pair as a tab-separated list of (field name, field value)
pairs. Here is an example record (with tabs replaced with newlines):
id
pair1718534
template1
how do people use $y ?
template2
what be common use for $y ?
typ
anything
count1
0.518446
count2
0.335112
typCount12
0.195711
count12
0.195711
typPmi
0.707756
pmi
0.687842
Each template in a record is a space-delimited list of lowercased, lemmatized
tokens. The token `$y` is a variable representing the argument slot position.
The numeric values in the records are scaled to be in [0, 1].
| Field | Description |
|---------------|-----------------------------------------------------------|
| `id` | The unique identifier for the pair of templates |
| `template1` | The first template |
| `template2` | The second template |
| `typ` | Unusued field, ignore |
| `count1` | Log count of the first template |
| `count2` | Log count of the second template |
| `typCount12` | Unused field, ignore |
| `count12` | Log joint-count of the template pair |
| `typPmi` | Unused field, ignore |
| `pmi` | Log pointwise mutual information of the template pair |
There are a total of 5,137,558 records in the file.
## Query Rewrite Data
The query rewrite operators are available for download at
http://knowitall.cs.washington.edu/oqa/data/query-rewrites.txt.gz. The file is
1G compressed and 8G decompressed. Each line in the file is a tab-separated
list of (field name, field value) pairs. Here is an example record (with tabs
replaced with newlines):
inverted
0
joint_count
18
marg_count1
263
marg_count2
102
pmi
-7.30675508757
rel1
be the language of the country
rel2
be widely speak in
Each record has statistics computed over a pair of relation phrases `rel1` and
`rel2`. The relation phrases are lowercased and lemmatized.
| Field | Description |
|---------------|-----------------------------------------------------------|
| `inverted` | 1 if the rule inverts arg. order, 0 otherwise |
| `joint_count` | The number of shared argument pairs in the KB |
| `marg_count1` | The number of argument pairs `rel1` takes in the KB |
| `marg_count2` | The number of argument pairs `rel2` takes in the KB |
| `pmi` | Log pointwise mutual information of `rel1` and `rel2` |
| `rel1` | Lemmatized, lowercased relation phrase 1 |
| `rel2` | Lemmatized, lowercased relation phrase 2 |
There are a total of 74,461,831 records in the file.
## Labeled Question-Answer Pairs
The questions and answers used for the evaluation are available at
http://knowitall.cs.washington.edu/oqa/data/questions/.
The questions are available in their own files:
* WebQuestions [train](http://knowitall.cs.washington.edu/oqa/data/questions/webquestions.train.txt) [devtest](http://knowitall.cs.washington.edu/oqa/data/questions/webquestions.devtest.txt) [test](http://knowitall.cs.washington.edu/oqa/data/questions/webquestions.test.txt)
* TREC [train](http://knowitall.cs.washington.edu/oqa/data/questions/trec.train.txt) [devtest](http://knowitall.cs.washington.edu/oqa/data/questions/trec.devtest.txt) [test](http://knowitall.cs.washington.edu/oqa/data/questions/trec.test.txt)
* WikiAnswers [train](http://knowitall.cs.washington.edu/oqa/data/questions/wikianswers.train.txt) [devtest](http://knowitall.cs.washington.edu/oqa/data/questions/wikianswers.devtest.txt) [test](http://knowitall.cs.washington.edu/oqa/data/questions/wikianswers.test.txt)
I labeled the top predictions for each system as correct or incorrect if they
the predicted answer was not found in the label sets provided with WebQuestions,
TREC, and WikiAnswers. These labels can be found at
http://knowitall.cs.washington.edu/oqa/data/questions/labels.txt. The format of
this file is a newline-separated list of tab-separated (`LABEL`, truth value,
question, answer) records. The questions and answers may be lowercased and
lemmatized.
## System Output
See the documentation in [oqa-data/predictions](oqa-data/predictions).
================================================
FILE: oqa-core/README.md
================================================
# Running OQA
Create a file called `questions.txt` that has one question per line. Running
the following command will run OQA on the questions and write the output to
the directory `output/`:
sbt 'run-main edu.knowitall.eval.qa.QASystemRunner questions.txt output'
Upon completion, `output/` will contain three files: `config.txt`, `output.txt`,
and `name.txt`. `config.txt` is a dump of the OQA settings used for this
execution. `name.txt` contains the input file name. `output.txt` contains the
output of the system, with one line per prediction. Each line is a tab-separated
record with the following fields:
1. The input question.
2. The predicted answer.
3. The score of the highest-scoring derivation from question to predicted answer.
4. A string representation of the higest-scoring derivation.
By default, OQA uses the feature weights in `models/full.txt`.
The configuration settings can be changed by editing
`src/main/resources/application.conf`.
================================================
FILE: oqa-core/build.sbt
================================================
scalaVersion := "2.10.2"
organization := "edu.knowitall.oqa"
name := "oqa"
version := "0.1-SNAPSHOT"
fork in run := true
javaOptions in run += "-Xmx8G"
libraryDependencies ++= Seq(
"org.slf4j" % "slf4j-api" % "1.7.10",
"org.slf4j" % "slf4j-simple" % "1.7.10",
"org.slf4j" % "slf4j-log4j12" % "1.7.10",
"com.typesafe" % "config" % "1.0.2",
"edu.washington.cs.knowitall.nlptools" %% "nlptools-postag-stanford" % "2.4.5",
"edu.washington.cs.knowitall.nlptools" %% "nlptools-tokenize-breeze" % "2.4.5",
"edu.washington.cs.knowitall.nlptools" %% "nlptools-stem-morpha" % "2.4.5",
"edu.washington.cs.knowitall.nlptools" %% "nlptools-tokenize-clear" % "2.4.5",
"edu.washington.cs.knowitall.nlptools" %% "nlptools-chunk-opennlp" % "2.4.5",
"edu.washington.cs.knowitall.taggers" %% "taggers-core" % "0.4",
"com.rockymadden.stringmetric" % "stringmetric-core" % "0.25.3",
"org.apache.solr" % "solr-solrj" % "4.3.1",
"com.twitter" %% "util-collection" % "6.3.6",
"org.scalaj" %% "scalaj-http" % "0.3.10",
"commons-logging" % "commons-logging" % "1.2"
)
libraryDependencies <+= scalaVersion("org.scala-lang" % "scala-actors" % _)
================================================
FILE: oqa-core/models/full.txt
================================================
question prefix = 'what' ^ answer shape = 'Aaaaa 111 Aaaaa' -0.9569500182415177
question prefix = 'what' ^ answer shape = 'a aaa AAA' 0.7544691718350967
lex category (postags) = Unary(WP VBP DT JJ NN VB) -0.2743524261218534
question prefix = 'where' ^ answer shape = 'Aaa Aaaaa' 1.0291864283108354
question prefix = 'UNK' ^ answer shape = 'aaa Aaaaa Aaaaa' 0.5757022984312294
lex category (postags) = Unary(WDT NN VB DT JJ NN VB IN) -0.9317767238234221
question prefix = 'be' ^ isDate 0.0
lex category (postags) = Unary(WDT NN NN VB NN IN JJ JJ NN) 0.0
question prefix = 'what' ^ answer shape = '1/11' -0.05107624954396206
lex category (postags) = Unary(WDT VB JJ NN NN) -0.8423932871214885
lex category (postags) = Unary(WP VB NN JJ VB VB TO) 0.0
lex category (postags) = Unary(WDT NN VBP IN NN NN) 0.0
lex category (postags) = Unary(WDT NN VB NN) 1.0693177672382341
lex category (postags) = Unary(WP VB DT JJ NN VBP) 0.21597956950018238
template arg pos tags = NN RB 0.8059102517329442
question prefix = 'how many' ^ answer shape = 'Aaaaa aaaa' -0.36847865742429775
parser lexical rule = fullPatternWhenBeIn 0.0
parser lexical rule = quantIdentity 0.8796059832178037
lex category (postags) = Unary(WP VBP JJ NN VB) 0.0
lex type = Unary ^ rightTag = VBP 0.0
template arg pos tags = VB NN NNS -0.6431959139000365
lex category (postags) = Unary(WDT NN VB JJ NN VB) 0.3578985771616199
template prefix how many => how many -0.3028091937249179
action type = RelSynRule -1.4483765049252098
lex category (postags) = Unary(WDT NN VBP NN NN VB) -0.4615103976650857
question prefix = 'who' ^ answer shape = 'Aaaaa AA' 0.0361182050346589
question prefix = 'what' ^ answer shape = 'Aaaa aaaa' 0.6136446552353155
lex category (postags) = Unary(WRB JJ NN VBP DT NN VB VB) 0.9875957679678949
lex category (postags) = Unary(WRB JJ NN VBP VB DT NN) -0.9875957679678949
lex category (postags) = Unary(WRB VBP DT NN NN VB) 0.10981393651951843
question prefix = 'what' ^ answer shape = 'Aaaaa aaaa aaaa' 0.1222181685516235
evidence similarity with question 4.2882653734688905
question prefix = 'what' ^ answer shape = '11-aaaa-aaa aaaa' -0.38270704122583
lex category (postags) = Unary(WDT NN VBP NN RB VB) -0.2218168551623495
action type = ParsedQuestion 0.0
lex category (postags) = Unary(WDT VB DT NN IN DT JJS NN) 0.0
lex category (postags) = Unary(WP VB VB NN NN) -0.7333090113097409
question prefix = 'where' ^ answer shape = 'aaa Aaaaa Aaaaa' -0.7997081357168916
template prefix when => who -0.5508938343670193
lex type = Identity ^ rightTag = WP -0.8701203940167822
question prefix = 'how' ^ answer shape = '1 aaaa 11**1' 0.7325793506019701
template arg pos tags = DT JJ NN NN 0.0
lex category (postags) = Unary(WP VB DT NN IN NN NN) 0.0
relSynRule pmi 0.9996351696461145
template arg pos tags = VBN 0.0
question prefix = 'what' ^ answer shape = 'aaa-aaaa' -0.7329441809558555
question prefix = 'how' ^ answer shape = 'aaa 11' 0.8011674571324334
lex category (postags) = Unary(WDT VB DT NN IN NN JJ NN) 0.0
lex category (postags) = Unary(WP VBP NN NN) 0.7891280554542137
lex category (postags) = Unary(WDT NN VBP NN VB IN) 1.422108719445458
template arg pos tags = VBG NN -0.11492156147391464
parser lexical rule = punctIdentity 0.0
answer is def noun -1.8340021889821232
lex category (postags) = Unary(WDT NN NN VBP VB NN) 0.2002918642831084
question prefix = 'what year' ^ isNumber 0.7650492520977745
template arg pos tags = NN JJ -0.1419190076614374
question prefix = 'who' ^ answer shape = 'Aaaa Aaaaa' -0.24917913170375774
lex category (postags) = Unary(WP VBZ NN IN NN) -0.608172199927034
minimum join key similarity 0.35604514334276016
lex category (postags) = Unary(WP VBP JJ NN) 0.8478657424297702
template prefix what => when 0.47427946005107624
parser lexical rule = fullPatternCop 0.46990149580445095
lex category (postags) = Unary(WDT VB JJ NN NNS NN) 1.6556001459321414
lex category (postags) = Unary(WDT NN VBP NN NNS VBP IN) 0.9452754469171835
template prefix when => what -0.33673841663626414
lex category (postags) = Unary(WDT VB DT NN IN DT JJ NN) 0.2743524261218534
question prefix = 'what' ^ answer shape = 'AA ?' 0.08099233856256838
lex type = Unary ^ leftTag = CC -0.8077344035023714
question prefix = 'what' ^ answer shape = 'Aaaaa Aaa' 0.4801167457132433
lex category (postags) = Unary(WDT NN VB NN VB VB) -0.46990149580445095
lex category (postags) = Unary(WP VB NN IN NN) 0.7482670558190443
question prefix = 'when' ^ answer shape = 'Aaaaa' -0.9317767238234221
lex category (postags) = Unary(WP VBP NNS VB IN) 0.0
lex category (postags) = Unary(WDT VB VBN JJ NN) -0.2725282743524261
lex category (postags) = Unary(WDT NN VB NN IN JJ NN) 0.0
lex type = Identity ^ leftTag = IN -1.1842393287121489
dropNameOf -0.9076979204669828
question prefix = 'how many' ^ answer shape = 'Aaaa' 0.06712878511492155
question prefix = 'what' ^ answer shape = 'aaaa aaaa aaaa' 0.009120758847136081
lex type = Identity ^ leftTag = VBN -0.8011674571324334
template pair pmi 2.0896136658507425
lex category (postags) = Unary(WDT VB DT NN IN JJ NN) 0.0747902225465158
lex category (postags) = Unary(WP VB NN NNS NN) 0.0
fbid join key violation 0.0
question prefix = 'what' ^ answer shape = '1111-11-11' 0.7245530828164903
question prefix = 'what' ^ answer shape = 'aaaa-aa-aaaa A-aaaa aaaa' 0.38380153228748637
lex category (postags) = Unary(WRB VBP NNP NNP) 0.041590660342940566
lex category (postags) = Unary(WRB VB JJ NN NNS NN) 0.4118934695366655
question prefix = 'UNK' ^ answer shape = 'Aaa Aaaaa' 0.2002918642831084
lex category (postags) = Unary(WRB VB DT NN NN NN) 0.0
template arg pos tags = NN NN VB 0.6023349142648668
question prefix = 'UNK' ^ answer shape = 'a aaaa' -0.5231667274717257
template arg pos tags = NN NNS LS 0.0
question prefix = 'what' ^ answer shape = 'aaa Aaaaa' -1.0496169281284202
template arg pos tags = DT JJ NN VB -0.9317767238234221
question prefix = 'what' ^ answer shape = 'aaa Aaaa Aaaaa' 0.3568040860999635
lex category (postags) = Unary(WRB VB NN NN) -0.7132433418460415
lex category (postags) = Unary(WRB VB DT NN VB) 0.8701203940167822
lex category (postags) = Unary(WP VB NN NN VB) -0.016782196278730455
parser lexical rule = fullPatternRelType -0.2929587741700108
lex category (postags) = Identity(WDT) -0.8898212331265961
question prefix = 'what' ^ answer shape = 'Aaa' -0.3079168186793141
question prefix = 'how' ^ answer shape = '11 aaa A' -0.659978110178767
question prefix = 'where' ^ answer shape = 'Aaaaa Aaaaa aa Aaaaa' -0.06785844582269251
answer is linked to freebase 0.6242247354979934
lex category (postags) = Unary(WRB VB DT JJ NN VB) 0.9317767238234221
lex category (postags) = Unary(WDT VB DT JJS NN VB) 0.29186428310835466
posToOf 0.02371397300255381
lex category (postags) = Unary(WDT VB NN NN NN VBZ NN) 0.5527179861364466
template arg pos tags = VB NN -0.7344035023713973
question prefix = 'what' ^ answer shape = '?Aaaaa' 1.2612185333819774
template arg pos tags = VB JJR NN 0.0
template arg pos tags = DT NN NN NN -0.011309740970448741
template arg pos tags = NN VB NN 0.0
question prefix = 'what' ^ answer shape = 'aaa aaaa' -0.29004013133892736
parser lexical rule = fullPatternWhenOn -0.09850419554906968
lex category (postags) = Unary(WDT NN VB JJ NN) -0.3101058008026268
lex category (postags) = Unary(WDT VB DT JJ NN NN VB) -0.037942356804086086
lex category (postags) = Unary(WP VBP CD JJ) 0.0
question prefix = 'what' ^ answer shape = 'AA' 0.009120758847136035
lex category (postags) = Unary(WDT NN VB DT NN NN VB NN IN) 0.6683692083181321
template prefix where => what 0.5534476468442175
lex type = Identity ^ leftTag = TO -0.1711054359722729
lex category (postags) = Unary(WDT VB DT JJ NN VBP IN) -0.543232396935425
question prefix = 'who' ^ answer shape = 'aaaa AAA' 0.4308646479387085
parser lexical rule = auxIdentity -0.44326887997081355
lex category (postags) = Unary(WP VBP DT NN IN NN) 0.9565851878876322
question prefix = 'where' ^ answer shape = 'aaa aaaa 1111a' -0.7132433418460415
lex category (postags) = Unary(WRB VB DT NN NN VB) -0.9689894199197373
template arg pos tags = WDT VB JJ NN -0.9627873039036848
lex category (postags) = Unary(WDT NN VBP VBN NN VB) 0.0
lex category (postags) = Unary(WDT NN NN VBP NN VB IN) 0.0
lex category (postags) = Unary(WDT NN VBP DT NN VB) 0.29259394381612547
question prefix = 'be' ^ isNumber -0.7457132433418461
tuple conceptVagueness_f -0.06978468085790701
question prefix = 'how' ^ answer shape = 'aaaa aaaa' -0.11236774899671652
question prefix = 'be' ^ answer shape = 'a1111' -0.7457132433418461
question prefix = 'what' ^ answer shape = 'a aaaa-aaaa aaaa' 0.07114191900766142
template prefix UNK => UNK -0.9627873039036848
question prefix = 'what' ^ answer shape = 'Aaa aaaa' 0.12951477562933236
template arg pos tags = VB JJ 0.0
lex category (postags) = Unary(WP DT NN VBP NN VB) 0.0
lex type = Identity ^ leftTag = <s> 0.24735497993433053
template arg pos tags = JJ JJ NN 0.0
template arg pos tags = NN NNS -0.9452754469171835
lex category (postags) = Unary(WDT VB DT NN IN JJ NN NN) 0.0
question prefix = 'how' ^ answer shape = 'Aaaaa 11aa' -0.6358993068223276
lex category (postags) = Unary(WDT VB NN NN JJ NNS NN) 0.0
template arg pos tags = DT JJ JJ 0.0
question prefix = 'who' ^ answer shape = 'Aaaa' -0.31047063115651224
template arg pos tags = VB IN NN NN 0.0
question prefix = 'where' ^ answer shape = 'Aaaaa' 1.0645749726377234
lex category (postags) = Unary(WDT VB VB DT NN IN NN) 0.9025902955125866
tuple num_extrs_i 0.23171075013440565
lex category (postags) = Unary(WRB VBP JJ NN VB) -0.10871944545786216
question prefix = 'who' ^ answer shape = 'Aaaa Aaaa' 0.19591390003648304
question prefix = 'how many' ^ answer shape = '111,111 aaaa' 0.21196643560744255
template arg pos tags = NNS JJ 0.0
lex category (postags) = Unary(WDT NN VB VBN NN VBP IN) -0.6402772710689529
question prefix = 'what' ^ answer shape = 'Aaaaa aa aaa Aaaaa'a Aaaaa aa Aaaaa' 0.44910616563298067
question prefix = 'what' ^ answer shape = 'Aaaaa Aaa Aaaaa' 0.2725282743524261
lex category (postags) = Unary(WDT VB VB NN) -0.7344035023713973
dropPP -1.999270339292229
lex type = Identity ^ rightTag = VBP -0.8077344035023714
question prefix = 'what' ^ answer shape = 'Aaa Aaaa aa Aaaaa Aaaaa' 0.2542867566581539
question prefix = 'what year' ^ answer shape = 'aaaa' -0.7650492520977745
parser combinator rule = UnaryIdentity 0.0
question prefix = 'how many' ^ isNumber -0.31229478292593943
lex category (postags) = Unary(WP VB DT NN IN DT NN) 0.0
question prefix = 'what' ^ answer shape = 'aaa Aaaaa Aaaaa aaaa' 0.3542502736227654
lex category (postags) = Unary(WP VBZ NN NN) -0.9551258664720905
question prefix = 'what' ^ answer shape = 'AAAa' -0.012404232032105056
lex category (postags) = Unary(WRB VB RB NN VB) 0.556366289675301
lex category (postags) = Unary(WRB JJ NN VB RB IN DT JJ NN) 0.5242612185333819
lex category (postags) = Unary(WDT VB DT NN VB) -1.1185698650127691
answer from namespace 'probase' 0.029186428310835462
template arg pos tags = NN NN NN 0.34002188982123316
template arg pos tags = NN IN JJ 0.0
action type = ProjectAction$ 0.0
template arg pos tags = VB DT CD NN 0.0
question prefix = 'what' ^ answer shape = 'Aa. AAAA' -0.43889091572418826
answer from namespace 'reverb' -0.4593214155417731
template arg pos tags = VB NN NN 0.0
lex category (postags) = Unary(WP NN VBP NN VB VB) 0.4005837285662167
question prefix = 'UNK' ^ answer shape = 'aaaa Aaaaa' 0.46990149580445095
template arg pos tags = RB JJ 0.0
lex category (postags) = Unary(WDT NN VB NN IN DT NN) 0.0
question prefix = 'UNK' ^ answer shape = 'AAAA' -0.5757022984312294
lex category (postags) = Unary(WP VB JJ NN NN VB IN) 0.0
template arg pos tags = JJ NN -0.3414812112367749
action type = DropStopAction$ -0.40897482670558194
lex type = Identity ^ leftTag = NN -0.7763589930682233
lex category (postags) = Unary(WDT NN VB NN IN NN) -0.08099233856256838
lex category (postags) = Unary(WDT NN VB VB IN CD DT NN NN) -0.7303903684786575
lex category (postags) = Unary(WDT VB JJ NN VB) -0.9627873039036848
parser combinator rule = UnaryIntersect -0.4421743889091573
lex category (postags) = Unary(WDT VB DT NN IN NN NN NN) -0.3009850419554907
lex type = Unary ^ leftTag = VB -0.13900036483035388
template arg pos tags = DT JJ 0.0
lex category (postags) = Unary(WDT VB DT NN NN IN NN) 0.8931047063115651
question prefix = 'UNK' ^ answer shape = 'aaa Aaaaa' 0.21597956950018238
lex type = Identity ^ rightTag = VB -0.096315213425757
template arg pos tags = NNP 0.0
lex category (postags) = Unary(WDT NN VBP NN VBP IN) -0.739875957679679
question prefix = 'be' ^ answer shape = 'a aaaa , aaaa aaaa' 0.4841298796059832
lex category (postags) = Unary(WDT VB NN NN VB VB) 0.0
lex category (postags) = Unary(WDT NN VB NN NN) 0.0
lex category (postags) = Unary(WRB VB JJ NN VBN) -0.8011674571324334
template arg pos tags = DT NN IN NN -0.5231667274717257
question prefix = 'what' ^ answer shape = 'Aaa Aaaa' -0.3870850054724553
question prefix = 'how' ^ answer shape = 'a aaaa' 0.30317402407880334
lex category (postags) = Unary(WDT VB DT JJ NN IN DT NN) -0.6450200656694637
lex category (postags) = Unary(WDT VB PRP$ NN) -0.4421743889091573
template prefix how => UNK 0.0
template prefix what => who -0.990879241152864
question prefix = 'how' ^ answer shape = '11' 0.3163079168186793
template prefix what => how many 0.40167821962787303
question prefix = 'what' ^ answer shape = 'aaaa aaa' 0.315213425757023
question prefix = 'what' ^ answer shape = 'Aaaaa Aaaaa Aaaaa' 0.23166727471725648
paraphrase lm -0.8559275264502015
question prefix = 'what' ^ answer shape = 'Aaaaa aaaa' -0.2032105071141919
num lexical rules -1.6143013498723098
lex category (postags) = Unary(WRB NNS VB NN VBN) -0.8777818314483765
lex category (postags) = Unary(WDT NNS DT NN IN DT JJ NN) 0.4421743889091573
lex category (postags) = Unary(WDT VB NN NNS JJS NN) -0.14921561473914635
parser lexical rule = fullPatternWhereIn -1.6811382707041225
lex category (postags) = Unary(WRB JJ NN VBP NN VB) 0.9755563662896753
lex category (postags) = Unary(WRB VBP NN NN VB RP) 0.0
lex category (postags) = Unary(WDT VB VB DT CD NN) 0.0
lex category (postags) = Unary(WRB JJ NN VBP NNS VB) 0.0
dropTypeOf 0.7128785114921561
lex category (postags) = Unary(WDT VB DT NN IN NN NNP) 0.6504925209777453
lex type = Identity ^ leftTag = RP 0.0
template arg pos tags = DT NN -1.5757022984312294
lex category (postags) = Unary(WDT VB DT NN IN NN JJ) 0.0
question prefix = 'who' ^ answer shape = 'Aa. Aaaa' 0.9565851878876322
template arg pos tags = NN VBN 0.8777818314483765
template prefix where => what year 0.4746442904049617
question prefix = 'who' ^ answer shape = 'Aaaaa' -1.385260853703028
template arg pos tags = NN VBP JJ NN 0.6887997081357169
template arg pos tags = IN NN 0.8704852243706677
lex category (postags) = Unary(WRB VBP NN VB) -0.38124771981028815
question prefix = 'what' ^ answer shape = '1111' -0.7854797519153593
lex category (postags) = Unary(WDT VB DT NN VB NN IN) 0.0
template arg pos tags = CD DT NN NN 0.0
lex category (postags) = Unary(WDT VB DT NN NN IN VBG NNP) -0.11492156147391464
lex category (postags) = Unary(WDT NN VB DT NN NN NN) -0.6683692083181321
question prefix = 'UNK' ^ answer shape = 'Aaaaa' -1.1911711054359722
question prefix = 'what' ^ answer shape = 'aaaa aa aaa Aaaaa Aaaaa' 0.15724188252462604
template arg pos tags = NN CD CD 0.0
lex category (postags) = Unary(WRB JJ NN VBP JJ NNS VB) -0.6898941991973733
lex category (postags) = Unary(WP VBP NN NN VBP VB) 0.3042685151404597
lex category (postags) = Unary(WDT VB NN NN NN VBG) -0.5527179861364466
template prefix be => what 0.0
lex category (postags) = Unary(WP VB VB TO JJ NN) -0.8609996351696461
question prefix = 'what' ^ answer shape = 'aaa Aaaaa aaaa' -0.26669098869025903
question prefix = 'how' ^ isDate -0.9073330901130974
question prefix = 'when' ^ answer shape = 'Aaaa' 0.6391827800072966
lex category (postags) = Identity(CC) -0.8077344035023714
lex category (postags) = Unary(WP VBP NN NN VB VB TO) -0.1711054359722729
question prefix = 'how' ^ isNumber 1.0211601605253557
num conjuncts -1.1762130609266692
lex category (postags) = Unary(WRB JJ NNS VB RB IN DT NN) -0.3283473184968989
question prefix = 'what' ^ answer shape = '11 aaaa' 0.9328712148850784
question prefix = 'where' ^ answer shape = '1111' -0.7971543232396936
template arg pos tags = CD 0.0
lex category (postags) = Unary(WP VBP NN JJ VB) 0.1419190076614374
action type = DropStopAction 0.9996351696461145
question prefix = 'what' ^ answer shape = 'Aa Aaaaa' 0.7643195913900036
template prefix UNK => be 0.7508208682962423
answer from namespace 'nell' -0.6242247354979934
lex category (postags) = Identity(WP) -0.9627873039036848
parser lexical rule = ignoreTypesIdentity 0.0
lex category (postags) = Unary(WDT VB DT NN NN IN DT NN) 0.4035023713973003
question prefix = 'who' ^ answer shape = 'aaa Aaaaa' 0.1944545786209413
question prefix = 'where' ^ answer shape = 'aaa Aaaaa Aaa' 0.8704852243706677
template prefix be => who 0.0
template prefix who => who 1.4611455673112004
lex category (postags) = Unary(WDT NN VB DT NN NN VBP IN) 0.0
question prefix = 'what' ^ answer shape = 'Aaaaa aaaa aaa' -0.5705946734768332
template prefix what => how 0.2725282743524261
lex category (postags) = Unary(WP VB JJ NN) 0.0
question prefix = 'what' ^ answer shape = 'Aaaaa Aaa aaaa' 0.2141554177307552
lex category (postags) = Unary(WDT VB DT NN NN IN JJ NN) 0.1908062750820868
lex category (postags) = Unary(WP VBP NN VB) 0.43013498723093757
question prefix = 'what' ^ answer shape = 'Aaaaa?a aaaa' -0.7814666180226195
lex category (postags) = Unary(WP VB DT NN IN NN) -0.8059102517329442
lex category (postags) = Unary(WDT VB DT NN IN NN NNS JJS NN) 0.14921561473914635
lex category (postags) = Unary(WRB JJ NN VB JJ NN NN) -0.44509303174024084
question prefix = 'how many' ^ answer shape = 'Aaaaa' -0.604888726742065
question prefix = 'UNK' ^ answer shape = 'Aaa aaaa aaaa' -0.2002918642831084
answer from namespace 'freebase' 0.704487413352791
lex category (postags) = Unary(WDT VB JJ NNS) -0.4162714337832908
question prefix = 'what' ^ answer shape = '? Aaaa' 0.6431959139000365
question prefix = 'what' ^ answer shape = 'Aaaa Aaaaa Aaaaa' 0.025173294418095585
parser lexical rule = conjIdentity -0.8077344035023714
question prefix = 'how' ^ answer shape = 'aaa aaaa' 0.7074060561838744
question prefix = 'where' ^ answer shape = 'Aaaaa Aaaa' 0.556366289675301
lex type = Identity ^ leftTag = VBG -0.5527179861364466
lex type = Identity ^ leftTag = RB 0.0
question prefix = 'how' ^ answer shape = 'aaaa Aaa Aaaa' -0.7325793506019701
lex category (postags) = Unary(WP VB NN IN NN NN) 0.4035023713973003
lex type = Identity ^ rightTag = WRB -0.8274352426121854
whatDate -0.8011674571324334
lex category (postags) = Unary(WDT VB NN NN) 0.2914994527544692
lex category (postags) = Unary(WDT NN VBP NN JJ NN) 0.0
lex category (postags) = Unary(WDT VB DT JJ NN VB) 0.9029551258664721
question prefix = 'how' ^ answer shape = 'a aaa aaaa' -0.5964976286026997
lex category (postags) = Unary(WDT NN VBP RP DT NN) 0.6450200656694637
template arg pos tags = NN IN JJ NN 0.688070047427946
lex category (postags) = Unary(WDT VB DT NN IN DT NN NN) 1.4761036118205035
template arg pos tags = DT RBS JJ NN 0.0
question prefix = 'what' ^ answer shape = 'Aaaaa--Aaaaa aaaa aaa aaaa--11aa aaaa' 0.7303903684786575
lex category (postags) = Unary(WDT JJ NN VB JJ NN) 0.0
parser lexical rule = fullPatternDobj 0.1484859540313752
tuple freq_i 0.6551340867111581
template arg pos tags = DT NN NN JJ 0.7617657789128056
question prefix = 'UNK' ^ answer shape = 'aaaa' -0.8475009120758847
lex category (postags) = Unary(WRB JJ NN VB DT NN NN) -0.21196643560744255
question prefix = 'when' and isDate 0.9996351696461145
lex category (postags) = Unary(WDT NN VBP JJ NN VB) 0.5370302809193723
query relation is light verb 1.0244436337103249
question prefix = 'where' ^ answer shape = 'Aaa Aaaa Aaaa' -0.6683692083181321
question prefix = 'where' ^ isDate -0.7971543232396936
lex category (postags) = Unary(WDT VB NN NNS NN) 0.09740970448741337
lex category (postags) = Unary(WDT NN VBP DT NN NN NN VB) -0.12513681138270705
template prefix what => UNK 0.2630426851514046
template arg pos tags = RB IN DT NN 0.3283473184968989
question prefix = 'who' ^ answer shape = 'aaa-aaaa-aaaa' 0.3619117110543597
lex category (postags) = Unary(WP VB NN NN) 0.7792776358993068
question prefix = 'where' ^ answer shape = 'Aaa Aaaa' -0.9675300985041956
lex category (postags) = Unary(WDT VB JJ NNS VBP) 0.0
question prefix = 'what' ^ answer shape = 'aaa 111?A' 0.47172564757387814
question prefix = 'what' ^ answer shape = 'aaa Aaaaa Aaaaa' -0.23166727471725646
question prefix = 'what' ^ answer shape = 'aaaa aaa aaaa' -0.7504560379423568
lex category (postags) = Unary(WP VB IN NN) 0.8059102517329442
template prefix who => where -0.8478657424297702
template prefix how => what 0.9098869025902956
lex category (postags) = Unary(WP VBP NNS VB) 0.0
parser lexical rule = fullPatternSubj 1.135716891645385
question prefix = 'who' ^ answer shape = 'Aaa Aaaaa' 0.5804450930317402
lex category (postags) = Unary(WDT VB JJ NN) 1.5804450930317402
question prefix = 'who' ^ answer shape = 'aaa aaa aaaa' -0.1039766508573513
template prefix when => where -0.9996351696461145
template arg pos tags = JJ NN NN 0.0
question prefix = 'what' ^ answer shape = 'Aaaaa'a Aaaaa' 0.34695366654505655
action type = ExecutionAction$ 0.0
question prefix = 'what year' ^ answer shape = '1111' 0.7650492520977745
question prefix = 'how' ^ answer shape = '1 aaaa' 0.09084275811747544
question prefix = 'what' ^ answer shape = 'a aaa' -0.2743524261218534
question prefix = 'who' ^ answer shape = 'Aaaaa (Aa aaa aaaa)' -0.23859905144107996
question prefix = 'UNK' ^ answer shape = 'Aaaa' -0.5169646114556732
question prefix = 'how' ^ answer shape = 'Aaa Aaaaa Aaa Aaa' 0.659978110178767
template arg pos tags = DT JJ NN VBN 0.0
lex category (postags) = Unary(WP VBP NN VB NN TO) 0.0
question prefix = 'how' ^ answer shape = '111.111' 0.9573148485954032
parser lexical rule = fullPatternPoss 1.036118205034659
question prefix = 'what' ^ answer shape = 'aaaa aaaa aaa' -0.5928493250638454
question prefix = 'what' ^ answer shape = 'aaaa aaaa' -0.35716891645384896
template prefix what => where -0.8445822692448012
question prefix = 'UNK' ^ answer shape = 'Aaaaa Aaaaa' 0.19299525720539948
lex category (postags) = Unary(WDT JJ NN VB IN NN) 0.688070047427946
lex type = Unary ^ leftTag = WRB 0.4005837285662167
lex category (postags) = Unary(WP VB NNP NNP VB) -0.5519883254286757
template arg pos tags = NN NNS VBP 0.0
template pair count1 -2.0042169835066455
lex category (postags) = Unary(WP VBP DT NN NN VB) 0.0
parser lexical rule = fullPatternTypeSubj -0.9525720539948924
lex category (postags) = Unary(WDT NN VBP NN NN VBP DT NN NN IN) 0.0
question prefix = 'how' ^ answer shape = '1111' 0.46625319226559647
question prefix = 'what' ^ answer shape = 'Aaaaa a aaaa' 0.6698285297336739
question prefix = 'UNK' ^ answer shape = 'aa aaaa' 0.08464064210142283
lex category (postags) = Unary(WP VBP DT JJ NN NN) 0.20102152499087922
lex category (postags) = Unary(WDT VB IN NN) 0.15286391827800072
lex type = Identity ^ rightTag = </s> 0.0
lex category (postags) = Unary(WDT VB DT NN TO DT NN) 0.7325793506019701
parser lexical rule = whIdentity -2.2597592119664354
lex category (postags) = Unary(WP VBP NN NN NN VB) 0.6636264137176213
template prefix how => what year -0.8011674571324334
question prefix = 'who' ^ answer shape = 'Aaaaa Aaaa' 0.2013863553447648
lex category (postags) = Unary(WDT VB DT JJ JJS NN IN DT NN) 0.0
question prefix = 'what' ^ isDate -0.40386720175118573
template arg pos tags = VBP NN 0.6822327617657789
question prefix = 'what' ^ answer shape = 'aaaa aa aaaa aaaa' 0.21524990879241152
parser lexical rule = fullPatternWhereIs -0.3870850054724553
lex category (postags) = Unary(WDT VB DT NN IN DT NN) -0.8394746442904051
question prefix = 'who' ^ answer shape = 'aaa AAA' -0.7676030645749726
lex category (postags) = Unary(WDT NN VBP JJ NN VB IN) 0.0
lex category (postags) = Unary(WRB VB DT NN NN) -0.8931047063115651
lex category (postags) = Unary(WDT VB JJ NN VB VB) 0.6202116016052536
lex category (postags) = Unary(WP VB NN) 0.0
lex category (postags) = Unary(WDT VB NN NN VBZ NN) -0.30134987230937615
question prefix = 'what' ^ answer shape = 'Aaaaa?Aaaaa Aaaa Aaaa' 0.13644655235315584
question prefix = 'what' ^ answer shape = '11 aaa aaaa' -0.7223641006931777
question prefix = 'when' ^ answer shape = 'Aaaaa 11' -0.5713243341846042
question prefix = 'where' ^ answer shape = 'Aaaaa Aaaaa' 0.5133163079168187
lex type = Identity ^ leftTag = WP -0.9627873039036848
question prefix = 'who' ^ answer shape = 'Aaaaa & Aaaaa' -0.6898941991973733
lex type = Unary ^ leftTag = <s> -0.24735497993433053
question prefix = 'when' ^ isDate 1.9277635899306822
question prefix = 'what' ^ answer shape = 'Aaaaa aa Aa Aaaaa' 0.3889091572418826
lex type = Identity ^ leftTag = VBP 0.21597956950018238
lex category (postags) = Unary(WRB JJ NN VBP DT JJ NN VB) -0.5242612185333819
lex category (postags) = Unary(WDT VB VB NN NN) 0.0
lex category (postags) = Unary(WP VB NN IN CD) 0.9273987595767967
lex type = Identity ^ leftTag = NNS -1.0594673476833272
question prefix = 'who' ^ answer shape = 'Aaa Aaa' 0.1039766508573513
question prefix = 'what' ^ answer shape = 'a ?aaa' -0.9204669828529733
question prefix = 'where' and isDate -0.9996351696461145
lex category (postags) = Unary(WDT VB JJ NN IN NN) 0.8719445457862094
question prefix = 'where' ^ answer shape = 'Aa Aaaaa aaa Aaa Aaaa' -0.041590660342940566
question prefix = 'who' ^ answer shape = 'aaa 11aa aaaa' -0.9689894199197373
template arg pos tags = JJ NNP -0.2520977745348413
question prefix = 'what' ^ answer shape = 'Aaaaa aaaa aaaa aaaa' 0.3060926669098869
lex category (postags) = Unary(WP VB VB JJ NN IN NN) 0.0
lex category (postags) = Unary(WRB VB NN NNS NN) 0.0
lex category (postags) = Unary(WP VB DT NN NN VB) 0.9689894199197373
lex category (postags) = Unary(WP VBP VB DT NN) -0.8701203940167822
lex category (postags) = Unary(WDT NN VBP NN VB) -0.4797519153593579
question prefix = 'what' ^ answer shape = 'aaa Aaaaa Aaa' 0.855162349507479
question prefix = 'what' ^ answer shape = 'aaaa Aaaaa' 0.40933965705946734
question prefix = 'where' ^ answer shape = 'a Aaaaa Aaaaa aaaa' 0.8128420284567677
question prefix = 'when' ^ answer shape = '11 Aaaa' 0.5746078073695732
question prefix = 'where' ^ answer shape = 'Aaaa' 0.6267785479751915
question prefix = 'what' ^ answer shape = 'a-aaaa' -0.7544691718350967
lex category (postags) = Unary(WDT NN VBP NN VBP TO) 0.0
question prefix = 'who' ^ answer shape = 'aaaa aaaa' 0.6683692083181321
template prefix what => what 0.7701568770521707
template arg pos tags = JJ NNS VBP 0.0
lex category (postags) = Unary(WRB JJ NN VB IN NN) 0.0
lex category (postags) = Unary(WP VBP CD) -0.9273987595767967
question prefix = 'what' ^ answer shape = '?aaaa aaaa?' 0.01824151769427218
question prefix = 'UNK' ^ answer shape = 'aaa Aaaaa aaaa' 0.9029551258664721
lex category (postags) = Unary(WDT VB DT NN NN JJ NN) -0.7617657789128056
lex category (postags) = Unary(WDT NN VBP JJ NNS VB) 0.0
question prefix = 'what' ^ answer shape = 'aa aaaa' 0.037942356804086086
dropAdverb -0.7544691718350967
template arg pos tags = WDT JJ VB VBP 0.7508208682962423
lex category (postags) = Unary(WP VB VBN NN) 0.0
question prefix = 'when' ^ answer shape = '1111 aaaa aaaa' -0.10981393651951843
lex category (postags) = Unary(WP VBP JJ NNS VBP IN) 0.0
lex category (postags) = Unary(WDT NN VB VB JJ NNP) 0.2520977745348413
template prefix when => when -0.46917183509668003
template arg pos tags = WDT NN 0.0
template prefix who => what -0.21233126596132812
template prefix where => who -0.8704852243706677
template arg pos tags = DT NN VB 0.9875957679678949
lex type = Identity ^ leftTag = CD 0.08609996351696461
lex category (postags) = Unary(WRB VBP DT CD DT NN JJ NN VB) 0.0
template prefix where => how many 0.11528639182780007
lex category (postags) = Unary(WRB VB NN JJ JJ VBP IN) 0.0
template prefix UNK => where 0.0
action type = ParaphraseRule -1.726742064939803
lex category (postags) = Unary(WP VB JJ NN VB) 0.8609996351696461
question prefix = 'what' ^ answer shape = 'AAAA AAAA' 0.04706311565122218
question prefix = 'who' ^ answer shape = 'aaaa aaaa aaaa' 0.02991608901860635
question prefix = 'when' ^ answer shape = 'Aaaaa 11 1111' -0.019336008755928558
lex category (postags) = Unary(WP VB NN NNS JJS NN) -0.4035023713973003
question prefix = 'what' ^ answer shape = 'Aaaaa aaaa aa Aaaaa' 0.5060197008391099
question prefix = 'what' ^ answer shape = 'Aaa aaaa aaaa aaaa' 1.1656329806639913
lex category (postags) = Unary(WDT NN VBP IN NN) 0.008755928493250638
question prefix = 'UNK' ^ answer shape = 'Aaaa Aaa Aaaaa' 0.7508208682962423
question prefix = 'what' ^ answer shape = 'Aaaaa Aaaaa aaaa' -0.8566216709230208
template pair count2 -2.9296376158757527
lex category (postags) = Unary(WDT NN VBP NN NN VB TO) 0.0
lex category (postags) = Unary(WDT JJ NN VBP JJ NN) 0.6887997081357169
lex type = Unary ^ leftTag = NN -0.4421743889091573
template arg pos tags = NN NNS NN 0.6431959139000365
question prefix = 'how many' ^ answer shape = 'Aaaaa Aaaaa' -0.2933236045238964
question prefix = 'what' ^ answer shape = 'a aaaa aaaa' -0.4771981028821598
lex category (postags) = Unary(WDT JJ NN VBP DT JJ NN VB) 0.0
question prefix = 'who' ^ answer shape = 'Aaaaa aa-Aaaaa' 0.8059102517329442
lex category (postags) = Unary(WDT JJ NN VBP NN VB) -0.688070047427946
lex category (postags) = Unary(WP VB VBN NNP NNP VBZ NN) -0.03575337468077344
lex category (postags) = Unary(WDT VB DT JJ NN IN NN) 0.0
parser lexical rule = fullPatternDefn -1.2506384531192996
question prefix = 'how' ^ answer shape = 'aaa aaaa aaaa' -0.46625319226559647
parser lexical rule = fullPatternHaveProp 0.026267785479751914
question prefix = 'what' ^ answer shape = 'aaaa' -2.579350601970084
question prefix = 'where' ^ answer shape = 'Aaaaa Aaaa Aaaa' 0.8931047063115651
lex category (postags) = Unary(WDT VB DT NN IN DT JJ NN NN) -0.16307916818679313
question prefix = 'how many' ^ answer shape = 'aaaa' 0.3746807734403502
lex category (postags) = Unary(WDT VB DT NNS IN JJ NN) -0.09157241882524625
question prefix = 'what' ^ answer shape = 'Aaaaa Aaaaa' 0.08427581174753729
lex category (postags) = Identity(VB) -0.44326887997081355
question prefix = 'what' ^ answer shape = 'Aaaaa Aaaa' -0.929222911346224
question prefix = 'what' ^ answer shape = 'Aaa Aaaa Aaaa' -0.527544691718351
lex category (postags) = Unary(WDT VB NN JJ VB VB) -0.7672382342210872
lex category (postags) = Unary(WDT NN VB DT NN VB IN) -0.7325793506019701
lex type = Identity ^ rightTag = NN 1.1514045968624589
template arg pos tags = NN NN 0.6763954761036118
uses full parser pattern 0.9996351696461145
question prefix = 'how' ^ answer shape = 'Aaaaa 11' -0.27143378329076984
lex category (postags) = Unary(WDT VB JJ NN NNS NN NN) -0.9547610361182051
question prefix = 'what' ^ answer shape = 'a aaaa' -0.008391098139365227
question prefix = 'what' ^ answer shape = 'aa aaa aaaa' -0.4264866836920832
question prefix = 'when' ^ answer shape = 'Aaaaa 11 , 1111' 0.019336008755928558
template arg pos tags = NNS 0.0
lex category (postags) = Unary(WDT NN VBP NN NN VB IN) -0.3268879970813572
lex category (postags) = Unary(WDT VB VBG NN NNS NN) 0.11492156147391464
lex category (postags) = Unary(WRB VB JJ NN VB) -0.8478657424297702
question prefix = 'who' ^ answer shape = 'Aaa Aaaa' -0.016782196278730455
lex category (postags) = Unary(WDT NN VB IN DT NN) 0.0
parser lexical rule = fullPatternProperty 1.4739146296971908
lex category (postags) = Unary(WP VBP NN NNS VB) 0.0
question prefix = 'what' ^ answer shape = 'aaaa-aaaa' 0.6278730390368479
lex category (postags) = Unary(WP VB DT NN IN DT JJ NN) 0.0
question prefix = 'who' ^ answer shape = 'aaa aaaa' 0.18642831083546152
question prefix = 'what' ^ isNumber -0.39255746078073694
template arg pos tags = JJ NN IN JJ 0.0
template prefix UNK => why 0.4005837285662167
lex category (postags) = Unary(WDT VB DT NN IN CD DT NN NN) 0.7303903684786575
template prefix UNK => when 0.0
lex type = Unary ^ leftTag = VBP 0.0
question prefix = 'who' ^ isDate -0.8478657424297702
lex category (postags) = Unary(WDT VB DT NN NN VB IN) 0.0
template pair count12 2.0999082942234693
question prefix = 'who' ^ answer shape = 'Aaaaa Aaaaa' 1.1342575702298432
lex category (postags) = Unary(WRB JJ NN VBP JJ NN VB) -0.9368843487778183
template prefix how many => what 0.5403137541043415
lex category (postags) = Unary(WDT VB DT NN IN NN) 1.3495074790222548
question prefix = 'what' ^ answer shape = 'AAAA' -0.9927033929222913
lex category (postags) = Unary(WRB VB JJ NN) -0.5899306822327618
question prefix = 'what' ^ answer shape = 'Aa'aaa-aa' 0.0722364100693178
tuple popularity_i 0.5574075851565106
template arg pos tags = WP VBP NN NN 0.0
template arg pos tags = '' NN '' 0.0
lex category (postags) = Unary(WDT VBP NN NN) 0.0
template prefix UNK => who 0.01568770521707406
question prefix = 'be' ^ answer shape = 'Aaaaa' 0.26158336373586283
lex category (postags) = Unary(WRB VBP NNP NNP VB) -0.041590660342940566
lex category (postags) = Unary(WP VBP DT NN VB) -0.9573148485954032
template arg pos tags = VB JJ NN 0.0
lex type = Identity ^ leftTag = VB 1.150674936154688
question prefix = 'who' ^ answer shape = 'Aaaaa aaaa 111 aaaa aaaa aaaa' 0.704487413352791
template arg pos tags = WRB VBP NNP NNP 0.0
question prefix = 'what' ^ answer shape = 'aa aaaa aaaa' -0.3889091572418826
template arg pos tags = RB 0.543232396935425
lex category (postags) = Unary(WRB VB NN RB VB) 0.09923385625684056
template arg pos tags = NN IN NN 0.0
template arg pos tags = VBN JJ 0.0
template arg pos tags = NNS JJS NN -0.4035023713973003
lex category (postags) = Unary(WRB JJ NN VBP NN NN VB) 1.3940167821962788
question prefix = 'who' ^ answer shape = 'Aaa' 0.4035023713973003
template arg pos tags = VB JJ NNP 0.2520977745348413
question prefix = 'where' ^ answer shape = 'Aaaa aaa Aaaaa' -0.8898212331265961
lex type = Identity ^ leftTag = WDT -0.8898212331265961
question prefix = 'what' ^ answer shape = 'Aaaaa Aaaaa aa Aaaaa' 0.05107624954396206
question prefix = 'what year' ^ isDate 0.7650492520977745
question prefix = 'when' ^ answer shape = 'aaa 1111 'a' 0.29952572053994897
question prefix = 'how' ^ answer shape = 'aaaa' -0.34950747902225465
question prefix = 'what' ^ answer shape = 'Aaa Aaaaa' -0.5257205399489238
template arg pos tags = WDT NN VB NN -0.46990149580445095
lex category (postags) = Unary(WRB VBP NN NN VB) 0.0
question prefix = 'who' ^ answer shape = 'Aaaaa aaaa' -0.608172199927034
question prefix = 'UNK' ^ answer shape = 'Aaaaa.' 0.5169646114556732
question prefix = 'UNK' ^ isNumber 0.0
question prefix = 'how many' ^ answer shape = 'aaaa://aa.aaaa.aaa/aaaa/Aaa%11Aaaaa%11Aaaa%11(AA%11aaaa)' -0.5242612185333819
lex category (postags) = Unary(WDT JJ NN VB RB IN DT NN) 0.3283473184968989
lex category (postags) = Unary(WDT NN VB DT NN NN JJ) 0.7617657789128056
template arg pos tags = VBP DT NN -1.1514045968624589
template arg pos tags = DT JJ NN -1.2013863553447646
template arg pos tags = JJ NNS NN -0.6504925209777453
question prefix = 'UNK' ^ isDate 0.0
question prefix = 'what' ^ answer shape = 'Aaaa' -0.6369937978839839
template prefix UNK => what -1.6563298066399126
parser lexical rule = fullPatternCopRel -0.48704852243706687
question prefix = 'what' ^ answer shape = '?AAAA' -0.5056548704852244
question prefix = 'where' ^ answer shape = 'Aa' 0.09923385625684056
steps -3.2630426851514045
lex category (postags) = Unary(WDT NN VBP DT NN) -0.16380882889456405
question prefix = 'who' ^ answer shape = 'Aaa 11-aaaa-aaa' -0.15432323969354256
question prefix = 'when' ^ answer shape = '1111' 1.3772345859175483
lex category (postags) = Unary(WDT VB DT NN IN NN NN) -1.363006202116016
template prefix when => what month 0.0
action type = AbstractArgAction -2.7347683327252827
lex category (postags) = Unary(WRB VB DT NN NNS VB) 0.0
template arg pos tags = WRB VB VBN -0.8898212331265961
lex category (postags) = Unary(WDT RB VBP NN NN) -0.3042685151404597
lex category (postags) = Unary(WP VBP NNP) 0.0
question prefix = 'what' ^ answer shape = 'Aaaa aa aaa Aaaa' 0.8515140459686246
answer from namespace 'openie4' -1.7599416271433783
question prefix = 'when' ^ answer shape = 'Aaa' 0.10981393651951843
question prefix = 'what' ^ answer shape = '?aaaa aaaa ?' -0.5946734768332725
lex category (postags) = Unary(WDT VB DT NN IN DT NN NN NN) -0.011309740970448741
lex category (postags) = Unary(WRB VB VBN NN NNS NN) -0.8898212331265961
lex category (postags) = Unary(WP VB NNP NNP) 0.5519883254286757
question prefix = 'where' ^ answer shape = 'a aaaa' -0.8128420284567677
lex category (postags) = Unary(WRB JJ NN VBP VB NN NNS) -0.6431959139000365
question prefix = 'what' ^ answer shape = 'aaaa.aaa' -0.3542502736227654
lex category (postags) = Unary(WRB VB NN) -0.9230207953301715
lex category (postags) = Unary(WP VBP NN CD CD) -0.47318496898942
lex category (postags) = Unary(WRB VB NN VB) -0.556366289675301
question prefix = 'how' ^ answer shape = 'aaa-AA, aaa-aaaa aaaa aaaa' 0.8847136081721999
question prefix = 'who' ^ isNumber -0.4188252462604889
template arg pos tags = JJ NN VB -0.02006566946369938
lex category (postags) = Unary(WRB VB NN NN VBZ NN NN) 0.7887632251003283
question prefix = 'what' ^ answer shape = 'Aaaaa'a' -0.03319956220357534
lex category (postags) = Unary(WDT NN VB NNS VB IN) 0.0
parser lexical rule = fullPatternTypeDobj 0.21853338197738048
question prefix = 'how' ^ answer shape = '111 aaaa aaaa' -0.8847136081721999
lex category (postags) = Unary(WDT VB DT JJS NN IN DT NN) 0.0
question prefix = 'what' ^ answer shape = 'aaaa-aaaa aaaa' 0.43305363006202113
template arg pos tags = NNP NNP -0.5519883254286757
template arg pos tags = NN VBP NN -0.9109813936519519
lex category (postags) = Unary(WP VBP NN NN VB) 1.2323969354250273
lex type = Unary ^ rightTag = </s> 0.0
lex category (postags) = Unary(WDT VB NN IN NN) -0.9496534111638089
lex category (postags) = Unary(WDT NN VBP DT JJ NN VBP JJ NN IN) 0.0
template arg pos tags = JJ JJ 0.6504925209777453
template arg pos tags = VBP NNS 0.0
question prefix = 'where' ^ answer shape = 'aaaa' -0.809923385625684
template prefix UNK => how 0.0
question prefix = 'where' ^ answer shape = 'aaaa-aaaa' -0.6950018241517695
lex category (postags) = Unary(WRB VB VBN NN) 1.8128420284567677
query similarity with question 3.3445331594912027
question prefix = 'what' ^ answer shape = 'aaaa.' 0.479022254651587
template arg pos tags = NN NNS JJS NN 0.14921561473914635
template arg pos tags = JJ VB VBP NN -0.7508208682962423
lex category (postags) = Unary(WDT NN VB NN VB) 0.1977380518059103
template arg pos tags = VB DT NN 0.03246990149580445
question prefix = 'how many' ^ answer shape = 'Aaaa Aaaaa' 0.9875957679678949
lex category (postags) = Unary(WP VBP NN NN VBP) 0.0
lex category (postags) = Unary(WDT VB DT NN) 0.0
question prefix = 'when' ^ isNumber 1.1787668734038672
lex category (postags) = Unary(WP VBP DT NN NN NN) 0.0
question prefix = 'who' ^ answer shape = 'aaa Aaa Aaaa Aaaa' 0.39584093396570597
lex type = Identity ^ leftTag = JJ 1.4928858080992338
lex type = Unary ^ leftTag = CD 0.7935060197008391
question prefix = 'what' ^ answer shape = '1,111a' -0.3535206129149946
question prefix = 'who' ^ answer shape = 'aaa Aaaaa Aaaaa' -0.3619117110543597
question prefix = 'where' ^ answer shape = 'aaa AAA' 0.7971543232396936
lex category (postags) = Unary(WRB VB NN VBN) 0.8777818314483765
question prefix = 'how' ^ answer shape = 'Aaaaa' -0.8011674571324334
template prefix who => when -0.9689894199197373
question prefix = 'when' ^ answer shape = 'Aaaaa 1 , 1111' -0.3914629697190807
lex category (postags) = Unary(WDT NN VB DT JJ NN VB) 0.0
question prefix = 'how many' ^ answer shape = 'Aaaaa Aaaa' 0.1495804450930317
template arg pos tags = JJ 1.038672017511857
lex category (postags) = Unary(WDT VB VB JJR NN) 0.0
lex category (postags) = Unary(WDT NNS DT NN IN JJ NN) -0.1908062750820868
question prefix = 'what' ^ answer shape = 'aaaa aa aaaa aaaa aaaa aaaa aaa aaaa aa aaaa aaaa' 0.6840569135352061
lex category (postags) = Identity(WRB) -0.4071506749361547
lex category (postags) = Unary(WP VBP VB NN IN DT NN) -0.2002918642831084
lex type = Identity ^ leftTag = WRB -0.8077344035023714
template prefix when => how many -0.44509303174024084
question prefix = 'what year' and isDate 0.9996351696461145
lex category (postags) = Unary(WDT JJ NN VBP NN NNS VB) 0.0
question prefix = 'what' ^ answer shape = 'AAA' 0.269974461875228
question prefix = 'how' ^ answer shape = '11 aaaa' 0.10871944545786216
question prefix = 'what' ^ answer shape = 'aaaa?a aaaa aaaa' -0.037942356804086086
lex category (postags) = Unary(WP VBP NN VB IN) 0.23823422108719444
question prefix = 'how many' ^ isDate 0.0
template prefix how => where -0.10871944545786216
lex category (postags) = Unary(WDT VB DT JJS NN VB RB VB) -0.29186428310835466
template arg pos tags = NN VBP 0.0
action type = TemplatePair -2.7347683327252827
lex category (postags) = Unary(WP VBP NN) -1.8664720904779277
template prefix where => when -0.9996351696461145
lex category (postags) = Unary(WDT VB NN IN NN JJ) 0.7311200291864283
lex category (postags) = Unary(WP VBP VB DT NN IN NN) -0.9565851878876322
question prefix = 'who' ^ answer shape = 'Aaaaa Aaaaa aa Aaaaa' -0.9273987595767967
lex category (postags) = Unary(WDT VB DT JJ NN IN NNP) 0.0
template arg pos tags = JJ VB 0.0
lex category (postags) = Unary(WDT VB DT JJ NN) -1.3451295147756293
question prefix = 'who' ^ answer shape = 'aaaa' -0.7351331630791682
lex category (postags) = Identity(CD) 0.8796059832178037
question prefix = 'what' ^ answer shape = 'a aaaa aaa' 0.7617657789128056
template arg pos tags = NN VB 1.20977745348413
lex category (postags) = Unary(WDT NN WDT NN VB) 0.0
lex category (postags) = Unary(WDT VB DT NN NN IN DT JJ NN) -0.07515505290040136
lex category (postags) = Unary(WRB VB DT PRP JJ NN) 0.0
question prefix = 'where' ^ isNumber -1.5103976650857351
lex category (postags) = Unary(WDT NN VBP NN VBP VB) 0.0
lex category (postags) = Unary(WP VB DT JJ NN IN NN) 0.0
lex category (postags) = Unary(WDT VB DT NN NN) -0.41663626413717614
lex category (postags) = Unary(WP VB DT NN NN IN DT JJ NN NN) 0.0
question prefix = 'what' ^ answer shape = 'Aaaaa' -0.6917183509668005
lex category (postags) = Identity(WRB RB) 0.0
lex type = Unary ^ rightTag = VB -0.4421743889091573
template prefix where => UNK 1.035388544326888
lex category (postags) = Unary(WP VBP DT NN VB IN) 0.16380882889456405
lex category (postags) = Identity(NNS) 0.0
parser lexical rule = fullPatternWhenIn 0.6410069317767237
template arg pos tags = NN -2.1280554542137904
question prefix = 'what' ^ answer shape = 'Aaaa Aaaaa' 0.32761765778912805
question prefix = 'what' ^ answer shape = 'Aaaaa AAa' -0.08099233856256838
template prefix who => how many -0.6898941991973733
template is typed -0.9689894199197373
lex category (postags) = Unary(WDT NN VBP NN VB NN IN) -0.9109813936519519
tuple conf_f -0.8841977847922853
question prefix = 'who' ^ answer shape = 'AA-Aa Aaaaa' -0.704487413352791
lex category (postags) = Unary(WRB VBP NN JJ VB VB) 0.0
lex category (postags) = Unary(WDT VB NN) 0.7344035023713973
question prefix = 'what' ^ answer shape = 'aa/aaa' -0.16380882889456405
question prefix = 'how' ^ answer shape = 'AAA AAAA' -0.5180591025173295
lex category (postags) = Unary(WDT VB DT NN IN NNP) 0.0
template arg pos tags = DT NN NN -0.19919737322145203
lex category (postags) = Unary(WDT CD NN VBP JJ NN) -0.6887997081357169
lex type = Identity ^ leftTag = NNP 1.3812477198102882
lex category (postags) = Unary(WDT NN VBP DT JJ NN VB) 0.07515505290040136
question prefix = 'what' ^ answer shape = 'Aaa Aaaaa aaa Aaaa aa aaa Aaaaa Aaaaa' -0.5501641736592484
lex category (postags) = Unary(WDT NN VB DT NN VB) -0.26705581904414444
question prefix = 'when' ^ answer shape = 'Aaaaa Aaaaa' -0.9959868661072602
template arg pos tags = DT NN NN VB 0.6683692083181321
question prefix = 'what' ^ answer shape = '?Aaaaa ?' 0.7672382342210872
template prefix when => UNK -0.10981393651951843
lex category (postags) = Unary(WP VB DT NN IN NN VBN) 0.0
lex category (postags) = Unary(WDT NN VBP NN JJ VB) 0.0
question prefix = 'who' ^ answer shape = 'Aaaaa aa Aaaaa' 0.8318132068588107
lex category (postags) = Identity(VBP) 0.0
lex category (postags) = Unary(WDT VB DT NN IN DT RBS JJ NN) 0.0
template prefix where => where -0.005107624954395984
template arg pos tags = WDT NN VBP NN 0.4005837285662167
lex category (postags) = Unary(WRB VBP NN VB NN IN) 0.0
question prefix = 'UNK' ^ answer shape = 'aaaa aaaa' -0.055454213790587376
lex category (postags) = Unary(WDT VB DT NN NN IN NN NN) 0.0
lex category (postags) = Unary(WDT VB NNP) 0.0
lex category (postags) = Unary(WDT VB IN NN NN) -0.05107624954396206
template arg pos tags = NN VBP NN VB 0.0
lex category (postags) = Unary(WDT VBP NN NN VB IN) -0.6410069317767239
lex category (postags) = Unary(WP VB DT NN IN NN CD CD) 0.47318496898942
lex category (postags) = Identity(.) 0.0
question prefix = 'what' ^ answer shape = 'Aaa Aaaaa Aaaaa' -0.04377964246625321
question prefix = 'what' ^ answer shape = 'Aaaaa Aaaa Aaaa' 1.3090113097409706
lex category (postags) = Unary(WDT NN VB NN VB IN) 0.8445822692448012
lex category (postags) = Unary(WDT NN VB VBP NN) 0.0
template arg pos tags = VB NN VBN -0.8777818314483765
question prefix = 'what' ^ answer shape = 'AA Aaaaa' 0.9452754469171835
lex category (postags) = Unary(WP VBD NN) -0.1039766508573513
lex category (postags) = Unary(WDT VB DT NN IN NN NNS NN) 0.6431959139000365
lex category (postags) = Unary(WRB VBP NN VBN IN) 0.0
================================================
FILE: oqa-core/questions.txt
================================================
Who assassinated JFK?
================================================
FILE: oqa-core/src/main/resources/application.conf
================================================
qa.maxDerivs = 100
qa.maxUQueries = 100
qa.maxParaphrases = 100
qa.maxAnswerGroups = 50
qa.defaultParaphraser = templatesLm
qa.defaultParser = regex
qa.defaultExecutor = identity
qa.defaultGrouper = basic
qa.defaultScorer = numDerivations
triplestore.url = "http://localhost:8983/solr/triplestore"
triplestore.maxHits = 100
triplestore.cacheSize = 100000
triplestore.timeout = 5000
triplestore.skipTimeouts = true
triplestore.namespaces = ["reverb", "freebase", "probase", "openie4", "nell"]
triplestore.skipNamespaces = "^$"
paraphrase.identityScore = 1.0
paraphrase.defaultLm = 1.0
paraphrase.defaultPmi = 1.0
paraphrase.template.maxHits = 100
paraphrase.template.url = "http://localhost:8985/solr/paraphrase"
paraphrase.template.maxArgLength = 4
paraphrase.template.scoringModel = pmiLm
paraphrase.template.minPmi = -25.0
paraphrase.template.maxPmi = 0.0
paraphrase.template.scale = true
paraphrase.template.multipleParaphrases = false
paraphrase.template.timeout = 2000
paraphrase.template.useTypes = false
paraphrase.template.skipTimeouts = true
paraphrase.template.numTemplates = 300000
paraphrase.template.probFalsePos = 0.01
paraphrase.template.stopTemplatesPath = "/edu/knowitall/paraphrasing/template/templatesStops.txt"
paraphrase.rules.ruleSetPath = "/edu/knowitall/paraphrasing/rules/rules.txt"
relsyn.url = "http://localhost:8984/solr/relsyn"
relsyn.scale = true
relsyn.maxPmi = 0.0
relsyn.minPmi = -32.0
relsyn.maxHits = 100
relsyn.cacheSize = 100000
relsyn.timeout = 2000
relsyn.skipTimeouts = true
relsyn.multipleSyns = false
lm.url = "http://localhost:9090"
lm.timeout = 2000
lm.batchSize = 100
lm.minValue = -35.0
lm.maxValue = -5.0
lm.scale = true
lm.retries = 2
lm.cacheSize = 100000
lm.skipTimeouts = true
eval.output.file = output.txt
eval.config.file = config.txt
eval.name.file = name.txt
eval.score.file = scores.txt
eval.pr.file = pr
random.seed = 123
search.beamType = typed
search.beamSize = 10000
search.goalSize = 1000
search.maxIters = 100
search.maxSearchTimeSec = 20
search.expandPerIter = 16
search.transitions.parse = true
search.transitions.templateParaphrase = true
search.transitions.relSyn = true
search.transitions.isaRelSyn = true
search.transitions.execute = true
search.transitions.project = true
search.transitions.ruleParaphrase = true
search.transitions.dropStops = true
learning.oracleMode = "interactive"
learning.labelsPath = "../oqa-data/knowitall.cs.washington.edu/oqa/data/questions/labels.txt"
learning.outputsPath = "models"
learning.numIters = 10
parsing.cg.lexiconClasspath = "/edu/knowitall/parsing/cg/lexicon.txt"
parsing.cg.macroClasspath = "/edu/knowitall/parsing/cg/macros.txt"
parsing.cg.lexicalRuleKeep = ".*"
parsing.cg.lexicalRuleSkip = "^$"
parsing.cg.maxConjuncts = 2
tuplefeatures.resourcePath = "/edu/knowitall/search/qa/tupleFeatures.txt"
scoring.weights = models/full.txt
================================================
FILE: oqa-core/src/main/resources/edu/knowitall/execution/stoplist.txt
================================================
there
others
anything
anybody
anyone
the book
the people
the woman
all
the man
someone
's
not
one
the ones
another option
no one
another
many people
the world
the right
the area
today
stuff
the way
many kinds
the result
both
neither
some people
the name
people
i've
everyone
every one
i'll
inc.
inc
ltd
ltd.
most
ever
the page
such
the following
the first
the second
the third
the last
the other
the others
each
all
following
here
text/html
the fact
lot
lots
more
less
former
text/html
i've
ive
i'm
im
i'd
who
what
where
when
why
how
sometimes
sometime
never
much
little
================================================
FILE: oqa-core/src/main/resources/edu/knowitall/execution/stopregex.txt
================================================
(?i)^this\b.*
(?i)^'s.*
(?i)^his\b.*
(?i)^her\b.*
(?i)^its\b.*
(?i)^their\b.*
(?i)^our\b.*
(?i)^my\b.*
(?i)^your\b.*
(?i)^these\b.*
(?i)^those\b.*
(?i)^this\b.*
(?i)^that\b.*
(?i)^another\b.*
(?i)^many\b.*
(?i)^some\b.*
(?i)^all\b.*
(?i)^other\b.*
(?i)^both\b.*
(?i)^most\b.*
^\p{Punct}+.*
================================================
FILE: oqa-core/src/main/resources/edu/knowitall/paraphrasing/rules/rules.txt
================================================
inWhatDate @inOn @whatwhich @dateWord (<rest>:@any+) := When $rest
whatDate @whatwhich @dateWord (<rest>:@any+) := When $rest
commonPrefix1 <lemma='name'> @quant? (<rest>:@any+) := $rest
commonPrefix2 <lemma='give'> <lemma='me'>? @quant? (<rest>:@any+) := $rest
commonPrefix3 <lemma='tell'> <lemma='me'>? @quant? (<rest>:@any+) := $rest
commonPrefix4 <lemma='list'> <lemma='me'>? @quant? (<rest>:@any+) := $rest
dropTypeOf (<left>:@any*) @type @of (<right>:@any*) := $left $right
dropNameOf (<left>:@any*) @det <lemma='name'> @of (<right>:@any*) := $left $right
posToOf (<left>:@any*) (<arg>:@np) @pos (<rel>:@np) (<right>:@any*) := $left $rel of $arg $right
presProgToSimple (<left>:@any*) @be (<rel>:@vbg) (<right>:@any*) := $left $rel $right
dropAdverb (<left>:@any*) @adv+ (<right>:@any*) := $left $right
================================================
FILE: oqa-core/src/main/resources/edu/knowitall/paraphrasing/template/templatesStops.txt
================================================
what be $y ?
$y ?
what $y ?
what be the $y ?
what be a $y ?
what do $y mean ?
who be $y ?
what do $y do ?
how $y ?
who $y ?
what do $y ?
how do $y ?
where $y ?
how many $y ?
how do you $y ?
what be the meaning of $y ?
what be the name of the $y ?
why $y ?
what $y do ?
how much $y ?
what be an $y ?
where do $y ?
who be the $y ?
where be the $y ?
what dose $y mean ?
how be $y ?
be $y ?
the $y ?
why do $y ?
when do $y ?
when $y ?
================================================
FILE: oqa-core/src/main/resources/edu/knowitall/parsing/cg/argFilters.txt
================================================
^many
================================================
FILE: oqa-core/src/main/resources/edu/knowitall/parsing/cg/lexicon.txt
================================================
# ruleName syntactic-pattern := semantic-type semantic-pattern
fullPatternSubj @whowhat (<rel>:@reverb) (<arg>:@np) := unary $x : ($x, $rel, $arg)
fullPatternDobj @whowhat @aux (<arg>:@np) (<rel>:@reverb) := unary $x : ($arg, $rel, $x)
fullPatternWhereIn @where (<aux>:@aux) (<arg>:@np) (<rel>:@reverb) := unary $x : ($arg, $aux $rel in, $x)
fullPatternWhereIs @where (<aux>:@aux) (<arg>:@np) := unary $x : ($arg, $aux in, $x)
fullPatternWhenIn @when (<aux>:@aux) (<arg>:@np) (<rel>:@reverb) := unary $x : ($arg, $aux $rel in, $x)
fullPatternWhenOn @when (<aux>:@aux) (<arg>:@np) (<rel>:@reverb) := unary $x : ($arg, $aux $rel on, $x)
fullPatternWhenBeIn @when @be (<arg>:@np) := unary $x : ($arg, be in, $x)
fullPatternWhenBeOn @when @be (<arg>:@np) := unary $x : ($arg, be on, $x)
fullPatternTypeDobj (@whatwhich|@howmany) (<type>:@np) @aux (<arg>:@np) (<rel>:@reverb) := unary $x : ($x, instance of, $type) ($arg, $rel, $x)
fullPatternTypeSubj (@whatwhich|@howmany) (<type>:@np) (<rel>:@reverb) (<arg>:@np) := unary $x : ($x, instance of, $type) ($x, $rel, $arg)
fullPatternProperty @what @be @det (<rel>:@np) @of (<arg>:@np) := unary $x : ($arg, $rel, $x)
fullPatternDefn @whowhat @be (<arg>:@np) := unary $x : ($arg, instance of, $x)
fullPatternRelType @whatwhich (<type>:@np) @aux (<arg>:@np) (<rel>:@reverb) := unary $x : ($arg, $rel $type, $x)
fullPatternCop @whatwhich (<rel>:@np) @be (<arg>:@np) := unary $x : ($arg, $rel, $x)
fullPatternHaveProp @wh (@be @det)? (<rel>:@np) (@aux|@relMarker) (<arg>:@np) @have := unary $x : ($arg, $rel, $x)
fullPatternPoss @wh @be (<arg>:@np) @pos (<rel>:@np) := unary $x : ($arg, $rel, $x)
fullPatternCopRel @wh (<rel>:@noun) @be (<arg>:@np) := unary $x : ($arg, $rel, $x)
whIdentity @wh := identity
auxIdentity @aux := identity
punctIdentity @punct := identity
relMarkerIdentity @relMarker := identity
conjIdentity @conj := identity
ignoreTypesIdentity @ignoreTypes := identity
quantIdentity @quant := identity
================================================
FILE: oqa-core/src/main/resources/edu/knowitall/parsing/cg/macros.txt
================================================
noun <pos=/N.*/|pos='CD'>
commonNoun <pos=/NNS?/>
propNoun <pos=/NNPS?/>
adj <pos=/J.*/>
adv <pos=/R.*/>
verb <pos=/V.*/>
det <pos='DT'|pos='PRP$'|lemma='the'|lemma='a'|lemma='an'>
the <lemma='the'>
num <pos='CD'>
conj <pos='CC'|lemma='and'|lemma='but'>
wh <lemma='who'|lemma='what'|lemma='where'|lemma='when'|lemma='why'> | (<lemma='how'> <lemma='many'|lemma='much'>)
whowhat <lemma='what'|lemma='who'>
whatwhich <lemma='what'|lemma='which'>
what <lemma='what'>
how <lemma='how'>
howmany <lemma='how'> <lemma='much'|lemma='many'>
some <lemma='some'>
quant <lemma='some'|lemma='all'|lemma='any'|lemma='enough'|lemma='most'|lemma='both'|lemma='each'|lemma='either'|lemma='other'|lemma='one'|lemma='two'|lemma='three'|lemma='four'|lemma='five'|string=/^[0-9]$/> <lemma='of'>?
where <lemma='where'>
when <lemma='when'>
ignoreTypes <lemma='thing'|lemma='stuff'|lemma='person'|lemma='people'>
aux <lemma='be'|lemma='have'|lemma='do'>
be <lemma='be'|lemma='s'|lemma="'s">
pos <pos='POS'|lemma='s'|lemma="'s">
nounMod <pos='$'|pos='PRP$'|pos='DT'|pos='JJ'|pos='JJS'|pos='JJR'|pos='POS'|pos='PRP'|pos='RB'|pos='RBR'|pos='RBS'|pos='VBN'|pos='VBG'>
np (@nounMod* @noun+ @nounMod*)+
vp (@aux? @adv* @verb+ @adv*)+
relMarker <lemma='who'|lemma='that'|lemma='which'>
prep <pos='RB'>* <pos='IN' | pos='TO' | pos='RP'> <pos='RB'>*
reverb (@vp) | (@vp @prep) | (@vp @np @prep)
reverbNoPrep @vp @np
type <lemma='kind'|lemma='type'|lemma='sort'|lemma='example'|lemma='form'>
of <lemma='of'>
punct <pos=".">
there <lemma='there'>
dateWord <lemma='month'|lemma='day'|lemma='date'|lemma='year'>
any <lemma=/.*/>
inOn <lemma='in'|lemma='on'>
have <lemma='have'>
vbg <pos='VBG'>
================================================
FILE: oqa-core/src/main/resources/edu/knowitall/parsing/cg/relFilters.txt
================================================
^(do|does|did|doing)$
^(be|is|are|was|were)$
^(has|have|had|having)$
================================================
FILE: oqa-core/src/main/resources/edu/knowitall/search/qa/isa.txt
================================================
is a instance of false 1 1 1 0
is an instance of false 1 1 1 0
be a instance of false 1 1 1 0
be an instance of false 1 1 1 0
isa instance of false 1 1 1 0
================================================
FILE: oqa-core/src/main/resources/edu/knowitall/search/qa/tupleFeatures.txt
================================================
conf_f min 0 1 linear
num_extrs_i min 1 100 log
freq_i min 1 24712 log
popularity_i min 1 13045 log
conceptVagueness_f min 0 0.848391051179 linear
================================================
FILE: oqa-core/src/main/resources/log4j.properties
================================================
# Root logger option
log4j.rootLogger=INFO, stdout
# Direct log messages to stdout
log4j.appender.stdout=org.apache.log4j.ConsoleAppender
log4j.appender.stdout.Target=System.out
log4j.appender.stdout.layout=org.apache.log4j.PatternLayout
log4j.appender.stdout.layout.ConversionPattern=%d{yyyy-MM-dd HH:mm:ss} %-5p %c{1}:%L - %m%n
================================================
FILE: oqa-core/src/main/resources/logback.xml
================================================
<?xml version="1.0"?>
<configuration>
<appender name="STDOUT" class="ch.qos.logback.core.ConsoleAppender">
<target>System.err</target>
<!-- encoders are assigned the type
ch.qos.logback.classic.encoder.PatternLayoutEncoder by default -->
<encoder>
<pattern>%d{HH:mm:ss.SSS} [%thread] %-5level %logger{36} - %msg%n</pattern>
</encoder>
</appender>
<root level="DEBUG">
<appender-ref ref="STDOUT"/>
</root>
<logger name="edu.knowitall" level="DEBUG" />
<logger name="edu.knowitall.search" level="DEBUG" />
<logger name="edu.knowitall.search.qa" level="DEBUG" />
</configuration>
================================================
FILE: oqa-core/src/main/scala/edu/knowitall/eval/Oracle.scala
================================================
package edu.knowitall.eval
import edu.knowitall.tool.tokenize.StanfordTokenizer
import edu.knowitall.tool.postag.StanfordPostagger
import edu.knowitall.tool.stem.MorphaStemmer
import java.io.InputStream
import scala.io.Source
import java.io.FileInputStream
import java.io.PrintWriter
import java.io.File
import org.slf4j.LoggerFactory
trait Oracle {
def inputs: List[String]
def getLabel(input: String, output: String): Option[Boolean]
def getCorrectOutputs(input: String): List[String]
def isCorrect(input: String, output: String): Boolean = {
getLabel(input, output) match {
case Some(label) => label
case _ => throw new IllegalStateException(s"No label for ($input, $output)")
}
}
def hasLabel(input: String, output: String): Boolean = {
getLabel(input, output) match {
case Some(label) => true
case _ => false
}
}
def toTrainingSet: List[(String, Set[String])] = {
for (i <- inputs; outputs = getCorrectOutputs(i).toSet; if outputs.size > 0)
yield (i, outputs)
}
}
trait UpdateableOracle extends Oracle {
def save
def update(input: String, output: String, label: Boolean)
}
object Oracle {
val tokenizer = new StanfordTokenizer()
val tagger = new StanfordPostagger()
val lemmatizer = new MorphaStemmer()
def normalizePair(input: String, output: String) = (normalize(input), normalize(output))
def decompose(s: String): String = java.text.Normalizer.normalize(s, java.text.Normalizer.Form.NFD).replaceAll("[\\p{InCombiningDiacriticalMarks}\\p{IsLm}\\p{IsSk}]+", "").replaceAll("\\P{Print}", "");
def normalize(t: String): String = {
val s = decompose(t)
val tokens = tokenizer(s)
if (tokens.size > 0) {
val tagged = tagger.postagTokenized(tokens)
val result = tagged.map(lemmatizer.lemmatizePostaggedToken(_).lemma.toLowerCase)
result.mkString(" ")
} else {
s.toLowerCase().mkString(" ")
}
}
def readLine(line: String): (String, String, Boolean) = {
val fields = line.split("\t", 4)
fields match {
case Array(tag, l, i, o) => (normalize(i), normalize(o), getBoolean(l))
case _ => throw new IllegalArgumentException(s"Could not parse line: '$line'")
}
}
def getBoolean(s: String) = s.toLowerCase() match {
case "0" => false
case "false" => false
case _ => true
}
def labelsFromInputStream(is: InputStream) = {
val triples = Source.fromInputStream(is, "UTF8").getLines.filter(_.startsWith("LABEL\t")).map(readLine)
triples.map(triple => (normalize(triple._1), normalize(triple._2)) -> triple._3).toMap
}
def fromFile(fn: String) = labelsFromInputStream(new FileInputStream(fn))
}
class FileOracle(path: String) extends UpdateableOracle {
val logger = LoggerFactory.getLogger(this.getClass)
val file = new File(path)
val labels = if (file.exists()) {
scala.collection.mutable.Map(Oracle.fromFile(path).toSeq: _*)
} else {
scala.collection.mutable.Map[(String, String), Boolean]()
}
def correctOutputs = {
val pairs = for ((input, output) <- labels.keys; if labels.getOrElse((input, output), false)) yield (input, output)
val grouped = pairs.groupBy(_._1).map { case (k,v) => (k,v.map(_._2).toList)}
grouped.toMap
}
override def inputs = {
labels.keys.map(_._1).toList
}
def normalize = Oracle.normalize _
override def getLabel(input: String, output: String) = {
val i = normalize(input)
val o = normalize(output)
val attempt = labels.get((i, o))
attempt match {
case Some(value) => Some(value)
case None => labels.get(normalize(i), normalize(o))
}
}
override def getCorrectOutputs(input: String): List[String] = correctOutputs.getOrElse(Oracle.normalize(input), List())
def save = {
logger.debug(s"Saving labels to $path")
val output = new PrintWriter(path, "UTF8")
for (((i, o), l) <- labels) output.println(s"LABEL\t$l\t$i\t$o")
output.close()
}
def update(i: String, o: String, label: Boolean) = {
labels += ((normalize(i), normalize(o)) -> label)
}
}
================================================
FILE: oqa-core/src/main/scala/edu/knowitall/eval/OutputRecord.scala
================================================
package edu.knowitall.eval
abstract class OutputRecord {
def input: String
def output: String
def score: Double
override def toString = s"$input\t$output\t$score"
}
object OutputRecord {
private case class OutputRecordImpl(input: String, output: String,
score: Double) extends OutputRecord {
def apply(input: String, output: String, score: Double) =
OutputRecordImpl(input, output, score)
}
def apply(input: String, output: String, score: Double): OutputRecord = OutputRecordImpl(input, output, score)
def fromLine(line: String): OutputRecord = line.split("\t").toList match {
case i :: o :: s :: rest => OutputRecordImpl(i, o, s.toDouble)
case _ => throw new IllegalArgumentException(s"Could not parse line: $line")
}
}
================================================
FILE: oqa-core/src/main/scala/edu/knowitall/eval/SystemOutput.scala
================================================
package edu.knowitall.eval
import scala.io.Source
import scala.collection.JavaConverters._
import java.io.File
import com.typesafe.config.ConfigFactory
import java.io.PrintWriter
import com.typesafe.config.ConfigRenderOptions
abstract class SystemOutput {
def inputs: List[String] = records.map(_.input).distinct
def inputOutputs: List[(String, String)] = records.map(r => (r.input, r.output)).toList.distinct
def config: Map[String, String]
def path: String
def normalize = Oracle.normalize _
def recordsFor(input: String, output: String): List[OutputRecord] = {
val in = normalize(input)
val on = normalize(output)
inputOutputToRecords.getOrElse((in, on), List()).toList
}
private val inputToRecords = records.groupBy(r => normalize(r.input))
def recordsFor(input: String): List[OutputRecord] = inputToRecords.getOrElse(normalize(input), List())
private val inputOutputToRecords = records.groupBy(r => (normalize(r.input), normalize(r.output)))
def topOutputFor(input: String): Option[String] = {
inputToRecords.get(normalize(input)) match {
case Some(l) => Some(l.maxBy(_.score).output)
case _ => None
}
}
def topScoreFor(input: String, output: String): Option[Double] = {
recordsFor(input, output) match {
case Nil => None
case l: List[OutputRecord] => Some(l.maxBy(_.score).score)
}
}
def hasOutputFor(input: String) = inputToRecords.contains(input)
def records: List[OutputRecord]
def save = {
val dir = new File(path)
if (dir.exists() && !dir.isDirectory()) throw new IllegalStateException(s"$dir exists but is not a directory")
if (!dir.exists()) dir.mkdirs()
val outputPath = new File(path, SystemOutput.outputFile)
val outputWriter = new PrintWriter(outputPath)
records.foreach(outputWriter.println(_))
outputWriter.close()
val configPath = new File(path, SystemOutput.configFile)
val configWriter = new PrintWriter(configPath)
for ((k, v) <- config) configWriter.println(s"$k\t$v")
configWriter.close()
}
}
case object SystemOutput {
val conf = ConfigFactory.load()
val outputFile = conf.getString("eval.output.file")
val configFile = conf.getString("eval.config.file")
val nameFile = conf.getString("eval.name.file")
private case class SystemOutputImpl(path: String, records: List[OutputRecord], config: Map[String, String]) extends SystemOutput {
def apply(path: String, records: List[OutputRecord], config: Map[String, String]) = SystemOutputImpl(path, records, config)
}
def apply(path: String, records: List[OutputRecord], config: Map[String, String]): SystemOutput = new SystemOutputImpl(path, records, config)
def apply(path: String, records: List[OutputRecord]): SystemOutput = new SystemOutputImpl(path, records, getCurrentConfig)
def loadRecords(path: String): List[OutputRecord] = {
val lines = Source.fromFile(new File(path, outputFile), "UTF8").getLines
lines.map(OutputRecord.fromLine).toList
}
def loadConfig(path: String) = {
val lines = Source.fromFile(new File(path, configFile)).getLines
val pairs = lines map { line: String =>
line.split("\t", 2) match {
case Array(k, v) => (k, v)
case _ => throw new IllegalArgumentException(s"Could not parse line: $line")
}
}
pairs.toMap
}
def getCurrentConfig = conf.root().asScala.map(pair => (pair._1, pair._2.render(ConfigRenderOptions.concise))).toMap
def fromPath(path: String): SystemOutput = SystemOutputImpl(path, loadRecords(path), getCurrentConfig)
}
================================================
FILE: oqa-core/src/main/scala/edu/knowitall/eval/qa/QAOutputRecord.scala
================================================
package edu.knowitall.eval.qa
import edu.knowitall.eval.OutputRecord
import edu.knowitall.execution.Tuple
import edu.knowitall.execution.Search
case class QAOutputRecord(question: String, answer: String, ascore: Double, derivation: String) extends OutputRecord {
override def toString = s"$question\t$answer\t$score\t$derivation"
override def input = question
override def output = answer
override def score = ascore
}
case object QAOutputRecord {
def fromLine(line: String) = line.trim.split("\t") match {
case Array(q, a, s, d) => QAOutputRecord(q, a, s.toDouble, d)
case Array(q, a, s) => QAOutputRecord(q, a, s.toDouble, "")
case _ => throw new IllegalArgumentException(s"Could not parse line: $line")
}
def project(t: Tuple): String = {
val tup = Search.ProjectTriples(List(t)).toList(0)
tup.toString
}
}
================================================
FILE: oqa-core/src/main/scala/edu/knowitall/eval/qa/QASystemOutput.scala
================================================
package edu.knowitall.eval.qa
import com.typesafe.config.ConfigFactory
import java.io.File
import java.io.PrintWriter
import scala.collection.JavaConverters._
import scala.io.Source
import com.typesafe.config.ConfigRenderOptions
import edu.knowitall.eval.SystemOutput
import edu.knowitall.eval.OutputRecord
case class QASystemOutput(path: String, records: List[QAOutputRecord], config: Map[String, String], name: String) extends SystemOutput {
def this(path: String, name: String) = this(path, QASystemOutput.loadRecords(path), SystemOutput.loadConfig(path), name)
def this(path: String, records: List[QAOutputRecord], name: String) = this(path, records, SystemOutput.getCurrentConfig, name)
val questions = records.map(_.question).distinct
val questionAnswers = records.map(r => (r.question, r.answer)).distinct
private val questionToRecords = records.groupBy(r => normalize(r.question))
private val questionAnswerToRecords = records.groupBy(r => (normalize(r.question), normalize(r.answer)))
val qaRecords = records
def qaRecordsFor(input: String, output: String): List[QAOutputRecord] = {
val in = normalize(input)
val on = normalize(output)
questionAnswerToRecords.getOrElse((in, on), List()).toList
}
override def save = {
val dir = new File(path)
if (dir.exists() && !dir.isDirectory()) throw new IllegalStateException(s"$dir exists but is not a directory")
if (!dir.exists()) dir.mkdirs()
val outputPath = new File(path, QASystemOutput.outputFile)
val outputWriter = new PrintWriter(outputPath)
records.foreach(outputWriter.println(_))
outputWriter.close()
val configPath = new File(path, QASystemOutput.configFile)
val configWriter = new PrintWriter(configPath)
for ((k, v) <- config) configWriter.println(s"$k\t$v")
configWriter.close()
val namePath = new File(path, QASystemOutput.nameFile)
val nameWriter = new PrintWriter(namePath)
nameWriter.println(name)
nameWriter.close()
}
}
case object QASystemOutput {
val conf = ConfigFactory.load()
val outputFile = conf.getString("eval.output.file")
val configFile = conf.getString("eval.config.file")
val nameFile = conf.getString("eval.name.file")
def loadRecords(path: String): List[QAOutputRecord] = {
val lines = Source.fromFile(new File(path, outputFile), "UTF8").getLines
lines.map(QAOutputRecord.fromLine).toList
}
def fromPath(path: String) = {
val name = Source.fromFile(new File(path, nameFile)).getLines.mkString("\n")
new QASystemOutput(path, name)
}
}
================================================
FILE: oqa-core/src/main/scala/edu/knowitall/eval/qa/QASystemRunner.scala
================================================
package edu.knowitall.eval.qa
import java.io.File
import java.io.IOException
import scala.io.Source
import org.slf4j.LoggerFactory
import edu.knowitall.model.QaModel
class QASystemRunner(qa: QaModel, path: String) {
val logger = LoggerFactory.getLogger(this.getClass)
val outputFile = new File(path)
if (!outputFile.exists()) {
outputFile.mkdirs()
}
if (outputFile.exists() && !outputFile.isDirectory()) {
throw new IOException(s"Could not write to $path, file exists")
}
def runFile(path: String) = {
val lines = Source.fromFile(path, "UTF8").getLines.toList
logger.info(s"Running QA System on '$path'")
logger.info(s"'$path' contains ${lines.size} questions")
run(path, lines)
}
def run(name: String, questions: List[String]) = {
val n = questions.size
val records = for ((q, i) <- questions.zipWithIndex;
deriv <- {
logger.info(s"Question ${i+1} of ${n}")
qa.candidatePredictions(q)
};
r = QAOutputRecord(q, deriv.answer, deriv.score, deriv.toString))
yield r
val output = new QASystemOutput(path, records.toList, name)
output.save
}
}
object QASystemRunner extends App {
val input = args(0)
val output = args(1)
val model = new QaModel()
val runner = new QASystemRunner(model, output)
runner.runFile(input)
}
================================================
FILE: oqa-core/src/main/scala/edu/knowitall/execution/AnswerFilter.scala
================================================
package edu.knowitall.execution
import edu.knowitall.tool.tokenize.ClearTokenizer
import edu.knowitall.tool.stem.MorphaStemmer
import scala.io.Source
import java.io.InputStream
import org.slf4j.LoggerFactory
import scala.util.matching.Regex
import edu.knowitall.util.ResourceUtils
trait AnswerFilter {
def filter(exec: QueryExecutor): QueryExecutor
}
object AnswerFilter {
// Mnemonics
type QE = QueryExecutor
type ETPred = (ExecTuple => Boolean)
type SPred = (String => Boolean)
def createExecTupleFilter(f: ETPred): (QE => QE) = exec => new QE {
def execute(q: ConjunctiveQuery) = exec.execute(q).filter(f)
}
def createStringFilter(f: SPred): (QE => QE) = {
val etpred = (et: ExecTuple) => f(et.answer.mkString(", "))
createExecTupleFilter(etpred)
}
def compose(af1: AnswerFilter, af2: AnswerFilter) = new AnswerFilter {
override def filter(exec: QueryExecutor) = af2.filter(af1.filter(exec))
}
}
case class StopListFilter(stops: Iterable[String]) extends AnswerFilter {
val tokenizer = new ClearTokenizer()
val logger = LoggerFactory.getLogger(this.getClass)
logger.debug(s"stop set: $stops")
val stopSet = stops.map(normalize).toSet
def normalize(s: String): String = {
val slc = s.toLowerCase()
val toks = tokenizer(slc)
val stems = toks.map(MorphaStemmer.stemToken)
val lems = stems.map(_.lemma)
val result = lems.mkString(" ")
result
}
def this(file: String) = this(Source.fromFile(file, "UTF8").getLines.toList)
def this(is: InputStream) = this(Source.fromInputStream(is, "UTF8").getLines.toList)
def keepAnswer(ans: String) = !stopSet.contains(normalize(ans))
override def filter(exec: QueryExecutor): QueryExecutor =
AnswerFilter.createStringFilter(keepAnswer)(exec)
}
case class StopRegexFilter(patStrs: Iterable[String]) extends AnswerFilter {
val pats = patStrs.toList.map(_.r)
def this(file: String) = this(Source.fromFile(file, "UTF8").getLines.toList)
def this(is: InputStream) = this(Source.fromInputStream(is, "UTF8").getLines.toList)
def keepAnswer(ans: String) = !pats.exists(p => ans match {
case p() => true
case _ => false
})
override def filter(exec: QueryExecutor) = AnswerFilter.createStringFilter(keepAnswer)(exec)
}
object DefaultFilters {
val logger = LoggerFactory.getLogger(this.getClass)
val idFilter = new AnswerFilter {
override def filter(exec: QueryExecutor) = exec
}
def wrap(executor: QueryExecutor) = {
val filters: List[AnswerFilter] = List(
new StopListFilter(ResourceUtils.resource("/edu/knowitall/execution/stoplist.txt")),
new StopRegexFilter(ResourceUtils.resource("/edu/knowitall/execution/stopregex.txt")))
val composed = filters.foldLeft(idFilter)(AnswerFilter.compose _)
composed.filter(executor)
}
}
================================================
FILE: oqa-core/src/main/scala/edu/knowitall/execution/ConjunctiveQuery.scala
================================================
package edu.knowitall.execution
import Search.Field
import Search.TSQuery
import Search.{FieldKeywords, FieldPhrase}
import Search.Conjunction
import org.slf4j.LoggerFactory
import Search._
import scala.Option.option2Iterable
import edu.knowitall.util.StringUtils
/**
* Base trait for triple values.
*/
trait TVal
/**
* Base trait for triple literal values.
*/
trait TLiteral extends TVal {
def value: String
def update(v: String): TLiteral
def toConjunct(field: Field): TSQuery
def subs(binding: Map[TVariable, TVal]): TLiteral
}
/**
* Triple literals can be unquoted, which has the semantics of doing a keyword
* search over a field.
*/
case class UnquotedTLiteral(value: String) extends TVal with TLiteral {
override def toString = value
override def toConjunct(field: Field) = FieldKeywords(field, value)
override def subs(binding: Map[TVariable, TVal]) = {
val map = binding map { case (k, v) => (k.name, v.toString) }
val newVal = StringUtils.interpolate(value, map)
copy(value = newVal)
}
override def update(v: String) = UnquotedTLiteral(v)
}
/**
* Triple literals can also be quoted, which has the semantics of doing an
* exact-match search over a field.
*/
case class QuotedTLiteral(value: String) extends TVal with TLiteral {
override def toString = s""""$value""""
override def toConjunct(field: Field) = FieldPhrase(field, value)
override def subs(binding: Map[TVariable, TVal]) = {
val map = binding map { case (k, v) => (k.name, v.toString) }
val newVal = StringUtils.interpolate(value, map)
copy(value = newVal)
}
override def update(v: String) = QuotedTLiteral(v)
}
case object QuotedTLiteral {
val quoted = """^"(.*)"$""".r
def fromString(s: String): Option[QuotedTLiteral] = s.trim() match {
case quoted(s) => Some(QuotedTLiteral(s))
case _ => None
}
}
/**
* Triple values can also be variables, which have a string name.
*/
case class TVariable(name: String) extends TVal {
override def toString = "$" + name
}
case object TVariable {
val vpat = """\$([A-Za-z0-9_]+)""".r
def fromString(s: String): Option[TVariable] = s.trim() match {
case vpat(v) => Some(TVariable(v))
case "?" => Some(TVariable("?"))
case _ => None
}
def fromStringMult(s: String): List[TVariable] = {
val parts = s.split(", *").toList
for (p <- parts; t = TVariable.fromString(p)) yield t match {
case Some(x) => x
case None => throw new
IllegalArgumentException(s"Could not parse variables in: $s")
}
}
}
/**
* TConjunct objects have a name (you can think of this as a unique
* identifier for the relational table returned) and map containing the
* field values. The field values map a field (arg1, rel, or arg2) to a
* value (literal or variable).
*/
case class TConjunct(name: String, values: Map[Field, TVal]) {
def literalFields: Iterable[(Field, TLiteral)] = {
for ((f, v) <- values) yield v match {
case l: TLiteral => Some((f, l))
case _ => None
}
}.flatten
def variableFields: Iterable[(Field, TVariable)] = {
for ((f, v) <- values) yield v match {
case TVariable(s) => Some((f, TVariable(s)))
case _ => None
}
}.flatten
def varsToFields: Map[TVariable, Field] = variableFields.map(_.swap).toMap
def partialQuery: TSQuery = {
val lfs = literalFields.toList
val conjuncts = for ((f, v) <- lfs) yield v.toConjunct(f)
Conjunction(conjuncts.toList:_*)
}
def joinKeys: Map[TVariable, String] = {
val vfs: Map[TVariable, Field] = varsToFields
val pairs = for (v <- vfs.keys; f <- vfs.get(v); a = name + "." + f)
yield (v, a)
pairs.toMap
}
def attrName(v: TVariable): Option[String] = joinKeys.get(v)
def vars: Iterable[TVariable] = varsToFields.keys.toSet
def subs(bindings: Map[TVariable, TVal]) = {
val newValues = values map {
case (field, value: TVariable) if bindings.contains(value) => (field, bindings(value))
case (field, value: TLiteral) => (field, value.subs(bindings))
case (field, value) => (field, value)
}
copy(values = newValues)
}
def subs(tvar: TVariable, tval: TVal): TConjunct = subs(Map(tvar -> tval))
def rename(n: String) = copy(name = n)
val xs = values.getOrElse(arg1, "")
val rs = values.getOrElse(rel, "")
val ys = values.getOrElse(arg2, "")
override def toString = s"($xs, $rs, $ys)"
}
case object TConjunct {
val logger = LoggerFactory.getLogger(this.getClass)
val qpat = """\(?(.+),(.+),(.+?)\)?""".r
def fromString(name: String, s: String): Option[TConjunct] = s match {
case qpat(x, r, y) => Some(fromTriple(name, x, r, y))
case _ => None
}
def getTLiteral(s: String): TLiteral = QuotedTLiteral.fromString(s) match {
case Some(QuotedTLiteral(y)) => QuotedTLiteral(y)
case _ => UnquotedTLiteral(s)
}
def getTVal(s: String): TVal = {
val v = TVariable.fromString(s)
v match {
case Some(TVariable(x)) => TVariable(x)
case _ => getTLiteral(s)
}
}
val fields = List(arg1, rel, arg2)
def fromTriple(name: String, x: String, r: String, y: String): TConjunct = {
val lst = List(x.trim(), r.trim(), y.trim())
val items = for ((f, a) <- fields.zip(lst); v = getTVal(a)) yield (f, v)
TConjunct(name, items.toMap)
}
val splitPat = """(?<=\))\s*?(?=\()"""
def fromStringMult(s: String): Iterable[TConjunct] = {
val parts = s.split(splitPat).toList.map(_.trim).filterNot(_ == "")
val queries = { for ((s, i) <- parts.zipWithIndex;
q <- fromString(s"r$i", s)) yield q }.toList
queries
}
def replaceField(c: TConjunct, f: Field, vs: List[TVal]): List[TConjunct] = {
for (v <- vs) yield TConjunct(c.name, c.values + (f -> v))
}
}
/**
* A conjunctive query consists of a list of qvars (query variables) and a list
* of conjuncts. A conjunctive query represents a select-join-project type
* operation. The list of conjuncts represents the data to be selected.
* The shared variables among the conjuncts encodes the join predicates.
* The qVars encodes the projection variables. qAttr is the tuple-attribute
* to project onto.
*/
trait ConjunctiveQuery {
def qVars: List[TVariable]
def qAttrs: List[String]
def conjuncts: List[TConjunct]
def subs(bindings: Map[TVariable, TVal]): ConjunctiveQuery
def subs(tvar: TVariable, tval: TVal): ConjunctiveQuery = subs(Map(tvar -> tval))
def combine(cq: ConjunctiveQuery): ConjunctiveQuery
def renameConjuncts(prefix: String): ConjunctiveQuery
override def toString(): String = {
val varString = qVars.map(_.toString).mkString(",")
val conjString = conjuncts.mkString(" ")
varString + ": " + conjString
}
def joinPairs = {
val grouped = conjuncts.flatMap(_.joinKeys.toList).groupBy(_._1)
for {
variable <- grouped.keys
(variable1, fieldName1) <- grouped(variable)
(variable2, fieldName2) <- grouped(variable)
if fieldName1 < fieldName2
} yield (fieldName1, fieldName2)
}
}
case class FieldIndex(conjunctName: String, field: Field) {
private def updateConjunct(c: TConjunct, fn: TVal => TVal): TConjunct = {
val newVals = for {
(f, v) <- c.values
newv = if (c.name == conjunctName && f == field) fn(v) else v
} yield (f, newv)
TConjunct(c.name, newVals)
}
def updateQuery(q: ConjunctiveQuery, fn: TVal => TVal): ConjunctiveQuery = {
val newConjs = q.conjuncts.map(updateConjunct(_, fn))
ListConjunctiveQuery(q.qVars, newConjs)
}
}
/**
* A conjunctive query backed by a list of conjuncts.
*/
case class ListConjunctiveQuery(qVars: List[TVariable], conjuncts: List[TConjunct])
extends ConjunctiveQuery {
private val logger = LoggerFactory.getLogger(this.getClass)
val conjunctNames = conjuncts.map(_.name)
if (conjunctNames.distinct.size != conjunctNames.size) throw new
IllegalArgumentException(s"Conjuncts must have distinct names: $conjuncts")
val qas = {for (v <- qVars; c <- conjuncts; a <- c.attrName(v)) yield (v, a)}.groupBy(_._1)
val qAttrs = for (v <- qVars; group <- qas.get(v); (v, a) <- group.find(x => true)) yield a
override def subs(bindings: Map[TVariable, TVal]) = {
val newConjs = conjuncts.map(_.subs(bindings))
val newQVars = newConjs.flatMap(_.vars).distinct
ListConjunctiveQuery(newQVars, newConjs)
}
def renameConjuncts(prefix: String) = {
val newConjs = conjuncts.zipWithIndex map {
case (c, i) => c.rename(s"${prefix}.$i")
}
copy(conjuncts = newConjs)
}
override def combine(cq: ConjunctiveQuery) = {
val conjNames1 = this.conjunctNames.toSet
val conjNames2 = cq.conjuncts.map(_.name).toSet
val namesIntersect = !conjNames1.intersect(conjNames2).isEmpty
val conjs1 = if (namesIntersect) {
logger.warn(s"Conjunction field names in ${this} and $cq intersect, renaming 'r' and 's': $conjNames1 vs. $conjNames2")
this.renameConjuncts("r").conjuncts
} else {
this.conjuncts
}
val conjs2 = if (namesIntersect) {
cq.renameConjuncts("s").conjuncts
} else {
cq.conjuncts
}
val newConjs = conjs1 ++ conjs2
val newVars = (this.qVars ++ cq.qVars).distinct
ListConjunctiveQuery(newVars, newConjs)
}
}
case object ListConjunctiveQuery {
def fromString(s: String): Option[ListConjunctiveQuery] = {
val parts = s.split(":", 2)
if (parts.size == 2) {
val left = parts(0)
val qVars = TVariable.fromStringMult(parts(0)) match {
case head :: rest => head :: rest
case _ =>
throw new IllegalArgumentException(s"Expected variable: $left")
}
val conjuncts = TConjunct.fromStringMult(parts(1))
Some(ListConjunctiveQuery(qVars, conjuncts.toList))
} else if (parts.size == 1) {
val s = parts(0)
val conjuncts = TConjunct.fromStringMult(s)
val qVars = conjuncts.flatMap(_.vars).toList match {
case v :: rest => v :: rest
case _ => throw new IllegalArgumentException(s"Expected variable: $s")
}
Some(ListConjunctiveQuery(qVars.distinct, conjuncts.toList))
} else {
None
}
}
}
/**
* A simple query is a conjunctive query that has a single conjunct.
*/
case class SimpleQuery(name: String, map: Map[Field, TVal])
extends ConjunctiveQuery {
val conjunct = TConjunct(name, map)
val conjuncts = List(conjunct)
val vars = map.values.collect{ case x: TVariable => x }.toList
val qVars = vars match {
case v :: Nil => List(v)
case _ => throw new
IllegalArgumentException(s"SimpleQuery must have exactly one variable, "
+ s"got: $vars")
}
val qAttrs = List(conjunct.joinKeys(qVars(0)))
override def subs(bindings: Map[TVariable, TVal]) = {
val newConj = conjunct.subs(bindings)
copy(map = newConj.values)
}
override def renameConjuncts(prefix: String) = {
copy(map = conjunct.rename(s"${prefix}0").values)
}
override def combine(cq: ConjunctiveQuery) = {
val newConjs = (this.conjuncts ++ cq.conjuncts).distinct
val newVars = (this.qVars ++ cq.qVars).distinct
ListConjunctiveQuery(newVars, newConjs)
}
}
case object SimpleQuery {
def fromString(s: String) = TConjunct.fromString("r", s) match {
case Some(TConjunct(name, map)) => Some(SimpleQuery(name, map))
case _ => None
}
}
object Utils {
def cartesian[A](xs: Traversable[Traversable[A]]): Seq[Seq[A]] =
xs.foldLeft(Seq(Seq.empty[A])) {
(x, y) => for (a <- x.view; b <- y) yield a :+ b
}
}
================================================
FILE: oqa-core/src/main/scala/edu/knowitall/execution/JoinPlanner.scala
================================================
package edu.knowitall.execution
import Search.PartialSearchJoin
import PartialFunction._
import Search.Field
import Conditions.TuplePred
import Operators.{Select, Product}
import Conditions.AttrsSim
import Operators.NestedLoopJoin
import org.slf4j.LoggerFactory
import edu.knowitall.triplestore.TriplestoreClient
import edu.knowitall.triplestore.TriplestorePlan
import scala.Option.option2Iterable
/**
* A Joiner object interfaces with a triplestore and executes a query
* against it. It uses a simple query plan optimizer to take a set of
* TConjunct objects and join them appropriately. It heuristically
* avoids joining large tables together by (1) limiting the number of rows
* returned by the triplestore, and (2) converting join(small table, large
* table) calls into a set of join(small table, small table) calls.
*
* The algorithm first picks a variable that appears in the TConjunct
* objects. It then eliminates that variable by executing the TConjunct
* and enforcing the join constraints between them.
*
* For example, suppose the set of queries is aq1 = ($x, type, us president),
* aq2 = ($x, born in, $y), and aq3 = ($y, type, us state). The joiner first
* picks a variable to eliminate, using a herustic; say it picks $x. Then,
* the joiner takes all queries that have $x as a value, loads their data,
* and joins them. In this case, it must load the data for aq1 and aq2, then
* join them together on the constraint aq1.arg1 = aq2.arg1. It saves the
* results as an intermediate table t. Then, it repeats, picking $y as the
* next variable to eliminate, and joining intermediate table t with aq3.
*
* The heuristic used to estimate the cost of a query is the number of rows
* returned by the triplestore.
*
* Internally, the Joiner uses two structures. The first is a QueryNode, which
* represents an unexecuted TConjunct. The second is a TuplesNode, which
* represents an intermediate table (a set of AbstractQueries that have been
* executed and joined across a single variable). The QueryNode class and
* TuplesNode class are subclasses of TableNode.
*
*/
case class Joiner(client: TriplestoreClient) {
val logger = LoggerFactory.getLogger(this.getClass)
val maxJoinHits = 10
/* Import some query plan objects from the client. */
val planning = TriplestorePlan(client)
import planning._
/* Runs the join algorithm on the given set of AbstractQuery objects.*/
def joinQueries(conjs: Iterable[TConjunct]): Tuples = {
val nodes = conjs.map(QueryNode(_)).toList
join(nodes)
}
/* Any table T joined with the emptyTuples set will return T. */
val emptyTuples = List(Tuple(Map.empty))
/* Takes the cartesian product of two tuple sets. */
val prod = (ts1: Iterable[Tuple], ts2: Iterable[Tuple]) =>
Product(ts1, ts2).toList
/* Joins the given TableNodes together. If the end result is not a single
* TableNode object, then just takes the cartesian product of the remaining
* nodes.
*/
def join(nodes: List[TableNode]): Iterable[Tuple] = {
val joined = mergeLowest(nodes).map(toTuplesNode(_))
val cleaned = joined map eliminateStrandedVars
cleaned.map(_.tuples).foldLeft(emptyTuples)(prod).toList
}
/*
* Eliminates any join variables that were not eliminated
* during the join process - for example,
* (salad, $r, $x) (beef, $r, $x) will leave $r stranded
* in a single TuplesNode at the end of join processing,
* but still referring to r0.rel and r1.rel. This method
* enforces the join condition within a single TuplesNode.
*/
def eliminateStrandedVars(tn: TuplesNode): TuplesNode = {
tn.joinAttrs.find(_._2.size > 1) match {
case Some((v, attrs)) => {
val tuples = tn.tuples.filter { t =>
attrs.sliding(2).forall {
case List(a1, a2) => AttrsSim(a1, a2, 0.9).apply(t)
case _ => throw new RuntimeException()
}
}
val newTuplesNode = TuplesNode(tuples, tn.joinAttrs-v)
eliminateStrandedVars(newTuplesNode)
}
case None => tn
}
}
/* Picks the lowest-cost variable, merges the nodes, and then repeats until
* there are no variables left to merge.
*/
def mergeLowest(nodes: List[TableNode]): List[TableNode] = {
val merged = lowestVariable(nodes) match {
case Some(v) => mergeLowest(groupThenMergeNodes(nodes, v))
case None => nodes
}
merged.map(toTuplesNode(_))
}
/* The cost of a Table node is... */
def cost(n: TableNode) = n match {
// ...the number of rows that satisfy it, if it's a QueryNode
case q: QueryNode => client.count(q.conj.partialQuery)
// ...or the number of rows, if it's a TuplesNode
case t: TuplesNode => t.tuples.size
}
/* Joining two tuples nodes together on a variable is easy, since all of
* the necessary data is in memory. All that needs to be done is to
* create the correct join predicate, and then execute the NestedLoopJoin.
*/
def joinTT(tn1: TuplesNode, tn2: TuplesNode, v: TVariable): Tuples = {
val attrPairs = for(a1 <- tn1.getJoinAttrs(v); a2 <- tn2.getJoinAttrs(v))
yield (a1, a2)
val pred = Joiner.pairsToCond(attrPairs)
NestedLoopJoin(pred)(tn1.tuples, tn2.tuples)
}
/* Joining a QueryNode with a TuplesNode involves doing a partial search
* join, which executes a query for each row in the TuplesNode.
*/
def joinQT(qn: QueryNode, tn: TuplesNode, v: TVariable): Tuples = {
// Get the names of the attributes to join on.
val attrPairs = for (
a1 <- tn.getJoinAttrs(v);
a2 <- qn.getJoinAttrs(v)) yield (a1, a2)
// The join predicate uses string similarity.
val bpred = attrPairs match {
case (a1, a2) :: tail => AttrsSim(a1, a2, 0.9)
case _ => AttrsSim("", "", 0.0)
}
// If there are multiple join conditions between the QueryNode and
// TuplesNode (i.e. if they share more than one variable) then the
// additional constraints need to be encoded in a Select predicate, since
// a partial search join can only involve a single field.
val spred = attrPairs match {
case (a1, a2) :: tail => Joiner.pairsToCond(tail)
case _ => Joiner.truep
}
val left = tn.tuples
val right = PartialSearchFor(qn.conj.name, maxJoinHits, qn.conj.partialQuery)
val joined = PartialSearchJoin(bpred)(left, right)
Select(spred)(joined)
}
/* Finds the nodes that have the given variable. Merges them together, leaving
* the other nodes unmerged.
*/
def groupThenMergeNodes(nodes: List[TableNode], v: TVariable): List[TableNode] = {
val (toMerge, toKeep) = nodes.partition(_.hasVariable(v))
mergeNodes(toMerge, v) +: toKeep
}
/* Finds the lowest-cost variable to merge. In order to be considered for
* merging, a variable must occur in at least two nodes. Variables are then
* assigned a cost equal to the lowest-costing node that they occur in.
*/
def lowestVariable(nodes: List[TableNode]): Option[TVariable] = {
val lst = for (n <- nodes; v <- n.joinAttrs.keySet) yield (v, n)
val varNodes = lst.groupBy(e => e._1).mapValues(e => e.map(x => x._2).toSet)
val varCosts = { for ((v, nodes) <- varNodes;
if nodes.size > 1;
costs = nodes.map(cost(_));
minCost = costs.min) yield (v, minCost) }.toMap
if (varCosts.size > 0) {
val vars = varCosts.keys
val lowest = vars.minBy(varCosts(_))
logger.debug(s"Lowest variable chosen: $lowest")
Some(lowest)
} else {
None
}
}
/* Merges the given nodes together, and removes the variable. */
def mergeNodes(nodes: List[TableNode], v: TVariable): TuplesNode = {
val sorted = nodes.sortBy(cost)
val node = eliminateVar(sorted, v)
TuplesNode(node.tuples, node.joinAttrs-v)
}
/* Recursively eliminates the variable from the given list of nodes.
*/
def eliminateVar(nodes: List[TableNode], v: TVariable): TuplesNode = {
nodes match {
case node :: Nil => toTuplesNode(node)
case node1 :: node2 :: rest => eliminateVar(doJoin(node1, node2, v) :: rest, v)
case _ => throw new IllegalArgumentException("empty node list")
}
}
/* Joins together two nodes on the given variable. */
def doJoin(n1: TableNode, n2: TableNode, v: TVariable): TuplesNode = {
val t = toTuplesNode(n1)
val tuples = n2 match {
case q: QueryNode => joinQT(q, t, v)
case t2: TuplesNode => joinTT(t, t2, v)
}
val merged = Joiner.mergeJoinAttrs(n1.joinAttrs, n2.joinAttrs)
TuplesNode(tuples.toList, merged)
}
/* Converts a TableNode to a TuplesNode. If the given node is already a
* TuplesNode, does nothing. If it is a QueryNode, it executes it and
* wraps the resulting tuples as a TuplesNode.
*/
def toTuplesNode(node: TableNode): TuplesNode = node match {
case t: TuplesNode => t
case q: QueryNode => queryToTuples(q)
case _ => throw new IllegalArgumentException("invalid node type: " + node)
}
/* Executes the given QueryNode to create a TuplesNode. */
def queryToTuples(q: QueryNode): TuplesNode = {
logger.debug(s"Making TuplesNode from $q")
val tuples = SearchFor(q.conj.name, q.conj.partialQuery)
val result = TuplesNode(tuples, q.joinAttrs)
logger.debug(s"Done making TuplesNode from $q")
result
}
}
/* Companion object for Joiner. */
case object Joiner {
// Mnemonic
type JA = Map[TVariable, List[String]]
// The join condition defaults to thresholded string similarity.
val eqCond = (a1: String, a2: String) => AttrsSim(a1, a2, 0.9)
// Merges the given maps.
def mergeJoinAttrs(attrs1: JA, attrs2: JA): JA = {
val allVars = attrs1.keySet union attrs2.keySet
val newPairs = for (v <- allVars;
as1 = attrs1.getOrElse(v, Nil).toSet;
as2 = attrs2.getOrElse(v, Nil).toSet)
yield (v, (as1 ++ as2).toList)
return newPairs.toMap
}
// Tuple predicate that always returns true.
val truep = (t: Tuple) => true
// The conjunction of two tuple predicates.
def and(p1: TuplePred, p2: TuplePred) = (t: Tuple) => p1(t) && p2(t)
// The conjunction of a list of predicates.
def andList(preds: Iterable[TuplePred]): TuplePred =
preds.foldLeft(truep)(and)
// Takes a list of tuple attribute pairs, returns a single predicate
// encoding them as a conjunction of join conditions.
def pairsToCond(pairs: List[(String, String)]): TuplePred = {
val preds = for ((a1, a2) <- pairs) yield eqCond(a1, a2)
andList(preds)
}
}
/* TuplesNodes can be either TableNodes or QueryNodes. */
case class TuplesNode(tuples: List[Tuple],
joinAttrs: Map[TVariable, List[String]]) extends TableNode {
}
/* TableNodes store data from partially-executed queries. */
trait TableNode {
val joinAttrs: Map[TVariable, List[String]]
def getJoinAttrs(v: TVariable) = joinAttrs.getOrElse(v, Nil)
def hasVariable(v: TVariable) = joinAttrs.contains(v)
}
/* QueryNodes represent unexecuted queries. */
case class QueryNode(conj: TConjunct) extends TableNode {
val jks = conj.joinKeys
val joinAttrs = {
for (v <- jks.keys; attr <- jks.get(v)) yield (v, List(attr))
}.toMap
}
================================================
FILE: oqa-core/src/main/scala/edu/knowitall/execution/QueryExecutor.scala
================================================
package edu.knowitall.execution
import edu.knowitall.execution.Search.Field
import edu.knowitall.triplestore.TriplestoreClient
import org.slf4j.LoggerFactory
import edu.knowitall.tool.stem.MorphaStemmer
import scala.collection.immutable.SortedMap
case class ExecTuple(tuple: Tuple, query: ConjunctiveQuery) {
val answer: List[String] = query.qAttrs.flatMap(a => tuple.getString(a))
val answerString: String = answer match {
case List(a) => a
case _ => "(" + answer.mkString(", ") + ")"
}
val toTripleString = {
val tstrs = for {
c <- query.conjuncts
n = c.name
x = tuple.attrs.getOrElse(s"$n.arg1", "")
r = tuple.attrs.getOrElse(s"$n.rel", "")
y = tuple.attrs.getOrElse(s"$n.arg2", "")
} yield s"($x, $r, $y)"
tstrs.mkString(" ")
}
}
trait QueryExecutor {
def execute(query: ConjunctiveQuery): Iterable[ExecTuple]
}
case class IdentityExecutor(client: TriplestoreClient) extends QueryExecutor {
val logger = LoggerFactory.getLogger(this.getClass)
val joiner = Joiner(client)
override def execute(q: ConjunctiveQuery): Iterable[ExecTuple] = {
val joined = joiner.joinQueries(q.conjuncts)
for (t <- joined; et = ExecTuple(t, q)) yield et
}
}
================================================
FILE: oqa-core/src/main/scala/edu/knowitall/execution/RelationalAlgebra.scala
================================================
package edu.knowitall.execution
import scala.language.implicitConversions
import com.rockymadden.stringmetric.similarity._
import org.apache.solr.client.solrj.util.ClientUtils
import scala.Array.canBuildFrom
import scala.Option.option2Iterable
/**
* Used to represent a Tuple (i.e. a row in a relational database). A tuple
* has a set of String attributes. Each attribute has a value of type Any.
*/
case class Tuple(attrs: Map[String, Any]) {
/* Concatenates two tuples together. Their attributes must be disjoint. */
def join(other: Tuple): Tuple = {
val t = Tuple(this.attrs ++ other.attrs)
if (t.attrs.size == this.attrs.size + other.attrs.size) {
return t
} else {
throw new
IllegalArgumentException(s"attr names not disjoint: $this, $other")
}
}
def get(a: String) = attrs.get(a)
/* Gets the string value of attribute a. Returns None if not possible */
def getString(a: String) = attrs.get(a) match {
case Some(x: String) => Some(x)
case _ => None
}
def getBoolean(a: String) = attrs.get(a) match {
case Some(x: Boolean) => Some(x)
case _ => None
}
def getFloat(a: String): Option[Float] = attrs.get(a) match {
case Some(x: Float) => Some(x)
case _ => None
}
def getInt(a: String): Option[Int] = attrs.get(a) match {
case Some(i: Int) => Some(i)
case _ => None
}
def getNumber(a: String): Option[Double] = attrs.get(a) match {
case Some(i: Int) => Some(i)
case Some(f: Float) => Some(f)
case Some(d: Double) => Some(d)
case _ => None
}
/* Renames the attributes using the given function */
def rename(f: String => String): Tuple = {
Tuple(attrs.map{ case (k, v) => (f(k), v) })
}
/* Adds "$p." before each attribute. */
def renamePrefix(p: String): Tuple = rename(k => p + "." + k)
override def toString: String = {
val pairs = attrs map { case (k, v) => k + ": " + v }
return "(" + pairs.mkString(", ") + ")"
}
}
/**
* Contains objects for select and join conditions.
*/
object Conditions {
// Mnemonics
type Attr = String
type Value = Any
type ValuePred = Value => Boolean
type BinaryStringPred = (String, String) => Boolean
type BinaryValuePred = (Value, Value) => Boolean
type TuplePred = Tuple => Boolean
def valPair(a1: Attr, a2: Attr, t: Tuple) =
for (v1 <- t.attrs.get(a1); v2 <- t.attrs.get(a2)) yield (v1, v2)
/* Converts the given predicate over value pairs to a tuple predicate. This
* can be used to convert a predicate like "string1 and string2 are equal"
* to a tuple predicate like "tuple.a1 and tuple.a2 are equal"
*/
def binaryAttrPred(a1: Attr, a2: Attr, f: BinaryValuePred): TuplePred =
(t: Tuple) => valPair(a1, a2, t).exists(f.tupled)
/* Converts the given predicate over value pairs to a tuple predicate. This
* can be used to convert a predicate like "string1 and string2 are equal"
* to a tuple predicate like "tuple.a = x".
*/
def unaryAttrPred(a: Attr, x: String, f: BinaryValuePred): TuplePred =
(t: Tuple) => {
for (v <- t.attrs.get(a)) yield (v, List(x))
}.exists(f.tupled)
/* Converts a predicate over (String, String) to a predicate over (Any, Any)
* by making non-String input always return false.
*/
def stringToAnyPred(f: BinaryStringPred): BinaryValuePred =
(v1: Value, v2: Value) => (v1, v2) match {
case (v1: String, v2: String) => f(v1, v2)
case _ => false
}
/* A shortcut for combining stringToAnyPred and binaryAttrPred. */
def binaryPredFromString(a1: Attr, a2: Attr, f: BinaryStringPred) =
binaryAttrPred(a1, a2, stringToAnyPred(f))
/* A shortcut for combining stringToAnyPred and unaryAttrPred. */
def unaryPredFromString(a: Attr, v: String, f: BinaryStringPred) =
unaryAttrPred(a, v, stringToAnyPred(f))
/* Wrapper for string equality, with optional case sensitivity. */
def StringEquality(caseSensitive: Boolean = true) = (x: String, y: String) =>
if (caseSensitive) x == y else x.toLowerCase() == y.toLowerCase()
/* Thresholded string-similarity predicate, returns true if the given strings
* have similarity above a given threshold.
*/
def strSim(thresh: Double) = (x: String, y: String) =>
StrSim.sim(x, y) > thresh
val strEq = StringEquality(false)
val valEq = (x: Value, y: Value) => x == y
/* A BinaryPred is a TuplePred that has access to two attribute names. */
trait BinaryPred {
def attr1: Attr
def attr2: Attr
def apply(t: Tuple): Boolean
}
/* AttrsEqual is a TuplePred that returns true if t.attr1 equals t.attr2. */
case class AttrsEqual(attr1: Attr, attr2: Attr) extends TuplePred
with BinaryPred {
val pred = binaryPredFromString(attr1, attr2, strEq)
def apply(t: Tuple) = pred(t)
}
/* AttrEquals is a TuplePred that returns true if t.attr equals value. */
case class AttrEquals(attr: Attr, value: String) extends TuplePred {
val pred = unaryPredFromString(attr, value, strEq)
def apply(t: Tuple) = pred(t)
}
/* AttrsSim is a TuplePred that returns true if t.attr1 and t.attr2 have
* similarity greater than thresh.
*/
case class AttrsSim(attr1: Attr, attr2: Attr, thresh: Double)
extends TuplePred with BinaryPred {
val pred = binaryPredFromString(attr1, attr2, strSim(thresh))
def apply(t: Tuple) = pred(t)
}
/* AttrSim is a TuplePred that returns true if t.attr and value have
* similarity greater than thresh.
*/
case class AttrSim(attr: Attr, value: String, thresh: Double)
extends TuplePred {
val pred = unaryPredFromString(attr, value, strSim(thresh))
def apply(t: Tuple) = pred(t)
}
/* On returns a function Tuple => Tuple that projects a tuple t onto the
* given attributes.
*/
def On(attrs: Attr*) = (t: Tuple) => {
val items = for (a <- attrs; v <- t.attrs.get(a)) yield (a, v)
Tuple(items.toMap)
}
}
/**
* The Operators object defines relational algebra operators, which are used
* to join, select, and project Tuple objects.
*/
object Operators {
// Mnemonics
type TuplePred = Tuple => Boolean
type TupleMap = Tuple => Tuple
type Tuples = Iterable[Tuple]
/* Select returns only those tuples that satisfy the predicate p. */
def Select(p: TuplePred) = (ts: Tuples) => ts.filter(p)
/* Project transforms each tuple using the given map m. */
def Project(m: TupleMap) = (ts: Tuples) => ts.map(m)
/* Union groups multiple iterables of tuples into a single iterable. */
def Union(tss: Tuples*) = tss.flatten
/* Join takes the cartesian product of two tuples and returns only those
* tuples that satisfy the predicate p. NestedLoopJoin implements this
* as a nested loop over each iterable of tuples.
*/
def NestedLoopJoin(p: TuplePred) = (ts1: Tuples, ts2: Tuples) => {
for (t1 <- ts1.par; t2 <- ts2; j = t1.join(t2); if p(j)) yield j
}.toList
/* Joins together all pairs of tuples. */
def Product(ts1: Tuples, ts2: Tuples): Tuples =
for (t1 <- ts1; t2 <- ts2) yield t1.join(t2)
}
/**
* Objects used to construct queries against a triplestore.
*/
object Search {
// Mnemonics
type Tuples = Iterable[Tuple]
type Attr = String
type Search = TSQuery => Tuples
import Conditions._
/* These are the possible fields in a triplestore. */
/*object Field extends Enumeration {
type Field = Value
val arg1, rel, arg2, namespace = Value
val arg1_exact, rel_exact, arg2_exact = Value
// Maps some fields to their exact-match versions
val exactMap = Map(arg1 -> arg1_exact, rel -> rel_exact, arg2 -> arg2_exact)
}
import Field._*/
trait Field {
val name: String
def toExact: Field
}
object Field {
implicit def field2string(f: Field) = f.name
}
val exactPat = ".*_exact$".r
case class TSField(name: String) extends Field {
override def toString = name
override def toExact = name match {
case exactPat(name) => TSField(name)
case _ => TSField(name + "_exact")
}
}
val arg1 = TSField("arg1")
val rel = TSField("rel")
val arg2 = TSField("arg2")
val namespace = TSField("namespace")
/* Used to represent a triplestore query. The only requirement is that it
* should have some method that converts it to a Lucene query string.
*/
trait TSQuery {
def toQueryString: String
}
/* Used to escape characters that have special meanings in Lucene. */
def luceneEscape = ClientUtils.escapeQueryChars _
def quoteLogic(w: String) = w match {
case "AND" => "\"AND\""
case "OR" => "\"OR\""
case "NOT" => "\"NOT\""
case _ => w
}
def escape(w: String) = quoteLogic(luceneEscape(w))
/* A query that searches the given field for the given keywords. Splits the
* string v into words, and then converts them into a Lucene query
* equal to the conjunctions of all the words. For example, if f = arg1
* and v = "barack obama", the resulting Lucene query string will be
* "arg1:barack AND arg1:obama".
*/
case class FieldKeywords(f: Field, v: String) extends TSQuery {
def toQueryString = {
for (w <- v.trim().split("\\s+");
x = f.toString() + ":" + escape(w))
yield x }.mkString(" AND ")
}
/* A query that searches the given field for the given phrase. Uses the
* exact-match version of the given field. For example, if f = arg1
* and v = "barack obama", then the resulting Lucene query string will be
* arg1_exact:"barack obama".
*/
case class FieldPhrase(f: Field, v: String) extends TSQuery {
val realField = f.toExact
def toQueryString = realField.toString() + ":\"" + escape(v) + "\""
}
case class CountQuery(arg: String) extends TSQuery {
def toQueryString = {
arg match {
case "" => "*:*" // much faster than arg1_exact:*
// just do arg1 for speed...
case _ => "arg1:\"%s\"".format(arg, arg)
}
}
}
/* Some shortcut functions for each of the fields. */
val Arg1Eq = (v: String) => FieldPhrase(arg1.toExact, v)
val Arg2Eq = (v: String) => FieldPhrase(arg2.toExact, v)
val RelEq = (v: String) => FieldPhrase(rel.toExact, v)
val Arg1Cont = (v: String) => FieldKeywords(arg1, v)
val Arg2Cont = (v: String) => FieldKeywords(arg2, v)
val RelCont = (v: String) => FieldKeywords(rel, v)
val NamespaceEq = (v: String) => FieldKeywords(namespace, v)
/* Returns the conjunction of the given queries. */
case class Conjunction(conjuncts: TSQuery*) extends TSQuery {
def toQueryString =
conjuncts.map("(" + _.toQueryString + ")").mkString(" AND ")
}
/* Returns the disjunction of the given queries. */
case class Disjunction(disjuncts: TSQuery*) extends TSQuery {
def toQueryString =
disjuncts.map("(" + _.toQueryString + ")").mkString(" OR ")
}
/* A shortcut method that adds FieldPhrase(f, v) as a conjunct to q. */
def AndPhrase(q: TSQuery, f: Field, v: String) =
Conjunction(q, FieldPhrase(f, v))
/* A pattern to match the required triplestore attribute names in a tuple. */
val tripColPat = ".*\\.(arg1|arg2|rel|namespace)$"
/* A projection operator that maps a tuple to just the required triplestore
* fields (arg1, rel, arg2, namespace).
*/
def OnTripleCols(t: Tuple): Tuple =
Tuple(t.attrs.filterKeys(a => a.matches(tripColPat)))
def ProjectTriples(ts: Tuples) = Operators.Project(OnTripleCols)(ts)
/* The code below is used for executing partial searches. A partial search
* is a way to lazily represent a query's tuples without actually executing
* the query against the triplestore. Parital searches are useful for
* joining a small table T1 with a large table T2. Instead of loading both
* tables into memory (which may be prohibitively slow), a partial-search
* joiner loads T1 into memory, then executes a query for each tuple t in T1.
* Each query is specifically searching for tuples that may be joined with t.
* This allows the system to make many small, restricted queries, instead of
* one large, unrestricted one.
*/
/* This class is just a name for a (query, search) pair, where search
* is some function that maps queries onto tuples.
*/
case class PartialSearcher(query: TSQuery, search: Search)
/* These patterns are used to infer the Field object to join from the string
* attribute name in a tuple.
*/
val Arg1Pat = "(.*)\\.arg1$".r
val Arg2Pat = "(.*)\\.arg2$".r
val RelPat = "(.*)\\.rel$".r
/* This defines a partial search join algorithm. The join condition cond is
* used both as a predicate (i.e. evaluating whether a joined tuple should
* be kept or discarded) but also for creating the tuple-specific queries
* on the fly.
*
* PartialSearchJoin is actually a function that takes a join condition
* as input, and returns a function (Tuples, PartialSearcher) => Tuples.
* This resulting function takes the smaller table as input, and joins it
* using the given PartialSearcher object, which encodes the query for
* the larger table.
*/
def PartialSearchJoin(cond: BinaryPred) = {
// The join attribute of the smaller table.
val lAttr = cond.attr1
// The join attribute of the larger table.
val rAttr = cond.attr2
// Code for inferring which field to search for when creating a query. It
// is possible that rAttr might not be mappable to a field, in which case
// it is not actually possible to execute the partial search join algo.
val (name, field) = rAttr match {
case Arg1Pat(n) => (n, arg1)
case Arg2Pat(n) => (n, arg2)
case RelPat(n) => (n, rel)
case _ => throw new
IllegalArgumentException(s"field must be arg1, rel, or arg2: $rAttr")
}
val tripleField = """r\d+\.(arg1|arg2|rel)""".r.pattern
(ts: Tuples, ps: PartialSearcher) => {
// split up into chunks
val splitGroups = ts.grouped(10).map(_.toSeq)
// make pairs of (join attributes, tuples) where join attributes is not empty.
val attrsGroups = splitGroups.map { tuples => (tuples.flatMap(_.getString(lAttr)), tuples) } filter(_._1.nonEmpty)
// map to new pairs of (Join Attribute Disjunction, Tuples) by converting join attributes to queries.
val queryGroups = attrsGroups.map { case (attrs, tuples) => (Disjunction(attrs.map(a => FieldKeywords(field, a)): _*), tuples) }
// map to (disjunctive search-join query, Tuples to join with) by combining disjunction with
val disjunctionGroups = queryGroups.map { case (disj, tuples) => (Conjunction(disj, ps.query), tuples) }
// for each pair, execute the disjunction and join the result with tuples
disjunctionGroups.toSeq.par.flatMap { case (q, tuples) =>
val qts = ps.search(q)
for (
t1 <- qts;
t2 <- tuples;
t3 = t1.join(t2);
if (cond(t3))) yield t3
}
}.toList
}
}
/**
* This object is used to create SQL-style table printouts from tuples. The
* code is ripped from this stackoverflow post:
* http://stackoverflow.com/questions/7539831/scala-draw-table-to-console
*/
object Tabulator {
def trim(s: String, l: Int) = {
val n = s.size
s.substring(0, Math.min(l, n))
}
def valToString(v: Any) = v match {
case x @ (_ :: _ :: _) => "{" + trim(x.mkString(", "), 40) + "}"
case x @ (y :: _) => y.toString
case x => x.toString
}
def tupleToList(t: Tuple, attrs: List[String]) = {
for(
a <- attrs;
v = t.attrs.getOrElse(a, "");
s = valToString(v)) yield s}.toList
def tuplesToTable(cols: List[String], ts: Iterable[Tuple]) = {
val lst = ts.toList
format(cols :: lst.map(t => tupleToList(t, cols)))
}
private val namePat = "^(.*)\\.(arg1|arg2|rel|namespace)$".r
def triplesToTable(ts: List[Tuple]): String = ts match {
case t :: rest => {
val conjNames = for {
a <- t.attrs.keys
(conj, field) <- a match {
case namePat(conj, field) => Some((conj, field))
case _ => None
}
} yield conj
val columns = conjNames.toList.distinct.flatMap(n => List(s"${n}.arg1", s"${n}.rel", s"${n}.arg2", s"${n}.namespace"))
tuplesToTable(columns, ts)
}
case _ => ""
}
def tuplesToTable(ts: Iterable[Tuple]): String = {
val lst = ts.toList
if (lst.size > 0) {
val cols = lst(0).attrs.keys.toList
tuplesToTable(cols, ts)
} else {
""
}
}
def format(table: Seq[Seq[Any]]) = table match {
case Seq() => ""
case _ =>
val sizes = for (row <- table) yield (for (cell <- row)
yield if (cell == null) 0 else cell.toString.length)
val colSizes = for (col <- sizes.transpose) yield col.max
val rows = for (row <- table) yield formatRow(row, colSizes)
formatRows(rowSeparator(colSizes), rows)
}
def formatRows(rowSeparator: String, rows: Seq[String]): String = (
rowSeparator ::
rows.head ::
rowSeparator ::
rows.tail.toList :::
rowSeparator ::
List()).mkString("\n")
def formatRow(row: Seq[Any], colSizes: Seq[Int]) = {
val cells = (for ((item, size) <- row.zip(colSizes))
yield if (size == 0) "" else ("%" + size + "s").format(item))
cells.mkString("|", "|", "|")
}
def rowSeparator(colSizes: Seq[Int]) =
colSizes map { "-" * _ } mkString ("+", "+", "+")
}
/**
* A custom string-similarity object. Measures the similarity between
* two strings. Lowercases them and removes some stop words first.
*/
object StrSim {
import edu.knowitall.tool.stem.Lemmatized
import edu.knowitall.tool.stem.MorphaStemmer
import edu.knowitall.tool.postag.PostaggedToken
import edu.knowitall.tool.chunk.OpenNlpChunker
import edu.knowitall.tool.chunk.ChunkedToken
val stops = Set("a", "an", "and", "are", "as", "at", "be", "but", "by",
"for", "if", "in", "into", "is", "it",
"no", "not", "of", "on", "or", "such",
"that", "the", "their", "then", "there", "these",
"they", "this", "to", "was", "will", "with", "i", "me", "your",
"our", "ours", "him", "he", "his", "her", "its", "you", "that",
"every", "all", "each", "those", "other", "both", "neither", "some",
"'s")
val morpha = new MorphaStemmer()
val chunker = new OpenNlpChunker()
def lemmatize[T <: PostaggedToken](tokens: Iterable[T]): Seq[Lemmatized[T]] =
morpha.synchronized {
tokens.toSeq map morpha.lemmatizePostaggedToken
}
def lemmatize(string: String): Seq[Lemmatized[ChunkedToken]] = chunker.synchronized(lemmatize(chunker(string)))
def normTokens(x: String) = {
val lc = x.toLowerCase()
val split = lc.split("\\s+")
val noStops = split.filter { t =>
val lookup = !stops.contains(t)
lookup
}
noStops
}
def norm(x: String) = normTokens(x).mkString(" ")
def sim(x: String, y: String): Double = {
// hack -- compare forwards and backwards to avoid high scores for prefixes
val nx = norm(x)
val ny = norm(y)
val forward = JaroWinklerMetric.compare(nx, ny).getOrElse(0.0)
val backward = JaroWinklerMetric.compare(nx.reverse, ny.reverse).getOrElse(0.0)
(forward + backward) / 2.0
}
}
================================================
FILE: oqa-core/src/main/scala/edu/knowitall/execution/StopwordExecutor.scala
================================================
package edu.knowitall.execution
case class StopwordExecutor(baseExecutor: QueryExecutor) extends QueryExecutor {
import java.util.regex.Pattern
val stops = Set("a", "an", "the", "'s", "these", "those", "some", "that", "something")
override def execute(q: ConjunctiveQuery): Iterable[ExecTuple] =
baseExecutor.execute(cleanQuery(q))
def cleanQuery(q: ConjunctiveQuery): ListConjunctiveQuery = {
ListConjunctiveQuery(q.qVars, q.conjuncts map cleanConjunct)
}
def cleanConjunct(c: TConjunct): TConjunct = {
val cleanValues = c.values.map {
case (key, UnquotedTLiteral(value)) =>
(key, UnquotedTLiteral(cleanWords(value)))
case (key, value) => (key, value)
}
c.copy(values = cleanValues)
}
def cleanWords(str: String) = {
val cleaned = str.split(" ").filterNot(stops.contains).mkString(" ")
if (cleaned.isEmpty) str else cleaned
}
}
================================================
FILE: oqa-core/src/main/scala/edu/knowitall/learning/CorrectnessModel.scala
================================================
package edu.knowitall.learning
trait CorrectnessModel[Input, Output] {
def isCorrect(input: Input, output: Output): Boolean
def pickCorrect(input: Input, candidates: Seq[Output]): Option[Output]
}
================================================
FILE: oqa-core/src/main/scala/edu/knowitall/learning/FeatureFunction.scala
================================================
package edu.knowitall.learning
import scala.language.implicitConversions
abstract class FeatureFunction[T] extends Function[T, SparseVector] {
override def apply(t: T): SparseVector
def sum(that: FeatureFunction[T]): FeatureFunction[T]
def +(that: FeatureFunction[T]) = this.sum(that)
}
object FeatureFunction {
def apply[T](f: T => SparseVector): FeatureFunction[T] = FeatureFunctionImpl(f)
implicit def functionToFeatureFunction[T](f: T => SparseVector): FeatureFunction[T] = FeatureFunction(f)
implicit def pairToFeatureFunction[T](f: T => (String, Double)): FeatureFunction[T] = FeatureFunction((t: T) => {
val (name, value) = f(t)
SparseVector(name -> value)
})
private case class FeatureFunctionImpl[T](f: Function[T, SparseVector]) extends FeatureFunction[T] {
override def apply(t: T) = f(t)
override def sum(that: FeatureFunction[T]): FeatureFunction[T] = FeatureFunctionImpl((t: T) => this(t) + that(t))
}
}
================================================
FILE: oqa-core/src/main/scala/edu/knowitall/learning/HiddenVariableModel.scala
================================================
package edu.knowitall.learning
trait HiddenVariableModel[Input, Output] {
def predict(input: Input): Option[Output]
def candidatePredictions(input: Input): Seq[Output]
def update(input: Input, predicted: Output, expected: Output): Unit
}
================================================
FILE: oqa-core/src/main/scala/edu/knowitall/learning/InteractiveOracle.scala
================================================
package edu.knowitall.learning
import edu.knowitall.util.TuplePrinter.printTuple
import edu.knowitall.execution.Tabulator.{format => toTable}
import edu.knowitall.model.Derivation
import edu.knowitall.search.qa.QueryState
class InteractiveOracle extends CorrectnessModel[String, Derivation] {
private def parseInt(s: String) =
try Some(s.toInt)
catch {
case e: Throwable => None
}
private def parseInts(s: String) =
try s.split("""[^-0-9]+""").map(_.toInt).toSeq
catch {
case e: Throwable => Nil
}
private def derivString(deriv: Derivation) = {
deriv.toString
}
private def derivsToTable(derivs: Seq[Derivation]) = {
val paired = derivs.zipWithIndex flatMap { case (a, b) =>
val sd = derivString(a).split("->").toList.reverse
val triples = sd.map((b, a.answer, _)).zipWithIndex map { case ((c, d, e), f) =>
if (f == 0) {
List(c, d, e)
} else {
List("", "", e)
}
}
triples :+ List("", "", "")
}
toTable(List("#", "answer", "evidence") +: paired)
}
private def getBoolean: Boolean = {
print("> ")
Console.readLine match {
case "1" => true
case "-1" => false
case "0" => false
case _ => {
println("Type 1 for true, 0 or -1 for false")
getBoolean
}
}
}
private def getInt(min: Int, max: Int): Int = {
print("> ")
parseInt(Console.readLine) match {
case Some(i) if min <= i && i <= max => i
case Some(i) => {
println(s"Must choose between $min and $max")
getInt(min, max)
}
case None => {
println(s"Must enter an integer")
getInt(min, max)
}
}
}
private def getInts(min: Int, max: Int): List[Int] = {
print("> ")
parseInts(Console.readLine) match {
case Nil => {
println(s"Must enter a list of integers")
getInts(min, max)
}
case lst if lst.contains(-1) && lst.size > 1 => {
println("Cannot have -1 in list")
getInts(min, max)
}
case lst if lst.forall(i => min <= i && i <= max) => lst.toList
case _ => {
println(s"Must enter a list of integers between $min and $max")
getInts(min, max)
}
}
}
def pickCorrectMultiple(question: String, derivs: Seq[Derivation]) =
if (derivs.size > 0) {
val iderivs = derivs.toIndexedSeq
println(s"Question = $question\n")
println(s"Pick from derivations below (-1 means no answer)")
println(derivsToTable(derivs))
getInts(-1, derivs.size-1) match {
case List(-1) => Nil
case lst => lst.map(iderivs(_))
}
} else {
Nil
}
override def isCorrect(question: String, deriv: Derivation) = {
println(s"Question = $question")
println(s"Answer = ${deriv.answer}")
println(s"Derivation = ${derivString(deriv)}")
println()
getBoolean
}
override def pickCorrect(question: String, derivs: Seq[Derivation]) =
if (derivs.size > 0) {
val iderivs = derivs.toIndexedSeq
println(s"Question = $question\n")
println(s"Pick from derivations below (-1 means no answer)")
println(derivsToTable(derivs))
getInt(-1, derivs.size-1) match {
case -1 => None
case i => Some(iderivs(i))
}
} else None
}
================================================
FILE: oqa-core/src/main/scala/edu/knowitall/learning/LabeledDataOracle.scala
================================================
package edu.knowitall.learning
import edu.knowitall.eval.Oracle
import edu.knowitall.eval.FileOracle
import edu.knowitall.model.Derivation
class LabeledDataOracle(oracle: Oracle) extends CorrectnessModel[String, Derivation] {
def this(path: String) = this(new FileOracle(path))
def isCorrectAnswer(question: String, answer: String) =
oracle.getLabel(question, answer).getOrElse(false)
override def isCorrect(question: String, deriv: Derivation) =
isCorrectAnswer(question, deriv.answer)
override def pickCorrect(question: String, derivs: Seq[Derivation]) =
derivs.filter(answer => isCorrect(question, answer)) match {
case d :: ds => Some(d)
case Nil => None
}
}
================================================
FILE: oqa-core/src/main/scala/edu/knowitall/learning/MemoryInteractiveOracle.scala
================================================
package edu.knowitall.learning
import edu.knowitall.eval.FileOracle
import org.slf4j.LoggerFactory
import edu.knowitall.model.Derivation
class MemoryInteractiveOracle(oracle: FileOracle) extends CorrectnessModel[String, Derivation] {
val logger = LoggerFactory.getLogger(this.getClass)
def this(path: String) = this(new FileOracle(path))
val labeled = new LabeledDataOracle(oracle)
val interactive = new InteractiveOracle()
override def isCorrect(question: String, deriv: Derivation) = {
val answer = deriv.answer
if (oracle.hasLabel(question, answer)) {
logger.debug(s"Using saved labels for $question")
labeled.isCorrect(question, deriv)
} else {
val result = interactive.isCorrect(question, deriv)
oracle.update(question, answer, result)
oracle.save
result
}
}
private def haveLabelFor(question: String, deriv: Derivation) =
oracle.hasLabel(question, deriv.answer)
override def pickCorrect(question: String, derivs: Seq[Derivation]) = {
labeled.pickCorrect(question, derivs) match {
case Some(deriv) => {
logger.debug(s"Using saved labels for $question")
logger.debug(s"Found '${deriv.answer}' as answer for '$question'")
Some(deriv)
}
case None => {
val unlabeled = derivs.filter(d => !haveLabelFor(question, d))
interactive.pickCorrectMultiple(question, unlabeled) match {
case seq: Seq[Derivation] if seq.size > 0 => {
for (d <- seq) {
oracle.update(question, d.answer, true)
}
oracle.save
logger.debug(s"Found '${seq(0)}' as answer for '$question'")
Some(seq(0))
}
case Nil => {
for (d <- unlabeled) {
oracle.update(question, d.answer, false)
}
oracle.save
logger.debug(s"Correct answer for '$question' is unreachable")
None
}
}
}
}
}
}
================================================
FILE: oqa-core/src/main/scala/edu/knowitall/learning/Perceptron.scala
================================================
package edu.knowitall.learning
class Perceptron[Input, Output](model: HiddenVariableModel[Input, Output],
oracle: CorrectnessModel[Input, Output]) {
def learnIter(input: Input) = for {
prediction <- model.predict(input)
if !oracle.isCorrect(input, prediction)
candidates = model.candidatePredictions(input)
correct <- oracle.pickCorrect(input, candidates)
} model.update(input, prediction, correct)
def learn(inputs: Traversable[Input]) = inputs foreach learnIter
}
================================================
FILE: oqa-core/src/main/scala/edu/knowitall/learning/QATrainer.scala
================================================
package edu.knowitall.learning
import com.typesafe.config.ConfigFactory
import edu.knowitall.eval.FileOracle
import edu.knowitall.eval.Oracle
import scala.io.Source
import edu.knowitall.eval.FileOracle
import java.io.File
import java.io.PrintWriter
import edu.knowitall.util.Counter
import edu.knowitall.model.QaModel
import edu.knowitall.model.Derivation
import java.text.SimpleDateFormat
import java.util.Calendar
import org.slf4j.LoggerFactory
import java.io.StringWriter
class QaTrainer(model: QaModel, oracle: CorrectnessModel[String, Derivation]) extends HiddenVariableModel[String, Derivation] {
private var avgWeights = model.costModel.weights
private var iter = 1.0
var numUpdates = 0
var numExamples = 0
private val perceptron = new Perceptron(this, oracle)
private val logger = LoggerFactory.getLogger(this.getClass)
override def predict(question: String) = model.predict(question)
override def candidatePredictions(question: String) = model.candidatePredictions(question)
override def update(question: String, predicted: Derivation, expected: Derivation) = {
logger.info(s"Updating:\ncorrect = ${expected}\n${expected.explainScore(model.costModel.weights)}\npredicted = ${predicted}\n${predicted.explainScore(model.costModel.weights)}")
model.update(question, predicted, expected)
numUpdates += 1
avgWeights = avgWeights + (expected.features - predicted.features) * iter
logger.info(s"Updated weights:\n${model.costModel.weights.toTable}")
}
def learnIter(question: String) = {
try {
logger.info(s"Question $iter = $question")
perceptron.learnIter(question)
iter += 1
numExamples += 1
} catch {
case e: Throwable => {
logger.warn(s"Encountered problem with example: $question")
logger.warn(s"Supressing error.")
val sw = new StringWriter()
val pw = new PrintWriter(sw)
e.printStackTrace(pw)
logger.warn(sw.toString())
}
}
}
def learn(inputs: Traversable[String]) = inputs foreach learnIter
def averagedWeights = model.costModel.weights - (avgWeights / iter)
}
object QaTrainer extends App {
def timestamp = {
val fmt = new SimpleDateFormat("yyyy-MM-dd-HHmmss")
val today = Calendar.getInstance.getTime
fmt.format(today)
}
val conf = ConfigFactory.load()
val oracleMode = conf.getString("learning.oracleMode")
val labelsPath = conf.getString("learning.labelsPath")
val inputsPath = conf.getString("learning.inputsPath")
val outputsPath = conf.getString("learning.outputsPath")
val numIters = conf.getInt("learning.numIters")
val runName = if (conf.hasPath("learning.runName")) conf.getString("learning.runName") else "unnamed"
val dir = new File(outputsPath, s"${runName}-${timestamp}")
if (dir.exists() && !dir.isDirectory())
throw new IllegalStateException(s"$dir exists but is not a directory")
if (!dir.exists()) dir.mkdirs()
val modelOutput = new File(dir, "model.txt")
val configOutput = new PrintWriter(new File(dir, "config.txt"))
configOutput.write(conf.root().render)
configOutput.close()
val oracle = oracleMode match {
case "interactive" => new MemoryInteractiveOracle(labelsPath)
case "file" => new LabeledDataOracle(labelsPath)
case _ => throw new IllegalStateException(s"Invalid oracle mode: $oracleMode")
}
val inputs = Source.fromFile(inputsPath, "UTF8").getLines.map(Oracle.normalize).toList
val model = QaModel()
val trainer = new QaTrainer(model, oracle)
println("Learning...")
for (i <- 1 to numIters) {
val start = System.currentTimeMillis
trainer.learn(inputs)
val file = new File(dir, s"model.$i.txt")
SparseVector.toFile(model.costModel.weights, file.toString())
val avgFile = new File(dir, s"model.$i.avg.txt")
SparseVector.toFile(trainer.averagedWeights, avgFile.toString())
val delta = System.currentTimeMillis - start
println(s"Done with iteration $i (${delta/1000} seconds, ${trainer.numUpdates} updates so far)")
}
println("Done learning")
SparseVector.toFile(model.costModel.weights, modelOutput.toString())
SparseVector.toFile(trainer.averagedWeights, (new File(dir, s"model.avg.txt")).toString())
}
================================================
FILE: oqa-core/src/main/scala/edu/knowitall/learning/QueryTupleSimilarity.scala
================================================
package edu.knowitall.learning
import edu.knowitall.execution.ConjunctiveQuery
import edu.knowitall.execution.Tuple
import edu.knowitall.tool.stem.MorphaStemmer
import scala.Option.option2Iterable
import edu.knowitall.execution.TLiteral
import edu.knowitall.execution.Search
object QueryTupleSimilarity {
def normalize(ss: List[String]): List[String] = ss.map(_.toLowerCase()).map(MorphaStemmer.stem)
def tokenize(s: String) = s.split(" ").toList
def queryWords(q: ConjunctiveQuery): List[String] = {
val literalFields = for (c <- q.conjuncts; (field, literal) <- c.literalFields) yield literal.value
normalize(literalFields.flatMap(tokenize))
}
def tupleWords(q: ConjunctiveQuery, t: Tuple): List[String] = {
val values = for (c <- q.conjuncts;
(field, literal) <- c.literalFields;
value <- t.getString(s"${c.name}.${field}"))
yield value
normalize(values.flatMap(tokenize))
}
def jaccard(x: List[String], y: List[String]): Double = {
val xset = x.toSet
val yset = y.toSet
if (x.size > 0 || y.size > 0) {
xset.intersect(yset).size.toDouble / xset.union(yset).size
} else {
0.0
}
}
def similarity(q: ConjunctiveQuery, t: Tuple): Double = {
val qws = queryWords(q)
val tws = tupleWords(q, t)
jaccard(qws, tws)
}
def tupleFieldWords(q: ConjunctiveQuery, t: Tuple, fields: Set[Search.Field]) = {
val values = for {
c <- q.conjuncts
(field, literal) <- c.literalFields
if fields.contains(field)
value <- t.getString(s"${c.name}.${field}")
} yield value
normalize(values.flatMap(tokenize))
}
def tupleWordsFields(t: Tuple, fields: Set[Search.Field]) = {
val values = for {
(a, v) <- t.attrs collect {
case (a: String, v: String) => (a, v)
}
f <- fields
if a.endsWith("." + f.name)
} yield v
normalize(values.toList.distinct.flatMap(tokenize))
}
def queryFieldWords(q: ConjunctiveQuery, fields: Set[Search.Field]) = {
val values = for {
c <- q.conjuncts
(field, literal) <- c.literalFields
if fields.contains(field)
value = literal.value
} yield value
normalize(values.flatMap(tokenize))
}
def argSimilarity(q: ConjunctiveQuery, t: Tuple) = {
val qws = queryFieldWords(q, Set(Search.arg1, Search.arg2))
val tws = tupleFieldWords(q, t, Set(Search.arg1, Search.arg2))
jaccard(qws, tws)
}
def relSimilarity(q: ConjunctiveQuery, t: Tuple) = {
val qws = queryFieldWords(q, Set(Search.rel))
val tws = tupleFieldWords(q, t, Set(Search.rel))
jaccard(qws, tws)
}
def questionQuerySimilarity(query: ConjunctiveQuery, ques: String) = {
val queryws = queryWords(query)
val quesws = normalize(tokenize(ques))
jaccard(queryws, quesws)
}
def questionTupleSimilarity(ques: String, t: Tuple) = {
val quesws = normalize(tokenize(ques))
val twords = tupleWordsFields(t, Set(Search.arg1, Search.rel, Search.arg2))
jaccard(quesws, twords)
}
}
================================================
FILE: oqa-core/src/main/scala/edu/knowitall/learning/SparseVector.scala
================================================
package edu.knowitall.learning
import scala.io.Source
import java.io.PrintWriter
import scala.language.implicitConversions
import java.io.InputStream
import java.io.File
import java.io.FileInputStream
import edu.knowitall.execution.Tabulator
abstract class SparseVector {
def activeComponents: Iterable[String]
def apply(i: String): Double
def add(that: SparseVector): SparseVector
def scalarMult(x: Double): SparseVector
def dot(that: SparseVector): Double
def subtract(that: SparseVector): SparseVector = this.add(that.scalarMult(-1.0))
def +(that: SparseVector): SparseVector = this.add(that)
def -(that: SparseVector): SparseVector = this.subtract(that)
def *(x: Double): SparseVector = this.scalarMult(x)
def *(that: SparseVector): Double = this.dot(that)
def /(x: Double): SparseVector = this.scalarMult(1/x)
def activeComponents(that: SparseVector): Iterable[String] = (this.activeComponents ++ that.activeComponents).toList.distinct
def toTable = {
val pairs = for (c <- activeComponents.toList.sortBy(-this(_)); if Math.abs(this(c)) > 1e-9) yield Seq(c, this(c))
Tabulator.format(Seq("Feature", "Weight") +: pairs.toSeq)
}
}
object SparseVector {
implicit def dPairToSparseVector(x: (String, Double)): SparseVector = SparseVectorImpl(Map(x._1 -> x._2))
implicit def bPairToSparseVector(x: (String, Boolean)): SparseVector = SparseVectorImpl(Map(x._1 -> {if (x._2) 1.0 else 0.0}))
implicit def iPairToSparseVector(x: (String, Int)): SparseVector = SparseVectorImpl(Map(x._1 -> x._2.toDouble))
implicit def pairsToSparseVector(pairs: TraversableOnce[(String, Double)]): SparseVector = SparseVectorImpl(pairs.toMap)
implicit def stringListToSparseVector(list: TraversableOnce[String]): SparseVector = SparseVectorImpl(list.map(s => (s, 1.0)).toMap)
implicit def stringToSparseVector(s: String): SparseVector = SparseVectorImpl(Map(s -> 1.0))
implicit def oStringToSparseVector(os: Option[String]): SparseVector = os match {
case Some(s) => SparseVectorImpl(Map(s -> 1.0))
case _ => SparseVectorImpl(Map())
}
def apply: SparseVector = SparseVectorImpl(Map())
def apply(pairs: TraversableOnce[(String, Double)]): SparseVector = SparseVectorImpl(pairs.toMap)
def apply(pairs: (String, Double)*): SparseVector = SparseVectorImpl(pairs.toMap)
def fromFile(path: String): SparseVector = {
fromInputStream(new FileInputStream(new File(path)))
}
def fromInputStream(in: InputStream): SparseVector = {
val lines = Source.fromInputStream(in, "UTF8").getLines
val pairs = lines.map { line => line.split("\t") match {
case Array(k, v) => (k, v.toDouble)
case _ => throw new IllegalStateException(s"Could not parse line: '$line'")
}}.toIterable
SparseVector(pairs)
}
def toFile(vector: SparseVector, path: String) = {
val writer = new PrintWriter(path)
vector.activeComponents.foreach(k => writer.println(s"${k}\t${vector(k)}"))
writer.close()
}
private case class SparseVectorImpl(map: Map[String, Double]) extends SparseVector {
override def activeComponents = map.keys
override def apply(i: String) = map.getOrElse(i, 0.0)
override def add(that: SparseVector): SparseVector = {
val pairs = for (k <- this.activeComponents(that)) yield (k, this(k) + that(k))
SparseVectorImpl(pairs.toMap)
}
override def scalarMult(x: Double): SparseVector = {
val pairs = for((k, v) <- map) yield (k, x * v)
SparseVectorImpl(pairs.toMap)
}
override def dot(that: SparseVector): Double = {
this.activeComponents(that).map(i => this(i) * that(i)).sum
}
override def toString = this.map.toString.replaceFirst("Map", "SparseVector")
}
final val zero = SparseVector()
}
================================================
FILE: oqa-core/src/main/scala/edu/knowitall/lm/LanguageModel.scala
================================================
package edu.knowitall.lm
import java.net.URL
import java.net.URI
import java.net.URLEncoder
import scalaj.http.Http
import scala.io.Source
import scalaj.http.HttpOptions
import com.typesafe.config.ConfigFactory
import edu.knowitall.util.MathUtils
import org.slf4j.LoggerFactory
import com.twitter.util.LruMap
import scala.collection.mutable.SynchronizedMap
trait LanguageModel {
/**
* Queries a string, returns its log probability.
*/
def query(s: String): Double
/**
* Does a batch query of a bunch of strings, returns a list of the (input,
* log probability) pairs.
*/
def query(s: Iterable[String]): List[(String, Double)]
}
case class KenLmServer(url: String, timeOut: Int,
scale: Boolean = KenLmServer.scale,
cacheSize: Int = KenLmServer.defaultCacheSize,
skipTimeouts: Boolean = KenLmServer.defaultSkipTimeouts) extends LanguageModel {
def this() = this(KenLmServer.defaultUrl, KenLmServer.defaultTimeout)
val logger = LoggerFactory.getLogger(this.getClass)
val root = s"${url}/score"
val retries = KenLmServer.retries
private val cache = new LruMap[String, Double](cacheSize) with SynchronizedMap[String, Double]
override def query(s: String): Double = cache.get(s) match {
case Some(x) => x
case None => try {
val result = queryHelper(s)
cache.put(s, result)
result
} catch {
case e: IllegalStateException => if (skipTimeouts) {
logger.warn(s"Could not compute LM score for '$s': $e")
scaleValue(Double.MinValue)
} else {
throw e
}
}
}
private def queryHelper(s: String, attempt: Int = 0): Double = {
if (attempt > retries) {
throw new IllegalStateException(s"Unable to query KenLM for '$s'")
} else {
try {
logger.debug(s"Querying for one string (attempt ${attempt+1}/$retries): $s")
scaleValue(Http(root).option(HttpOptions.connTimeout(timeOut)).params("q" -> s).asString.toDouble)
} catch {
case e: Throwable => {
queryHelper(s, attempt + 1)
}
}
}
}
def queryBatch(s: Iterable[String]) = {
logger.debug(s"Querying for ${s.size} strings")
val lst = s.toList
val joined = lst.mkString("|")
val lines = Http.post(root).
option(HttpOptions.connTimeout(timeOut)).
option(HttpOptions.readTimeout(timeOut)).
params("q" -> joined).
asString.trim.split("\n")
val results = lst.zip(lines).map { case (a, b) => (a, scaleValue(b.toDouble)) }
for ((a, b) <- results) cache.put(a, b)
results
}
override def query(s: Iterable[String]) = {
val groups = s.grouped(KenLmServer.batchSize)
groups.flatMap(queryBatch).toList
}
private def scaleValue(x: Double): Double =
if (scale) MathUtils.clipScale(x, KenLmServer.minValue, KenLmServer.maxValue)
else x
}
case object KenLmServer {
val conf = ConfigFactory.load()
val defaultUrl = conf.getString("lm.url")
val defaultTimeout = conf.getInt("lm.timeout")
val retries = conf.getInt("lm.retries")
val batchSize = conf.getInt("lm.batchSize");
val minValue = conf.getDouble("lm.minValue")
val maxValue = conf.getDouble("lm.maxValue")
val scale = conf.getBoolean("lm.scale")
val defaultSkipTimeouts = conf.getBoolean("lm.skipTimeouts")
val defaultCacheSize = conf.getInt("lm.cacheSize")
}
================================================
FILE: oqa-core/src/main/scala/edu/knowitall/model/Derivation.scala
================================================
package edu.knowitall.model
import edu.knowitall.search.qa.AnswerState
import edu.knowitall.search.qa.QuestionState
import edu.knowitall.search.Edge
import edu.knowitall.search.qa.QaState
import edu.knowitall.search.qa.QaAction
import edu.knowitall.learning.SparseVector
import edu.knowitall.search.qa.QaStep
import edu.knowitall.execution.ExecTuple
import edu.knowitall.search.qa.ExecutionAction
import edu.knowitall.execution.Tabulator
case class Derivation(question: String,
answer: String,
steps: IndexedSeq[QaStep],
features: SparseVector,
score: Double,
searchTime: Long = 0L) {
assert(steps.size >= 2)
def questionState: QuestionState = steps.head.fromState match {
case q: QuestionState => q
case x =>
throw new IllegalStateException(s"Expected QuestionState, got $x, steps = $steps")
}
def answerState: AnswerState = steps.last.toState match {
case a: AnswerState => a
case x =>
throw new IllegalStateException(s"Expected AnswerState, got $x, steps = $steps")
}
def explainScore(weights: SparseVector) = {
val rows = for {
fname <- features.activeComponents.toList.sortBy(f => -1*features(f)*weights(f))
fvalue = features(fname)
weight = weights(fname)
product = fvalue * weight
} yield Seq(product, weight, fvalue, fname)
val allRows: Seq[Seq[Any]] = Seq(Seq("prod", "weight", "value", "feature")) ++ rows.toSeq
Tabulator.format(allRows)
}
override def toString = {
val l = List(questionState) ++ steps.map(_.toState)
l.map(_.toString).mkString(" -> ") + s" (${searchTime}ms)"
}
}
================================================
FILE: oqa-core/src/main/scala/edu/knowitall/model/QaModel.scala
================================================
package edu.knowitall.model
import edu.knowitall.search.qa.QaStep
import edu.knowitall.search.qa.QaState
import edu.knowitall.search.qa.QaAction
import edu.knowitall.learning.HiddenVariableModel
import edu.knowitall.learning.SparseVector
import edu.knowitall.search.qa.QaCostModel
import edu.knowitall.search.qa.QaTransitionModel
import edu.knowitall.search.qa.QaSearchProblem
import edu.knowitall.search.BeamSearch
import com.typesafe.config.ConfigFactory
import edu.knowitall.search.Edge
import edu.knowitall.search.Node
import edu.knowitall.search.qa.AnswerState
import org.slf4j.LoggerFactory
import edu.knowitall.search.qa.QaBeamSearch
import edu.knowitall.search.SearchAlgorithm
case class QaModel(transitionModel: QaTransitionModel = QaModel.defaultTransitionModel,
costModel: QaCostModel = QaModel.defaultCostModel)
extends HiddenVariableModel[String, Derivation] {
val logger = LoggerFactory.getLogger(this.getClass)
private def createSearchProblem(question: String) =
new QaSearchProblem(question, transitionModel, costModel)
private def pathToSteps(q: String, path: List[(QaState, QaAction, QaState)]) =
path map { case (fromState, action, toState) =>
QaStep(q, fromState, action, toState)
}
private def makeDerivation(q: String, n: Node[QaState, QaAction], t0: Long) =
n.state match {
case as: AnswerState => {
val a = as.answer
val steps = pathToSteps(q, n.path())
val feats = steps.map(costModel.features).fold(SparseVector.zero)(_+_)
val score = -1 * n.pathCost
val searchTime = n.creationTime - t0
Some(Derivation(q, a, steps.toIndexedSeq, feats, score, searchTime))
}
case _ => None
}
override def predict(question: String) = {
val preds = candidatePredictions(question)
preds.sortBy(-1 * _.score) match {
case d :: rest => {
logger.debug(s"Prediction: $question => ${d.answer}")
Some(d)
}
case _ => {
logger.debug(s"Prediction: $question => None")
None
}
}
}
override def candidatePredictions(question: String) = {
val problem = createSearchProblem(question)
val searcher = new QaBeamSearch(problem)
val goals = searcher.search
goals.flatMap(makeDerivation(question, _, searcher.startTime))
}
override def update(q: String, output: Derivation, expected: Derivation) = {
logger.debug(s"Updating model with ${expected.answer} - ${output.answer}")
val delta = expected.features - output.features
val oldWeights = costModel.weights
val newWeights = oldWeights + delta
costModel.weights = newWeights
logger.debug(s"Updated model = $newWeights")
}
}
case object QaModel {
lazy val defaultTransitionModel = new QaTransitionModel
lazy val defaultCostModel = new QaCostModel
}
================================================
FILE: oqa-core/src/main/scala/edu/knowitall/paraphrasing/Paraphrase.scala
================================================
package edu.knowitall.paraphrasing
abstract class Paraphrase private () {
def source: String
def target: String
def derivation: ScoredParaphraseDerivation
}
object Paraphrase {
private case class ParaphraseImpl(source: String, target: String,
derivation: ScoredParaphraseDerivation) extends Paraphrase
def apply(source: String, target: String,
derivation: ScoredParaphraseDerivation): Paraphrase =
ParaphraseImpl(source, target, derivation)
}
================================================
FILE: oqa-core/src/main/scala/edu/knowitall/paraphrasing/ParaphraseDerivation.scala
================================================
package edu.knowitall.paraphrasing
import com.typesafe.config.ConfigFactory
trait ParaphraseDerivation
trait ScoredParaphraseDerivation extends ParaphraseDerivation {
def score: Double
}
case object IdentityDerivation extends ScoredParaphraseDerivation {
val conf = ConfigFactory.load()
override val score = conf.getDouble("paraphrase.identityScore")
}
================================================
FILE: oqa-core/src/main/scala/edu/knowitall/paraphrasing/Paraphraser.scala
================================================
package edu.knowitall.paraphrasing
trait Paraphraser {
def paraphrase(s: String): List[Paraphrase]
def paraphraseToStrings(s: String): List[String] =
paraphrase(s).map(pp => pp.target)
}
object EmptyParaphraser extends Paraphraser {
override def paraphrase(s: String) = List()
}
object IdentityParaphraser extends Paraphraser {
override def paraphrase(s: String) = List(Paraphrase(s, s, IdentityDerivation))
}
================================================
FILE: oqa-core/src/main/scala/edu/knowitall/paraphrasing/rules/ParaphraseRule.scala
================================================
package edu.knowitall.paraphrasing.rules
import edu.knowitall.parsing.cg.SentencePattern
import edu.knowitall.execution.UnquotedTLiteral
import edu.knowitall.repr.sentence.Lemmatized
import edu.knowitall.repr.sentence.Chunked
import edu.knowitall.repr.sentence.Sentence
import edu.knowitall.execution.TVariable
import edu.knowitall.parsing.cg.LexiconPreprocessor
import edu.knowitall.search.qa.QaAction
case class ParaphraseRule(name: String, input: SentencePattern, output: String) extends QaAction {
private val sp = UnquotedTLiteral(output)
def apply(s: Sentence with Chunked with Lemmatized) = if (input.matches(s)) {
val groups = input.groups(s)
val bindings = groups map {
case (name, value) => (TVariable(name), UnquotedTLiteral(value))
}
val result = sp.subs(bindings)
Some(result.value)
} else {
None
}
override def toString = name
}
case object ParaphraseRule {
lazy val preprocessor = LexiconPreprocessor()
def fromStrings(strings: IndexedSeq[String]) = for {
line <- strings
if !line.trim.startsWith("#") && line.trim != ""
} yield fromString(line)
def fromString(s: String) = s.split("\\s+:=\\s+", 2) match {
case Array(input, output) => input.split("\\s+", 2) match {
case Array(name, pat) =>
ParaphraseRule(name, SentencePattern(preprocessor(pat)), output)
case _ => throw new IllegalArgumentException(s"Invalid pattern: $input")
}
case _ => throw new IllegalArgumentException(s"Invalid rule: $s")
}
}
================================================
FILE: oqa-core/src/main/scala/edu/knowitall/paraphrasing/rules/ParaphraseRuleSet.scala
================================================
package edu.knowitall.paraphrasing.rules
import edu.knowitall.repr.sentence.Sentence
import edu.knowitall.repr.sentence.Chunked
import edu.knowitall.repr.sentence.Lemmatized
import edu.knowitall.util.ResourceUtils
import com.typesafe.config.ConfigFactory
import edu.knowitall.util.NlpTools
import scala.io.Source
case class ParaphraseRuleSet(rules: List[ParaphraseRule] = ParaphraseRuleSet.defaultRules) {
def apply(s: Sentence with Chunked with Lemmatized) = for {
r <- rules
p <- r(s)
} yield (r, p)
}
case object ParaphraseRuleSet {
val conf = ConfigFactory.load()
val defaultRuleSetPath = conf.getString("paraphrase.rules.ruleSetPath")
lazy val defaultRules = {
val strings = ResourceUtils.resourceSource(defaultRuleSetPath).getLines.toIndexedSeq
ParaphraseRule.fromStrings(strings)
}.toList
def fromPath(p: String) = {
val lines = Source.fromFile(p, "UTF-8").getLines.toIndexedSeq
ParaphraseRuleSet(ParaphraseRule.fromStrings(lines).toList)
}
}
================================================
FILE: oqa-core/src/main/scala/edu/knowitall/paraphrasing/template/LmParaphraseScorer.scala
================================================
package edu.knowitall.paraphrasing.template
import edu.knowitall.lm.KenLmServer
import edu.knowitall.paraphrasing.ScoredParaphraseDerivation
class LmParaphraseScorer extends ParaphraseScorer {
val client = new KenLmServer()
override def scoreAll(derivs: Iterable[TemplateParaphraseDerivation]): Iterable[TemplateParaphraseDerivation] = {
val dlist = derivs.toList
val lmScores = client.query(dlist.map(_.paraphrase.question.mkString(" "))).map(_._2)
for ((d, score) <- dlist.zip(lmScores)) yield d.copy(score = score, lm = score)
}
}
================================================
FILE: oqa-core/src/main/scala/edu/knowitall/paraphrasing/template/ParaphraseScorer.scala
================================================
package edu.knowitall.paraphrasing.template
import edu.knowitall.paraphrasing.ScoredParaphraseDerivation
trait ParaphraseScorer {
def scoreAll(derivs: Iterable[TemplateParaphraseDerivation]): Iterable[TemplateParaphraseDerivation]
}
================================================
FILE: oqa-core/src/main/scala/edu/knowitall/paraphrasing/template/PmiLmParaphraseScorer.scala
================================================
package edu.knowitall.paraphrasing.template
import edu.knowitall.tool.tokenize.ClearTokenizer
import edu.knowitall.tool.stem.MorphaStemmer
import edu.knowitall.lm.KenLmServer
import edu.knowitall.paraphrasing.ScoredParaphraseDerivation
class PmiLmParaphraseScorer() extends ParaphraseScorer {
val client = new KenLmServer()
override def scoreAll(derivs: Iterable[TemplateParaphraseDerivation]): Iterable[TemplateParaphraseDerivation] = {
val dlist = derivs.toList
val lmScores = client.query(dlist.map(_.paraphrase.question.mkString(" "))).map(_._2)
for ((d, lmScore) <- dlist.zip(lmScores)) yield d.copy(score = -lmScore * d.templates.pmi, lm = lmScore)
}
}
================================================
FILE: oqa-core/src/main/scala/edu/knowitall/paraphrasing/template/PmiParaphraseScorer.scala
================================================
package edu.knowitall.paraphrasing.template
import edu.knowitall.lm.KenLmServer
class PmiParaphraseScorer() extends ParaphraseScorer {
val client = new KenLmServer()
override def scoreAll(derivs: Iterable[TemplateParaphraseDerivation]): Iterable[TemplateParaphraseDerivation] = {
val dlist = derivs.toList
val lmScores = client.query(dlist.map(_.paraphrase.question.mkString(" "))).map(_._2)
for ((d, score) <- dlist.zip(lmScores)) yield d.copy(score = d.templates.pmi)
}
}
================================================
FILE: oqa-core/src/main/scala/edu/knowitall/paraphrasing/template/Template.scala
================================================
package edu.knowitall.paraphrasing.template
import edu.knowitall.tool.stem.Lemmatized
import edu.knowitall.tool.chunk.ChunkedToken
import edu.knowitall.util.NlpUtils.makeRegex
import scala.collection.JavaConversions._
import edu.knowitall.util.NlpUtils
import com.typesafe.config.ConfigFactory
import edu.knowitall.tool.stem.Lemmatized.viewAsToken
case class Template(left: Seq[Lemmatized[ChunkedToken]], right: Seq[Lemmatized[ChunkedToken]]) {
def substitute(value: Seq[Lemmatized[ChunkedToken]]) = left ++ value ++ right
def serialize = NlpUtils.serialize(left) + "|" + NlpUtils.serialize(right)
val templateString = (left.map(_.lemma.toLowerCase()).mkString(" ") + " $y " + right.map(_.lemma.toLowerCase()).mkString(" ")).trim
}
case object Template {
def deserialize(s: String): Template = {
s.split("|") match {
case Array(s1, s2) => Template(NlpUtils.deserialize(s1), NlpUtils.deserialize(s2))
case _ => throw new IllegalArgumentException(s"Could not deserialize template: $s")
}
}
}
case class AbstractedQuestion(value: Seq[Lemmatized[ChunkedToken]], template: Template) {
def this(q: Seq[Lemmatized[ChunkedToken]], i: Int, j: Int) = this(q.slice(i, j), Template(q.slice(0, i), q.slice(j, q.size)))
def substitute = template.substitute(value)
val valueString = value.map(_.lemma.toLowerCase()).mkString(" ").trim()
def serialize = NlpUtils.serialize(value) + "|" + template.serialize
}
case object AbstractedQuestion {
val conf = ConfigFactory.load()
def deserialize(s: String): AbstractedQuestion = {
s.split("|", 1) match {
case Array(value, rest) => AbstractedQuestion(NlpUtils.deserialize(value), Template.deserialize(rest))
case _ => throw new IllegalArgumentException(s"Could not deserialize abstracted question: $s")
}
}
val maxSize = conf.getInt("paraphrase.template.maxArgLength")
val valuePattern = makeRegex("^<pos='$' | pos='PRP$' | pos='CD' | pos='DT' | pos='JJ' | pos='JJS' | pos='JJR' | pos='NN' " +
"| pos='NNS' | pos='NNP' | pos='NNPS' | pos='POS' | pos='PRP' | pos='RB' | pos='RBR' | pos='RBS' " +
"| pos='VBN' | pos='VBG'>+$")
val argPos = "$ PRP$ CD DT JJ JJS JJR NN NNS NNP NNPS POS PRP RB RBR RBS VBN VBG".split(" ").toSet
def keepArg(arg: Seq[Lemmatized[ChunkedToken]]) = arg.forall(t => argPos.contains(t.postag))
def intervals(size: Int, max: Int) =
for (i <- Range(0, size); j <- Range(i, size); if j+1-i <= max) yield (i, j+1)
def detInTemplate(abs: AbstractedQuestion) = abs.template.left.size > 0 && abs.template.left.last.postag == "DT"
def keepAbs(abs: AbstractedQuestion) = !detInTemplate(abs)
def generateAbstracted(question: Seq[Lemmatized[ChunkedToken]]): Iterable[AbstractedQuestion] =
for ((i, j) <- intervals(question.size, maxSize);
arg = question.slice(i, j);
if keepArg(arg);
abs = new AbstractedQuestion(question, i, j);
if keepAbs(abs))
//if valuePattern(abs.value) && keepAbs(abs))
yield abs
}
================================================
FILE: oqa-core/src/main/scala/edu/knowitall/paraphrasing/template/TemplateIndexer.scala
================================================
package edu.knowitall.paraphrasing.template
import scala.io.Source
import scala.collection.JavaConversions._
import org.apache.solr.common.SolrDocument
import org.apache.solr.common.SolrInputDocument
import org.apache.solr.client.solrj.impl.ConcurrentUpdateSolrServer
import org.apache.solr.client.solrj.SolrServer
import org.slf4j.LoggerFactory
import org.apache.solr.client.solrj.impl.HttpSolrServer
import org.apache.solr.client.solrj.SolrQuery
import org.apache.solr.client.solrj.SolrQuery.SortClause
import scala.Option.option2Iterable
import com.typesafe.config.ConfigFactory
import edu.knowitall.util.MathUtils
import edu.knowitall.search.qa.QaAction
import edu.knowitall.triplestore.SolrClient
import edu.knowitall.util.ResourceUtils
import org.apache.solr.common.params.GroupParams
import org.apache.solr.client.solrj.response.QueryResponse
case class ParaphraseTemplateClient(solrUrl: String,
maxHits: Int, scale: Boolean = ParaphraseTemplateClient.scale,
timeout: Int = ParaphraseTemplateClient.defaultTimeout,
stopTemplates: Set[String] = ParaphraseTemplateClient.stopTemplates) {
def this() = this(ParaphraseTemplateClient.defaultUrl, ParaphraseTemplateClient.defaultMaxHits, ParaphraseTemplateClient.scale)
val logger = LoggerFactory.getLogger(this.getClass)
val server = new HttpSolrServer(solrUrl)
server.setConnectionTimeout(timeout)
server.setSoTimeout(timeout)
server.setMaxRetries(1)
val searchField = "template1_exact"
def paraphrases(s: String, argTypes: List[String] = List("anything"), limit: Int = maxHits) =
queryParaphrases(s, argTypes, limit)
private def responseToPairs(r: QueryResponse) = for {
value <- r.getGroupResponse.getValues
groupValue <- value.getValues
doc <- groupValue.getResult.toList
pair <- TemplatePair.fromDocument(doc)
if !(stopTemplates contains pair.template2)
} yield pair
private def createQuery(s: String, argTypes: List[String], limit: Int = maxHits) = {
val typePred = { argTypes map { t =>
val esc = SolrClient.escape(t)
s"""typ_exact:"${t}""""
} }.mkString(s" OR ")
val qStr = s"""${searchField}:"${s}" AND ($typePred)"""
val query = new SolrQuery(SolrClient.fixQuery(qStr))
query.setRows(maxHits)
query.addSort(new SortClause("pmi", SolrQuery.ORDER.desc))
query.set(GroupParams.GROUP, true)
query.set(GroupParams.GROUP_FIELD, "template2_exact")
query.setParam("shards.tolerant", true)
query
}
def queryParaphrases(s: String, argTypes: List[String] = List("anything"), limit: Int = maxHits): List[TemplatePair] = {
val query = createQuery(s, argTypes, limit)
val resp = server.query(query)
val pairs = responseToPairs(resp).toList
pairs
}
}
case object ParaphraseTemplateClient {
val conf = ConfigFactory.load()
val minPmi = conf.getDouble("paraphrase.template.minPmi")
val maxPmi = conf.getDouble("paraphrase.template.maxPmi")
val scale = conf.getBoolean("paraphrase.template.scale")
val defaultUrl = conf.getString("paraphrase.template.url")
val defaultMaxHits = conf.getInt("paraphrase.template.maxHits")
val defaultTimeout = conf.getInt("paraphrase.template.timeout")
val stopTemplatesPath = conf.getString("paraphrase.template.stopTemplatesPath")
lazy val stopTemplates = ResourceUtils.resourceSource(stopTemplatesPath).getLines.toSet
}
case class TemplatePair(template1: String, template2: String, typ: String, count1: Double, count2: Double, count12: Double, pmi: Double) extends QaAction
case object TemplatePair {
def fromString(s: String): Option[TemplatePair] = {
s.split("\t", 9) match {
case Array(t1, t2, typ, count1, count2, count12, pmi) =>
Some(TemplatePair(t1, t2, typ, count1.toDouble, count2.toDouble, count12.toDouble, pmi.toDouble))
case _ => None
}
}
def fromDocument(doc: SolrDocument): Option[TemplatePair] = {
val t1obj: Any = doc.getFieldValue("template1")
val t2obj: Any = doc.getFieldValue("template2")
val typobj: Any = doc.getFieldValue("typ")
val count1obj: Any = doc.getFieldValue("count1")
val count2obj: Any = doc.getFieldValue("count2")
val count12Obj: Any = doc.getFieldValue("count12")
val pmiObj: Any = doc.getFieldValue("pmi")
(t1obj, t2obj, typobj, count1obj, count2obj, count12Obj, pmiObj) match {
case (t1: String, t2: String, typ: String, count1: Float, count2: Float, count12: Float, pmi: Float) => Some(TemplatePair(t1, t2, typ, count1, count2, count12, pmi))
case _ => None
}
}
}
================================================
FILE: oqa-core/src/main/scala/edu/knowitall/paraphrasing/template/TemplateParaphraseGenerator.scala
================================================
package edu.knowitall.paraphrasing.template
import edu.knowitall.collection.immutable.Interval
import com.typesafe.config.ConfigFactory
import edu.knowitall.paraphrasing.ScoredParaphraseDerivation
import edu.knowitall.lm.KenLmServer
case class ArgQuestion(question: Seq[String], argInterval: Interval) {
def arg: String = question.slice(argInterval.start, argInterval.end).mkString(" ")
}
case class TemplateParaphraseDerivation(question: ArgQuestion,
paraphrase: ArgQuestion, templates: TemplatePair, score: Double = 0.0, pmi: Double = 0.0, lm: Double = 0.0) extends ScoredParaphraseDerivation {
val questionString = question.question.mkString(" ")
}
trait TemplateParaphraseGenerator {
def generate(question: Seq[String]): Iterable[TemplateParaphraseDerivation]
}
class SolrParaphraseGenerator(url: String, maxHits: Int, maxArgLength: Int) extends TemplateParaphraseGenerator {
def this() = this(SolrParaphraseGenerator.defaultUrl,
SolrParaphraseGenerator.defaultMaxHits,
SolrParaphraseGenerator.defaultMaxArgLength)
val client = new ParaphraseTemplateClient()
def intervals(size: Int) =
for (i <- Range(0, size); j <- Range(i, size); if j+1-i <= maxArgLength) yield Interval.open(i, j+1)
def templates(q: ArgQuestion): List[TemplatePair] = {
val i = q.argInterval.start
val j = q.argInterval.end
val n = q.question.size
val left = q.question.slice(0, i).mkString(" ")
val right = q.question.slice(j, n).mkString(" ")
val query = left + " $y " + right
client.paraphrases(query, limit = maxHits)
}
def abstractQuestion(q: Seq[String]): Iterable[ArgQuestion] = {
val n = q.size
for (i <- intervals(n)) yield ArgQuestion(q, i)
}
def substitute(q: ArgQuestion, t: TemplatePair): ArgQuestion = {
val templ = t.template2
val templSeq = templ.split(" ").toSeq
val arg = q.question.slice(q.argInterval.start, q.argInterval.end)
val i = templSeq.indexOf("$y")
if (i >= 0) {
val left = templSeq.slice(0, i)
val right = templSeq.slice(i+1, templSeq.size)
val para = ArgQuestion(left ++ arg ++ right, Interval.open(i, i+arg.size))
para
} else {
throw new IllegalArgumentException(s"Could not find var in: $templ")
}
}
override def generate(question: Seq[String]): Iterable[TemplateParaphraseDerivation] = {
for (aq <- abstractQuestion(question); t <- templates(aq); para = substitute(aq, t))
yield TemplateParaphraseDerivation(aq, para, t, score = 0.0, pmi = t.pmi, lm = Double.MinValue)
}
}
case object SolrParaphraseGenerator {
val conf = ConfigFactory.load()
val defaultUrl = conf.getString("paraphrase.template.url")
val defaultMaxHits = conf.getInt("paraphrase.template.maxHits")
val defaultMaxArgLength = conf.getInt("paraphrase.template.maxArgLength")
}
================================================
FILE: oqa-core/src/main/scala/edu/knowitall/paraphrasing/template/TemplateParaphraser.scala
================================================
package edu.knowitall.paraphrasing.template
import edu.knowitall.paraphrasing.Paraphraser
import edu.knowitall.tool.postag.StanfordPostagger
import edu.knowitall.tool.tokenize.ClearTokenizer
import org.slf4j.LoggerFactory
import edu.knowitall.tool.stem.MorphaStemmer
import edu.knowitall.paraphrasing.Paraphrase
import com.typesafe.config.ConfigFactory
case class TemplateParaphraser(scorer: ParaphraseScorer, generator: TemplateParaphraseGenerator) extends Paraphraser {
def this() = this(TemplateParaphraser.defaultScorer, new SolrParaphraseGenerator())
lazy val tagger = new StanfordPostagger()
lazy val tokenizer = new ClearTokenizer()
val logger = LoggerFactory.getLogger(this.getClass)
def stemString(s: String): Seq[String] = {
val tokens = tokenizer(s)
val tagged = tagger.postagTokenized(tokens)
val lemmas = tagged.map(t => MorphaStemmer.lemmatizePostaggedToken(t).lemma.toLowerCase())
lemmas
}
override def paraphrase(s: String) = {
val stemmed = stemString(s)
val paraphrases = generator.generate(stemmed)
val scored = scorer.scoreAll(paraphrases).toList
val grouped = scored.groupBy(sp => sp.paraphrase.question).values
val maxed = grouped.map(g => g.maxBy(d => d.score)).toList
val sorted = maxed.sortBy(d => -d.score)
for (deriv <- sorted; target = deriv.paraphrase.question.mkString(" "))
yield Paraphrase(s, target, deriv)
}
}
case object TemplateParaphraser {
val conf = ConfigFactory.load()
val scoringModel = conf.getString("paraphrase.template.scoringModel")
val defaultScorer = scoringModel match {
case "pmi" => new PmiParaphraseScorer()
case "lm" => new LmParaphraseScorer()
case "pmiLm" => new PmiLmParaphraseScorer()
case _ => throw new IllegalStateException(s"Could not load default scoring model '$scoringModel'")
}
}
================================================
FILE: oqa-core/src/main/scala/edu/knowitall/parsing/cg/CKY.scala
================================================
package edu.knowitall.parsing.cg
import edu.knowitall.repr.sentence.Sentence
import edu.knowitall.repr.sentence.Lemmatized
import edu.knowitall.repr.sentence.Chunked
import edu.knowitall.collection.immutable.Interval
import scala.collection.mutable.{Map => MutableMap}
import edu.knowitall.util.MathUtils
sealed trait Node {
def span: Interval
def category: Category
}
case class CatSpan(category: Category, span: Interval)
case class Terminal(catspan: CatSpan,
rule: TerminalRule) extends Node {
override val span = catspan.span
override val category = catspan.category
}
case class NonTerminal(catspan: CatSpan, left: CatSpan, right: CatSpan,
rule: Combinator) extends Node {
override val span = catspan.span
override val category = catspan.category
}
sealed trait Derivation {
def catspan: CatSpan
def category = catspan.category
def interval = catspan.span
def terminals: List[LexicalStep]
def combinators: List[Combinator]
}
case class CombinatorStep(catspan: CatSpan, rule: Combinator, left: Derivation, right: Derivation) extends Derivation {
override def combinators = rule :: (left.combinators ++ right.combinators)
override def terminals = left.terminals ++ right.terminals
}
case class LexicalStep(catspan: CatSpan, rule: TerminalRule) extends Derivation {
override def combinators = Nil
override def terminals = List(this)
override def toString = s"$rule => $interval $category"
}
case class CKY(input: Sentence with Chunked with Lemmatized, size: Int,
terminalRules: IndexedSeq[TerminalRule],
combinators: IndexedSeq[Combinator]) {
val cats = MutableMap.empty[Interval, Set[Category]]
val nodes = MutableMap.empty[CatSpan, Node]
private def applyTerminalRules = for {
interval <- MathUtils.allIntervals(size)
rule <- terminalRules
category <- rule(interval, input)
catspan = CatSpan(category, interval)
terminal = Terminal(catspan, rule)
} yield {
cats += (interval -> (cats.getOrElse(interval, Set.empty) + category))
nodes += (catspan -> terminal)
}
private def applyCombinators(length: Int) = for {
interval <- MathUtils.intervals(length, size)
(left, right) <- MathUtils.splits(interval)
lcat <- cats.getOrElse(left, Set.empty)
rcat <- cats.getOrElse(right, Set.empty)
combinator <- combinators
cat <- combinator(lcat, rcat)
node = NonTerminal(CatSpan(cat, interval), CatSpan(lcat, left), CatSpan(rcat, right), combinator)
} {
cats += (interval -> (cats.getOrElse(interval, Set.empty) + cat))
nodes += (CatSpan(cat, interval) -> node)
}
def parse = {
applyTerminalRules
for (length <- 2 to size) applyCombinators(length)
}
private val fullSpan = Interval.open(0, size)
def rootCategories = cats.getOrElse(fullSpan, Set())
def derivations(catspan: CatSpan): Iterable[Derivation] = nodes.get(catspan) match {
case None => Iterable.empty
case Some(node) => node match {
case Terminal(cs, rule) => Iterable(LexicalStep(catspan, rule))
case NonTerminal(cs, left, right, rule) => for {
leftd <- derivations(left)
rightd <- derivations(right)
} yield CombinatorStep(catspan, rule, leftd, rightd)
}
}
def rootDerivations = for {
c <- cats.getOrElse(fullSpan, Set.empty)
cs = CatSpan(c, fullSpan)
d <- derivations(cs)
} yield d
}
================================================
FILE: oqa-core/src/main/scala/edu/knowitall/parsing/cg/Categories.scala
================================================
package edu.knowitall.parsing.cg
import edu.knowitall.execution.TLiteral
import edu.knowitall.execution.TVariable
import edu.knowitall.execution.ConjunctiveQuery
import edu.knowitall.execution.FieldIndex
import edu.knowitall.execution.TVal
import edu.knowitall.execution.UnquotedTLiteral
trait Category {
def categoryString: String
}
case class Arg(value: TLiteral) extends Category {
override val categoryString = "Arg"
}
case class Unary(freeVar: TVariable, query: ConjunctiveQuery, modFields: Set[FieldIndex] = Set.empty) extends Category {
override val categoryString = "Unary"
private def renameFieldIndex(prefix: String, index: FieldIndex) = {
val i = query.conjuncts.indexWhere(c => c.name == index.conjunctName)
assume(i >= 0, s"field index $index not in query $query")
index.copy(conjunctName = s"${prefix}.$i")
}
def renameConjuncts(prefix: String): Unary = {
val newFields = modFields.map(renameFieldIndex(prefix, _))
val newQuery = query.renameConjuncts(prefix)
Unary(freeVar, newQuery, newFields)
}
def intersect(that: Unary): Unary = {
val u1 = this.renameConjuncts("r")
val u2 = that.renameConjuncts("s")
val newVar = TVariable(u1.freeVar.name + u2.freeVar.name)
val oldVar1 = u1.freeVar
val oldVar2 = u2.freeVar
val query1 = u1.query.subs(oldVar1, newVar)
val query2 = u2.query.subs(oldVar2, newVar)
val newQuery = query1.combine(query2).subs(newVar, Unary.finalVar)
Unary(newVar, newQuery, u1.modFields ++ u2.modFields)
}
}
case object Unary {
val finalVar = TVariable("x")
}
case class Binary(leftVar: TVariable, rightVar: TVariable,
query: ConjunctiveQuery, modFields: Set[FieldIndex] = Set.empty) extends Category {
override val categoryString = "Binary"
def leftApply(a: Arg): Unary = {
val newQuery = query.subs(leftVar, a.value)
Unary(rightVar, newQuery, modFields)
}
def rightApply(a: Arg): Unary = {
val newQuery = query.subs(rightVar, a.value)
Unary(leftVar, newQuery, modFields)
}
}
case class Mod(value: String) extends Category {
override val categoryString = "Mod"
private def updateValue(v: TVal) = v match {
case l: TLiteral => l.update(s"${l.value} $value")
case _ => v
}
private def modifyFields(is: List[FieldIndex], q: ConjunctiveQuery): ConjunctiveQuery = is match {
case Nil => q
case i :: rest => modifyFields(rest, i.updateQuery(q, updateValue))
}
def modify(u: Unary): Option[Unary] = {
val newQuery = modifyFields(u.modFields.toList, u.query)
if (newQuery == u.query) {
None
} else {
Some(u.copy(query = newQuery))
}
}
override def toString = s"Mod($value)"
}
object Identity extends Category {
override val categoryString = "Identity"
override def toString = "Identity"
}
================================================
FILE: oqa-core/src/main/scala/edu/knowitall/parsing/cg/CategoryPattern.scala
================================================
package edu.knowitall.parsing.cg
import edu.knowitall.execution.TVariable
import edu.knowitall.execution.ListConjunctiveQuery
import edu.knowitall.execution.UnquotedTLiteral
import edu.knowitall.execution.Search.rel
import edu.knowitall.execution.FieldIndex
trait CategoryPattern {
def apply(bindings: Map[TVariable, String]): Option[Category]
}
object CategoryPattern {
def fromString(s: String) = s.trim().split("\\s+", 2) match {
case Array("identity") => IdentityPattern
case Array("unary", pattern) => UnaryPattern(pattern)
case Array("binary", pattern) => BinaryPattern(pattern)
case Array("argument", pattern) => ArgumentPattern(pattern)
case Array("mod", pattern) => ModPattern(pattern)
case _ => throw new IllegalArgumentException(s"Invalid pattern string: $s")
}
}
case class UnaryPattern(pattern: String) extends CategoryPattern {
private val cqp = ConjunctiveQueryPattern(pattern)
assume(cqp.boundVars.size == 1, s"UnaryPattern $pattern must have 1 bound variable")
val freeVar = cqp.query.qVars(0)
override def apply(bindings: Map[TVariable, String]) = for {
query <- cqp(bindings)
} yield Unary(freeVar, query)
}
case class BinaryPattern(pattern: String) extends CategoryPattern {
private val cqp = ConjunctiveQueryPattern(pattern)
assume(cqp.boundVars.size == 2, s"BinaryPattern $pattern must have 2 bound variables")
val leftVar = cqp.query.qVars(0)
val rightVar = cqp.query.qVars(1)
override def apply(bindings: Map[TVariable, String]) = for {
query <- cqp(bindings)
relFields = for {
c <- query.conjuncts
(field, value) <- c.values
if field == rel
} yield FieldIndex(c.name, field)
} yield Binary(leftVar, rightVar, query, relFields.toSet)
}
case class ArgumentPattern(pattern: String) extends CategoryPattern {
private val sp = UnquotedTLiteral(pattern)
override def apply(bindings: Map[TVariable, String]) = {
val valBindings = bindings map { case (k, v) => (k, UnquotedTLiteral(v)) }
Some(Arg(sp.subs(valBindings)))
}
}
case class ModPattern(pattern: String) extends CategoryPattern {
private val sp = UnquotedTLiteral(pattern)
override def apply(bindings: Map[TVariable, String]) = {
val valBindings = bindings map { case (k, v) => (k, UnquotedTLiteral(v)) }
Some(Mod(sp.subs(valBindings).toString))
}
}
object IdentityPattern extends CategoryPattern {
override def apply(bindings: Map[TVariable, String]) = Some(Identity)
}
case class ConjunctiveQueryPattern(pattern: String) {
val query = ListConjunctiveQuery.fromString(pattern) match {
case Some(x) => x
case None => throw new IllegalArgumentException(s"Invalid pattern: $pattern")
}
val boundVars = query.qVars
val freeVars = query.conjuncts.flatMap(_.vars).toSet -- boundVars
def apply(bindings: Map[TVariable, String]) = {
if (freeVars.subsetOf(bindings.keys.toSet)) {
val literals = bindings map { case (tvar, s) => (tvar, UnquotedTLiteral(s)) }
Some(query.subs(literals))
} else {
None
}
}
}
================================================
FILE: oqa-core/src/main/scala/edu/knowitall/parsing/cg/CgParser.scala
================================================
package edu.knowitall.parsing.cg
import com.typesafe.config.ConfigFactory
import java.io.FileInputStream
import java.io.File
import edu.knowitall.util.ResourceUtils
import edu.knowitall.util.NlpTools
import edu.knowitall.tool.chunk.Chunker
import edu.knowitall.tool.stem.Stemmer
import edu.knowitall.execution.ConjunctiveQuery
import edu.knowitall.search.qa.QaAction
import edu.knowitall.repr.sentence.Lemmatized
import edu.knowitall.repr.sentence.Chunked
import edu.knowitall.repr.sentence.Sentence
import edu.knowitall.collection.immutable.Interval
import edu.knowitall.execution.TLiteral
case class ParsedQuestion(question: Sentence with Chunked with Lemmatized,
query: ConjunctiveQuery, derivation: Derivation) extends QaAction {
private def sliceString[A](seq: Traversable[A], i: Interval) =
seq.slice(i.start, i.end).mkString(" ")
def postags(i: Interval) = sliceString(question.postags, i)
}
case class CgParser(lexicon: IndexedSeq[LexicalRule] = CgParser.defaultLexicon,
combinators: IndexedSeq[Combinator] = CgParser.defaultCombinators,
chunker: Chunker = NlpTools.dummyChunker,
lemmatizer: Stemmer = NlpTools.stemmer,
maxConjuncts: Int = CgParser.defaultMaxConjuncts,
outputFilter: ParsedQuestion => Boolean = CgParser.defaultOutputFilter) {
private def process(s: String) = NlpTools.process(s, chunker, lemmatizer)
private def getQuery(cat: Category) = cat match {
case Unary(freeVar, query, _) => Some(query)
case _ => None
}
def parse(s: String) = {
val sent = process(s)
val n = sent.tokens.size
val cky = new CKY(sent, n, lexicon, combinators)
cky.parse
for {
derivation <- cky.rootDerivations
query <- derivation.category match {
case u: Unary => Some(u.query)
case _ => None
}
output = ParsedQuestion(sent, query, derivation)
if output.query.conjuncts.size <= maxConjuncts
if outputFilter(output)
} yield ParsedQuestion(sent, query, derivation)
}
def apply(s: String) = parse(s)
}
case object CgParser {
val conf = ConfigFactory.load()
val defaultCombinators = IndexedSeq(RightApply, LeftApply, UnaryIntersect,
UnaryIdentity, ApplyMod)
lazy val lexiconIn = if (conf.hasPath("parsing.cg.lexiconPath")) {
new FileInputStream(new File(conf.getString("parsing.cg.lexiconPath")))
} else {
ResourceUtils.resource(conf.getString("parsing.cg.lexiconClasspath"))
}
lazy val ruleKeep = conf.getString("parsing.cg.lexicalRuleKeep").r
lazy val ruleSkip = conf.getString("parsing.cg.lexicalRuleSkip").r
lazy val defaultLexicon = LexicalRule.fromInputStream(lexiconIn).filter {
rule => ruleKeep.findPrefixMatchOf(rule.name).isDefined &&
!ruleSkip.findPrefixMatchOf(rule.name).isDefined
}
lazy val defaultMaxConjuncts = conf.getInt("parsing.cg.maxConjuncts")
lazy val defaultOutputFilter = {
val relIn = ResourceUtils.resource("/edu/knowitall/parsing/cg/relFilters.txt")
val rels = ParserRelFilter.fromInputStream(relIn)
val argIn = ResourceUtils.resource("/edu/knowitall/parsing/cg/argFilters.txt")
val args = ParserArgFilter.fromInputStream(argIn)
(rels ++ args).reduce((a, b) => (x => a(x) && b(x)))
}
}
================================================
FILE: oqa-core/src/main/scala/edu/knowitall/parsing/cg/Combinators.scala
================================================
package edu.knowitall.parsing.cg
import edu.knowitall.execution.ListConjunctiveQuery
import edu.knowitall.execution.UnquotedTLiteral
import edu.knowitall.execution.TVariable
import edu.knowitall.collection.immutable.Interval
import edu.knowitall.repr.sentence.Lemmatized
import edu.knowitall.repr.sentence.Chunked
import edu.knowitall.repr.sentence.Sentence
import edu.knowitall.tool.typer.Type
trait Combinator {
def apply(left: Category, right: Category): Option[Category]
}
trait TerminalRule {
def apply(interval: Interval, sent: Sentence with Chunked with Lemmatized): Option[Category]
}
object RightApply extends Combinator {
override def apply(left: Category, right: Category) = (left, right) match {
case (b: Binary, a: Arg) => Some(b.rightApply(a))
case _ => None
}
override def toString = "RightApply"
}
object LeftApply extends Combinator {
override def apply(left: Category, right: Category) = (left, right) match {
case (a: Arg, b: Binary) => Some(b.leftApply(a))
case _ => None
}
override def toString = "LeftApply"
}
object UnaryIntersect extends Combinator {
override def apply(left: Category, right: Category) = (left, right) match {
case (u1: Unary, u2: Unary) => {
Some(u1.intersect(u2))
}
case _ => None
}
override def toString = "UnaryIntersect"
}
object UnaryIdentity extends Combinator {
override def apply(left: Category, right: Category) = (left, right) match {
case (Identity, u: Unary) => Some(u)
case (u: Unary, Identity) => Some(u)
case _ => None
}
override def toString = "UnaryIdentity"
}
object ApplyMod extends Combinator {
override def apply(left: Category, right: Category) = (left, right) match {
case (m: Mod, u: Unary) => m.modify(u)
case _ => None
}
override def toString = "Mod"
}
================================================
FILE: oqa-core/src/main/scala/edu/knowitall/parsing/cg/LexicalRule.scala
================================================
package edu.knowitall.parsing.cg
import edu.knowitall.repr.sentence.Lemmatized
import edu.knowitall.repr.sentence.Chunked
import edu.knowitall.repr.sentence.Sentence
import edu.knowitall.collection.immutable.Interval
import edu.knowitall.util.NlpUtils
import java.io.InputStream
import scala.io.Source
import edu.knowitall.util.ResourceUtils
case class LexicalRule(syntax: PatternExtractor, semantics: CategoryPattern) extends TerminalRule {
val name = syntax.patternName
override def apply(interval: Interval, sent: Sentence with Chunked with Lemmatized) = {
val span = NlpUtils.split(sent, interval.start, interval.end)
if (syntax.matches(span)) {
semantics(syntax(span))
} else {
None
}
}
override def toString = name
}
object LexicalRule {
lazy val pr
gitextract_8frwjrok/
├── README.md
├── oqa-core/
│ ├── README.md
│ ├── build.sbt
│ ├── models/
│ │ └── full.txt
│ ├── questions.txt
│ └── src/
│ └── main/
│ ├── resources/
│ │ ├── application.conf
│ │ ├── edu/
│ │ │ └── knowitall/
│ │ │ ├── execution/
│ │ │ │ ├── stoplist.txt
│ │ │ │ └── stopregex.txt
│ │ │ ├── paraphrasing/
│ │ │ │ ├── rules/
│ │ │ │ │ └── rules.txt
│ │ │ │ └── template/
│ │ │ │ └── templatesStops.txt
│ │ │ ├── parsing/
│ │ │ │ └── cg/
│ │ │ │ ├── argFilters.txt
│ │ │ │ ├── lexicon.txt
│ │ │ │ ├── macros.txt
│ │ │ │ └── relFilters.txt
│ │ │ └── search/
│ │ │ └── qa/
│ │ │ ├── isa.txt
│ │ │ └── tupleFeatures.txt
│ │ ├── log4j.properties
│ │ └── logback.xml
│ └── scala/
│ └── edu/
│ └── knowitall/
│ ├── eval/
│ │ ├── Oracle.scala
│ │ ├── OutputRecord.scala
│ │ ├── SystemOutput.scala
│ │ └── qa/
│ │ ├── QAOutputRecord.scala
│ │ ├── QASystemOutput.scala
│ │ └── QASystemRunner.scala
│ ├── execution/
│ │ ├── AnswerFilter.scala
│ │ ├── ConjunctiveQuery.scala
│ │ ├── JoinPlanner.scala
│ │ ├── QueryExecutor.scala
│ │ ├── RelationalAlgebra.scala
│ │ └── StopwordExecutor.scala
│ ├── learning/
│ │ ├── CorrectnessModel.scala
│ │ ├── FeatureFunction.scala
│ │ ├── HiddenVariableModel.scala
│ │ ├── InteractiveOracle.scala
│ │ ├── LabeledDataOracle.scala
│ │ ├── MemoryInteractiveOracle.scala
│ │ ├── Perceptron.scala
│ │ ├── QATrainer.scala
│ │ ├── QueryTupleSimilarity.scala
│ │ └── SparseVector.scala
│ ├── lm/
│ │ └── LanguageModel.scala
│ ├── model/
│ │ ├── Derivation.scala
│ │ └── QaModel.scala
│ ├── paraphrasing/
│ │ ├── Paraphrase.scala
│ │ ├── ParaphraseDerivation.scala
│ │ ├── Paraphraser.scala
│ │ ├── rules/
│ │ │ ├── ParaphraseRule.scala
│ │ │ └── ParaphraseRuleSet.scala
│ │ └── template/
│ │ ├── LmParaphraseScorer.scala
│ │ ├── ParaphraseScorer.scala
│ │ ├── PmiLmParaphraseScorer.scala
│ │ ├── PmiParaphraseScorer.scala
│ │ ├── Template.scala
│ │ ├── TemplateIndexer.scala
│ │ ├── TemplateParaphraseGenerator.scala
│ │ └── TemplateParaphraser.scala
│ ├── parsing/
│ │ └── cg/
│ │ ├── CKY.scala
│ │ ├── Categories.scala
│ │ ├── CategoryPattern.scala
│ │ ├── CgParser.scala
│ │ ├── Combinators.scala
│ │ ├── LexicalRule.scala
│ │ ├── LexiconPreprocessor.scala
│ │ ├── ParserFieldFilter.scala
│ │ ├── PatternExtractor.scala
│ │ └── SentencePattern.scala
│ ├── relsyn/
│ │ ├── IsaRelSynClient.scala
│ │ ├── ListRelSynClient.scala
│ │ ├── RelSynClient.scala
│ │ ├── RelSynRule.scala
│ │ └── SolrRelSynClient.scala
│ ├── search/
│ │ ├── Beam.scala
│ │ ├── BeamSearch.scala
│ │ ├── BestFirstSearch.scala
│ │ ├── SearchAlgorithm.scala
│ │ ├── SearchProblem.scala
│ │ ├── Transition.scala
│ │ └── qa/
│ │ ├── AbstractArgTransition.scala
│ │ ├── AbstractedArgState.scala
│ │ ├── AnswerState.scala
│ │ ├── CgParseTransition.scala
│ │ ├── DropQueryStopsTransition.scala
│ │ ├── ExecutionTransition.scala
│ │ ├── ParaphraseRuleTransition.scala
│ │ ├── ProjectionTransition.scala
│ │ ├── QaAction.scala
│ │ ├── QaBeamSearch.scala
│ │ ├── QaCostModel.scala
│ │ ├── QaFeatures.scala
│ │ ├── QaLayeredSearch.scala
│ │ ├── QaSearchProblem.scala
│ │ ├── QaState.scala
│ │ ├── QaStateComparator.scala
│ │ ├── QaStep.scala
│ │ ├── QaTransitionModel.scala
│ │ ├── QueryState.scala
│ │ ├── QuestionState.scala
│ │ ├── RelSynTransition.scala
│ │ ├── TemplateTransition.scala
│ │ ├── TupleFeatureTemplate.scala
│ │ └── TupleState.scala
│ ├── triplestore/
│ │ ├── IsaClient.scala
│ │ └── TriplestoreClient.scala
│ └── util/
│ ├── AlignedWordProcessor.scala
│ ├── Counter.scala
│ ├── DummyChunker.scala
│ ├── HadoopUtils.scala
│ ├── MathUtils.scala
│ ├── NlpTools.scala
│ ├── NlpUtils.scala
│ ├── PPDBParser.scala
│ ├── ResourceUtils.scala
│ ├── StringUtils.scala
│ ├── TimingUtils.scala
│ ├── TuplePrinter.scala
│ └── WikiAnswersSampler.scala
├── oqa-data/
│ ├── README.md
│ ├── predictions/
│ │ ├── README.md
│ │ ├── oqa-trec.txt
│ │ ├── oqa-webquestions.txt
│ │ ├── oqa-wikianswers.txt
│ │ ├── paralex-trec.txt
│ │ ├── paralex-webquestions.txt
│ │ ├── paralex-wikianswers.txt
│ │ ├── sempre-trec.txt
│ │ ├── sempre-webquestions.txt
│ │ └── sempre-wikianswers.txt
│ └── src/
│ └── main/
│ └── scripts/
│ └── download-oqa-data.sh
├── oqa-lm/
│ ├── README.md
│ └── src/
│ └── main/
│ └── scripts/
│ ├── build-lm.sh
│ ├── install-kenlm.sh
│ ├── server.py
│ ├── start.sh
│ └── stop.sh
└── oqa-solr/
├── README.md
├── paraphrase/
│ ├── README.txt
│ ├── cloud-scripts/
│ │ ├── zkcli.bat
│ │ └── zkcli.sh
│ ├── contexts/
│ │ └── solr-jetty-context.xml
│ ├── etc/
│ │ ├── create-solrtest.keystore.sh
│ │ ├── jetty.xml
│ │ ├── logging.properties
│ │ ├── solrtest.keystore
│ │ └── webdefault.xml
│ ├── example-DIH/
│ │ ├── README.txt
│ │ ├── hsqldb/
│ │ │ ├── ex.backup
│ │ │ ├── ex.data
│ │ │ ├── ex.log
│ │ │ ├── ex.properties
│ │ │ └── ex.script
│ │ └── solr/
│ │ ├── db/
│ │ │ ├── conf/
│ │ │ │ ├── admin-extra.html
│ │ │ │ ├── admin-extra.menu-bottom.html
│ │ │ │ ├── admin-extra.menu-top.html
│ │ │ │ ├── db-data-config.xml
│ │ │ │ ├── elevate.xml
│ │ │ │ ├── protwords.txt
│ │ │ │ ├── schema.xml
│ │ │ │ ├── scripts.conf
│ │ │ │ ├── solrconfig.xml
│ │ │ │ ├── stopwords.txt
│ │ │ │ ├── synonyms.txt
│ │ │ │ └── xslt/
│ │ │ │ ├── example.xsl
│ │ │ │ ├── example_atom.xsl
│ │ │ │ ├── example_rss.xsl
│ │ │ │ └── luke.xsl
│ │ │ └── lib/
│ │ │ ├── derby-10.9.1.0.jar
│ │ │ └── hsqldb-1.8.0.10.jar
│ │ ├── mail/
│ │ │ └── conf/
│ │ │ ├── admin-extra.html
│ │ │ ├── admin-extra.menu-bottom.html
│ │ │ ├── admin-extra.menu-top.html
│ │ │ ├── data-config.xml
│ │ │ ├── protwords.txt
│ │ │ ├── schema.xml
│ │ │ ├── solrconfig.xml
│ │ │ ├── stopwords.txt
│ │ │ └── synonyms.txt
│ │ ├── rss/
│ │ │ └── conf/
│ │ │ ├── admin-extra.html
│ │ │ ├── admin-extra.menu-bottom.html
│ │ │ ├── admin-extra.menu-top.html
│ │ │ ├── elevate.xml
│ │ │ ├── protwords.txt
│ │ │ ├── rss-data-config.xml
│ │ │ ├── schema.xml
│ │ │ ├── scripts.conf
│ │ │ ├── solrconfig.xml
│ │ │ ├── stopwords.txt
│ │ │ └── synonyms.txt
│ │ ├── solr/
│ │ │ └── conf/
│ │ │ ├── admin-extra.html
│ │ │ ├── admin-extra.menu-bottom.html
│ │ │ ├── admin-extra.menu-top.html
│ │ │ ├── elevate.xml
│ │ │ ├── protwords.txt
│ │ │ ├── schema.xml
│ │ │ ├── scripts.conf
│ │ │ ├── solr-data-config.xml
│ │ │ ├── solrconfig.xml
│ │ │ ├── stopwords.txt
│ │ │ └── synonyms.txt
│ │ ├── solr.xml
│ │ └── tika/
│ │ └── conf/
│ │ ├── admin-extra.html
│ │ ├── admin-extra.menu-bottom.html
│ │ ├── admin-extra.menu-top.html
│ │ ├── schema.xml
│ │ ├── solrconfig.xml
│ │ └── tika-data-config.xml
│ ├── exampledocs/
│ │ ├── books.csv
│ │ ├── books.json
│ │ ├── gb18030-example.xml
│ │ ├── hd.xml
│ │ ├── ipod_other.xml
│ │ ├── ipod_video.xml
│ │ ├── manufacturers.xml
│ │ ├── mem.xml
│ │ ├── money.xml
│ │ ├── monitor.xml
│ │ ├── monitor2.xml
│ │ ├── mp500.xml
│ │ ├── post.jar
│ │ ├── post.sh
│ │ ├── sd500.xml
│ │ ├── solr.xml
│ │ ├── test_utf8.sh
│ │ ├── utf8-example.xml
│ │ └── vidcard.xml
│ ├── lib/
│ │ ├── ext/
│ │ │ ├── jcl-over-slf4j-1.6.6.jar
│ │ │ ├── jul-to-slf4j-1.6.6.jar
│ │ │ ├── log4j-1.2.16.jar
│ │ │ ├── slf4j-api-1.6.6.jar
│ │ │ └── slf4j-log4j12-1.6.6.jar
│ │ ├── jetty-continuation-8.1.8.v20121106.jar
│ │ ├── jetty-deploy-8.1.8.v20121106.jar
│ │ ├── jetty-http-8.1.8.v20121106.jar
│ │ ├── jetty-io-8.1.8.v20121106.jar
│ │ ├── jetty-jmx-8.1.8.v20121106.jar
│ │ ├── jetty-security-8.1.8.v20121106.jar
│ │ ├── jetty-server-8.1.8.v20121106.jar
│ │ ├── jetty-servlet-8.1.8.v20121106.jar
│ │ ├── jetty-util-8.1.8.v20121106.jar
│ │ ├── jetty-webapp-8.1.8.v20121106.jar
│ │ ├── jetty-xml-8.1.8.v20121106.jar
│ │ └── servlet-api-3.0.jar
│ ├── multicore/
│ │ ├── README.txt
│ │ ├── core0/
│ │ │ └── conf/
│ │ │ ├── schema.xml
│ │ │ └── solrconfig.xml
│ │ ├── core1/
│ │ │ └── conf/
│ │ │ ├── schema.xml
│ │ │ └── solrconfig.xml
│ │ ├── exampledocs/
│ │ │ ├── ipod_other.xml
│ │ │ └── ipod_video.xml
│ │ ├── solr.xml
│ │ └── zoo.cfg
│ ├── resources/
│ │ └── log4j.properties
│ ├── solr/
│ │ ├── README.txt
│ │ ├── paraphrase/
│ │ │ ├── README.txt
│ │ │ ├── conf/
│ │ │ │ ├── admin-extra.html
│ │ │ │ ├── admin-extra.menu-bottom.html
│ │ │ │ ├── admin-extra.menu-top.html
│ │ │ │ ├── currency.xml
│ │ │ │ ├── elevate.xml
│ │ │ │ ├── lang/
│ │ │ │ │ ├── contractions_ca.txt
│ │ │ │ │ ├── contractions_fr.txt
│ │ │ │ │ ├── contractions_ga.txt
│ │ │ │ │ ├── contractions_it.txt
│ │ │ │ │ ├── hyphenations_ga.txt
│ │ │ │ │ ├── stemdict_nl.txt
│ │ │ │ │ ├── stoptags_ja.txt
│ │ │ │ │ ├── stopwords_ar.txt
│ │ │ │ │ ├── stopwords_bg.txt
│ │ │ │ │ ├── stopwords_ca.txt
│ │ │ │ │ ├── stopwords_cz.txt
│ │ │ │ │ ├── stopwords_da.txt
│ │ │ │ │ ├── stopwords_de.txt
│ │ │ │ │ ├── stopwords_el.txt
│ │ │ │ │ ├── stopwords_en.txt
│ │ │ │ │ ├── stopwords_es.txt
│ │ │ │ │ ├── stopwords_eu.txt
│ │ │ │ │ ├── stopwords_fa.txt
│ │ │ │ │ ├── stopwords_fi.txt
│ │ │ │ │ ├── stopwords_fr.txt
│ │ │ │ │ ├── stopwords_ga.txt
│ │ │ │ │ ├── stopwords_gl.txt
│ │ │ │ │ ├── stopwords_hi.txt
│ │ │ │ │ ├── stopwords_hu.txt
│ │ │ │ │ ├── stopwords_hy.txt
│ │ │ │ │ ├── stopwords_id.txt
│ │ │ │ │ ├── stopwords_it.txt
│ │ │ │ │ ├── stopwords_ja.txt
│ │ │ │ │ ├── stopwords_lv.txt
│ │ │ │ │ ├── stopwords_nl.txt
│ │ │ │ │ ├── stopwords_no.txt
│ │ │ │ │ ├── stopwords_pt.txt
│ │ │ │ │ ├── stopwords_ro.txt
│ │ │ │ │ ├── stopwords_ru.txt
│ │ │ │ │ ├── stopwords_sv.txt
│ │ │ │ │ ├── stopwords_th.txt
│ │ │ │ │ ├── stopwords_tr.txt
│ │ │ │ │ └── userdict_ja.txt
│ │ │ │ ├── mapping-FoldToASCII.txt
│ │ │ │ ├── mapping-ISOLatin1Accent.txt
│ │ │ │ ├── protwords.txt
│ │ │ │ ├── schema.xml
│ │ │ │ ├── scripts.conf
│ │ │ │ ├── solrconfig.xml
│ │ │ │ ├── spellings.txt
│ │ │ │ ├── stopwords.txt
│ │ │ │ ├── synonyms.txt
│ │ │ │ ├── update-script.js
│ │ │ │ ├── velocity/
│ │ │ │ │ ├── VM_global_library.vm
│ │ │ │ │ ├── browse.vm
│ │ │ │ │ ├── cluster.vm
│ │ │ │ │ ├── clusterResults.vm
│ │ │ │ │ ├── debug.vm
│ │ │ │ │ ├── did_you_mean.vm
│ │ │ │ │ ├── facet_fields.vm
│ │ │ │ │ ├── facet_pivot.vm
│ │ │ │ │ ├── facet_queries.vm
│ │ │ │ │ ├── facet_ranges.vm
│ │ │ │ │ ├── facets.vm
│ │ │ │ │ ├── footer.vm
│ │ │ │ │ ├── head.vm
│ │ │ │ │ ├── header.vm
│ │ │ │ │ ├── hit.vm
│ │ │ │ │ ├── hitGrouped.vm
│ │ │ │ │ ├── join-doc.vm
│ │ │ │ │ ├── jquery.autocomplete.css
│ │ │ │ │ ├── jquery.autocomplete.js
│ │ │ │ │ ├── layout.vm
│ │ │ │ │ ├── main.css
│ │ │ │ │ ├── product-doc.vm
│ │ │ │ │ ├── query.vm
│ │ │ │ │ ├── queryGroup.vm
│ │ │ │ │ ├── querySpatial.vm
│ │ │ │ │ ├── richtext-doc.vm
│ │ │ │ │ ├── suggest.vm
│ │ │ │ │ └── tabs.vm
│ │ │ │ └── xslt/
│ │ │ │ ├── example.xsl
│ │ │ │ ├── example_atom.xsl
│ │ │ │ ├── example_rss.xsl
│ │ │ │ ├── luke.xsl
│ │ │ │ └── updateXml.xsl
│ │ │ └── lib/
│ │ │ └── triplestore-lemmatizer-assembly-0.1.jar
│ │ ├── solr.xml
│ │ └── zoo.cfg
│ ├── solr-webapp/
│ │ └── webapp/
│ │ ├── META-INF/
│ │ │ ├── LICENSE.txt
│ │ │ ├── MANIFEST.MF
│ │ │ └── NOTICE.txt
│ │ ├── WEB-INF/
│ │ │ ├── lib/
│ │ │ │ ├── commons-cli-1.2.jar
│ │ │ │ ├── commons-codec-1.7.jar
│ │ │ │ ├── commons-fileupload-1.2.1.jar
│ │ │ │ ├── commons-io-2.1.jar
│ │ │ │ ├── commons-lang-2.6.jar
│ │ │ │ ├── guava-13.0.1.jar
│ │ │ │ ├── httpclient-4.2.3.jar
│ │ │ │ ├── httpcore-4.2.2.jar
│ │ │ │ ├── httpmime-4.2.3.jar
│ │ │ │ ├── lucene-analyzers-common-4.3.0.jar
│ │ │ │ ├── lucene-analyzers-kuromoji-4.3.0.jar
│ │ │ │ ├── lucene-analyzers-phonetic-4.3.0.jar
│ │ │ │ ├── lucene-codecs-4.3.0.jar
│ │ │ │ ├── lucene-core-4.3.0.jar
│ │ │ │ ├── lucene-grouping-4.3.0.jar
│ │ │ │ ├── lucene-highlighter-4.3.0.jar
│ │ │ │ ├── lucene-memory-4.3.0.jar
│ │ │ │ ├── lucene-misc-4.3.0.jar
│ │ │ │ ├── lucene-queries-4.3.0.jar
│ │ │ │ ├── lucene-queryparser-4.3.0.jar
│ │ │ │ ├── lucene-spatial-4.3.0.jar
│ │ │ │ ├── lucene-suggest-4.3.0.jar
│ │ │ │ ├── noggit-0.5.jar
│ │ │ │ ├── org.restlet-2.1.1.jar
│ │ │ │ ├── org.restlet.ext.servlet-2.1.1.jar
│ │ │ │ ├── solr-core-4.3.0.jar
│ │ │ │ ├── solr-solrj-4.3.0.jar
│ │ │ │ ├── spatial4j-0.3.jar
│ │ │ │ ├── wstx-asl-3.2.7.jar
│ │ │ │ └── zookeeper-3.4.5.jar
│ │ │ ├── web.xml
│ │ │ └── weblogic.xml
│ │ ├── admin.html
│ │ ├── css/
│ │ │ ├── chosen.css
│ │ │ └── styles/
│ │ │ ├── analysis.css
│ │ │ ├── cloud.css
│ │ │ ├── common.css
│ │ │ ├── cores.css
│ │ │ ├── dashboard.css
│ │ │ ├── dataimport.css
│ │ │ ├── index.css
│ │ │ ├── java-properties.css
│ │ │ ├── logging.css
│ │ │ ├── menu.css
│ │ │ ├── plugins.css
│ │ │ ├── query.css
│ │ │ ├── replication.css
│ │ │ ├── schema-browser.css
│ │ │ └── threads.css
│ │ ├── img/
│ │ │ ├── ZeroClipboard.swf
│ │ │ └── filetypes/
│ │ │ └── README
│ │ ├── js/
│ │ │ ├── lib/
│ │ │ │ ├── ZeroClipboard.js
│ │ │ │ ├── chosen.js
│ │ │ │ ├── console.js
│ │ │ │ ├── d3.js
│ │ │ │ ├── highlight.js
│ │ │ │ ├── jquery.autogrow.js
│ │ │ │ ├── jquery.blockUI.js
│ │ │ │ ├── jquery.cookie.js
│ │ │ │ ├── jquery.form.js
│ │ │ │ ├── jquery.jstree.js
│ │ │ │ ├── jquery.sammy.js
│ │ │ │ ├── jquery.timeago.js
│ │ │ │ ├── linker.js
│ │ │ │ └── order.js
│ │ │ ├── main.js
│ │ │ ├── require.js
│ │ │ └── scripts/
│ │ │ ├── analysis.js
│ │ │ ├── app.js
│ │ │ ├── cloud.js
│ │ │ ├── cores.js
│ │ │ ├── dashboard.js
│ │ │ ├── dataimport.js
│ │ │ ├── file.js
│ │ │ ├── index.js
│ │ │ ├── java-properties.js
│ │ │ ├── logging.js
│ │ │ ├── ping.js
│ │ │ ├── plugins.js
│ │ │ ├── query.js
│ │ │ ├── replication.js
│ │ │ ├── schema-browser.js
│ │ │ └── threads.js
│ │ └── tpl/
│ │ ├── analysis.html
│ │ ├── cloud.html
│ │ ├── cores.html
│ │ ├── dashboard.html
│ │ ├── dataimport.html
│ │ ├── index.html
│ │ ├── logging.html
│ │ ├── plugins.html
│ │ ├── query.html
│ │ ├── replication.html
│ │ ├── schema-browser.html
│ │ └── threads.html
│ ├── start.jar
│ └── webapps/
│ └── solr.war
├── relsyn/
│ ├── README.txt
│ ├── cloud-scripts/
│ │ ├── zkcli.bat
│ │ └── zkcli.sh
│ ├── contexts/
│ │ └── solr-jetty-context.xml
│ ├── etc/
│ │ ├── create-solrtest.keystore.sh
│ │ ├── jetty.xml
│ │ ├── logging.properties
│ │ ├── solrtest.keystore
│ │ └── webdefault.xml
│ ├── example-DIH/
│ │ ├── README.txt
│ │ ├── hsqldb/
│ │ │ ├── ex.backup
│ │ │ ├── ex.data
│ │ │ ├── ex.log
│ │ │ ├── ex.properties
│ │ │ └── ex.script
│ │ └── solr/
│ │ ├── db/
│ │ │ ├── conf/
│ │ │ │ ├── admin-extra.html
│ │ │ │ ├── admin-extra.menu-bottom.html
│ │ │ │ ├── admin-extra.menu-top.html
│ │ │ │ ├── db-data-config.xml
│ │ │ │ ├── elevate.xml
│ │ │ │ ├── protwords.txt
│ │ │ │ ├── schema.xml
│ │ │ │ ├── scripts.conf
│ │ │ │ ├── solrconfig.xml
│ │ │ │ ├── stopwords.txt
│ │ │ │ ├── synonyms.txt
│ │ │ │ └── xslt/
│ │ │ │ ├── example.xsl
│ │ │ │ ├── example_atom.xsl
│ │ │ │ ├── example_rss.xsl
│ │ │ │ └── luke.xsl
│ │ │ └── lib/
│ │ │ ├── derby-10.9.1.0.jar
│ │ │ └── hsqldb-1.8.0.10.jar
│ │ ├── mail/
│ │ │ └── conf/
│ │ │ ├── admin-extra.html
│ │ │ ├── admin-extra.menu-bottom.html
│ │ │ ├── admin-extra.menu-top.html
│ │ │ ├── data-config.xml
│ │ │ ├── protwords.txt
│ │ │ ├── schema.xml
│ │ │ ├── solrconfig.xml
│ │ │ ├── stopwords.txt
│ │ │ └── synonyms.txt
│ │ ├── rss/
│ │ │ └── conf/
│ │ │ ├── admin-extra.html
│ │ │ ├── admin-extra.menu-bottom.html
│ │ │ ├── admin-extra.menu-top.html
│ │ │ ├── elevate.xml
│ │ │ ├── protwords.txt
│ │ │ ├── rss-data-config.xml
│ │ │ ├── schema.xml
│ │ │ ├── scripts.conf
│ │ │ ├── solrconfig.xml
│ │ │ ├── stopwords.txt
│ │ │ └── synonyms.txt
│ │ ├── solr/
│ │ │ └── conf/
│ │ │ ├── admin-extra.html
│ │ │ ├── admin-extra.menu-bottom.html
│ │ │ ├── admin-extra.menu-top.html
│ │ │ ├── elevate.xml
│ │ │ ├── protwords.txt
│ │ │ ├── schema.xml
│ │ │ ├── scripts.conf
│ │ │ ├── solr-data-config.xml
│ │ │ ├── solrconfig.xml
│ │ │ ├── stopwords.txt
│ │ │ └── synonyms.txt
│ │ ├── solr.xml
│ │ └── tika/
│ │ └── conf/
│ │ ├── admin-extra.html
│ │ ├── admin-extra.menu-bottom.html
│ │ ├── admin-extra.menu-top.html
│ │ ├── schema.xml
│ │ ├── solrconfig.xml
│ │ └── tika-data-config.xml
│ ├── exampledocs/
│ │ ├── books.csv
│ │ ├── books.json
│ │ ├── gb18030-example.xml
│ │ ├── hd.xml
│ │ ├── ipod_other.xml
│ │ ├── ipod_video.xml
│ │ ├── manufacturers.xml
│ │ ├── mem.xml
│ │ ├── money.xml
│ │ ├── monitor.xml
│ │ ├── monitor2.xml
│ │ ├── mp500.xml
│ │ ├── post.jar
│ │ ├── post.sh
│ │ ├── sd500.xml
│ │ ├── solr.xml
│ │ ├── test_utf8.sh
│ │ ├── utf8-example.xml
│ │ └── vidcard.xml
│ ├── lib/
│ │ ├── ext/
│ │ │ ├── jcl-over-slf4j-1.6.6.jar
│ │ │ ├── jul-to-slf4j-1.6.6.jar
│ │ │ ├── log4j-1.2.16.jar
│ │ │ ├── slf4j-api-1.6.6.jar
│ │ │ └── slf4j-log4j12-1.6.6.jar
│ │ ├── jetty-continuation-8.1.8.v20121106.jar
│ │ ├── jetty-deploy-8.1.8.v20121106.jar
│ │ ├── jetty-http-8.1.8.v20121106.jar
│ │ ├── jetty-io-8.1.8.v20121106.jar
│ │ ├── jetty-jmx-8.1.8.v20121106.jar
│ │ ├── jetty-security-8.1.8.v20121106.jar
│ │ ├── jetty-server-8.1.8.v20121106.jar
│ │ ├── jetty-servlet-8.1.8.v20121106.jar
│ │ ├── jetty-util-8.1.8.v20121106.jar
│ │ ├── jetty-webapp-8.1.8.v20121106.jar
│ │ ├── jetty-xml-8.1.8.v20121106.jar
│ │ └── servlet-api-3.0.jar
│ ├── multicore/
│ │ ├── README.txt
│ │ ├── core0/
│ │ │ └── conf/
│ │ │ ├── schema.xml
│ │ │ └── solrconfig.xml
│ │ ├── core1/
│ │ │ └── conf/
│ │ │ ├── schema.xml
│ │ │ └── solrconfig.xml
│ │ ├── exampledocs/
│ │ │ ├── ipod_other.xml
│ │ │ └── ipod_video.xml
│ │ ├── solr.xml
│ │ └── zoo.cfg
│ ├── resources/
│ │ └── log4j.properties
│ ├── solr/
│ │ ├── README.txt
│ │ ├── relsyn/
│ │ │ ├── README.txt
│ │ │ ├── conf/
│ │ │ │ ├── admin-extra.html
│ │ │ │ ├── admin-extra.menu-bottom.html
│ │ │ │ ├── admin-extra.menu-top.html
│ │ │ │ ├── currency.xml
│ │ │ │ ├── elevate.xml
│ │ │ │ ├── lang/
│ │ │ │ │ ├── contractions_ca.txt
│ │ │ │ │ ├── contractions_fr.txt
│ │ │ │ │ ├── contractions_ga.txt
│ │ │ │ │ ├── contractions_it.txt
│ │ │ │ │ ├── hyphenations_ga.txt
│ │ │ │ │ ├── stemdict_nl.txt
│ │ │ │ │ ├── stoptags_ja.txt
│ │ │ │ │ ├── stopwords_ar.txt
│ │ │ │ │ ├── stopwords_bg.txt
│ │ │ │ │ ├── stopwords_ca.txt
│ │ │ │ │ ├── stopwords_cz.txt
│ │ │ │ │ ├── stopwords_da.txt
│ │ │ │ │ ├── stopwords_de.txt
│ │ │ │ │ ├── stopwords_el.txt
│ │ │ │ │ ├── stopwords_en.txt
│ │ │ │ │ ├── stopwords_es.txt
│ │ │ │ │ ├── stopwords_eu.txt
│ │ │ │ │ ├── stopwords_fa.txt
│ │ │ │ │ ├── stopwords_fi.txt
│ │ │ │ │ ├── stopwords_fr.txt
│ │ │ │ │ ├── stopwords_ga.txt
│ │ │ │ │ ├── stopwords_gl.txt
│ │ │ │ │ ├── stopwords_hi.txt
│ │ │ │ │ ├── stopwords_hu.txt
│ │ │ │ │ ├── stopwords_hy.txt
│ │ │ │ │ ├── stopwords_id.txt
│ │ │ │ │ ├── stopwords_it.txt
│ │ │ │ │ ├── stopwords_ja.txt
│ │ │ │ │ ├── stopwords_lv.txt
│ │ │ │ │ ├── stopwords_nl.txt
│ │ │ │ │ ├── stopwords_no.txt
│ │ │ │ │ ├── stopwords_pt.txt
│ │ │ │ │ ├── stopwords_ro.txt
│ │ │ │ │ ├── stopwords_ru.txt
│ │ │ │ │ ├── stopwords_sv.txt
│ │ │ │ │ ├── stopwords_th.txt
│ │ │ │ │ ├── stopwords_tr.txt
│ │ │ │ │ └── userdict_ja.txt
│ │ │ │ ├── mapping-FoldToASCII.txt
│ │ │ │ ├── mapping-ISOLatin1Accent.txt
│ │ │ │ ├── protwords.txt
│ │ │ │ ├── schema.xml
│ │ │ │ ├── scripts.conf
│ │ │ │ ├── solrconfig.xml
│ │ │ │ ├── spellings.txt
│ │ │ │ ├── stopwords.txt
│ │ │ │ ├── synonyms.txt
│ │ │ │ ├── update-script.js
│ │ │ │ ├── velocity/
│ │ │ │ │ ├── VM_global_library.vm
│ │ │ │ │ ├── browse.vm
│ │ │ │ │ ├── cluster.vm
│ │ │ │ │ ├── clusterResults.vm
│ │ │ │ │ ├── debug.vm
│ │ │ │ │ ├── did_you_mean.vm
│ │ │ │ │ ├── facet_fields.vm
│ │ │ │ │ ├── facet_pivot.vm
│ │ │ │ │ ├── facet_queries.vm
│ │ │ │ │ ├── facet_ranges.vm
│ │ │ │ │ ├── facets.vm
│ │ │ │ │ ├── footer.vm
│ │ │ │ │ ├── head.vm
│ │ │ │ │ ├── header.vm
│ │ │ │ │ ├── hit.vm
│ │ │ │ │ ├── hitGrouped.vm
│ │ │ │ │ ├── join-doc.vm
│ │ │ │ │ ├── jquery.autocomplete.css
│ │ │ │ │ ├── jquery.autocomplete.js
│ │ │ │ │ ├── layout.vm
│ │ │ │ │ ├── main.css
│ │ │ │ │ ├── product-doc.vm
│ │ │ │ │ ├── query.vm
│ │ │ │ │ ├── queryGroup.vm
│ │ │ │ │ ├── querySpatial.vm
│ │ │ │ │ ├── richtext-doc.vm
│ │ │ │ │ ├── suggest.vm
│ │ │ │ │ └── tabs.vm
│ │ │ │ └── xslt/
│ │ │ │ ├── example.xsl
│ │ │ │ ├── example_atom.xsl
│ │ │ │ ├── example_rss.xsl
│ │ │ │ ├── luke.xsl
│ │ │ │ └── updateXml.xsl
│ │ │ └── lib/
│ │ │ └── triplestore-lemmatizer-assembly-0.1.jar
│ │ ├── solr.xml
│ │ └── zoo.cfg
│ ├── solr-webapp/
│ │ └── webapp/
│ │ ├── META-INF/
│ │ │ ├── LICENSE.txt
│ │ │ ├── MANIFEST.MF
│ │ │ └── NOTICE.txt
│ │ ├── WEB-INF/
│ │ │ ├── lib/
│ │ │ │ ├── commons-cli-1.2.jar
│ │ │ │ ├── commons-codec-1.7.jar
│ │ │ │ ├── commons-fileupload-1.2.1.jar
│ │ │ │ ├── commons-io-2.1.jar
│ │ │ │ ├── commons-lang-2.6.jar
│ │ │ │ ├── guava-13.0.1.jar
│ │ │ │ ├── httpclient-4.2.3.jar
│ │ │ │ ├── httpcore-4.2.2.jar
│ │ │ │ ├── httpmime-4.2.3.jar
│ │ │ │ ├── lucene-analyzers-common-4.3.0.jar
│ │ │ │ ├── lucene-analyzers-kuromoji-4.3.0.jar
│ │ │ │ ├── lucene-analyzers-phonetic-4.3.0.jar
│ │ │ │ ├── lucene-codecs-4.3.0.jar
│ │ │ │ ├── lucene-core-4.3.0.jar
│ │ │ │ ├── lucene-grouping-4.3.0.jar
│ │ │ │ ├── lucene-highlighter-4.3.0.jar
│ │ │ │ ├── lucene-memory-4.3.0.jar
│ │ │ │ ├── lucene-misc-4.3.0.jar
│ │ │ │ ├── lucene-queries-4.3.0.jar
│ │ │ │ ├── lucene-queryparser-4.3.0.jar
│ │ │ │ ├── lucene-spatial-4.3.0.jar
│ │ │ │ ├── lucene-suggest-4.3.0.jar
│ │ │ │ ├── noggit-0.5.jar
│ │ │ │ ├── org.restlet-2.1.1.jar
│ │ │ │ ├── org.restlet.ext.servlet-2.1.1.jar
│ │ │ │ ├── solr-core-4.3.0.jar
│ │ │ │ ├── solr-solrj-4.3.0.jar
│ │ │ │ ├── spatial4j-0.3.jar
│ │ │ │ ├── wstx-asl-3.2.7.jar
│ │ │ │ └── zookeeper-3.4.5.jar
│ │ │ ├── web.xml
│ │ │ └── weblogic.xml
│ │ ├── admin.html
│ │ ├── css/
│ │ │ ├── chosen.css
│ │ │ └── styles/
│ │ │ ├── analysis.css
│ │ │ ├── cloud.css
│ │ │ ├── common.css
│ │ │ ├── cores.css
│ │ │ ├── dashboard.css
│ │ │ ├── dataimport.css
│ │ │ ├── index.css
│ │ │ ├── java-properties.css
│ │ │ ├── logging.css
│ │ │ ├── menu.css
│ │ │ ├── plugins.css
│ │ │ ├── query.css
│ │ │ ├── replication.css
│ │ │ ├── schema-browser.css
│ │ │ └── threads.css
│ │ ├── img/
│ │ │ ├── ZeroClipboard.swf
│ │ │ └── filetypes/
│ │ │ └── README
│ │ ├── js/
│ │ │ ├── lib/
│ │ │ │ ├── ZeroClipboard.js
│ │ │ │ ├── chosen.js
│ │ │ │ ├── console.js
│ │ │ │ ├── d3.js
│ │ │ │ ├── highlight.js
│ │ │ │ ├── jquery.autogrow.js
│ │ │ │ ├── jquery.blockUI.js
│ │ │ │ ├── jquery.cookie.js
│ │ │ │ ├── jquery.form.js
│ │ │ │ ├── jquery.jstree.js
│ │ │ │ ├── jquery.sammy.js
│ │ │ │ ├── jquery.timeago.js
│ │ │ │ ├── linker.js
│ │ │ │ └── order.js
│ │ │ ├── main.js
│ │ │ ├── require.js
│ │ │ └── scripts/
│ │ │ ├── analysis.js
│ │ │ ├── app.js
│ │ │ ├── cloud.js
│ │ │ ├── cores.js
│ │ │ ├── dashboard.js
│ │ │ ├── dataimport.js
│ │ │ ├── file.js
│ │ │ ├── index.js
│ │ │ ├── java-properties.js
│ │ │ ├── logging.js
│ │ │ ├── ping.js
│ │ │ ├── plugins.js
│ │ │ ├── query.js
│ │ │ ├── replication.js
│ │ │ ├── schema-browser.js
│ │ │ └── threads.js
│ │ └── tpl/
│ │ ├── analysis.html
│ │ ├── cloud.html
│ │ ├── cores.html
│ │ ├── dashboard.html
│ │ ├── dataimport.html
│ │ ├── index.html
│ │ ├── logging.html
│ │ ├── plugins.html
│ │ ├── query.html
│ │ ├── replication.html
│ │ ├── schema-browser.html
│ │ └── threads.html
│ ├── start.jar
│ └── webapps/
│ └── solr.war
├── src/
│ └── main/
│ └── scripts/
│ ├── create-indexes-small.sh
│ ├── create-indexes.sh
│ ├── index-relsyn.py
│ ├── index.py
│ ├── start-all.sh
│ ├── start.sh
│ ├── stop-all.sh
│ ├── stop.sh
│ └── utils.py
└── triplestore/
├── README.txt
├── cloud-scripts/
│ ├── zkcli.bat
│ └── zkcli.sh
├── contexts/
│ └── solr-jetty-context.xml
├── etc/
│ ├── create-solrtest.keystore.sh
│ ├── jetty.xml
│ ├── logging.properties
│ ├── solrtest.keystore
│ └── webdefault.xml
├── example-DIH/
│ ├── README.txt
│ ├── hsqldb/
│ │ ├── ex.backup
│ │ ├── ex.data
│ │ ├── ex.log
│ │ ├── ex.properties
│ │ └── ex.script
│ └── solr/
│ ├── db/
│ │ ├── conf/
│ │ │ ├── admin-extra.html
│ │ │ ├── admin-extra.menu-bottom.html
│ │ │ ├── admin-extra.menu-top.html
│ │ │ ├── db-data-config.xml
│ │ │ ├── elevate.xml
│ │ │ ├── protwords.txt
│ │ │ ├── schema.xml
│ │ │ ├── scripts.conf
│ │ │ ├── solrconfig.xml
│ │ │ ├── stopwords.txt
│ │ │ ├── synonyms.txt
│ │ │ └── xslt/
│ │ │ ├── example.xsl
│ │ │ ├── example_atom.xsl
│ │ │ ├── example_rss.xsl
│ │ │ └── luke.xsl
│ │ └── lib/
│ │ ├── derby-10.9.1.0.jar
│ │ └── hsqldb-1.8.0.10.jar
│ ├── mail/
│ │ └── conf/
│ │ ├── admin-extra.html
│ │ ├── admin-extra.menu-bottom.html
│ │ ├── admin-extra.menu-top.html
│ │ ├── data-config.xml
│ │ ├── protwords.txt
│ │ ├── schema.xml
│ │ ├── solrconfig.xml
│ │ ├── stopwords.txt
│ │ └── synonyms.txt
│ ├── rss/
│ │ └── conf/
│ │ ├── admin-extra.html
│ │ ├── admin-extra.menu-bottom.html
│ │ ├── admin-extra.menu-top.html
│ │ ├── elevate.xml
│ │ ├── protwords.txt
│ │ ├── rss-data-config.xml
│ │ ├── schema.xml
│ │ ├── scripts.conf
│ │ ├── solrconfig.xml
│ │ ├── stopwords.txt
│ │ └── synonyms.txt
│ ├── solr/
│ │ └── conf/
│ │ ├── admin-extra.html
│ │ ├── admin-extra.menu-bottom.html
│ │ ├── admin-extra.menu-top.html
│ │ ├── elevate.xml
│ │ ├── protwords.txt
│ │ ├── schema.xml
│ │ ├── scripts.conf
│ │ ├── solr-data-config.xml
│ │ ├── solrconfig.xml
│ │ ├── stopwords.txt
│ │ └── synonyms.txt
│ ├── solr.xml
│ └── tika/
│ └── conf/
│ ├── admin-extra.html
│ ├── admin-extra.menu-bottom.html
│ ├── admin-extra.menu-top.html
│ ├── schema.xml
│ ├── solrconfig.xml
│ └── tika-data-config.xml
├── exampledocs/
│ ├── books.csv
│ ├── books.json
│ ├── gb18030-example.xml
│ ├── hd.xml
│ ├── ipod_other.xml
│ ├── ipod_video.xml
│ ├── manufacturers.xml
│ ├── mem.xml
│ ├── money.xml
│ ├── monitor.xml
│ ├── monitor2.xml
│ ├── mp500.xml
│ ├── post.jar
│ ├── post.sh
│ ├── sd500.xml
│ ├── solr.xml
│ ├── test_utf8.sh
│ ├── utf8-example.xml
│ └── vidcard.xml
├── lib/
│ ├── ext/
│ │ ├── jcl-over-slf4j-1.6.6.jar
│ │ ├── jul-to-slf4j-1.6.6.jar
│ │ ├── log4j-1.2.16.jar
│ │ ├── slf4j-api-1.6.6.jar
│ │ └── slf4j-log4j12-1.6.6.jar
│ ├── jetty-continuation-8.1.8.v20121106.jar
│ ├── jetty-deploy-8.1.8.v20121106.jar
│ ├── jetty-http-8.1.8.v20121106.jar
│ ├── jetty-io-8.1.8.v20121106.jar
│ ├── jetty-jmx-8.1.8.v20121106.jar
│ ├── jetty-security-8.1.8.v20121106.jar
│ ├── jetty-server-8.1.8.v20121106.jar
│ ├── jetty-servlet-8.1.8.v20121106.jar
│ ├── jetty-util-8.1.8.v20121106.jar
│ ├── jetty-webapp-8.1.8.v20121106.jar
│ ├── jetty-xml-8.1.8.v20121106.jar
│ └── servlet-api-3.0.jar
├── multicore/
│ ├── README.txt
│ ├── core0/
│ │ └── conf/
│ │ ├── schema.xml
│ │ └── solrconfig.xml
│ ├── core1/
│ │ └── conf/
│ │ ├── schema.xml
│ │ └── solrconfig.xml
│ ├── exampledocs/
│ │ ├── ipod_other.xml
│ │ └── ipod_video.xml
│ ├── solr.xml
│ └── zoo.cfg
├── resources/
│ └── log4j.properties
├── solr/
│ ├── README.txt
│ ├── solr.xml
│ ├── triplestore/
│ │ ├── README.txt
│ │ ├── conf/
│ │ │ ├── admin-extra.html
│ │ │ ├── admin-extra.menu-bottom.html
│ │ │ ├── admin-extra.menu-top.html
│ │ │ ├── currency.xml
│ │ │ ├── elevate.xml
│ │ │ ├── lang/
│ │ │ │ ├── contractions_ca.txt
│ │ │ │ ├── contractions_fr.txt
│ │ │ │ ├── contractions_ga.txt
│ │ │ │ ├── contractions_it.txt
│ │ │ │ ├── hyphenations_ga.txt
│ │ │ │ ├── stemdict_nl.txt
│ │ │ │ ├── stoptags_ja.txt
│ │ │ │ ├── stopwords_ar.txt
│ │ │ │ ├── stopwords_bg.txt
│ │ │ │ ├── stopwords_ca.txt
│ │ │ │ ├── stopwords_cz.txt
│ │ │ │ ├── stopwords_da.txt
│ │ │ │ ├── stopwords_de.txt
│ │ │ │ ├── stopwords_el.txt
│ │ │ │ ├── stopwords_en.txt
│ │ │ │ ├── stopwords_es.txt
│ │ │ │ ├── stopwords_eu.txt
│ │ │ │ ├── stopwords_fa.txt
│ │ │ │ ├── stopwords_fi.txt
│ │ │ │ ├── stopwords_fr.txt
│ │ │ │ ├── stopwords_ga.txt
│ │ │ │ ├── stopwords_gl.txt
│ │ │ │ ├── stopwords_hi.txt
│ │ │ │ ├── stopwords_hu.txt
│ │ │ │ ├── stopwords_hy.txt
│ │ │ │ ├── stopwords_id.txt
│ │ │ │ ├── stopwords_it.txt
│ │ │ │ ├── stopwords_ja.txt
│ │ │ │ ├── stopwords_lv.txt
│ │ │ │ ├── stopwords_nl.txt
│ │ │ │ ├── stopwords_no.txt
│ │ │ │ ├── stopwords_pt.txt
│ │ │ │ ├── stopwords_ro.txt
│ │ │ │ ├── stopwords_ru.txt
│ │ │ │ ├── stopwords_sv.txt
│ │ │ │ ├── stopwords_th.txt
│ │ │ │ ├── stopwords_tr.txt
│ │ │ │ └── userdict_ja.txt
│ │ │ ├── mapping-FoldToASCII.txt
│ │ │ ├── mapping-ISOLatin1Accent.txt
│ │ │ ├── protwords.txt
│ │ │ ├── schema.xml
│ │ │ ├── scripts.conf
│ │ │ ├── solrconfig.xml
│ │ │ ├── spellings.txt
│ │ │ ├── stopwords.txt
│ │ │ ├── synonyms.txt
│ │ │ ├── update-script.js
│ │ │ ├── velocity/
│ │ │ │ ├── VM_global_library.vm
│ │ │ │ ├── browse.vm
│ │ │ │ ├── cluster.vm
│ │ │ │ ├── clusterResults.vm
│ │ │ │ ├── debug.vm
│ │ │ │ ├── did_you_mean.vm
│ │ │ │ ├── facet_fields.vm
│ │ │ │ ├── facet_pivot.vm
│ │ │ │ ├── facet_queries.vm
│ │ │ │ ├── facet_ranges.vm
│ │ │ │ ├── facets.vm
│ │ │ │ ├── footer.vm
│ │ │ │ ├── head.vm
│ │ │ │ ├── header.vm
│ │ │ │ ├── hit.vm
│ │ │ │ ├── hitGrouped.vm
│ │ │ │ ├── join-doc.vm
│ │ │ │ ├── jquery.autocomplete.css
│ │ │ │ ├── jquery.autocomplete.js
│ │ │ │ ├── layout.vm
│ │ │ │ ├── main.css
│ │ │ │ ├── product-doc.vm
│ │ │ │ ├── query.vm
│ │ │ │ ├── queryGroup.vm
│ │ │ │ ├── querySpatial.vm
│ │ │ │ ├── richtext-doc.vm
│ │ │ │ ├── suggest.vm
│ │ │ │ └── tabs.vm
│ │ │ └── xslt/
│ │ │ ├── example.xsl
│ │ │ ├── example_atom.xsl
│ │ │ ├── example_rss.xsl
│ │ │ ├── luke.xsl
│ │ │ └── updateXml.xsl
│ │ └── lib/
│ │ └── triplestore-lemmatizer-assembly-0.1.jar
│ └── zoo.cfg
├── solr-webapp/
│ └── webapp/
│ ├── META-INF/
│ │ ├── LICENSE.txt
│ │ ├── MANIFEST.MF
│ │ └── NOTICE.txt
│ ├── WEB-INF/
│ │ ├── lib/
│ │ │ ├── commons-cli-1.2.jar
│ │ │ ├── commons-codec-1.7.jar
│ │ │ ├── commons-fileupload-1.2.1.jar
│ │ │ ├── commons-io-2.1.jar
│ │ │ ├── commons-lang-2.6.jar
│ │ │ ├── guava-13.0.1.jar
│ │ │ ├── httpclient-4.2.3.jar
│ │ │ ├── httpcore-4.2.2.jar
│ │ │ ├── httpmime-4.2.3.jar
│ │ │ ├── lucene-analyzers-common-4.3.0.jar
│ │ │ ├── lucene-analyzers-kuromoji-4.3.0.jar
│ │ │ ├── lucene-analyzers-phonetic-4.3.0.jar
│ │ │ ├── lucene-codecs-4.3.0.jar
│ │ │ ├── lucene-core-4.3.0.jar
│ │ │ ├── lucene-grouping-4.3.0.jar
│ │ │ ├── lucene-highlighter-4.3.0.jar
│ │ │ ├── lucene-memory-4.3.0.jar
│ │ │ ├── lucene-misc-4.3.0.jar
│ │ │ ├── lucene-queries-4.3.0.jar
│ │ │ ├── lucene-queryparser-4.3.0.jar
│ │ │ ├── lucene-spatial-4.3.0.jar
│ │ │ ├── lucene-suggest-4.3.0.jar
│ │ │ ├── noggit-0.5.jar
│ │ │ ├── org.restlet-2.1.1.jar
│ │ │ ├── org.restlet.ext.servlet-2.1.1.jar
│ │ │ ├── solr-core-4.3.0.jar
│ │ │ ├── solr-solrj-4.3.0.jar
│ │ │ ├── spatial4j-0.3.jar
│ │ │ ├── wstx-asl-3.2.7.jar
│ │ │ └── zookeeper-3.4.5.jar
│ │ ├── web.xml
│ │ └── weblogic.xml
│ ├── admin.html
│ ├── css/
│ │ ├── chosen.css
│ │ └── styles/
│ │ ├── analysis.css
│ │ ├── cloud.css
│ │ ├── common.css
│ │ ├── cores.css
│ │ ├── dashboard.css
│ │ ├── dataimport.css
│ │ ├── index.css
│ │ ├── java-properties.css
│ │ ├── logging.css
│ │ ├── menu.css
│ │ ├── plugins.css
│ │ ├── query.css
│ │ ├── replication.css
│ │ ├── schema-browser.css
│ │ └── threads.css
│ ├── img/
│ │ ├── ZeroClipboard.swf
│ │ └── filetypes/
│ │ └── README
│ ├── js/
│ │ ├── lib/
│ │ │ ├── ZeroClipboard.js
│ │ │ ├── chosen.js
│ │ │ ├── console.js
│ │ │ ├── d3.js
│ │ │ ├── highlight.js
│ │ │ ├── jquery.autogrow.js
│ │ │ ├── jquery.blockUI.js
│ │ │ ├── jquery.cookie.js
│ │ │ ├── jquery.form.js
│ │ │ ├── jquery.jstree.js
│ │ │ ├── jquery.sammy.js
│ │ │ ├── jquery.timeago.js
│ │ │ ├── linker.js
│ │ │ └── order.js
│ │ ├── main.js
│ │ ├── require.js
│ │ └── scripts/
│ │ ├── analysis.js
│ │ ├── app.js
│ │ ├── cloud.js
│ │ ├── cores.js
│ │ ├── dashboard.js
│ │ ├── dataimport.js
│ │ ├── file.js
│ │ ├── index.js
│ │ ├── java-properties.js
│ │ ├── logging.js
│ │ ├── ping.js
│ │ ├── plugins.js
│ │ ├── query.js
│ │ ├── replication.js
│ │ ├── schema-browser.js
│ │ └── threads.js
│ └── tpl/
│ ├── analysis.html
│ ├── cloud.html
│ ├── cores.html
│ ├── dashboard.html
│ ├── dataimport.html
│ ├── index.html
│ ├── logging.html
│ ├── plugins.html
│ ├── query.html
│ ├── replication.html
│ ├── schema-browser.html
│ └── threads.html
├── start.jar
└── webapps/
└── solr.war
SYMBOL INDEX (1365 symbols across 39 files)
FILE: oqa-lm/src/main/scripts/server.py
class MyApplication (line 19) | class MyApplication(web.application):
method run (line 20) | def run(self, port=8080, *middleware):
class score (line 26) | class score:
method get_scores (line 28) | def get_scores(self, queries):
method GET (line 31) | def GET(self):
method POST (line 37) | def POST(self):
FILE: oqa-solr/paraphrase/solr-webapp/webapp/js/lib/chosen.js
function SelectParser (line 15) | function SelectParser() {
function AbstractChosen (line 105) | function AbstractChosen(form_field, options) {
function ctor (line 263) | function ctor() { this.constructor = child; }
function Chosen (line 284) | function Chosen() {
FILE: oqa-solr/paraphrase/solr-webapp/webapp/js/lib/d3.js
function d3_class (line 14) | function d3_class(ctor, properties) {
function d3_arrayCopy (line 28) | function d3_arrayCopy(pseudoarray) {
function d3_arraySlice (line 34) | function d3_arraySlice(pseudoarray) {
function d3_Map (line 61) | function d3_Map() {}
function d3_this (line 103) | function d3_this() {
function d3_rebind (line 119) | function d3_rebind(target, source, method) {
function d3_number (line 213) | function d3_number(x) {
function d3_zipLength (line 251) | function d3_zipLength(d) {
function map (line 315) | function map(array, depth) {
function entries (line 345) | function entries(map, depth) {
function d3_splitter (line 440) | function d3_splitter(d) {
function d3_collapse (line 443) | function d3_collapse(s) {
function d3_range_integerScale (line 465) | function d3_range_integerScale(x) {
function ready (line 492) | function ready(req) {
function ready (line 517) | function ready(req) {
function d3_dispatch (line 556) | function d3_dispatch() {}
function d3_dispatch_event (line 573) | function d3_dispatch_event(dispatch) {
function d3_format_precision (line 692) | function d3_format_precision(x, p) {
function d3_format_typeDefault (line 696) | function d3_format_typeDefault(x) {
function d3_format_group (line 701) | function d3_format_group(value) {
function d3_formatPrefix (line 721) | function d3_formatPrefix(d, i) {
function d3_ease_clamp (line 796) | function d3_ease_clamp(f) {
function d3_ease_reverse (line 802) | function d3_ease_reverse(f) {
function d3_ease_reflect (line 808) | function d3_ease_reflect(f) {
function d3_ease_identity (line 814) | function d3_ease_identity(t) {
function d3_ease_poly (line 818) | function d3_ease_poly(e) {
function d3_ease_sin (line 824) | function d3_ease_sin(t) {
function d3_ease_exp (line 828) | function d3_ease_exp(t) {
function d3_ease_circle (line 832) | function d3_ease_circle(t) {
function d3_ease_elastic (line 836) | function d3_ease_elastic(a, p) {
function d3_ease_back (line 846) | function d3_ease_back(s) {
function d3_ease_bounce (line 853) | function d3_ease_bounce(t) {
function d3_eventCancel (line 861) | function d3_eventCancel() {
function d3_eventSource (line 866) | function d3_eventSource() {
function d3_eventDispatch (line 876) | function d3_eventDispatch(target) {
function d3_interpolateByName (line 1125) | function d3_interpolateByName(n) {
function d3_uninterpolateNumber (line 1138) | function d3_uninterpolateNumber(a, b) {
function d3_uninterpolateClamp (line 1143) | function d3_uninterpolateClamp(a, b) {
function d3_rgb (line 1154) | function d3_rgb(r, g, b) {
function d3_Rgb (line 1158) | function d3_Rgb(r, g, b) {
function d3_rgb_hex (line 1196) | function d3_rgb_hex(v) {
function d3_rgb_parse (line 1202) | function d3_rgb_parse(format, rgb, hsl) {
function d3_rgb_hsl (line 1254) | function d3_rgb_hsl(r, g, b) {
function d3_rgb_parseNumber (line 1273) | function d3_rgb_parseNumber(c) { // either integer or percentage
function d3_hsl (line 1438) | function d3_hsl(h, s, l) {
function d3_Hsl (line 1442) | function d3_Hsl(h, s, l) {
function d3_hsl_rgb (line 1466) | function d3_hsl_rgb(h, s, l) {
function d3_selection (line 1494) | function d3_selection(groups) {
function d3_selection_selector (line 1544) | function d3_selection_selector(selector) {
function d3_selection_selectorAll (line 1568) | function d3_selection_selectorAll(selector) {
function attrNull (line 1584) | function attrNull() {
function attrNullNS (line 1588) | function attrNullNS() {
function attrConstant (line 1592) | function attrConstant() {
function attrConstantNS (line 1596) | function attrConstantNS() {
function attrFunction (line 1600) | function attrFunction() {
function attrFunctionNS (line 1606) | function attrFunctionNS() {
function d3_selection_classed (line 1632) | function d3_selection_classed(name, value) {
function styleNull (line 1686) | function styleNull() {
function styleConstant (line 1690) | function styleConstant() {
function styleFunction (line 1694) | function styleFunction() {
function propertyNull (line 1709) | function propertyNull() {
function propertyConstant (line 1713) | function propertyConstant() {
function propertyFunction (line 1717) | function propertyFunction() {
function append (line 1746) | function append() {
function appendNS (line 1750) | function appendNS() {
function insert (line 1762) | function insert() {
function insertNS (line 1768) | function insertNS() {
function bind (line 1802) | function bind(group, groupData) {
function d3_selection_dataNode (line 1903) | function d3_selection_dataNode(data) {
function d3_selection_filter (line 1933) | function d3_selection_filter(selector) {
function d3_selection_sortComparator (line 1955) | function d3_selection_sortComparator(comparator) {
function l (line 1991) | function l(e) {
function d3_selection_enter (line 2068) | function d3_selection_enter(selection) {
function d3_transition (line 2106) | function d3_transition(groups, id, time) {
function d3_transitionNull (line 2196) | function d3_transitionNull(d, i, a) {
function d3_transitionTween (line 2200) | function d3_transitionTween(name, b) {
function attrTween (line 2289) | function attrTween(d, i) {
function attrTweenNS (line 2296) | function attrTweenNS(d, i) {
function d3_transition_each (line 2344) | function d3_transition_each(callback) {
function d3_timer_step (line 2416) | function d3_timer_step() {
function d3_timer_flush (line 2455) | function d3_timer_flush() {
function d3_transform (line 2490) | function d3_transform(m) {
function d3_transformDot (line 2516) | function d3_transformDot(a, b) {
function d3_transformNormalize (line 2520) | function d3_transformNormalize(a) {
function d3_transformCombine (line 2529) | function d3_transformCombine(a, b, k) {
function d3_mousePoint (line 2543) | function d3_mousePoint(container, e) {
function d3_noop (line 2578) | function d3_noop() {}
function d3_scaleExtent (line 2581) | function d3_scaleExtent(domain) {
function d3_scaleRange (line 2586) | function d3_scaleRange(scale) {
function d3_scale_nice (line 2589) | function d3_scale_nice(domain, nice) {
function d3_scale_niceDefault (line 2610) | function d3_scale_niceDefault() {
function d3_scale_linear (line 2617) | function d3_scale_linear(domain, range, interpolate, clamp) {
function d3_scale_linearRebind (line 2686) | function d3_scale_linearRebind(scale, linear) {
function d3_scale_linearNice (line 2690) | function d3_scale_linearNice(dx) {
function d3_scale_linearTickRange (line 2698) | function d3_scale_linearTickRange(domain, m) {
function d3_scale_linearTicks (line 2716) | function d3_scale_linearTicks(domain, m) {
function d3_scale_linearTickFormat (line 2720) | function d3_scale_linearTickFormat(domain, m) {
function d3_scale_bilinear (line 2723) | function d3_scale_bilinear(domain, range, uninterpolate, interpolate) {
function d3_scale_polylinear (line 2730) | function d3_scale_polylinear(domain, range, uninterpolate, interpolate) {
function d3_scale_log (line 2756) | function d3_scale_log(linear, log) {
function d3_scale_logp (line 2822) | function d3_scale_logp(x) {
function d3_scale_logn (line 2826) | function d3_scale_logn(x) {
function d3_scale_pow (line 2841) | function d3_scale_pow(linear, exponent) {
function d3_scale_powPow (line 2886) | function d3_scale_powPow(e) {
function d3_scale_ordinal (line 2898) | function d3_scale_ordinal(domain, ranger) {
function d3_scale_quantile (line 3038) | function d3_scale_quantile(domain, range) {
function d3_scale_quantize (line 3081) | function d3_scale_quantize(x0, x1, range) {
function d3_scale_identity (line 3117) | function d3_scale_identity(domain) {
function arc (line 3150) | function arc() {
function d3_svg_arcInnerRadius (line 3224) | function d3_svg_arcInnerRadius(d) {
function d3_svg_arcOuterRadius (line 3228) | function d3_svg_arcOuterRadius(d) {
function d3_svg_arcStartAngle (line 3232) | function d3_svg_arcStartAngle(d) {
function d3_svg_arcEndAngle (line 3236) | function d3_svg_arcEndAngle(d) {
function d3_svg_line (line 3239) | function d3_svg_line(projection) {
function d3_svg_linePoints (line 3286) | function d3_svg_linePoints(self, d, x, y) {
function d3_svg_lineX (line 3309) | function d3_svg_lineX(d) {
function d3_svg_lineY (line 3314) | function d3_svg_lineY(d) {
function d3_svg_lineLinear (line 3336) | function d3_svg_lineLinear(points) {
function d3_svg_lineStepBefore (line 3346) | function d3_svg_lineStepBefore(points) {
function d3_svg_lineStepAfter (line 3356) | function d3_svg_lineStepAfter(points) {
function d3_svg_lineCardinalOpen (line 3366) | function d3_svg_lineCardinalOpen(points, tension) {
function d3_svg_lineCardinalClosed (line 3374) | function d3_svg_lineCardinalClosed(points, tension) {
function d3_svg_lineCardinal (line 3383) | function d3_svg_lineCardinal(points, tension, closed) {
function d3_svg_lineHermite (line 3391) | function d3_svg_lineHermite(points, tangents) {
function d3_svg_lineCardinalTangents (line 3438) | function d3_svg_lineCardinalTangents(points, tension) {
function d3_svg_lineBasis (line 3456) | function d3_svg_lineBasis(points) {
function d3_svg_lineBasisOpen (line 3483) | function d3_svg_lineBasisOpen(points) {
function d3_svg_lineBasisClosed (line 3508) | function d3_svg_lineBasisClosed(points) {
function d3_svg_lineBundle (line 3534) | function d3_svg_lineBundle(points, tension) {
function d3_svg_lineDot4 (line 3553) | function d3_svg_lineDot4(a, b) {
function d3_svg_lineBasisBezier (line 3565) | function d3_svg_lineBasisBezier(path, x, y) {
function d3_svg_lineSlope (line 3576) | function d3_svg_lineSlope(p0, p1) {
function d3_svg_lineFiniteDifferences (line 3582) | function d3_svg_lineFiniteDifferences(points) {
function d3_svg_lineMonotoneTangents (line 3599) | function d3_svg_lineMonotoneTangents(points) {
function d3_svg_lineMonotone (line 3651) | function d3_svg_lineMonotone(points) {
function d3_svg_lineRadial (line 3664) | function d3_svg_lineRadial(points) {
function d3_svg_area (line 3679) | function d3_svg_area(projection) {
function d3_svg_areaX (line 3758) | function d3_svg_areaX(points) {
function d3_svg_areaY (line 3764) | function d3_svg_areaY(points) {
function chord (line 3788) | function chord(d, i) {
function subgroup (line 3800) | function subgroup(self, f, d, i) {
function equals (line 3814) | function equals(a, b) {
function arc (line 3818) | function arc(r, p, a) {
function curve (line 3822) | function curve(r0, p0, r1, p1) {
function d3_svg_chordSource (line 3859) | function d3_svg_chordSource(d) {
function d3_svg_chordTarget (line 3863) | function d3_svg_chordTarget(d) {
function d3_svg_chordRadius (line 3867) | function d3_svg_chordRadius(d) {
function d3_svg_chordStartAngle (line 3871) | function d3_svg_chordStartAngle(d) {
function d3_svg_chordEndAngle (line 3875) | function d3_svg_chordEndAngle(d) {
function diagonal (line 3883) | function diagonal(d, i) {
function d3_svg_diagonalProjection (line 3913) | function d3_svg_diagonalProjection(d) {
function d3_svg_diagonalRadialProjection (line 3930) | function d3_svg_diagonalRadialProjection(projection) {
function symbol (line 3944) | function symbol(d, i) {
function d3_svg_symbolSize (line 3966) | function d3_svg_symbolSize() {
function d3_svg_symbolType (line 3970) | function d3_svg_symbolType() {
function d3_svg_symbolCircle (line 3974) | function d3_svg_symbolCircle(size) {
function axis (line 4052) | function axis(g) {
function d3_svg_axisX (line 4214) | function d3_svg_axisX(selection, x) {
function d3_svg_axisY (line 4218) | function d3_svg_axisY(selection, y) {
function d3_svg_axisSubdivide (line 4222) | function d3_svg_axisSubdivide(scale, ticks, m) {
function brush (line 4253) | function brush(g) {
function redraw (line 4311) | function redraw(g) {
function redrawX (line 4317) | function redrawX(g) {
function redrawY (line 4322) | function redrawY(g) {
function brushstart (line 4327) | function brushstart() {
function drag (line 4610) | function drag() {
function mousedown (line 4615) | function mousedown() {
function zoom (line 4701) | function zoom() {
function location (line 4745) | function location(p) {
function point (line 4749) | function point(l) {
function scaleTo (line 4753) | function scaleTo(s) {
function translateTo (line 4757) | function translateTo(p, l) {
function dispatch (line 4763) | function dispatch(event) {
function mousedown (line 4770) | function mousedown() {
function mousewheel (line 4799) | function mousewheel() {
function mousemove (line 4806) | function mousemove() {
function dblclick (line 4810) | function dblclick() {
function touchstart (line 4817) | function touchstart() {
function touchmove (line 4835) | function touchmove() {
function d3_behavior_zoomDelta (line 4855) | function d3_behavior_zoomDelta() {
function d3_layout_bundlePath (line 4898) | function d3_layout_bundlePath(link) {
function d3_layout_bundleAncestors (line 4915) | function d3_layout_bundleAncestors(node) {
function d3_layout_bundleLeastCommonAncestor (line 4927) | function d3_layout_bundleLeastCommonAncestor(a, b) {
function relayout (line 4952) | function relayout() {
function resort (line 5039) | function resort() {
function repulse (line 5114) | function repulse(node) {
function position (line 5330) | function position(dimension, size) {
function neighbor (line 5340) | function neighbor() {
function dragstart (line 5379) | function dragstart(d) {
function d3_layout_forceDragOver (line 5390) | function d3_layout_forceDragOver(d) {
function d3_layout_forceDragOut (line 5394) | function d3_layout_forceDragOut(d) {
function d3_layout_forceDragEnd (line 5398) | function d3_layout_forceDragEnd() {
function d3_layout_forceDrag (line 5403) | function d3_layout_forceDrag() {
function d3_layout_forceAccumulate (line 5409) | function d3_layout_forceAccumulate(quad, alpha, charges) {
function d3_layout_forceLinkDistance (line 5442) | function d3_layout_forceLinkDistance(link) {
function d3_layout_forceLinkStrength (line 5446) | function d3_layout_forceLinkStrength(link) {
function position (line 5453) | function position(node, x, dx, dy) {
function depth (line 5472) | function depth(node) {
function partition (line 5483) | function partition(d, i) {
function pie (line 5503) | function pie(data, i) {
function stack (line 5599) | function stack(data, index) {
function d3_layout_stackX (line 5676) | function d3_layout_stackX(d) {
function d3_layout_stackY (line 5680) | function d3_layout_stackY(d) {
function d3_layout_stackOut (line 5684) | function d3_layout_stackOut(d, y0, y) {
function d3_layout_stackOrderDefault (line 5797) | function d3_layout_stackOrderDefault(data) {
function d3_layout_stackOffsetZero (line 5801) | function d3_layout_stackOffsetZero(data) {
function d3_layout_stackMaxIndex (line 5809) | function d3_layout_stackMaxIndex(array) {
function d3_layout_stackReduceSum (line 5824) | function d3_layout_stackReduceSum(d) {
function d3_layout_stackSum (line 5828) | function d3_layout_stackSum(p, d) {
function histogram (line 5837) | function histogram(data, i) {
function d3_layout_histogramBinSturges (line 5917) | function d3_layout_histogramBinSturges(range, values) {
function d3_layout_histogramBinFixed (line 5921) | function d3_layout_histogramBinFixed(range, n) {
function d3_layout_histogramRange (line 5930) | function d3_layout_histogramRange(values) {
function recurse (line 5940) | function recurse(data, depth, nodes) {
function revalue (line 5966) | function revalue(node, depth) {
function hierarchy (line 5981) | function hierarchy(d) {
function d3_layout_hierarchyRebind (line 6015) | function d3_layout_hierarchyRebind(object, hierarchy) {
function d3_layout_hierarchyChildren (line 6030) | function d3_layout_hierarchyChildren(d) {
function d3_layout_hierarchyValue (line 6034) | function d3_layout_hierarchyValue(d) {
function d3_layout_hierarchySort (line 6038) | function d3_layout_hierarchySort(a, b) {
function d3_layout_hierarchyLinks (line 6043) | function d3_layout_hierarchyLinks(nodes) {
function pack (line 6057) | function pack(d, i) {
function d3_layout_packSort (line 6084) | function d3_layout_packSort(a, b) {
function d3_layout_packInsert (line 6088) | function d3_layout_packInsert(a, b) {
function d3_layout_packSplice (line 6096) | function d3_layout_packSplice(a, b) {
function d3_layout_packIntersects (line 6101) | function d3_layout_packIntersects(a, b) {
function d3_layout_packCircle (line 6108) | function d3_layout_packCircle(nodes) {
function d3_layout_packLink (line 6200) | function d3_layout_packLink(node) {
function d3_layout_packUnlink (line 6204) | function d3_layout_packUnlink(node) {
function d3_layout_packTree (line 6209) | function d3_layout_packTree(node) {
function d3_layout_packTransform (line 6219) | function d3_layout_packTransform(node, x, y, k) {
function d3_layout_packPlace (line 6230) | function d3_layout_packPlace(a, b, c) {
function cluster (line 6255) | function cluster(d, i) {
function d3_layout_clusterY (line 6306) | function d3_layout_clusterY(children) {
function d3_layout_clusterX (line 6312) | function d3_layout_clusterX(children) {
function d3_layout_clusterLeft (line 6318) | function d3_layout_clusterLeft(node) {
function d3_layout_clusterRight (line 6323) | function d3_layout_clusterRight(node) {
function tree (line 6333) | function tree(d, i) {
function d3_layout_treeSeparation (line 6469) | function d3_layout_treeSeparation(a, b) {
function d3_layout_treeLeft (line 6477) | function d3_layout_treeLeft(node) {
function d3_layout_treeRight (line 6482) | function d3_layout_treeRight(node) {
function d3_layout_treeSearch (line 6488) | function d3_layout_treeSearch(node, compare) {
function d3_layout_treeRightmost (line 6503) | function d3_layout_treeRightmost(a, b) {
function d3_layout_treeLeftmost (line 6507) | function d3_layout_treeLeftmost(a, b) {
function d3_layout_treeDeepest (line 6511) | function d3_layout_treeDeepest(a, b) {
function d3_layout_treeVisitAfter (line 6515) | function d3_layout_treeVisitAfter(node, callback) {
function d3_layout_treeShift (line 6534) | function d3_layout_treeShift(node) {
function d3_layout_treeMove (line 6548) | function d3_layout_treeMove(ancestor, node, shift) {
function d3_layout_treeAncestor (line 6559) | function d3_layout_treeAncestor(vim, node, ancestor) {
function scale (line 6577) | function scale(children, k) {
function squarify (line 6589) | function squarify(node) {
function stickify (line 6626) | function stickify(node) {
function worst (line 6648) | function worst(row, u) {
function position (line 6668) | function position(row, u, rect, flush) {
function treemap (line 6704) | function treemap(d) {
function padFunction (line 6727) | function padFunction(node) {
function padConstant (line 6734) | function padConstant(node) {
function d3_layout_treemapPadNull (line 6768) | function d3_layout_treemapPadNull(node) {
function d3_layout_treemapPad (line 6772) | function d3_layout_treemapPad(node, padding) {
function token (line 6812) | function token() {
function d3_csv_formatRow (line 6863) | function d3_csv_formatRow(row) {
function d3_csv_formatValue (line 6867) | function d3_csv_formatValue(text) {
function azimuthal (line 6886) | function azimuthal(coordinates) {
function albers (line 6969) | function albers(coordinates) {
function reload (line 6990) | function reload() {
function albersUsa (line 7049) | function albersUsa(coordinates) {
function bonne (line 7089) | function bonne(coordinates) {
function equirectangular (line 7155) | function equirectangular(coordinates) {
function mercator (line 7191) | function mercator(coordinates) {
function d3_geo_type (line 7223) | function d3_geo_type(types, defaultValue) {
function path (line 7240) | function path(d, i) {
function project (line 7247) | function project(coordinates) {
function polygonArea (line 7406) | function polygonArea(coordinates) {
function polygonCentroid (line 7414) | function polygonCentroid(coordinates) {
function area (line 7472) | function area(coordinates) {
function d3_path_circle (line 7493) | function d3_path_circle(radius) {
function d3_geo_bounds (line 7519) | function d3_geo_bounds(o, f) {
function d3_geo_boundsFeature (line 7535) | function d3_geo_boundsFeature(o, f) {
function d3_geo_boundsFeatureCollection (line 7539) | function d3_geo_boundsFeatureCollection(o, f) {
function d3_geo_boundsGeometryCollection (line 7545) | function d3_geo_boundsGeometryCollection(o, f) {
function d3_geo_boundsLineString (line 7551) | function d3_geo_boundsLineString(o, f) {
function d3_geo_boundsMultiLineString (line 7557) | function d3_geo_boundsMultiLineString(o, f) {
function d3_geo_boundsMultiPolygon (line 7565) | function d3_geo_boundsMultiPolygon(o, f) {
function d3_geo_boundsPoint (line 7573) | function d3_geo_boundsPoint(o, f) {
function d3_geo_boundsPolygon (line 7577) | function d3_geo_boundsPolygon(o, f) {
function circle (line 7590) | function circle() {
function visible (line 7594) | function visible(point) {
function clip (line 7654) | function clip(coordinates) {
function resample (line 7689) | function resample(coordinates) {
function greatArc (line 7733) | function greatArc() {
function d3_geo_greatArcSource (line 7777) | function d3_geo_greatArcSource(d) {
function d3_geo_greatArcTarget (line 7781) | function d3_geo_greatArcTarget(d) {
function d3_geo_greatArcInterpolate (line 7785) | function d3_geo_greatArcInterpolate(a, b) {
function d3_geom_contourStart (line 7869) | function d3_geom_contourStart(grid) {
function d3_geom_hullCCW (line 7979) | function d3_geom_hullCCW(i1, i2, i3, v) {
function d3_geom_polygonInside (line 8057) | function d3_geom_polygonInside(p, a, b) {
function d3_geom_polygonIntersect (line 8062) | function d3_geom_polygonIntersect(c, d, a, b) {
function d3_voronoi_tessellate (line 8145) | function d3_voronoi_tessellate(vertices, callback) {
function insert (line 8557) | function insert(n, p, x1, y1, x2, y2) {
function insertChild (line 8583) | function insertChild(n, p, x1, y1, x2, y2) {
function d3_geom_quadtreeNode (line 8617) | function d3_geom_quadtreeNode() {
function d3_geom_quadtreeVisit (line 8625) | function d3_geom_quadtreeVisit(f, node, x1, y1, x2, y2) {
function d3_geom_quadtreePoint (line 8637) | function d3_geom_quadtreePoint(p) {
function d3_time_utc (line 8647) | function d3_time_utc() {
function format (line 8680) | function format(date) {
function d3_time_parse (line 8720) | function d3_time_parse(date, template, string, j) {
function d3_time_parseWeekdayAbbrev (line 8800) | function d3_time_parseWeekdayAbbrev(date, string, i) {
function d3_time_parseWeekday (line 8805) | function d3_time_parseWeekday(date, string, i) {
function d3_time_parseMonthAbbrev (line 8815) | function d3_time_parseMonthAbbrev(date, string, i) {
function d3_time_parseMonth (line 8835) | function d3_time_parseMonth(date, string, i) {
function d3_time_parseLocaleFull (line 8873) | function d3_time_parseLocaleFull(date, string, i) {
function d3_time_parseLocaleDate (line 8877) | function d3_time_parseLocaleDate(date, string, i) {
function d3_time_parseLocaleTime (line 8881) | function d3_time_parseLocaleTime(date, string, i) {
function d3_time_parseFullYear (line 8885) | function d3_time_parseFullYear(date, string, i) {
function d3_time_parseYear (line 8891) | function d3_time_parseYear(date, string, i) {
function d3_time_century (line 8897) | function d3_time_century() {
function d3_time_parseMonthNumber (line 8901) | function d3_time_parseMonthNumber(date, string, i) {
function d3_time_parseDay (line 8907) | function d3_time_parseDay(date, string, i) {
function d3_time_parseHour24 (line 8914) | function d3_time_parseHour24(date, string, i) {
function d3_time_parseMinutes (line 8920) | function d3_time_parseMinutes(date, string, i) {
function d3_time_parseSeconds (line 8926) | function d3_time_parseSeconds(date, string, i) {
function d3_time_parseMilliseconds (line 8932) | function d3_time_parseMilliseconds(date, string, i) {
function d3_time_parseAmPm (line 8941) | function d3_time_parseAmPm(date, string, i) {
function d3_time_zone (line 8952) | function d3_time_zone(d) {
function format (line 8962) | function format(date) {
function d3_time_formatIsoNative (line 8991) | function d3_time_formatIsoNative(date) {
function d3_time_interval (line 9000) | function d3_time_interval(local, step, number) {
function d3_time_interval_utc (line 9057) | function d3_time_interval_utc(method) {
function d3_time_scale (line 9162) | function d3_time_scale(linear, methods, format) {
function d3_time_scaleExtent (line 9212) | function d3_time_scaleExtent(domain) {
function d3_time_scaleDate (line 9217) | function d3_time_scaleDate(t) {
function d3_time_scaleFormat (line 9221) | function d3_time_scaleFormat(formats) {
function d3_time_scaleSetYear (line 9229) | function d3_time_scaleSetYear(y) {
function d3_time_scaleGetYear (line 9235) | function d3_time_scaleGetYear(d) {
function d3_time_scaleUTCSetYear (line 9322) | function d3_time_scaleUTCSetYear(y) {
function d3_time_scaleUTCGetYear (line 9328) | function d3_time_scaleUTCGetYear(d) {
FILE: oqa-solr/paraphrase/solr-webapp/webapp/js/lib/highlight.js
function l (line 1) | function l(o){return o.replace(/&/gm,"&").replace(/</gm,"<").repl...
function b (line 1) | function b(p){for(var o=p.firstChild;o;o=o.nextSibling){if(o.nodeName=="...
function h (line 1) | function h(p,o){return Array.prototype.map.call(p.childNodes,function(q)...
function a (line 1) | function a(q){var p=(q.className+" "+q.parentNode.className).split(/\s+/...
function c (line 1) | function c(q){var o=[];(function p(r,s){for(var t=r.firstChild;t;t=t.nex...
function j (line 1) | function j(x,v,w){var p=0;var y="";var r=[];function t(){if(x.length&&v....
function f (line 1) | function f(q){function o(s,r){return RegExp(s,"m"+(q.cI?"i":"")+(r?"g":"...
function d (line 1) | function d(D,E){function o(r,M){for(var L=0;L<M.c.length;L++){var K=M.c[...
function g (line 1) | function g(s){var o={keyword_count:0,r:0,value:l(s)};var q=o;for(var p i...
function i (line 1) | function i(q,p,o){if(p){q=q.replace(/^((<[^>]+>|\t)+)/gm,function(r,v,u,...
function m (line 1) | function m(r,u,p){var v=h(r,p);var t=a(r);if(t=="no-highlight"){return}v...
function n (line 1) | function n(){if(n.called){return}n.called=true;Array.prototype.map.call(...
function k (line 1) | function k(){window.addEventListener("DOMContentLoaded",n,false);window....
FILE: oqa-solr/paraphrase/solr-webapp/webapp/js/lib/jquery.blockUI.js
function install (line 192) | function install(el, opts) {
function remove (line 379) | function remove(el, opts) {
function reset (line 414) | function reset(els,data,opts,el) {
function bind (line 434) | function bind(b, el, opts) {
function handler (line 457) | function handler(e) {
function focus (line 479) | function focus(back) {
function center (line 487) | function center(el, x, y) {
function sz (line 495) | function sz(el, p) {
FILE: oqa-solr/paraphrase/solr-webapp/webapp/js/lib/jquery.form.js
function fileUpload (line 180) | function fileUpload() {
function log (line 770) | function log() {
FILE: oqa-solr/paraphrase/solr-webapp/webapp/js/lib/jquery.jstree.js
function exec (line 1254) | function exec(i, event) {
FILE: oqa-solr/paraphrase/solr-webapp/webapp/js/lib/jquery.timeago.js
function substitute (line 70) | function substitute(stringOrFunction, number) {
function refresh (line 134) | function refresh() {
function prepareData (line 142) | function prepareData(element) {
function inWords (line 154) | function inWords(date) {
function distance (line 158) | function distance(date) {
FILE: oqa-solr/paraphrase/solr-webapp/webapp/js/lib/order.js
function scriptCacheCallback (line 54) | function scriptCacheCallback(evt) {
function onFetchOnly (line 96) | function onFetchOnly(node) {
FILE: oqa-solr/paraphrase/solr-webapp/webapp/js/require.js
function isFunction (line 46) | function isFunction(it) {
function isArray (line 50) | function isArray(it) {
function mixin (line 61) | function mixin(target, source, force) {
function makeError (line 78) | function makeError(id, msg, err) {
function configurePackageDir (line 92) | function configurePackageDir(pkgs, currentPackages, dir) {
function jQueryHoldReady (line 128) | function jQueryHoldReady($, shouldHold) {
function newContext (line 171) | function newContext(contextName) {
function getInteractiveScript (line 1659) | function getInteractiveScript() {
function jQuerySub (line 2924) | function jQuerySub( selector, context ) {
function doScrollCheck (line 2990) | function doScrollCheck() {
function createFlags (line 3017) | function createFlags( flags ) {
function resolveFunc (line 3349) | function resolveFunc( i ) {
function progressFunc (line 3357) | function progressFunc( i ) {
function dataAttr (line 3984) | function dataAttr( elem, key, data ) {
function isEmptyDataObject (line 4015) | function isEmptyDataObject( obj ) {
function handleQueueMarkDefer (line 4033) | function handleQueueMarkDefer( elem, type, src ) {
function resolve (line 4186) | function resolve() {
function returnFalse (line 5518) | function returnFalse() {
function returnTrue (line 5521) | function returnTrue() {
function dirNodeCheck (line 7221) | function dirNodeCheck( dir, cur, doneName, checkSet, nodeCheck, isXML ) {
function dirCheck (line 7254) | function dirCheck( dir, cur, doneName, checkSet, nodeCheck, isXML ) {
function isDisconnected (line 7527) | function isDisconnected( node ) {
function winnow (line 7644) | function winnow( elements, qualifier, keep ) {
function createSafeFragment (line 7681) | function createSafeFragment( document ) {
function root (line 8045) | function root( elem, cur ) {
function cloneCopyEvent (line 8052) | function cloneCopyEvent( src, dest ) {
function cloneFixAttributes (line 8080) | function cloneFixAttributes( src, dest ) {
function getAll (line 8216) | function getAll( elem ) {
function fixDefaultChecked (line 8229) | function fixDefaultChecked( elem ) {
function findInputs (line 8235) | function findInputs( elem ) {
function shimCloneNode (line 8246) | function shimCloneNode( elem ) {
function evalScript (line 8478) | function evalScript( i, elem ) {
function getWH (line 8820) | function getWH( elem, name, extra ) {
function addToPrefiltersOrTransports (line 8948) | function addToPrefiltersOrTransports( structure ) {
function inspectPrefiltersOrTransports (line 8984) | function inspectPrefiltersOrTransports( structure, options, originalOpti...
function ajaxExtend (line 9026) | function ajaxExtend( target, src ) {
function done (line 9370) | function done( status, nativeStatusText, responses, headers ) {
function buildParams (line 9685) | function buildParams( prefix, obj, traditional, add ) {
function ajaxHandleResponses (line 9735) | function ajaxHandleResponses( s, jqXHR, responses ) {
function ajaxConvert (line 9800) | function ajaxConvert( s, response ) {
function createStandardXHR (line 10066) | function createStandardXHR() {
function createActiveXHR (line 10072) | function createActiveXHR() {
function doAnimation (line 10404) | function doAnimation() {
function stopQueue (line 10547) | function stopQueue( elem, data, index ) {
function createFxNow (line 10589) | function createFxNow() {
function clearFxNow (line 10594) | function clearFxNow() {
function genFx (line 10599) | function genFx( type, num ) {
function t (line 10714) | function t( gotoEnd ) {
function defaultDisplay (line 10906) | function defaultDisplay( nodeName ) {
function getWindow (line 11215) | function getWindow( elem ) {
FILE: oqa-solr/paraphrase/solr-webapp/webapp/js/scripts/dataimport.js
function dataimport_fetch_config (line 157) | function dataimport_fetch_config()
function dataimport_fetch_status (line 414) | function dataimport_fetch_status( clear_timeout )
FILE: oqa-solr/paraphrase/solr/paraphrase/conf/update-script.js
function processAdd (line 10) | function processAdd(cmd) {
function processDelete (line 35) | function processDelete(cmd) {
function processMergeIndexes (line 39) | function processMergeIndexes(cmd) {
function processCommit (line 43) | function processCommit(cmd) {
function processRollback (line 47) | function processRollback(cmd) {
function finish (line 51) | function finish() {
FILE: oqa-solr/paraphrase/solr/paraphrase/conf/velocity/jquery.autocomplete.js
function findValueCallback (line 171) | function findValueCallback(q, data) {
function selectCurrent (line 201) | function selectCurrent() {
function onChange (line 223) | function onChange(crap, skipPrevCheck) {
function trimWords (line 248) | function trimWords(value) {
function lastWord (line 261) | function lastWord(value) {
function autoFill (line 271) | function autoFill(q, sValue){
function hideResults (line 282) | function hideResults() {
function hideResultsNow (line 287) | function hideResultsNow() {
function receiveData (line 313) | function receiveData(q, data) {
function request (line 324) | function request(term, success, failure) {
function parse (line 366) | function parse(data) {
function stopLoading (line 383) | function stopLoading() {
function matchSubset (line 421) | function matchSubset(s, sub) {
function add (line 432) | function add(q, value) {
function populate (line 442) | function populate(){
function flush (line 497) | function flush(){
function init (line 569) | function init() {
function target (line 601) | function target(event) {
function moveSelect (line 611) | function moveSelect(step) {
function movePosition (line 628) | function movePosition(step) {
function limitNumberOfItems (line 637) | function limitNumberOfItems(available) {
function fillList (line 643) | function fillList() {
FILE: oqa-solr/relsyn/solr-webapp/webapp/js/lib/chosen.js
function SelectParser (line 15) | function SelectParser() {
function AbstractChosen (line 105) | function AbstractChosen(form_field, options) {
function ctor (line 263) | function ctor() { this.constructor = child; }
function Chosen (line 284) | function Chosen() {
FILE: oqa-solr/relsyn/solr-webapp/webapp/js/lib/d3.js
function d3_class (line 14) | function d3_class(ctor, properties) {
function d3_arrayCopy (line 28) | function d3_arrayCopy(pseudoarray) {
function d3_arraySlice (line 34) | function d3_arraySlice(pseudoarray) {
function d3_Map (line 61) | function d3_Map() {}
function d3_this (line 103) | function d3_this() {
function d3_rebind (line 119) | function d3_rebind(target, source, method) {
function d3_number (line 213) | function d3_number(x) {
function d3_zipLength (line 251) | function d3_zipLength(d) {
function map (line 315) | function map(array, depth) {
function entries (line 345) | function entries(map, depth) {
function d3_splitter (line 440) | function d3_splitter(d) {
function d3_collapse (line 443) | function d3_collapse(s) {
function d3_range_integerScale (line 465) | function d3_range_integerScale(x) {
function ready (line 492) | function ready(req) {
function ready (line 517) | function ready(req) {
function d3_dispatch (line 556) | function d3_dispatch() {}
function d3_dispatch_event (line 573) | function d3_dispatch_event(dispatch) {
function d3_format_precision (line 692) | function d3_format_precision(x, p) {
function d3_format_typeDefault (line 696) | function d3_format_typeDefault(x) {
function d3_format_group (line 701) | function d3_format_group(value) {
function d3_formatPrefix (line 721) | function d3_formatPrefix(d, i) {
function d3_ease_clamp (line 796) | function d3_ease_clamp(f) {
function d3_ease_reverse (line 802) | function d3_ease_reverse(f) {
function d3_ease_reflect (line 808) | function d3_ease_reflect(f) {
function d3_ease_identity (line 814) | function d3_ease_identity(t) {
function d3_ease_poly (line 818) | function d3_ease_poly(e) {
function d3_ease_sin (line 824) | function d3_ease_sin(t) {
function d3_ease_exp (line 828) | function d3_ease_exp(t) {
function d3_ease_circle (line 832) | function d3_ease_circle(t) {
function d3_ease_elastic (line 836) | function d3_ease_elastic(a, p) {
function d3_ease_back (line 846) | function d3_ease_back(s) {
function d3_ease_bounce (line 853) | function d3_ease_bounce(t) {
function d3_eventCancel (line 861) | function d3_eventCancel() {
function d3_eventSource (line 866) | function d3_eventSource() {
function d3_eventDispatch (line 876) | function d3_eventDispatch(target) {
function d3_interpolateByName (line 1125) | function d3_interpolateByName(n) {
function d3_uninterpolateNumber (line 1138) | function d3_uninterpolateNumber(a, b) {
function d3_uninterpolateClamp (line 1143) | function d3_uninterpolateClamp(a, b) {
function d3_rgb (line 1154) | function d3_rgb(r, g, b) {
function d3_Rgb (line 1158) | function d3_Rgb(r, g, b) {
function d3_rgb_hex (line 1196) | function d3_rgb_hex(v) {
function d3_rgb_parse (line 1202) | function d3_rgb_parse(format, rgb, hsl) {
function d3_rgb_hsl (line 1254) | function d3_rgb_hsl(r, g, b) {
function d3_rgb_parseNumber (line 1273) | function d3_rgb_parseNumber(c) { // either integer or percentage
function d3_hsl (line 1438) | function d3_hsl(h, s, l) {
function d3_Hsl (line 1442) | function d3_Hsl(h, s, l) {
function d3_hsl_rgb (line 1466) | function d3_hsl_rgb(h, s, l) {
function d3_selection (line 1494) | function d3_selection(groups) {
function d3_selection_selector (line 1544) | function d3_selection_selector(selector) {
function d3_selection_selectorAll (line 1568) | function d3_selection_selectorAll(selector) {
function attrNull (line 1584) | function attrNull() {
function attrNullNS (line 1588) | function attrNullNS() {
function attrConstant (line 1592) | function attrConstant() {
function attrConstantNS (line 1596) | function attrConstantNS() {
function attrFunction (line 1600) | function attrFunction() {
function attrFunctionNS (line 1606) | function attrFunctionNS() {
function d3_selection_classed (line 1632) | function d3_selection_classed(name, value) {
function styleNull (line 1686) | function styleNull() {
function styleConstant (line 1690) | function styleConstant() {
function styleFunction (line 1694) | function styleFunction() {
function propertyNull (line 1709) | function propertyNull() {
function propertyConstant (line 1713) | function propertyConstant() {
function propertyFunction (line 1717) | function propertyFunction() {
function append (line 1746) | function append() {
function appendNS (line 1750) | function appendNS() {
function insert (line 1762) | function insert() {
function insertNS (line 1768) | function insertNS() {
function bind (line 1802) | function bind(group, groupData) {
function d3_selection_dataNode (line 1903) | function d3_selection_dataNode(data) {
function d3_selection_filter (line 1933) | function d3_selection_filter(selector) {
function d3_selection_sortComparator (line 1955) | function d3_selection_sortComparator(comparator) {
function l (line 1991) | function l(e) {
function d3_selection_enter (line 2068) | function d3_selection_enter(selection) {
function d3_transition (line 2106) | function d3_transition(groups, id, time) {
function d3_transitionNull (line 2196) | function d3_transitionNull(d, i, a) {
function d3_transitionTween (line 2200) | function d3_transitionTween(name, b) {
function attrTween (line 2289) | function attrTween(d, i) {
function attrTweenNS (line 2296) | function attrTweenNS(d, i) {
function d3_transition_each (line 2344) | function d3_transition_each(callback) {
function d3_timer_step (line 2416) | function d3_timer_step() {
function d3_timer_flush (line 2455) | function d3_timer_flush() {
function d3_transform (line 2490) | function d3_transform(m) {
function d3_transformDot (line 2516) | function d3_transformDot(a, b) {
function d3_transformNormalize (line 2520) | function d3_transformNormalize(a) {
function d3_transformCombine (line 2529) | function d3_transformCombine(a, b, k) {
function d3_mousePoint (line 2543) | function d3_mousePoint(container, e) {
function d3_noop (line 2578) | function d3_noop() {}
function d3_scaleExtent (line 2581) | function d3_scaleExtent(domain) {
function d3_scaleRange (line 2586) | function d3_scaleRange(scale) {
function d3_scale_nice (line 2589) | function d3_scale_nice(domain, nice) {
function d3_scale_niceDefault (line 2610) | function d3_scale_niceDefault() {
function d3_scale_linear (line 2617) | function d3_scale_linear(domain, range, interpolate, clamp) {
function d3_scale_linearRebind (line 2686) | function d3_scale_linearRebind(scale, linear) {
function d3_scale_linearNice (line 2690) | function d3_scale_linearNice(dx) {
function d3_scale_linearTickRange (line 2698) | function d3_scale_linearTickRange(domain, m) {
function d3_scale_linearTicks (line 2716) | function d3_scale_linearTicks(domain, m) {
function d3_scale_linearTickFormat (line 2720) | function d3_scale_linearTickFormat(domain, m) {
function d3_scale_bilinear (line 2723) | function d3_scale_bilinear(domain, range, uninterpolate, interpolate) {
function d3_scale_polylinear (line 2730) | function d3_scale_polylinear(domain, range, uninterpolate, interpolate) {
function d3_scale_log (line 2756) | function d3_scale_log(linear, log) {
function d3_scale_logp (line 2822) | function d3_scale_logp(x) {
function d3_scale_logn (line 2826) | function d3_scale_logn(x) {
function d3_scale_pow (line 2841) | function d3_scale_pow(linear, exponent) {
function d3_scale_powPow (line 2886) | function d3_scale_powPow(e) {
function d3_scale_ordinal (line 2898) | function d3_scale_ordinal(domain, ranger) {
function d3_scale_quantile (line 3038) | function d3_scale_quantile(domain, range) {
function d3_scale_quantize (line 3081) | function d3_scale_quantize(x0, x1, range) {
function d3_scale_identity (line 3117) | function d3_scale_identity(domain) {
function arc (line 3150) | function arc() {
function d3_svg_arcInnerRadius (line 3224) | function d3_svg_arcInnerRadius(d) {
function d3_svg_arcOuterRadius (line 3228) | function d3_svg_arcOuterRadius(d) {
function d3_svg_arcStartAngle (line 3232) | function d3_svg_arcStartAngle(d) {
function d3_svg_arcEndAngle (line 3236) | function d3_svg_arcEndAngle(d) {
function d3_svg_line (line 3239) | function d3_svg_line(projection) {
function d3_svg_linePoints (line 3286) | function d3_svg_linePoints(self, d, x, y) {
function d3_svg_lineX (line 3309) | function d3_svg_lineX(d) {
function d3_svg_lineY (line 3314) | function d3_svg_lineY(d) {
function d3_svg_lineLinear (line 3336) | function d3_svg_lineLinear(points) {
function d3_svg_lineStepBefore (line 3346) | function d3_svg_lineStepBefore(points) {
function d3_svg_lineStepAfter (line 3356) | function d3_svg_lineStepAfter(points) {
function d3_svg_lineCardinalOpen (line 3366) | function d3_svg_lineCardinalOpen(points, tension) {
function d3_svg_lineCardinalClosed (line 3374) | function d3_svg_lineCardinalClosed(points, tension) {
function d3_svg_lineCardinal (line 3383) | function d3_svg_lineCardinal(points, tension, closed) {
function d3_svg_lineHermite (line 3391) | function d3_svg_lineHermite(points, tangents) {
function d3_svg_lineCardinalTangents (line 3438) | function d3_svg_lineCardinalTangents(points, tension) {
function d3_svg_lineBasis (line 3456) | function d3_svg_lineBasis(points) {
function d3_svg_lineBasisOpen (line 3483) | function d3_svg_lineBasisOpen(points) {
function d3_svg_lineBasisClosed (line 3508) | function d3_svg_lineBasisClosed(points) {
function d3_svg_lineBundle (line 3534) | function d3_svg_lineBundle(points, tension) {
function d3_svg_lineDot4 (line 3553) | function d3_svg_lineDot4(a, b) {
function d3_svg_lineBasisBezier (line 3565) | function d3_svg_lineBasisBezier(path, x, y) {
function d3_svg_lineSlope (line 3576) | function d3_svg_lineSlope(p0, p1) {
function d3_svg_lineFiniteDifferences (line 3582) | function d3_svg_lineFiniteDifferences(points) {
function d3_svg_lineMonotoneTangents (line 3599) | function d3_svg_lineMonotoneTangents(points) {
function d3_svg_lineMonotone (line 3651) | function d3_svg_lineMonotone(points) {
function d3_svg_lineRadial (line 3664) | function d3_svg_lineRadial(points) {
function d3_svg_area (line 3679) | function d3_svg_area(projection) {
function d3_svg_areaX (line 3758) | function d3_svg_areaX(points) {
function d3_svg_areaY (line 3764) | function d3_svg_areaY(points) {
function chord (line 3788) | function chord(d, i) {
function subgroup (line 3800) | function subgroup(self, f, d, i) {
function equals (line 3814) | function equals(a, b) {
function arc (line 3818) | function arc(r, p, a) {
function curve (line 3822) | function curve(r0, p0, r1, p1) {
function d3_svg_chordSource (line 3859) | function d3_svg_chordSource(d) {
function d3_svg_chordTarget (line 3863) | function d3_svg_chordTarget(d) {
function d3_svg_chordRadius (line 3867) | function d3_svg_chordRadius(d) {
function d3_svg_chordStartAngle (line 3871) | function d3_svg_chordStartAngle(d) {
function d3_svg_chordEndAngle (line 3875) | function d3_svg_chordEndAngle(d) {
function diagonal (line 3883) | function diagonal(d, i) {
function d3_svg_diagonalProjection (line 3913) | function d3_svg_diagonalProjection(d) {
function d3_svg_diagonalRadialProjection (line 3930) | function d3_svg_diagonalRadialProjection(projection) {
function symbol (line 3944) | function symbol(d, i) {
function d3_svg_symbolSize (line 3966) | function d3_svg_symbolSize() {
function d3_svg_symbolType (line 3970) | function d3_svg_symbolType() {
function d3_svg_symbolCircle (line 3974) | function d3_svg_symbolCircle(size) {
function axis (line 4052) | function axis(g) {
function d3_svg_axisX (line 4214) | function d3_svg_axisX(selection, x) {
function d3_svg_axisY (line 4218) | function d3_svg_axisY(selection, y) {
function d3_svg_axisSubdivide (line 4222) | function d3_svg_axisSubdivide(scale, ticks, m) {
function brush (line 4253) | function brush(g) {
function redraw (line 4311) | function redraw(g) {
function redrawX (line 4317) | function redrawX(g) {
function redrawY (line 4322) | function redrawY(g) {
function brushstart (line 4327) | function brushstart() {
function drag (line 4610) | function drag() {
function mousedown (line 4615) | function mousedown() {
function zoom (line 4701) | function zoom() {
function location (line 4745) | function location(p) {
function point (line 4749) | function point(l) {
function scaleTo (line 4753) | function scaleTo(s) {
function translateTo (line 4757) | function translateTo(p, l) {
function dispatch (line 4763) | function dispatch(event) {
function mousedown (line 4770) | function mousedown() {
function mousewheel (line 4799) | function mousewheel() {
function mousemove (line 4806) | function mousemove() {
function dblclick (line 4810) | function dblclick() {
function touchstart (line 4817) | function touchstart() {
function touchmove (line 4835) | function touchmove() {
function d3_behavior_zoomDelta (line 4855) | function d3_behavior_zoomDelta() {
function d3_layout_bundlePath (line 4898) | function d3_layout_bundlePath(link) {
function d3_layout_bundleAncestors (line 4915) | function d3_layout_bundleAncestors(node) {
function d3_layout_bundleLeastCommonAncestor (line 4927) | function d3_layout_bundleLeastCommonAncestor(a, b) {
function relayout (line 4952) | function relayout() {
function resort (line 5039) | function resort() {
function repulse (line 5114) | function repulse(node) {
function position (line 5330) | function position(dimension, size) {
function neighbor (line 5340) | function neighbor() {
function dragstart (line 5379) | function dragstart(d) {
function d3_layout_forceDragOver (line 5390) | function d3_layout_forceDragOver(d) {
function d3_layout_forceDragOut (line 5394) | function d3_layout_forceDragOut(d) {
function d3_layout_forceDragEnd (line 5398) | function d3_layout_forceDragEnd() {
function d3_layout_forceDrag (line 5403) | function d3_layout_forceDrag() {
function d3_layout_forceAccumulate (line 5409) | function d3_layout_forceAccumulate(quad, alpha, charges) {
function d3_layout_forceLinkDistance (line 5442) | function d3_layout_forceLinkDistance(link) {
function d3_layout_forceLinkStrength (line 5446) | function d3_layout_forceLinkStrength(link) {
function position (line 5453) | function position(node, x, dx, dy) {
function depth (line 5472) | function depth(node) {
function partition (line 5483) | function partition(d, i) {
function pie (line 5503) | function pie(data, i) {
function stack (line 5599) | function stack(data, index) {
function d3_layout_stackX (line 5676) | function d3_layout_stackX(d) {
function d3_layout_stackY (line 5680) | function d3_layout_stackY(d) {
function d3_layout_stackOut (line 5684) | function d3_layout_stackOut(d, y0, y) {
function d3_layout_stackOrderDefault (line 5797) | function d3_layout_stackOrderDefault(data) {
function d3_layout_stackOffsetZero (line 5801) | function d3_layout_stackOffsetZero(data) {
function d3_layout_stackMaxIndex (line 5809) | function d3_layout_stackMaxIndex(array) {
function d3_layout_stackReduceSum (line 5824) | function d3_layout_stackReduceSum(d) {
function d3_layout_stackSum (line 5828) | function d3_layout_stackSum(p, d) {
function histogram (line 5837) | function histogram(data, i) {
function d3_layout_histogramBinSturges (line 5917) | function d3_layout_histogramBinSturges(range, values) {
function d3_layout_histogramBinFixed (line 5921) | function d3_layout_histogramBinFixed(range, n) {
function d3_layout_histogramRange (line 5930) | function d3_layout_histogramRange(values) {
function recurse (line 5940) | function recurse(data, depth, nodes) {
function revalue (line 5966) | function revalue(node, depth) {
function hierarchy (line 5981) | function hierarchy(d) {
function d3_layout_hierarchyRebind (line 6015) | function d3_layout_hierarchyRebind(object, hierarchy) {
function d3_layout_hierarchyChildren (line 6030) | function d3_layout_hierarchyChildren(d) {
function d3_layout_hierarchyValue (line 6034) | function d3_layout_hierarchyValue(d) {
function d3_layout_hierarchySort (line 6038) | function d3_layout_hierarchySort(a, b) {
function d3_layout_hierarchyLinks (line 6043) | function d3_layout_hierarchyLinks(nodes) {
function pack (line 6057) | function pack(d, i) {
function d3_layout_packSort (line 6084) | function d3_layout_packSort(a, b) {
function d3_layout_packInsert (line 6088) | function d3_layout_packInsert(a, b) {
function d3_layout_packSplice (line 6096) | function d3_layout_packSplice(a, b) {
function d3_layout_packIntersects (line 6101) | function d3_layout_packIntersects(a, b) {
function d3_layout_packCircle (line 6108) | function d3_layout_packCircle(nodes) {
function d3_layout_packLink (line 6200) | function d3_layout_packLink(node) {
function d3_layout_packUnlink (line 6204) | function d3_layout_packUnlink(node) {
function d3_layout_packTree (line 6209) | function d3_layout_packTree(node) {
function d3_layout_packTransform (line 6219) | function d3_layout_packTransform(node, x, y, k) {
function d3_layout_packPlace (line 6230) | function d3_layout_packPlace(a, b, c) {
function cluster (line 6255) | function cluster(d, i) {
function d3_layout_clusterY (line 6306) | function d3_layout_clusterY(children) {
function d3_layout_clusterX (line 6312) | function d3_layout_clusterX(children) {
function d3_layout_clusterLeft (line 6318) | function d3_layout_clusterLeft(node) {
function d3_layout_clusterRight (line 6323) | function d3_layout_clusterRight(node) {
function tree (line 6333) | function tree(d, i) {
function d3_layout_treeSeparation (line 6469) | function d3_layout_treeSeparation(a, b) {
function d3_layout_treeLeft (line 6477) | function d3_layout_treeLeft(node) {
function d3_layout_treeRight (line 6482) | function d3_layout_treeRight(node) {
function d3_layout_treeSearch (line 6488) | function d3_layout_treeSearch(node, compare) {
function d3_layout_treeRightmost (line 6503) | function d3_layout_treeRightmost(a, b) {
function d3_layout_treeLeftmost (line 6507) | function d3_layout_treeLeftmost(a, b) {
function d3_layout_treeDeepest (line 6511) | function d3_layout_treeDeepest(a, b) {
function d3_layout_treeVisitAfter (line 6515) | function d3_layout_treeVisitAfter(node, callback) {
function d3_layout_treeShift (line 6534) | function d3_layout_treeShift(node) {
function d3_layout_treeMove (line 6548) | function d3_layout_treeMove(ancestor, node, shift) {
function d3_layout_treeAncestor (line 6559) | function d3_layout_treeAncestor(vim, node, ancestor) {
function scale (line 6577) | function scale(children, k) {
function squarify (line 6589) | function squarify(node) {
function stickify (line 6626) | function stickify(node) {
function worst (line 6648) | function worst(row, u) {
function position (line 6668) | function position(row, u, rect, flush) {
function treemap (line 6704) | function treemap(d) {
function padFunction (line 6727) | function padFunction(node) {
function padConstant (line 6734) | function padConstant(node) {
function d3_layout_treemapPadNull (line 6768) | function d3_layout_treemapPadNull(node) {
function d3_layout_treemapPad (line 6772) | function d3_layout_treemapPad(node, padding) {
function token (line 6812) | function token() {
function d3_csv_formatRow (line 6863) | function d3_csv_formatRow(row) {
function d3_csv_formatValue (line 6867) | function d3_csv_formatValue(text) {
function azimuthal (line 6886) | function azimuthal(coordinates) {
function albers (line 6969) | function albers(coordinates) {
function reload (line 6990) | function reload() {
function albersUsa (line 7049) | function albersUsa(coordinates) {
function bonne (line 7089) | function bonne(coordinates) {
function equirectangular (line 7155) | function equirectangular(coordinates) {
function mercator (line 7191) | function mercator(coordinates) {
function d3_geo_type (line 7223) | function d3_geo_type(types, defaultValue) {
function path (line 7240) | function path(d, i) {
function project (line 7247) | function project(coordinates) {
function polygonArea (line 7406) | function polygonArea(coordinates) {
function polygonCentroid (line 7414) | function polygonCentroid(coordinates) {
function area (line 7472) | function area(coordinates) {
function d3_path_circle (line 7493) | function d3_path_circle(radius) {
function d3_geo_bounds (line 7519) | function d3_geo_bounds(o, f) {
function d3_geo_boundsFeature (line 7535) | function d3_geo_boundsFeature(o, f) {
function d3_geo_boundsFeatureCollection (line 7539) | function d3_geo_boundsFeatureCollection(o, f) {
function d3_geo_boundsGeometryCollection (line 7545) | function d3_geo_boundsGeometryCollection(o, f) {
function d3_geo_boundsLineString (line 7551) | function d3_geo_boundsLineString(o, f) {
function d3_geo_boundsMultiLineString (line 7557) | function d3_geo_boundsMultiLineString(o, f) {
function d3_geo_boundsMultiPolygon (line 7565) | function d3_geo_boundsMultiPolygon(o, f) {
function d3_geo_boundsPoint (line 7573) | function d3_geo_boundsPoint(o, f) {
function d3_geo_boundsPolygon (line 7577) | function d3_geo_boundsPolygon(o, f) {
function circle (line 7590) | function circle() {
function visible (line 7594) | function visible(point) {
function clip (line 7654) | function clip(coordinates) {
function resample (line 7689) | function resample(coordinates) {
function greatArc (line 7733) | function greatArc() {
function d3_geo_greatArcSource (line 7777) | function d3_geo_greatArcSource(d) {
function d3_geo_greatArcTarget (line 7781) | function d3_geo_greatArcTarget(d) {
function d3_geo_greatArcInterpolate (line 7785) | function d3_geo_greatArcInterpolate(a, b) {
function d3_geom_contourStart (line 7869) | function d3_geom_contourStart(grid) {
function d3_geom_hullCCW (line 7979) | function d3_geom_hullCCW(i1, i2, i3, v) {
function d3_geom_polygonInside (line 8057) | function d3_geom_polygonInside(p, a, b) {
function d3_geom_polygonIntersect (line 8062) | function d3_geom_polygonIntersect(c, d, a, b) {
function d3_voronoi_tessellate (line 8145) | function d3_voronoi_tessellate(vertices, callback) {
function insert (line 8557) | function insert(n, p, x1, y1, x2, y2) {
function insertChild (line 8583) | function insertChild(n, p, x1, y1, x2, y2) {
function d3_geom_quadtreeNode (line 8617) | function d3_geom_quadtreeNode() {
function d3_geom_quadtreeVisit (line 8625) | function d3_geom_quadtreeVisit(f, node, x1, y1, x2, y2) {
function d3_geom_quadtreePoint (line 8637) | function d3_geom_quadtreePoint(p) {
function d3_time_utc (line 8647) | function d3_time_utc() {
function format (line 8680) | function format(date) {
function d3_time_parse (line 8720) | function d3_time_parse(date, template, string, j) {
function d3_time_parseWeekdayAbbrev (line 8800) | function d3_time_parseWeekdayAbbrev(date, string, i) {
function d3_time_parseWeekday (line 8805) | function d3_time_parseWeekday(date, string, i) {
function d3_time_parseMonthAbbrev (line 8815) | function d3_time_parseMonthAbbrev(date, string, i) {
function d3_time_parseMonth (line 8835) | function d3_time_parseMonth(date, string, i) {
function d3_time_parseLocaleFull (line 8873) | function d3_time_parseLocaleFull(date, string, i) {
function d3_time_parseLocaleDate (line 8877) | function d3_time_parseLocaleDate(date, string, i) {
function d3_time_parseLocaleTime (line 8881) | function d3_time_parseLocaleTime(date, string, i) {
function d3_time_parseFullYear (line 8885) | function d3_time_parseFullYear(date, string, i) {
function d3_time_parseYear (line 8891) | function d3_time_parseYear(date, string, i) {
function d3_time_century (line 8897) | function d3_time_century() {
function d3_time_parseMonthNumber (line 8901) | function d3_time_parseMonthNumber(date, string, i) {
function d3_time_parseDay (line 8907) | function d3_time_parseDay(date, string, i) {
function d3_time_parseHour24 (line 8914) | function d3_time_parseHour24(date, string, i) {
function d3_time_parseMinutes (line 8920) | function d3_time_parseMinutes(date, string, i) {
function d3_time_parseSeconds (line 8926) | function d3_time_parseSeconds(date, string, i) {
function d3_time_parseMilliseconds (line 8932) | function d3_time_parseMilliseconds(date, string, i) {
function d3_time_parseAmPm (line 8941) | function d3_time_parseAmPm(date, string, i) {
function d3_time_zone (line 8952) | function d3_time_zone(d) {
function format (line 8962) | function format(date) {
function d3_time_formatIsoNative (line 8991) | function d3_time_formatIsoNative(date) {
function d3_time_interval (line 9000) | function d3_time_interval(local, step, number) {
function d3_time_interval_utc (line 9057) | function d3_time_interval_utc(method) {
function d3_time_scale (line 9162) | function d3_time_scale(linear, methods, format) {
function d3_time_scaleExtent (line 9212) | function d3_time_scaleExtent(domain) {
function d3_time_scaleDate (line 9217) | function d3_time_scaleDate(t) {
function d3_time_scaleFormat (line 9221) | function d3_time_scaleFormat(formats) {
function d3_time_scaleSetYear (line 9229) | function d3_time_scaleSetYear(y) {
function d3_time_scaleGetYear (line 9235) | function d3_time_scaleGetYear(d) {
function d3_time_scaleUTCSetYear (line 9322) | function d3_time_scaleUTCSetYear(y) {
function d3_time_scaleUTCGetYear (line 9328) | function d3_time_scaleUTCGetYear(d) {
FILE: oqa-solr/relsyn/solr-webapp/webapp/js/lib/highlight.js
function l (line 1) | function l(o){return o.replace(/&/gm,"&").replace(/</gm,"<").repl...
function b (line 1) | function b(p){for(var o=p.firstChild;o;o=o.nextSibling){if(o.nodeName=="...
function h (line 1) | function h(p,o){return Array.prototype.map.call(p.childNodes,function(q)...
function a (line 1) | function a(q){var p=(q.className+" "+q.parentNode.className).split(/\s+/...
function c (line 1) | function c(q){var o=[];(function p(r,s){for(var t=r.firstChild;t;t=t.nex...
function j (line 1) | function j(x,v,w){var p=0;var y="";var r=[];function t(){if(x.length&&v....
function f (line 1) | function f(q){function o(s,r){return RegExp(s,"m"+(q.cI?"i":"")+(r?"g":"...
function d (line 1) | function d(D,E){function o(r,M){for(var L=0;L<M.c.length;L++){var K=M.c[...
function g (line 1) | function g(s){var o={keyword_count:0,r:0,value:l(s)};var q=o;for(var p i...
function i (line 1) | function i(q,p,o){if(p){q=q.replace(/^((<[^>]+>|\t)+)/gm,function(r,v,u,...
function m (line 1) | function m(r,u,p){var v=h(r,p);var t=a(r);if(t=="no-highlight"){return}v...
function n (line 1) | function n(){if(n.called){return}n.called=true;Array.prototype.map.call(...
function k (line 1) | function k(){window.addEventListener("DOMContentLoaded",n,false);window....
FILE: oqa-solr/relsyn/solr-webapp/webapp/js/lib/jquery.blockUI.js
function install (line 192) | function install(el, opts) {
function remove (line 379) | function remove(el, opts) {
function reset (line 414) | function reset(els,data,opts,el) {
function bind (line 434) | function bind(b, el, opts) {
function handler (line 457) | function handler(e) {
function focus (line 479) | function focus(back) {
function center (line 487) | function center(el, x, y) {
function sz (line 495) | function sz(el, p) {
FILE: oqa-solr/relsyn/solr-webapp/webapp/js/lib/jquery.form.js
function fileUpload (line 180) | function fileUpload() {
function log (line 770) | function log() {
FILE: oqa-solr/relsyn/solr-webapp/webapp/js/lib/jquery.jstree.js
function exec (line 1254) | function exec(i, event) {
FILE: oqa-solr/relsyn/solr-webapp/webapp/js/lib/jquery.timeago.js
function substitute (line 70) | function substitute(stringOrFunction, number) {
function refresh (line 134) | function refresh() {
function prepareData (line 142) | function prepareData(element) {
function inWords (line 154) | function inWords(date) {
function distance (line 158) | function distance(date) {
FILE: oqa-solr/relsyn/solr-webapp/webapp/js/lib/order.js
function scriptCacheCallback (line 54) | function scriptCacheCallback(evt) {
function onFetchOnly (line 96) | function onFetchOnly(node) {
FILE: oqa-solr/relsyn/solr-webapp/webapp/js/require.js
function isFunction (line 46) | function isFunction(it) {
function isArray (line 50) | function isArray(it) {
function mixin (line 61) | function mixin(target, source, force) {
function makeError (line 78) | function makeError(id, msg, err) {
function configurePackageDir (line 92) | function configurePackageDir(pkgs, currentPackages, dir) {
function jQueryHoldReady (line 128) | function jQueryHoldReady($, shouldHold) {
function newContext (line 171) | function newContext(contextName) {
function getInteractiveScript (line 1659) | function getInteractiveScript() {
function jQuerySub (line 2924) | function jQuerySub( selector, context ) {
function doScrollCheck (line 2990) | function doScrollCheck() {
function createFlags (line 3017) | function createFlags( flags ) {
function resolveFunc (line 3349) | function resolveFunc( i ) {
function progressFunc (line 3357) | function progressFunc( i ) {
function dataAttr (line 3984) | function dataAttr( elem, key, data ) {
function isEmptyDataObject (line 4015) | function isEmptyDataObject( obj ) {
function handleQueueMarkDefer (line 4033) | function handleQueueMarkDefer( elem, type, src ) {
function resolve (line 4186) | function resolve() {
function returnFalse (line 5518) | function returnFalse() {
function returnTrue (line 5521) | function returnTrue() {
function dirNodeCheck (line 7221) | function dirNodeCheck( dir, cur, doneName, checkSet, nodeCheck, isXML ) {
function dirCheck (line 7254) | function dirCheck( dir, cur, doneName, checkSet, nodeCheck, isXML ) {
function isDisconnected (line 7527) | function isDisconnected( node ) {
function winnow (line 7644) | function winnow( elements, qualifier, keep ) {
function createSafeFragment (line 7681) | function createSafeFragment( document ) {
function root (line 8045) | function root( elem, cur ) {
function cloneCopyEvent (line 8052) | function cloneCopyEvent( src, dest ) {
function cloneFixAttributes (line 8080) | function cloneFixAttributes( src, dest ) {
function getAll (line 8216) | function getAll( elem ) {
function fixDefaultChecked (line 8229) | function fixDefaultChecked( elem ) {
function findInputs (line 8235) | function findInputs( elem ) {
function shimCloneNode (line 8246) | function shimCloneNode( elem ) {
function evalScript (line 8478) | function evalScript( i, elem ) {
function getWH (line 8820) | function getWH( elem, name, extra ) {
function addToPrefiltersOrTransports (line 8948) | function addToPrefiltersOrTransports( structure ) {
function inspectPrefiltersOrTransports (line 8984) | function inspectPrefiltersOrTransports( structure, options, originalOpti...
function ajaxExtend (line 9026) | function ajaxExtend( target, src ) {
function done (line 9370) | function done( status, nativeStatusText, responses, headers ) {
function buildParams (line 9685) | function buildParams( prefix, obj, traditional, add ) {
function ajaxHandleResponses (line 9735) | function ajaxHandleResponses( s, jqXHR, responses ) {
function ajaxConvert (line 9800) | function ajaxConvert( s, response ) {
function createStandardXHR (line 10066) | function createStandardXHR() {
function createActiveXHR (line 10072) | function createActiveXHR() {
function doAnimation (line 10404) | function doAnimation() {
function stopQueue (line 10547) | function stopQueue( elem, data, index ) {
function createFxNow (line 10589) | function createFxNow() {
function clearFxNow (line 10594) | function clearFxNow() {
function genFx (line 10599) | function genFx( type, num ) {
function t (line 10714) | function t( gotoEnd ) {
function defaultDisplay (line 10906) | function defaultDisplay( nodeName ) {
function getWindow (line 11215) | function getWindow( elem ) {
FILE: oqa-solr/relsyn/solr-webapp/webapp/js/scripts/dataimport.js
function dataimport_fetch_config (line 157) | function dataimport_fetch_config()
function dataimport_fetch_status (line 414) | function dataimport_fetch_status( clear_timeout )
FILE: oqa-solr/relsyn/solr/relsyn/conf/update-script.js
function processAdd (line 10) | function processAdd(cmd) {
function processDelete (line 35) | function processDelete(cmd) {
function processMergeIndexes (line 39) | function processMergeIndexes(cmd) {
function processCommit (line 43) | function processCommit(cmd) {
function processRollback (line 47) | function processRollback(cmd) {
function finish (line 51) | function finish() {
FILE: oqa-solr/relsyn/solr/relsyn/conf/velocity/jquery.autocomplete.js
function findValueCallback (line 171) | function findValueCallback(q, data) {
function selectCurrent (line 201) | function selectCurrent() {
function onChange (line 223) | function onChange(crap, skipPrevCheck) {
function trimWords (line 248) | function trimWords(value) {
function lastWord (line 261) | function lastWord(value) {
function autoFill (line 271) | function autoFill(q, sValue){
function hideResults (line 282) | function hideResults() {
function hideResultsNow (line 287) | function hideResultsNow() {
function receiveData (line 313) | function receiveData(q, data) {
function request (line 324) | function request(term, success, failure) {
function parse (line 366) | function parse(data) {
function stopLoading (line 383) | function stopLoading() {
function matchSubset (line 421) | function matchSubset(s, sub) {
function add (line 432) | function add(q, value) {
function populate (line 442) | function populate(){
function flush (line 497) | function flush(){
function init (line 569) | function init() {
function target (line 601) | function target(event) {
function moveSelect (line 611) | function moveSelect(step) {
function movePosition (line 628) | function movePosition(step) {
function limitNumberOfItems (line 637) | function limitNumberOfItems(available) {
function fillList (line 643) | function fillList() {
FILE: oqa-solr/src/main/scripts/index-relsyn.py
function add_id (line 5) | def add_id(input):
FILE: oqa-solr/src/main/scripts/utils.py
function grouper (line 6) | def grouper(iterable, n, fillvalue=None):
function solr_url (line 10) | def solr_url(host, port, coll):
function index_objects (line 13) | def index_objects(objects, host, port, collection):
function parse_line (line 20) | def parse_line(line):
function index_stream (line 27) | def index_stream(input, port, coll, host='localhost', chunk_size=10000):
FILE: oqa-solr/triplestore/solr-webapp/webapp/js/lib/chosen.js
function SelectParser (line 15) | function SelectParser() {
function AbstractChosen (line 105) | function AbstractChosen(form_field, options) {
function ctor (line 263) | function ctor() { this.constructor = child; }
function Chosen (line 284) | function Chosen() {
FILE: oqa-solr/triplestore/solr-webapp/webapp/js/lib/d3.js
function d3_class (line 14) | function d3_class(ctor, properties) {
function d3_arrayCopy (line 28) | function d3_arrayCopy(pseudoarray) {
function d3_arraySlice (line 34) | function d3_arraySlice(pseudoarray) {
function d3_Map (line 61) | function d3_Map() {}
function d3_this (line 103) | function d3_this() {
function d3_rebind (line 119) | function d3_rebind(target, source, method) {
function d3_number (line 213) | function d3_number(x) {
function d3_zipLength (line 251) | function d3_zipLength(d) {
function map (line 315) | function map(array, depth) {
function entries (line 345) | function entries(map, depth) {
function d3_splitter (line 440) | function d3_splitter(d) {
function d3_collapse (line 443) | function d3_collapse(s) {
function d3_range_integerScale (line 465) | function d3_range_integerScale(x) {
function ready (line 492) | function ready(req) {
function ready (line 517) | function ready(req) {
function d3_dispatch (line 556) | function d3_dispatch() {}
function d3_dispatch_event (line 573) | function d3_dispatch_event(dispatch) {
function d3_format_precision (line 692) | function d3_format_precision(x, p) {
function d3_format_typeDefault (line 696) | function d3_format_typeDefault(x) {
function d3_format_group (line 701) | function d3_format_group(value) {
function d3_formatPrefix (line 721) | function d3_formatPrefix(d, i) {
function d3_ease_clamp (line 796) | function d3_ease_clamp(f) {
function d3_ease_reverse (line 802) | function d3_ease_reverse(f) {
function d3_ease_reflect (line 808) | function d3_ease_reflect(f) {
function d3_ease_identity (line 814) | function d3_ease_identity(t) {
function d3_ease_poly (line 818) | function d3_ease_poly(e) {
function d3_ease_sin (line 824) | function d3_ease_sin(t) {
function d3_ease_exp (line 828) | function d3_ease_exp(t) {
function d3_ease_circle (line 832) | function d3_ease_circle(t) {
function d3_ease_elastic (line 836) | function d3_ease_elastic(a, p) {
function d3_ease_back (line 846) | function d3_ease_back(s) {
function d3_ease_bounce (line 853) | function d3_ease_bounce(t) {
function d3_eventCancel (line 861) | function d3_eventCancel() {
function d3_eventSource (line 866) | function d3_eventSource() {
function d3_eventDispatch (line 876) | function d3_eventDispatch(target) {
function d3_interpolateByName (line 1125) | function d3_interpolateByName(n) {
function d3_uninterpolateNumber (line 1138) | function d3_uninterpolateNumber(a, b) {
function d3_uninterpolateClamp (line 1143) | function d3_uninterpolateClamp(a, b) {
function d3_rgb (line 1154) | function d3_rgb(r, g, b) {
function d3_Rgb (line 1158) | function d3_Rgb(r, g, b) {
function d3_rgb_hex (line 1196) | function d3_rgb_hex(v) {
function d3_rgb_parse (line 1202) | function d3_rgb_parse(format, rgb, hsl) {
function d3_rgb_hsl (line 1254) | function d3_rgb_hsl(r, g, b) {
function d3_rgb_parseNumber (line 1273) | function d3_rgb_parseNumber(c) { // either integer or percentage
function d3_hsl (line 1438) | function d3_hsl(h, s, l) {
function d3_Hsl (line 1442) | function d3_Hsl(h, s, l) {
function d3_hsl_rgb (line 1466) | function d3_hsl_rgb(h, s, l) {
function d3_selection (line 1494) | function d3_selection(groups) {
function d3_selection_selector (line 1544) | function d3_selection_selector(selector) {
function d3_selection_selectorAll (line 1568) | function d3_selection_selectorAll(selector) {
function attrNull (line 1584) | function attrNull() {
function attrNullNS (line 1588) | function attrNullNS() {
function attrConstant (line 1592) | function attrConstant() {
function attrConstantNS (line 1596) | function attrConstantNS() {
function attrFunction (line 1600) | function attrFunction() {
function attrFunctionNS (line 1606) | function attrFunctionNS() {
function d3_selection_classed (line 1632) | function d3_selection_classed(name, value) {
function styleNull (line 1686) | function styleNull() {
function styleConstant (line 1690) | function styleConstant() {
function styleFunction (line 1694) | function styleFunction() {
function propertyNull (line 1709) | function propertyNull() {
function propertyConstant (line 1713) | function propertyConstant() {
function propertyFunction (line 1717) | function propertyFunction() {
function append (line 1746) | function append() {
function appendNS (line 1750) | function appendNS() {
function insert (line 1762) | function insert() {
function insertNS (line 1768) | function insertNS() {
function bind (line 1802) | function bind(group, groupData) {
function d3_selection_dataNode (line 1903) | function d3_selection_dataNode(data) {
function d3_selection_filter (line 1933) | function d3_selection_filter(selector) {
function d3_selection_sortComparator (line 1955) | function d3_selection_sortComparator(comparator) {
function l (line 1991) | function l(e) {
function d3_selection_enter (line 2068) | function d3_selection_enter(selection) {
function d3_transition (line 2106) | function d3_transition(groups, id, time) {
function d3_transitionNull (line 2196) | function d3_transitionNull(d, i, a) {
function d3_transitionTween (line 2200) | function d3_transitionTween(name, b) {
function attrTween (line 2289) | function attrTween(d, i) {
function attrTweenNS (line 2296) | function attrTweenNS(d, i) {
function d3_transition_each (line 2344) | function d3_transition_each(callback) {
function d3_timer_step (line 2416) | function d3_timer_step() {
function d3_timer_flush (line 2455) | function d3_timer_flush() {
function d3_transform (line 2490) | function d3_transform(m) {
function d3_transformDot (line 2516) | function d3_transformDot(a, b) {
function d3_transformNormalize (line 2520) | function d3_transformNormalize(a) {
function d3_transformCombine (line 2529) | function d3_transformCombine(a, b, k) {
function d3_mousePoint (line 2543) | function d3_mousePoint(container, e) {
function d3_noop (line 2578) | function d3_noop() {}
function d3_scaleExtent (line 2581) | function d3_scaleExtent(domain) {
function d3_scaleRange (line 2586) | function d3_scaleRange(scale) {
function d3_scale_nice (line 2589) | function d3_scale_nice(domain, nice) {
function d3_scale_niceDefault (line 2610) | function d3_scale_niceDefault() {
function d3_scale_linear (line 2617) | function d3_scale_linear(domain, range, interpolate, clamp) {
function d3_scale_linearRebind (line 2686) | function d3_scale_linearRebind(scale, linear) {
function d3_scale_linearNice (line 2690) | function d3_scale_linearNice(dx) {
function d3_scale_linearTickRange (line 2698) | function d3_scale_linearTickRange(domain, m) {
function d3_scale_linearTicks (line 2716) | function d3_scale_linearTicks(domain, m) {
function d3_scale_linearTickFormat (line 2720) | function d3_scale_linearTickFormat(domain, m) {
function d3_scale_bilinear (line 2723) | function d3_scale_bilinear(domain, range, uninterpolate, interpolate) {
function d3_scale_polylinear (line 2730) | function d3_scale_polylinear(domain, range, uninterpolate, interpolate) {
function d3_scale_log (line 2756) | function d3_scale_log(linear, log) {
function d3_scale_logp (line 2822) | function d3_scale_logp(x) {
function d3_scale_logn (line 2826) | function d3_scale_logn(x) {
function d3_scale_pow (line 2841) | function d3_scale_pow(linear, exponent) {
function d3_scale_powPow (line 2886) | function d3_scale_powPow(e) {
function d3_scale_ordinal (line 2898) | function d3_scale_ordinal(domain, ranger) {
function d3_scale_quantile (line 3038) | function d3_scale_quantile(domain, range) {
function d3_scale_quantize (line 3081) | function d3_scale_quantize(x0, x1, range) {
function d3_scale_identity (line 3117) | function d3_scale_identity(domain) {
function arc (line 3150) | function arc() {
function d3_svg_arcInnerRadius (line 3224) | function d3_svg_arcInnerRadius(d) {
function d3_svg_arcOuterRadius (line 3228) | function d3_svg_arcOuterRadius(d) {
function d3_svg_arcStartAngle (line 3232) | function d3_svg_arcStartAngle(d) {
function d3_svg_arcEndAngle (line 3236) | function d3_svg_arcEndAngle(d) {
function d3_svg_line (line 3239) | function d3_svg_line(projection) {
function d3_svg_linePoints (line 3286) | function d3_svg_linePoints(self, d, x, y) {
function d3_svg_lineX (line 3309) | function d3_svg_lineX(d) {
function d3_svg_lineY (line 3314) | function d3_svg_lineY(d) {
function d3_svg_lineLinear (line 3336) | function d3_svg_lineLinear(points) {
function d3_svg_lineStepBefore (line 3346) | function d3_svg_lineStepBefore(points) {
function d3_svg_lineStepAfter (line 3356) | function d3_svg_lineStepAfter(points) {
function d3_svg_lineCardinalOpen (line 3366) | function d3_svg_lineCardinalOpen(points, tension) {
function d3_svg_lineCardinalClosed (line 3374) | function d3_svg_lineCardinalClosed(points, tension) {
function d3_svg_lineCardinal (line 3383) | function d3_svg_lineCardinal(points, tension, closed) {
function d3_svg_lineHermite (line 3391) | function d3_svg_lineHermite(points, tangents) {
function d3_svg_lineCardinalTangents (line 3438) | function d3_svg_lineCardinalTangents(points, tension) {
function d3_svg_lineBasis (line 3456) | function d3_svg_lineBasis(points) {
function d3_svg_lineBasisOpen (line 3483) | function d3_svg_lineBasisOpen(points) {
function d3_svg_lineBasisClosed (line 3508) | function d3_svg_lineBasisClosed(points) {
function d3_svg_lineBundle (line 3534) | function d3_svg_lineBundle(points, tension) {
function d3_svg_lineDot4 (line 3553) | function d3_svg_lineDot4(a, b) {
function d3_svg_lineBasisBezier (line 3565) | function d3_svg_lineBasisBezier(path, x, y) {
function d3_svg_lineSlope (line 3576) | function d3_svg_lineSlope(p0, p1) {
function d3_svg_lineFiniteDifferences (line 3582) | function d3_svg_lineFiniteDifferences(points) {
function d3_svg_lineMonotoneTangents (line 3599) | function d3_svg_lineMonotoneTangents(points) {
function d3_svg_lineMonotone (line 3651) | function d3_svg_lineMonotone(points) {
function d3_svg_lineRadial (line 3664) | function d3_svg_lineRadial(points) {
function d3_svg_area (line 3679) | function d3_svg_area(projection) {
function d3_svg_areaX (line 3758) | function d3_svg_areaX(points) {
function d3_svg_areaY (line 3764) | function d3_svg_areaY(points) {
function chord (line 3788) | function chord(d, i) {
function subgroup (line 3800) | function subgroup(self, f, d, i) {
function equals (line 3814) | function equals(a, b) {
function arc (line 3818) | function arc(r, p, a) {
function curve (line 3822) | function curve(r0, p0, r1, p1) {
function d3_svg_chordSource (line 3859) | function d3_svg_chordSource(d) {
function d3_svg_chordTarget (line 3863) | function d3_svg_chordTarget(d) {
function d3_svg_chordRadius (line 3867) | function d3_svg_chordRadius(d) {
function d3_svg_chordStartAngle (line 3871) | function d3_svg_chordStartAngle(d) {
function d3_svg_chordEndAngle (line 3875) | function d3_svg_chordEndAngle(d) {
function diagonal (line 3883) | function diagonal(d, i) {
function d3_svg_diagonalProjection (line 3913) | function d3_svg_diagonalProjection(d) {
function d3_svg_diagonalRadialProjection (line 3930) | function d3_svg_diagonalRadialProjection(projection) {
function symbol (line 3944) | function symbol(d, i) {
function d3_svg_symbolSize (line 3966) | function d3_svg_symbolSize() {
function d3_svg_symbolType (line 3970) | function d3_svg_symbolType() {
function d3_svg_symbolCircle (line 3974) | function d3_svg_symbolCircle(size) {
function axis (line 4052) | function axis(g) {
function d3_svg_axisX (line 4214) | function d3_svg_axisX(selection, x) {
function d3_svg_axisY (line 4218) | function d3_svg_axisY(selection, y) {
function d3_svg_axisSubdivide (line 4222) | function d3_svg_axisSubdivide(scale, ticks, m) {
function brush (line 4253) | function brush(g) {
function redraw (line 4311) | function redraw(g) {
function redrawX (line 4317) | function redrawX(g) {
function redrawY (line 4322) | function redrawY(g) {
function brushstart (line 4327) | function brushstart() {
function drag (line 4610) | function drag() {
function mousedown (line 4615) | function mousedown() {
function zoom (line 4701) | function zoom() {
function location (line 4745) | function location(p) {
function point (line 4749) | function point(l) {
function scaleTo (line 4753) | function scaleTo(s) {
function translateTo (line 4757) | function translateTo(p, l) {
function dispatch (line 4763) | function dispatch(event) {
function mousedown (line 4770) | function mousedown() {
function mousewheel (line 4799) | function mousewheel() {
function mousemove (line 4806) | function mousemove() {
function dblclick (line 4810) | function dblclick() {
function touchstart (line 4817) | function touchstart() {
function touchmove (line 4835) | function touchmove() {
function d3_behavior_zoomDelta (line 4855) | function d3_behavior_zoomDelta() {
function d3_layout_bundlePath (line 4898) | function d3_layout_bundlePath(link) {
function d3_layout_bundleAncestors (line 4915) | function d3_layout_bundleAncestors(node) {
function d3_layout_bundleLeastCommonAncestor (line 4927) | function d3_layout_bundleLeastCommonAncestor(a, b) {
function relayout (line 4952) | function relayout() {
function resort (line 5039) | function resort() {
function repulse (line 5114) | function repulse(node) {
function position (line 5330) | function position(dimension, size) {
function neighbor (line 5340) | function neighbor() {
function dragstart (line 5379) | function dragstart(d) {
function d3_layout_forceDragOver (line 5390) | function d3_layout_forceDragOver(d) {
function d3_layout_forceDragOut (line 5394) | function d3_layout_forceDragOut(d) {
function d3_layout_forceDragEnd (line 5398) | function d3_layout_forceDragEnd() {
function d3_layout_forceDrag (line 5403) | function d3_layout_forceDrag() {
function d3_layout_forceAccumulate (line 5409) | function d3_layout_forceAccumulate(quad, alpha, charges) {
function d3_layout_forceLinkDistance (line 5442) | function d3_layout_forceLinkDistance(link) {
function d3_layout_forceLinkStrength (line 5446) | function d3_layout_forceLinkStrength(link) {
function position (line 5453) | function position(node, x, dx, dy) {
function depth (line 5472) | function depth(node) {
function partition (line 5483) | function partition(d, i) {
function pie (line 5503) | function pie(data, i) {
function stack (line 5599) | function stack(data, index) {
function d3_layout_stackX (line 5676) | function d3_layout_stackX(d) {
function d3_layout_stackY (line 5680) | function d3_layout_stackY(d) {
function d3_layout_stackOut (line 5684) | function d3_layout_stackOut(d, y0, y) {
function d3_layout_stackOrderDefault (line 5797) | function d3_layout_stackOrderDefault(data) {
function d3_layout_stackOffsetZero (line 5801) | function d3_layout_stackOffsetZero(data) {
function d3_layout_stackMaxIndex (line 5809) | function d3_layout_stackMaxIndex(array) {
function d3_layout_stackReduceSum (line 5824) | function d3_layout_stackReduceSum(d) {
function d3_layout_stackSum (line 5828) | function d3_layout_stackSum(p, d) {
function histogram (line 5837) | function histogram(data, i) {
function d3_layout_histogramBinSturges (line 5917) | function d3_layout_histogramBinSturges(range, values) {
function d3_layout_histogramBinFixed (line 5921) | function d3_layout_histogramBinFixed(range, n) {
function d3_layout_histogramRange (line 5930) | function d3_layout_histogramRange(values) {
function recurse (line 5940) | function recurse(data, depth, nodes) {
function revalue (line 5966) | function revalue(node, depth) {
function hierarchy (line 5981) | function hierarchy(d) {
function d3_layout_hierarchyRebind (line 6015) | function d3_layout_hierarchyRebind(object, hierarchy) {
function d3_layout_hierarchyChildren (line 6030) | function d3_layout_hierarchyChildren(d) {
function d3_layout_hierarchyValue (line 6034) | function d3_layout_hierarchyValue(d) {
function d3_layout_hierarchySort (line 6038) | function d3_layout_hierarchySort(a, b) {
function d3_layout_hierarchyLinks (line 6043) | function d3_layout_hierarchyLinks(nodes) {
function pack (line 6057) | function pack(d, i) {
function d3_layout_packSort (line 6084) | function d3_layout_packSort(a, b) {
function d3_layout_packInsert (line 6088) | function d3_layout_packInsert(a, b) {
function d3_layout_packSplice (line 6096) | function d3_layout_packSplice(a, b) {
function d3_layout_packIntersects (line 6101) | function d3_layout_packIntersects(a, b) {
function d3_layout_packCircle (line 6108) | function d3_layout_packCircle(nodes) {
function d3_layout_packLink (line 6200) | function d3_layout_packLink(node) {
function d3_layout_packUnlink (line 6204) | function d3_layout_packUnlink(node) {
function d3_layout_packTree (line 6209) | function d3_layout_packTree(node) {
function d3_layout_packTransform (line 6219) | function d3_layout_packTransform(node, x, y, k) {
function d3_layout_packPlace (line 6230) | function d3_layout_packPlace(a, b, c) {
function cluster (line 6255) | function cluster(d, i) {
function d3_layout_clusterY (line 6306) | function d3_layout_clusterY(children) {
function d3_layout_clusterX (line 6312) | function d3_layout_clusterX(children) {
function d3_layout_clusterLeft (line 6318) | function d3_layout_clusterLeft(node) {
function d3_layout_clusterRight (line 6323) | function d3_layout_clusterRight(node) {
function tree (line 6333) | function tree(d, i) {
function d3_layout_treeSeparation (line 6469) | function d3_layout_treeSeparation(a, b) {
function d3_layout_treeLeft (line 6477) | function d3_layout_treeLeft(node) {
function d3_layout_treeRight (line 6482) | function d3_layout_treeRight(node) {
function d3_layout_treeSearch (line 6488) | function d3_layout_treeSearch(node, compare) {
function d3_layout_treeRightmost (line 6503) | function d3_layout_treeRightmost(a, b) {
function d3_layout_treeLeftmost (line 6507) | function d3_layout_treeLeftmost(a, b) {
function d3_layout_treeDeepest (line 6511) | function d3_layout_treeDeepest(a, b) {
function d3_layout_treeVisitAfter (line 6515) | function d3_layout_treeVisitAfter(node, callback) {
function d3_layout_treeShift (line 6534) | function d3_layout_treeShift(node) {
function d3_layout_treeMove (line 6548) | function d3_layout_treeMove(ancestor, node, shift) {
function d3_layout_treeAncestor (line 6559) | function d3_layout_treeAncestor(vim, node, ancestor) {
function scale (line 6577) | function scale(children, k) {
function squarify (line 6589) | function squarify(node) {
function stickify (line 6626) | function stickify(node) {
function worst (line 6648) | function worst(row, u) {
function position (line 6668) | function position(row, u, rect, flush) {
function treemap (line 6704) | function treemap(d) {
function padFunction (line 6727) | function padFunction(node) {
function padConstant (line 6734) | function padConstant(node) {
function d3_layout_treemapPadNull (line 6768) | function d3_layout_treemapPadNull(node) {
function d3_layout_treemapPad (line 6772) | function d3_layout_treemapPad(node, padding) {
function token (line 6812) | function token() {
function d3_csv_formatRow (line 6863) | function d3_csv_formatRow(row) {
function d3_csv_formatValue (line 6867) | function d3_csv_formatValue(text) {
function azimuthal (line 6886) | function azimuthal(coordinates) {
function albers (line 6969) | function albers(coordinates) {
function reload (line 6990) | function reload() {
function albersUsa (line 7049) | function albersUsa(coordinates) {
function bonne (line 7089) | function bonne(coordinates) {
function equirectangular (line 7155) | function equirectangular(coordinates) {
function mercator (line 7191) | function mercator(coordinates) {
function d3_geo_type (line 7223) | function d3_geo_type(types, defaultValue) {
function path (line 7240) | function path(d, i) {
function project (line 7247) | function project(coordinates) {
function polygonArea (line 7406) | function polygonArea(coordinates) {
function polygonCentroid (line 7414) | function polygonCentroid(coordinates) {
function area (line 7472) | function area(coordinates) {
function d3_path_circle (line 7493) | function d3_path_circle(radius) {
function d3_geo_bounds (line 7519) | function d3_geo_bounds(o, f) {
function d3_geo_boundsFeature (line 7535) | function d3_geo_boundsFeature(o, f) {
function d3_geo_boundsFeatureCollection (line 7539) | function d3_geo_boundsFeatureCollection(o, f) {
function d3_geo_boundsGeometryCollection (line 7545) | function d3_geo_boundsGeometryCollection(o, f) {
function d3_geo_boundsLineString (line 7551) | function d3_geo_boundsLineString(o, f) {
function d3_geo_boundsMultiLineString (line 7557) | function d3_geo_boundsMultiLineString(o, f) {
function d3_geo_boundsMultiPolygon (line 7565) | function d3_geo_boundsMultiPolygon(o, f) {
function d3_geo_boundsPoint (line 7573) | function d3_geo_boundsPoint(o, f) {
function d3_geo_boundsPolygon (line 7577) | function d3_geo_boundsPolygon(o, f) {
function circle (line 7590) | function circle() {
function visible (line 7594) | function visible(point) {
function clip (line 7654) | function clip(coordinates) {
function resample (line 7689) | function resample(coordinates) {
function greatArc (line 7733) | function greatArc() {
function d3_geo_greatArcSource (line 7777) | function d3_geo_greatArcSource(d) {
function d3_geo_greatArcTarget (line 7781) | function d3_geo_greatArcTarget(d) {
function d3_geo_greatArcInterpolate (line 7785) | function d3_geo_greatArcInterpolate(a, b) {
function d3_geom_contourStart (line 7869) | function d3_geom_contourStart(grid) {
function d3_geom_hullCCW (line 7979) | function d3_geom_hullCCW(i1, i2, i3, v) {
function d3_geom_polygonInside (line 8057) | function d3_geom_polygonInside(p, a, b) {
function d3_geom_polygonIntersect (line 8062) | function d3_geom_polygonIntersect(c, d, a, b) {
function d3_voronoi_tessellate (line 8145) | function d3_voronoi_tessellate(vertices, callback) {
function insert (line 8557) | function insert(n, p, x1, y1, x2, y2) {
function insertChild (line 8583) | function insertChild(n, p, x1, y1, x2, y2) {
function d3_geom_quadtreeNode (line 8617) | function d3_geom_quadtreeNode() {
function d3_geom_quadtreeVisit (line 8625) | function d3_geom_quadtreeVisit(f, node, x1, y1, x2, y2) {
function d3_geom_quadtreePoint (line 8637) | function d3_geom_quadtreePoint(p) {
function d3_time_utc (line 8647) | function d3_time_utc() {
function format (line 8680) | function format(date) {
function d3_time_parse (line 8720) | function d3_time_parse(date, template, string, j) {
function d3_time_parseWeekdayAbbrev (line 8800) | function d3_time_parseWeekdayAbbrev(date, string, i) {
function d3_time_parseWeekday (line 8805) | function d3_time_parseWeekday(date, string, i) {
function d3_time_parseMonthAbbrev (line 8815) | function d3_time_parseMonthAbbrev(date, string, i) {
function d3_time_parseMonth (line 8835) | function d3_time_parseMonth(date, string, i) {
function d3_time_parseLocaleFull (line 8873) | function d3_time_parseLocaleFull(date, string, i) {
function d3_time_parseLocaleDate (line 8877) | function d3_time_parseLocaleDate(date, string, i) {
function d3_time_parseLocaleTime (line 8881) | function d3_time_parseLocaleTime(date, string, i) {
function d3_time_parseFullYear (line 8885) | function d3_time_parseFullYear(date, string, i) {
function d3_time_parseYear (line 8891) | function d3_time_parseYear(date, string, i) {
function d3_time_century (line 8897) | function d3_time_century() {
function d3_time_parseMonthNumber (line 8901) | function d3_time_parseMonthNumber(date, string, i) {
function d3_time_parseDay (line 8907) | function d3_time_parseDay(date, string, i) {
function d3_time_parseHour24 (line 8914) | function d3_time_parseHour24(date, string, i) {
function d3_time_parseMinutes (line 8920) | function d3_time_parseMinutes(date, string, i) {
function d3_time_parseSeconds (line 8926) | function d3_time_parseSeconds(date, string, i) {
function d3_time_parseMilliseconds (line 8932) | function d3_time_parseMilliseconds(date, string, i) {
function d3_time_parseAmPm (line 8941) | function d3_time_parseAmPm(date, string, i) {
function d3_time_zone (line 8952) | function d3_time_zone(d) {
function format (line 8962) | function format(date) {
function d3_time_formatIsoNative (line 8991) | function d3_time_formatIsoNative(date) {
function d3_time_interval (line 9000) | function d3_time_interval(local, step, number) {
function d3_time_interval_utc (line 9057) | function d3_time_interval_utc(method) {
function d3_time_scale (line 9162) | function d3_time_scale(linear, methods, format) {
function d3_time_scaleExtent (line 9212) | function d3_time_scaleExtent(domain) {
function d3_time_scaleDate (line 9217) | function d3_time_scaleDate(t) {
function d3_time_scaleFormat (line 9221) | function d3_time_scaleFormat(formats) {
function d3_time_scaleSetYear (line 9229) | function d3_time_scaleSetYear(y) {
function d3_time_scaleGetYear (line 9235) | function d3_time_scaleGetYear(d) {
function d3_time_scaleUTCSetYear (line 9322) | function d3_time_scaleUTCSetYear(y) {
function d3_time_scaleUTCGetYear (line 9328) | function d3_time_scaleUTCGetYear(d) {
FILE: oqa-solr/triplestore/solr-webapp/webapp/js/lib/highlight.js
function l (line 1) | function l(o){return o.replace(/&/gm,"&").replace(/</gm,"<").repl...
function b (line 1) | function b(p){for(var o=p.firstChild;o;o=o.nextSibling){if(o.nodeName=="...
function h (line 1) | function h(p,o){return Array.prototype.map.call(p.childNodes,function(q)...
function a (line 1) | function a(q){var p=(q.className+" "+q.parentNode.className).split(/\s+/...
function c (line 1) | function c(q){var o=[];(function p(r,s){for(var t=r.firstChild;t;t=t.nex...
function j (line 1) | function j(x,v,w){var p=0;var y="";var r=[];function t(){if(x.length&&v....
function f (line 1) | function f(q){function o(s,r){return RegExp(s,"m"+(q.cI?"i":"")+(r?"g":"...
function d (line 1) | function d(D,E){function o(r,M){for(var L=0;L<M.c.length;L++){var K=M.c[...
function g (line 1) | function g(s){var o={keyword_count:0,r:0,value:l(s)};var q=o;for(var p i...
function i (line 1) | function i(q,p,o){if(p){q=q.replace(/^((<[^>]+>|\t)+)/gm,function(r,v,u,...
function m (line 1) | function m(r,u,p){var v=h(r,p);var t=a(r);if(t=="no-highlight"){return}v...
function n (line 1) | function n(){if(n.called){return}n.called=true;Array.prototype.map.call(...
function k (line 1) | function k(){window.addEventListener("DOMContentLoaded",n,false);window....
FILE: oqa-solr/triplestore/solr-webapp/webapp/js/lib/jquery.blockUI.js
function install (line 192) | function install(el, opts) {
function remove (line 379) | function remove(el, opts) {
function reset (line 414) | function reset(els,data,opts,el) {
function bind (line 434) | function bind(b, el, opts) {
function handler (line 457) | function handler(e) {
function focus (line 479) | function focus(back) {
function center (line 487) | function center(el, x, y) {
function sz (line 495) | function sz(el, p) {
FILE: oqa-solr/triplestore/solr-webapp/webapp/js/lib/jquery.form.js
function fileUpload (line 180) | function fileUpload() {
function log (line 770) | function log() {
FILE: oqa-solr/triplestore/solr-webapp/webapp/js/lib/jquery.jstree.js
function exec (line 1254) | function exec(i, event) {
FILE: oqa-solr/triplestore/solr-webapp/webapp/js/lib/jquery.timeago.js
function substitute (line 70) | function substitute(stringOrFunction, number) {
function refresh (line 134) | function refresh() {
function prepareData (line 142) | function prepareData(element) {
function inWords (line 154) | function inWords(date) {
function distance (line 158) | function distance(date) {
FILE: oqa-solr/triplestore/solr-webapp/webapp/js/lib/order.js
function scriptCacheCallback (line 54) | function scriptCacheCallback(evt) {
function onFetchOnly (line 96) | function onFetchOnly(node) {
FILE: oqa-solr/triplestore/solr-webapp/webapp/js/require.js
function isFunction (line 46) | function isFunction(it) {
function isArray (line 50) | function isArray(it) {
function mixin (line 61) | function mixin(target, source, force) {
function makeError (line 78) | function makeError(id, msg, err) {
function configurePackageDir (line 92) | function configurePackageDir(pkgs, currentPackages, dir) {
function jQueryHoldReady (line 128) | function jQueryHoldReady($, shouldHold) {
function newContext (line 171) | function newContext(contextName) {
function getInteractiveScript (line 1659) | function getInteractiveScript() {
function jQuerySub (line 2924) | function jQuerySub( selector, context ) {
function doScrollCheck (line 2990) | function doScrollCheck() {
function createFlags (line 3017) | function createFlags( flags ) {
function resolveFunc (line 3349) | function resolveFunc( i ) {
function progressFunc (line 3357) | function progressFunc( i ) {
function dataAttr (line 3984) | function dataAttr( elem, key, data ) {
function isEmptyDataObject (line 4015) | function isEmptyDataObject( obj ) {
function handleQueueMarkDefer (line 4033) | function handleQueueMarkDefer( elem, type, src ) {
function resolve (line 4186) | function resolve() {
function returnFalse (line 5518) | function returnFalse() {
function returnTrue (line 5521) | function returnTrue() {
function dirNodeCheck (line 7221) | function dirNodeCheck( dir, cur, doneName, checkSet, nodeCheck, isXML ) {
function dirCheck (line 7254) | function dirCheck( dir, cur, doneName, checkSet, nodeCheck, isXML ) {
function isDisconnected (line 7527) | function isDisconnected( node ) {
function winnow (line 7644) | function winnow( elements, qualifier, keep ) {
function createSafeFragment (line 7681) | function createSafeFragment( document ) {
function root (line 8045) | function root( elem, cur ) {
function cloneCopyEvent (line 8052) | function cloneCopyEvent( src, dest ) {
function cloneFixAttributes (line 8080) | function cloneFixAttributes( src, dest ) {
function getAll (line 8216) | function getAll( elem ) {
function fixDefaultChecked (line 8229) | function fixDefaultChecked( elem ) {
function findInputs (line 8235) | function findInputs( elem ) {
function shimCloneNode (line 8246) | function shimCloneNode( elem ) {
function evalScript (line 8478) | function evalScript( i, elem ) {
function getWH (line 8820) | function getWH( elem, name, extra ) {
function addToPrefiltersOrTransports (line 8948) | function addToPrefiltersOrTransports( structure ) {
function inspectPrefiltersOrTransports (line 8984) | function inspectPrefiltersOrTransports( structure, options, originalOpti...
function ajaxExtend (line 9026) | function ajaxExtend( target, src ) {
function done (line 9370) | function done( status, nativeStatusText, responses, headers ) {
function buildParams (line 9685) | function buildParams( prefix, obj, traditional, add ) {
function ajaxHandleResponses (line 9735) | function ajaxHandleResponses( s, jqXHR, responses ) {
function ajaxConvert (line 9800) | function ajaxConvert( s, response ) {
function createStandardXHR (line 10066) | function createStandardXHR() {
function createActiveXHR (line 10072) | function createActiveXHR() {
function doAnimation (line 10404) | function doAnimation() {
function stopQueue (line 10547) | function stopQueue( elem, data, index ) {
function createFxNow (line 10589) | function createFxNow() {
function clearFxNow (line 10594) | function clearFxNow() {
function genFx (line 10599) | function genFx( type, num ) {
function t (line 10714) | function t( gotoEnd ) {
function defaultDisplay (line 10906) | function defaultDisplay( nodeName ) {
function getWindow (line 11215) | function getWindow( elem ) {
FILE: oqa-solr/triplestore/solr-webapp/webapp/js/scripts/dataimport.js
function dataimport_fetch_config (line 157) | function dataimport_fetch_config()
function dataimport_fetch_status (line 414) | function dataimport_fetch_status( clear_timeout )
FILE: oqa-solr/triplestore/solr/triplestore/conf/update-script.js
function processAdd (line 10) | function processAdd(cmd) {
function processDelete (line 35) | function processDelete(cmd) {
function processMergeIndexes (line 39) | function processMergeIndexes(cmd) {
function processCommit (line 43) | function processCommit(cmd) {
function processRollback (line 47) | function processRollback(cmd) {
function finish (line 51) | function finish() {
FILE: oqa-solr/triplestore/solr/triplestore/conf/velocity/jquery.autocomplete.js
function findValueCallback (line 171) | function findValueCallback(q, data) {
function selectCurrent (line 201) | function selectCurrent() {
function onChange (line 223) | function onChange(crap, skipPrevCheck) {
function trimWords (line 248) | function trimWords(value) {
function lastWord (line 261) | function lastWord(value) {
function autoFill (line 271) | function autoFill(q, sValue){
function hideResults (line 282) | function hideResults() {
function hideResultsNow (line 287) | function hideResultsNow() {
function receiveData (line 313) | function receiveData(q, data) {
function request (line 324) | function request(term, success, failure) {
function parse (line 366) | function parse(data) {
function stopLoading (line 383) | function stopLoading() {
function matchSubset (line 421) | function matchSubset(s, sub) {
function add (line 432) | function add(q, value) {
function populate (line 442) | function populate(){
function flush (line 497) | function flush(){
function init (line 569) | function init() {
function target (line 601) | function target(event) {
function moveSelect (line 611) | function moveSelect(step) {
function movePosition (line 628) | function movePosition(step) {
function limitNumberOfItems (line 637) | function limitNumberOfItems(available) {
function fillList (line 643) | function fillList() {
Copy disabled (too large)
Download .json
Condensed preview — 1065 files, each showing path, character count, and a content snippet. Download the .json file for the full structured content (25,414K chars).
[
{
"path": "README.md",
"chars": 11148,
"preview": "This is a repository for the code and data from the paper _Open Question\nAnswering Over Curated and Extracted Knowledge "
},
{
"path": "oqa-core/README.md",
"chars": 970,
"preview": "# Running OQA\nCreate a file called `questions.txt` that has one question per line. Running\nthe following command will ru"
},
{
"path": "oqa-core/build.sbt",
"chars": 1155,
"preview": "scalaVersion := \"2.10.2\"\n\norganization := \"edu.knowitall.oqa\"\n\nname := \"oqa\"\n\nversion := \"0.1-SNAPSHOT\"\n\nfork in run := "
},
{
"path": "oqa-core/models/full.txt",
"chars": 45750,
"preview": "question prefix = 'what' ^ answer shape = 'Aaaaa 111 Aaaaa'\t-0.9569500182415177\nquestion prefix = 'what' ^ answer shape "
},
{
"path": "oqa-core/questions.txt",
"chars": 22,
"preview": "Who assassinated JFK?\n"
},
{
"path": "oqa-core/src/main/resources/application.conf",
"chars": 2858,
"preview": "qa.maxDerivs = 100\nqa.maxUQueries = 100\nqa.maxParaphrases = 100\nqa.maxAnswerGroups = 50\nqa.defaultParaphraser = template"
},
{
"path": "oqa-core/src/main/resources/edu/knowitall/execution/stoplist.txt",
"chars": 571,
"preview": "there\nothers\nanything\nanybody\nanyone\nthe book\nthe people\nthe woman\nall\nthe man\nsomeone\n's\nnot\none\nthe ones\nanother optio"
},
{
"path": "oqa-core/src/main/resources/edu/knowitall/execution/stopregex.txt",
"chars": 290,
"preview": "(?i)^this\\b.*\n(?i)^'s.*\n(?i)^his\\b.*\n(?i)^her\\b.*\n(?i)^its\\b.*\n(?i)^their\\b.*\n(?i)^our\\b.*\n(?i)^my\\b.*\n(?i)^your\\b.*\n(?i"
},
{
"path": "oqa-core/src/main/resources/edu/knowitall/paraphrasing/rules/rules.txt",
"chars": 809,
"preview": "inWhatDate @inOn @whatwhich @dateWord (<rest>:@any+) := When $rest\nwhatDate @whatwhich @dateWord (<rest>:@any+) := When "
},
{
"path": "oqa-core/src/main/resources/edu/knowitall/paraphrasing/template/templatesStops.txt",
"chars": 431,
"preview": "what be $y ?\n$y ?\nwhat $y ?\nwhat be the $y ?\nwhat be a $y ?\nwhat do $y mean ?\nwho be $y ?\nwhat do $y do ?\nhow $y ?\nwho $"
},
{
"path": "oqa-core/src/main/resources/edu/knowitall/parsing/cg/argFilters.txt",
"chars": 6,
"preview": "^many\n"
},
{
"path": "oqa-core/src/main/resources/edu/knowitall/parsing/cg/lexicon.txt",
"chars": 1970,
"preview": "# ruleName syntactic-pattern := semantic-type semantic-pattern\n\nfullPatternSubj @whowhat (<rel>:@reverb) (<arg>:@np) "
},
{
"path": "oqa-core/src/main/resources/edu/knowitall/parsing/cg/macros.txt",
"chars": 1656,
"preview": "noun <pos=/N.*/|pos='CD'>\ncommonNoun <pos=/NNS?/>\npropNoun <pos=/NNPS?/>\nadj <pos=/J.*/>\nadv <pos=/R.*/>\nverb <pos=/V.*/"
},
{
"path": "oqa-core/src/main/resources/edu/knowitall/parsing/cg/relFilters.txt",
"chars": 69,
"preview": "^(do|does|did|doing)$\n^(be|is|are|was|were)$\n^(has|have|had|having)$\n"
},
{
"path": "oqa-core/src/main/resources/edu/knowitall/search/qa/isa.txt",
"chars": 164,
"preview": "is a\tinstance of\tfalse\t1\t1\t1\t0\t\t\nis an\tinstance of\tfalse\t1\t1\t1\t0\t\t\nbe a\tinstance of\tfalse\t1\t1\t1\t0\t\t\nbe an\tinstance of\tfa"
},
{
"path": "oqa-core/src/main/resources/edu/knowitall/search/qa/tupleFeatures.txt",
"chars": 147,
"preview": "conf_f\tmin\t0\t1\tlinear\nnum_extrs_i\tmin\t1\t100\tlog\nfreq_i\tmin\t1\t24712\tlog\npopularity_i\tmin\t1\t13045\tlog\nconceptVagueness_f\tm"
},
{
"path": "oqa-core/src/main/resources/log4j.properties",
"chars": 332,
"preview": "# Root logger option\nlog4j.rootLogger=INFO, stdout\n \n# Direct log messages to stdout\nlog4j.appender.stdout=org.apache.lo"
},
{
"path": "oqa-core/src/main/resources/logback.xml",
"chars": 626,
"preview": "<?xml version=\"1.0\"?>\n<configuration>\n <appender name=\"STDOUT\" class=\"ch.qos.logback.core.ConsoleAppender\">\n <target"
},
{
"path": "oqa-core/src/main/scala/edu/knowitall/eval/Oracle.scala",
"chars": 4111,
"preview": "package edu.knowitall.eval\n\nimport edu.knowitall.tool.tokenize.StanfordTokenizer\nimport edu.knowitall.tool.postag.Stanfo"
},
{
"path": "oqa-core/src/main/scala/edu/knowitall/eval/OutputRecord.scala",
"chars": 776,
"preview": "package edu.knowitall.eval\n\nabstract class OutputRecord {\n def input: String\n def output: String\n def score: Double\n "
},
{
"path": "oqa-core/src/main/scala/edu/knowitall/eval/SystemOutput.scala",
"chars": 3630,
"preview": "package edu.knowitall.eval\n\nimport scala.io.Source\nimport scala.collection.JavaConverters._\nimport java.io.File\nimport c"
},
{
"path": "oqa-core/src/main/scala/edu/knowitall/eval/qa/QAOutputRecord.scala",
"chars": 848,
"preview": "package edu.knowitall.eval.qa\n\nimport edu.knowitall.eval.OutputRecord\nimport edu.knowitall.execution.Tuple\nimport edu.kn"
},
{
"path": "oqa-core/src/main/scala/edu/knowitall/eval/qa/QASystemOutput.scala",
"chars": 2606,
"preview": "package edu.knowitall.eval.qa\n\nimport com.typesafe.config.ConfigFactory\nimport java.io.File\nimport java.io.PrintWriter\ni"
},
{
"path": "oqa-core/src/main/scala/edu/knowitall/eval/qa/QASystemRunner.scala",
"chars": 1389,
"preview": "package edu.knowitall.eval.qa\n\nimport java.io.File\nimport java.io.IOException\nimport scala.io.Source\nimport org.slf4j.Lo"
},
{
"path": "oqa-core/src/main/scala/edu/knowitall/execution/AnswerFilter.scala",
"chars": 2823,
"preview": "package edu.knowitall.execution\n\nimport edu.knowitall.tool.tokenize.ClearTokenizer\nimport edu.knowitall.tool.stem.Morpha"
},
{
"path": "oqa-core/src/main/scala/edu/knowitall/execution/ConjunctiveQuery.scala",
"chars": 11575,
"preview": "package edu.knowitall.execution\n\nimport Search.Field\nimport Search.TSQuery\nimport Search.{FieldKeywords, FieldPhrase}\nim"
},
{
"path": "oqa-core/src/main/scala/edu/knowitall/execution/JoinPlanner.scala",
"chars": 11275,
"preview": "package edu.knowitall.execution\nimport Search.PartialSearchJoin\nimport PartialFunction._\nimport Search.Field\nimport Cond"
},
{
"path": "oqa-core/src/main/scala/edu/knowitall/execution/QueryExecutor.scala",
"chars": 1223,
"preview": "package edu.knowitall.execution\nimport edu.knowitall.execution.Search.Field\nimport edu.knowitall.triplestore.Triplestore"
},
{
"path": "oqa-core/src/main/scala/edu/knowitall/execution/RelationalAlgebra.scala",
"chars": 19152,
"preview": "package edu.knowitall.execution\n\nimport scala.language.implicitConversions\nimport com.rockymadden.stringmetric.similarit"
},
{
"path": "oqa-core/src/main/scala/edu/knowitall/execution/StopwordExecutor.scala",
"chars": 912,
"preview": "package edu.knowitall.execution\n\ncase class StopwordExecutor(baseExecutor: QueryExecutor) extends QueryExecutor {\n \n i"
},
{
"path": "oqa-core/src/main/scala/edu/knowitall/learning/CorrectnessModel.scala",
"chars": 201,
"preview": "package edu.knowitall.learning\n\ntrait CorrectnessModel[Input, Output] {\n def isCorrect(input: Input, output: Output): B"
},
{
"path": "oqa-core/src/main/scala/edu/knowitall/learning/FeatureFunction.scala",
"chars": 954,
"preview": "package edu.knowitall.learning\nimport scala.language.implicitConversions\n\nabstract class FeatureFunction[T] extends Func"
},
{
"path": "oqa-core/src/main/scala/edu/knowitall/learning/HiddenVariableModel.scala",
"chars": 244,
"preview": "package edu.knowitall.learning\n\ntrait HiddenVariableModel[Input, Output] {\n def predict(input: Input): Option[Output]\n "
},
{
"path": "oqa-core/src/main/scala/edu/knowitall/learning/InteractiveOracle.scala",
"chars": 3355,
"preview": "package edu.knowitall.learning\n\nimport edu.knowitall.util.TuplePrinter.printTuple\nimport edu.knowitall.execution.Tabulat"
},
{
"path": "oqa-core/src/main/scala/edu/knowitall/learning/LabeledDataOracle.scala",
"chars": 715,
"preview": "package edu.knowitall.learning\n\nimport edu.knowitall.eval.Oracle\nimport edu.knowitall.eval.FileOracle\nimport edu.knowita"
},
{
"path": "oqa-core/src/main/scala/edu/knowitall/learning/MemoryInteractiveOracle.scala",
"chars": 2016,
"preview": "package edu.knowitall.learning\n\nimport edu.knowitall.eval.FileOracle\nimport org.slf4j.LoggerFactory\nimport edu.knowitall"
},
{
"path": "oqa-core/src/main/scala/edu/knowitall/learning/Perceptron.scala",
"chars": 502,
"preview": "package edu.knowitall.learning\n\nclass Perceptron[Input, Output](model: HiddenVariableModel[Input, Output], \n oracle: "
},
{
"path": "oqa-core/src/main/scala/edu/knowitall/learning/QATrainer.scala",
"chars": 4272,
"preview": "package edu.knowitall.learning\n\nimport com.typesafe.config.ConfigFactory\nimport edu.knowitall.eval.FileOracle\nimport edu"
},
{
"path": "oqa-core/src/main/scala/edu/knowitall/learning/QueryTupleSimilarity.scala",
"chars": 3056,
"preview": "package edu.knowitall.learning\n\nimport edu.knowitall.execution.ConjunctiveQuery\nimport edu.knowitall.execution.Tuple\nimp"
},
{
"path": "oqa-core/src/main/scala/edu/knowitall/learning/SparseVector.scala",
"chars": 3740,
"preview": "package edu.knowitall.learning\n\nimport scala.io.Source\nimport java.io.PrintWriter\nimport scala.language.implicitConversi"
},
{
"path": "oqa-core/src/main/scala/edu/knowitall/lm/LanguageModel.scala",
"chars": 3361,
"preview": "package edu.knowitall.lm\n\nimport java.net.URL\nimport java.net.URI\nimport java.net.URLEncoder\nimport scalaj.http.Http\nimp"
},
{
"path": "oqa-core/src/main/scala/edu/knowitall/model/Derivation.scala",
"chars": 1634,
"preview": "package edu.knowitall.model\n\nimport edu.knowitall.search.qa.AnswerState\nimport edu.knowitall.search.qa.QuestionState\nimp"
},
{
"path": "oqa-core/src/main/scala/edu/knowitall/model/QaModel.scala",
"chars": 2857,
"preview": "package edu.knowitall.model\n\nimport edu.knowitall.search.qa.QaStep\nimport edu.knowitall.search.qa.QaState\nimport edu.kno"
},
{
"path": "oqa-core/src/main/scala/edu/knowitall/paraphrasing/Paraphrase.scala",
"chars": 476,
"preview": "package edu.knowitall.paraphrasing\n\nabstract class Paraphrase private () {\n def source: String\n def target: String\n d"
},
{
"path": "oqa-core/src/main/scala/edu/knowitall/paraphrasing/ParaphraseDerivation.scala",
"chars": 362,
"preview": "package edu.knowitall.paraphrasing\n\nimport com.typesafe.config.ConfigFactory\n\ntrait ParaphraseDerivation\n\ntrait ScoredPa"
},
{
"path": "oqa-core/src/main/scala/edu/knowitall/paraphrasing/Paraphraser.scala",
"chars": 425,
"preview": "package edu.knowitall.paraphrasing\n\n\ntrait Paraphraser {\n def paraphrase(s: String): List[Paraphrase]\n def paraphraseT"
},
{
"path": "oqa-core/src/main/scala/edu/knowitall/paraphrasing/rules/ParaphraseRule.scala",
"chars": 1524,
"preview": "package edu.knowitall.paraphrasing.rules\n\nimport edu.knowitall.parsing.cg.SentencePattern\nimport edu.knowitall.execution"
},
{
"path": "oqa-core/src/main/scala/edu/knowitall/paraphrasing/rules/ParaphraseRuleSet.scala",
"chars": 992,
"preview": "package edu.knowitall.paraphrasing.rules\n\nimport edu.knowitall.repr.sentence.Sentence\nimport edu.knowitall.repr.sentence"
},
{
"path": "oqa-core/src/main/scala/edu/knowitall/paraphrasing/template/LmParaphraseScorer.scala",
"chars": 554,
"preview": "package edu.knowitall.paraphrasing.template\n\nimport edu.knowitall.lm.KenLmServer\nimport edu.knowitall.paraphrasing.Score"
},
{
"path": "oqa-core/src/main/scala/edu/knowitall/paraphrasing/template/ParaphraseScorer.scala",
"chars": 240,
"preview": "package edu.knowitall.paraphrasing.template\n\nimport edu.knowitall.paraphrasing.ScoredParaphraseDerivation\n\ntrait Paraphr"
},
{
"path": "oqa-core/src/main/scala/edu/knowitall/paraphrasing/template/PmiLmParaphraseScorer.scala",
"chars": 679,
"preview": "package edu.knowitall.paraphrasing.template\n\nimport edu.knowitall.tool.tokenize.ClearTokenizer\nimport edu.knowitall.tool"
},
{
"path": "oqa-core/src/main/scala/edu/knowitall/paraphrasing/template/PmiParaphraseScorer.scala",
"chars": 494,
"preview": "package edu.knowitall.paraphrasing.template\n\nimport edu.knowitall.lm.KenLmServer\n\nclass PmiParaphraseScorer() extends Pa"
},
{
"path": "oqa-core/src/main/scala/edu/knowitall/paraphrasing/template/Template.scala",
"chars": 3033,
"preview": "package edu.knowitall.paraphrasing.template\n\nimport edu.knowitall.tool.stem.Lemmatized\nimport edu.knowitall.tool.chunk.C"
},
{
"path": "oqa-core/src/main/scala/edu/knowitall/paraphrasing/template/TemplateIndexer.scala",
"chars": 4551,
"preview": "package edu.knowitall.paraphrasing.template\nimport scala.io.Source\nimport scala.collection.JavaConversions._\nimport org."
},
{
"path": "oqa-core/src/main/scala/edu/knowitall/paraphrasing/template/TemplateParaphraseGenerator.scala",
"chars": 2843,
"preview": "package edu.knowitall.paraphrasing.template\nimport edu.knowitall.collection.immutable.Interval\nimport com.typesafe.confi"
},
{
"path": "oqa-core/src/main/scala/edu/knowitall/paraphrasing/template/TemplateParaphraser.scala",
"chars": 1858,
"preview": "package edu.knowitall.paraphrasing.template\n\nimport edu.knowitall.paraphrasing.Paraphraser\nimport edu.knowitall.tool.pos"
},
{
"path": "oqa-core/src/main/scala/edu/knowitall/parsing/cg/CKY.scala",
"chars": 3393,
"preview": "package edu.knowitall.parsing.cg\n\nimport edu.knowitall.repr.sentence.Sentence\nimport edu.knowitall.repr.sentence.Lemmati"
},
{
"path": "oqa-core/src/main/scala/edu/knowitall/parsing/cg/Categories.scala",
"chars": 2840,
"preview": "package edu.knowitall.parsing.cg\n\nimport edu.knowitall.execution.TLiteral\nimport edu.knowitall.execution.TVariable\nimpor"
},
{
"path": "oqa-core/src/main/scala/edu/knowitall/parsing/cg/CategoryPattern.scala",
"chars": 3064,
"preview": "package edu.knowitall.parsing.cg\n\nimport edu.knowitall.execution.TVariable\nimport edu.knowitall.execution.ListConjunctiv"
},
{
"path": "oqa-core/src/main/scala/edu/knowitall/parsing/cg/CgParser.scala",
"chars": 3259,
"preview": "package edu.knowitall.parsing.cg\n\nimport com.typesafe.config.ConfigFactory\nimport java.io.FileInputStream\nimport java.io"
},
{
"path": "oqa-core/src/main/scala/edu/knowitall/parsing/cg/Combinators.scala",
"chars": 1819,
"preview": "package edu.knowitall.parsing.cg\n\nimport edu.knowitall.execution.ListConjunctiveQuery\nimport edu.knowitall.execution.Unq"
},
{
"path": "oqa-core/src/main/scala/edu/knowitall/parsing/cg/LexicalRule.scala",
"chars": 1712,
"preview": "package edu.knowitall.parsing.cg\n\nimport edu.knowitall.repr.sentence.Lemmatized\nimport edu.knowitall.repr.sentence.Chunk"
},
{
"path": "oqa-core/src/main/scala/edu/knowitall/parsing/cg/LexiconPreprocessor.scala",
"chars": 1974,
"preview": "package edu.knowitall.parsing.cg\n\nimport com.typesafe.config.ConfigFactory\nimport scala.io.Source\nimport edu.knowitall.u"
},
{
"path": "oqa-core/src/main/scala/edu/knowitall/parsing/cg/ParserFieldFilter.scala",
"chars": 1769,
"preview": "package edu.knowitall.parsing.cg\n\nimport edu.knowitall.execution.Search\nimport edu.knowitall.execution.TLiteral\nimport j"
},
{
"path": "oqa-core/src/main/scala/edu/knowitall/parsing/cg/PatternExtractor.scala",
"chars": 1174,
"preview": "package edu.knowitall.parsing.cg\n\nimport edu.knowitall.taggers.tag.PatternTagger\nimport edu.knowitall.repr.sentence.Lemm"
},
{
"path": "oqa-core/src/main/scala/edu/knowitall/parsing/cg/SentencePattern.scala",
"chars": 1401,
"preview": "package edu.knowitall.parsing.cg\n\nimport edu.knowitall.taggers.pattern.PatternBuilder\nimport edu.knowitall.repr.sentence"
},
{
"path": "oqa-core/src/main/scala/edu/knowitall/relsyn/IsaRelSynClient.scala",
"chars": 329,
"preview": "package edu.knowitall.relsyn\n\nimport edu.knowitall.util.ResourceUtils\nimport edu.knowitall.execution.TConjunct\n\nobject I"
},
{
"path": "oqa-core/src/main/scala/edu/knowitall/relsyn/ListRelSynClient.scala",
"chars": 792,
"preview": "package edu.knowitall.relsyn\n\nimport scala.io.Source\nimport java.io.InputStream\nimport edu.knowitall.execution.TConjunct"
},
{
"path": "oqa-core/src/main/scala/edu/knowitall/relsyn/RelSynClient.scala",
"chars": 140,
"preview": "package edu.knowitall.relsyn\n\nimport edu.knowitall.execution.TConjunct\n\ntrait RelSynClient {\n def relSyns(c: TConjunct)"
},
{
"path": "oqa-core/src/main/scala/edu/knowitall/relsyn/RelSynRule.scala",
"chars": 1751,
"preview": "package edu.knowitall.relsyn\n\nimport edu.knowitall.execution.TConjunct\nimport edu.knowitall.execution.Search\nimport edu."
},
{
"path": "oqa-core/src/main/scala/edu/knowitall/relsyn/SolrRelSynClient.scala",
"chars": 4614,
"preview": "package edu.knowitall.relsyn\n\nimport com.typesafe.config.ConfigFactory\nimport org.apache.solr.client.solrj.impl.HttpSolr"
},
{
"path": "oqa-core/src/main/scala/edu/knowitall/search/Beam.scala",
"chars": 1979,
"preview": "package edu.knowitall.search\n\ntrait Beam[State, Action] {\n def nodes: Iterable[Node[State, Action]]\n def splitAt(k: In"
},
{
"path": "oqa-core/src/main/scala/edu/knowitall/search/BeamSearch.scala",
"chars": 1965,
"preview": "package edu.knowitall.search\n\nimport scala.collection.mutable.{Set => MutableSet}\nimport scala.collection.mutable.{Map ="
},
{
"path": "oqa-core/src/main/scala/edu/knowitall/search/BestFirstSearch.scala",
"chars": 994,
"preview": "package edu.knowitall.search\n\nimport scala.collection.mutable.{Set => MutableSet}\nimport scala.collection.mutable.{Map ="
},
{
"path": "oqa-core/src/main/scala/edu/knowitall/search/SearchAlgorithm.scala",
"chars": 2875,
"preview": "package edu.knowitall.search\n\nimport org.slf4j.LoggerFactory\nimport scala.collection.mutable.{Map => MutableMap}\nimport "
},
{
"path": "oqa-core/src/main/scala/edu/knowitall/search/SearchProblem.scala",
"chars": 239,
"preview": "package edu.knowitall.search\n\ntrait SearchProblem[State, Action] {\n def initialState: State\n def successors(s: State):"
},
{
"path": "oqa-core/src/main/scala/edu/knowitall/search/Transition.scala",
"chars": 396,
"preview": "package edu.knowitall.search\n\ntrait Transition[State, Action] extends Function[State, Iterable[(Action, State)]] {\n def"
},
{
"path": "oqa-core/src/main/scala/edu/knowitall/search/qa/AbstractArgTransition.scala",
"chars": 2932,
"preview": "package edu.knowitall.search.qa\n\nimport edu.knowitall.tool.tokenize.Tokenizer\nimport com.typesafe.config.ConfigFactory\ni"
},
{
"path": "oqa-core/src/main/scala/edu/knowitall/search/qa/AbstractedArgState.scala",
"chars": 1055,
"preview": "package edu.knowitall.search.qa\n\nimport edu.knowitall.collection.immutable.Interval\nimport edu.knowitall.repr.sentence.L"
},
{
"path": "oqa-core/src/main/scala/edu/knowitall/search/qa/AnswerState.scala",
"chars": 207,
"preview": "package edu.knowitall.search.qa\n\nimport edu.knowitall.execution.ExecTuple\n\ncase class AnswerState(answer: String) extend"
},
{
"path": "oqa-core/src/main/scala/edu/knowitall/search/qa/CgParseTransition.scala",
"chars": 644,
"preview": "package edu.knowitall.search.qa\n\nimport edu.knowitall.parsing.cg.CgParser\nimport edu.knowitall.search.Transition\n\ncase c"
},
{
"path": "oqa-core/src/main/scala/edu/knowitall/search/qa/DropQueryStopsTransition.scala",
"chars": 1706,
"preview": "package edu.knowitall.search.qa\n\nimport edu.knowitall.search.Transition\nimport org.slf4j.LoggerFactory\nimport edu.knowit"
},
{
"path": "oqa-core/src/main/scala/edu/knowitall/search/qa/ExecutionTransition.scala",
"chars": 1885,
"preview": "package edu.knowitall.search.qa\n\nimport edu.knowitall.search.Transition\nimport edu.knowitall.triplestore.TriplestoreClie"
},
{
"path": "oqa-core/src/main/scala/edu/knowitall/search/qa/ParaphraseRuleTransition.scala",
"chars": 559,
"preview": "package edu.knowitall.search.qa\n\nimport edu.knowitall.paraphrasing.rules.ParaphraseRuleSet\nimport edu.knowitall.search.T"
},
{
"path": "oqa-core/src/main/scala/edu/knowitall/search/qa/ProjectionTransition.scala",
"chars": 385,
"preview": "package edu.knowitall.search.qa\n\nimport edu.knowitall.search.Transition\n\nclass ProjectionTransition extends Transition[Q"
},
{
"path": "oqa-core/src/main/scala/edu/knowitall/search/qa/QaAction.scala",
"chars": 47,
"preview": "package edu.knowitall.search.qa\n\ntrait QaAction"
},
{
"path": "oqa-core/src/main/scala/edu/knowitall/search/qa/QaBeamSearch.scala",
"chars": 982,
"preview": "package edu.knowitall.search.qa\n\nimport com.typesafe.config.ConfigFactory\nimport edu.knowitall.search.SingleBeam\nimport "
},
{
"path": "oqa-core/src/main/scala/edu/knowitall/search/qa/QaCostModel.scala",
"chars": 875,
"preview": "package edu.knowitall.search.qa\n\nimport edu.knowitall.learning.SparseVector\nimport com.typesafe.config.ConfigFactory\nimp"
},
{
"path": "oqa-core/src/main/scala/edu/knowitall/search/qa/QaFeatures.scala",
"chars": 9026,
"preview": "package edu.knowitall.search.qa\nimport edu.knowitall.paraphrasing.template.TemplatePair\nimport edu.knowitall.execution.E"
},
{
"path": "oqa-core/src/main/scala/edu/knowitall/search/qa/QaLayeredSearch.scala",
"chars": 1252,
"preview": "package edu.knowitall.search.qa\n\nimport edu.knowitall.search.SearchAlgorithm\nimport com.google.common.collect.MinMaxPrio"
},
{
"path": "oqa-core/src/main/scala/edu/knowitall/search/qa/QaSearchProblem.scala",
"chars": 1296,
"preview": "package edu.knowitall.search.qa\n\nimport edu.knowitall.paraphrasing.template.TemplateParaphraser\nimport edu.knowitall.exe"
},
{
"path": "oqa-core/src/main/scala/edu/knowitall/search/qa/QaState.scala",
"chars": 74,
"preview": "package edu.knowitall.search.qa\n\ntrait QaState {\n def stateType: String\n}"
},
{
"path": "oqa-core/src/main/scala/edu/knowitall/search/qa/QaStateComparator.scala",
"chars": 515,
"preview": "package edu.knowitall.search.qa\n\nimport java.util.Comparator\n\nobject QaStateComparator extends Comparator[QaState] {\n d"
},
{
"path": "oqa-core/src/main/scala/edu/knowitall/search/qa/QaStep.scala",
"chars": 128,
"preview": "package edu.knowitall.search.qa\n\ncase class QaStep(question: String, fromState: QaState, action: QaAction,\n toState: "
},
{
"path": "oqa-core/src/main/scala/edu/knowitall/search/qa/QaTransitionModel.scala",
"chars": 2310,
"preview": "package edu.knowitall.search.qa\n\nimport edu.knowitall.tool.postag.StanfordPostagger\nimport edu.knowitall.tool.stem.Morph"
},
{
"path": "oqa-core/src/main/scala/edu/knowitall/search/qa/QueryState.scala",
"chars": 261,
"preview": "package edu.knowitall.search.qa\n\nimport edu.knowitall.execution.ConjunctiveQuery\n\ncase class QueryState(query: Conjuncti"
},
{
"path": "oqa-core/src/main/scala/edu/knowitall/search/qa/QuestionState.scala",
"chars": 841,
"preview": "package edu.knowitall.search.qa\n\nimport edu.knowitall.repr.sentence.Chunked\nimport edu.knowitall.repr.sentence.Lemmatize"
},
{
"path": "oqa-core/src/main/scala/edu/knowitall/search/qa/RelSynTransition.scala",
"chars": 1928,
"preview": "package edu.knowitall.search.qa\n\nimport edu.knowitall.relsyn.SolrRelSynClient\nimport edu.knowitall.search.Transition\nimp"
},
{
"path": "oqa-core/src/main/scala/edu/knowitall/search/qa/TemplateTransition.scala",
"chars": 1743,
"preview": "package edu.knowitall.search.qa\n\nimport edu.knowitall.search.Transition\nimport edu.knowitall.paraphrasing.template.Parap"
},
{
"path": "oqa-core/src/main/scala/edu/knowitall/search/qa/TupleFeatureTemplate.scala",
"chars": 2056,
"preview": "package edu.knowitall.search.qa\n\nimport edu.knowitall.execution.Tuple\nimport edu.knowitall.learning.SparseVector\nimport "
},
{
"path": "oqa-core/src/main/scala/edu/knowitall/search/qa/TupleState.scala",
"chars": 229,
"preview": "package edu.knowitall.search.qa\n\nimport edu.knowitall.execution.ExecTuple\n\ncase class TupleState(execTuple: ExecTuple) e"
},
{
"path": "oqa-core/src/main/scala/edu/knowitall/triplestore/IsaClient.scala",
"chars": 1482,
"preview": "package edu.knowitall.triplestore\n\nimport edu.knowitall.relsyn.IsaRelSynClient\nimport edu.knowitall.execution.ListConjun"
},
{
"path": "oqa-core/src/main/scala/edu/knowitall/triplestore/TriplestoreClient.scala",
"chars": 9570,
"preview": "package edu.knowitall.triplestore\nimport scala.collection.JavaConverters._\nimport org.apache.solr.client.solrj.impl.Http"
},
{
"path": "oqa-core/src/main/scala/edu/knowitall/util/AlignedWordProcessor.scala",
"chars": 5288,
"preview": "package edu.knowitall.util\n\nimport scala.collection.JavaConverters._\nimport edu.knowitall.common.Resource.using\n\nobject "
},
{
"path": "oqa-core/src/main/scala/edu/knowitall/util/Counter.scala",
"chars": 441,
"preview": "package edu.knowitall.util\nimport scala.collection.mutable\n\ncase class Counter(counts: mutable.Map[String, Double]) {\n "
},
{
"path": "oqa-core/src/main/scala/edu/knowitall/util/DummyChunker.scala",
"chars": 509,
"preview": "package edu.knowitall.util\n\nimport edu.knowitall.tool.postag.Postagger\nimport edu.knowitall.tool.chunk.Chunker\nimport ed"
},
{
"path": "oqa-core/src/main/scala/edu/knowitall/util/HadoopUtils.scala",
"chars": 280,
"preview": "package edu.knowitall.util\n\nobject HadoopUtils {\n \n \n \n def groupIterator[S, T](iter: Iterator[T], f: (T => S)): Ite"
},
{
"path": "oqa-core/src/main/scala/edu/knowitall/util/MathUtils.scala",
"chars": 878,
"preview": "package edu.knowitall.util\n\nimport org.slf4j.LoggerFactory\nimport edu.knowitall.collection.immutable.Interval\n\nobject Ma"
},
{
"path": "oqa-core/src/main/scala/edu/knowitall/util/NlpTools.scala",
"chars": 1248,
"preview": "package edu.knowitall.util\n\nimport edu.knowitall.tool.postag.StanfordPostagger\nimport edu.knowitall.tool.stem.MorphaStem"
},
{
"path": "oqa-core/src/main/scala/edu/knowitall/util/NlpUtils.scala",
"chars": 4953,
"preview": "package edu.knowitall.util\n\nimport edu.knowitall.tool.stem.Lemmatized\nimport edu.knowitall.repr.sentence.{Lemmatized => "
},
{
"path": "oqa-core/src/main/scala/edu/knowitall/util/PPDBParser.scala",
"chars": 651,
"preview": "package edu.knowitall.util\n\nobject PPDBParser extends App {\n\n val source = io.Source.fromFile(args(0), \"UTF8\")\n \n val"
},
{
"path": "oqa-core/src/main/scala/edu/knowitall/util/ResourceUtils.scala",
"chars": 420,
"preview": "package edu.knowitall.util\n\nimport java.io.InputStream\nimport scala.io.Source\n\nobject ResourceUtils {\n def resource(pat"
},
{
"path": "oqa-core/src/main/scala/edu/knowitall/util/StringUtils.scala",
"chars": 486,
"preview": "package edu.knowitall.util\n\nobject StringUtils {\n \n def parseDouble(s: String): Option[Double] = try { Some(s.toDouble"
},
{
"path": "oqa-core/src/main/scala/edu/knowitall/util/TimingUtils.scala",
"chars": 408,
"preview": "package edu.knowitall.util\n\nimport scala.actors.Futures\n\nobject TimingUtils {\n \n def time[R](block: => R): (Long, R) ="
},
{
"path": "oqa-core/src/main/scala/edu/knowitall/util/TuplePrinter.scala",
"chars": 760,
"preview": "package edu.knowitall.util\n\nimport edu.knowitall.execution.Tuple\n\nobject TuplePrinter {\n \n val fieldNames = Seq(\"arg1\""
},
{
"path": "oqa-core/src/main/scala/edu/knowitall/util/WikiAnswersSampler.scala",
"chars": 1397,
"preview": "package edu.knowitall.util\n\nimport edu.knowitall.common.Resource.using\nimport java.io.PrintStream\nimport scala.Array.can"
},
{
"path": "oqa-data/README.md",
"chars": 330,
"preview": "Data\n====\nTo download the data, run the following command:\n\n ./src/main/scripts/download-oqa-data.sh\n\nThis will downl"
},
{
"path": "oqa-data/predictions/README.md",
"chars": 464,
"preview": "# System Predictions\nThis directory contains the predictions made by each system during evaluation.\nEach file is a colle"
},
{
"path": "oqa-data/predictions/oqa-trec.txt",
"chars": 7922250,
"preview": "What was the official name of the Big Dig?\tThe Big Dig\t-1.4649652558726443\tWhat was the official name of the Big Dig? ->"
},
{
"path": "oqa-data/predictions/paralex-trec.txt",
"chars": 7724467,
"preview": "What does SIDS stand for?\tSimulated Interaction Device\t0.111111111111\tWhat does SIDS stand for? -> $x: (sids, stand for,"
},
{
"path": "oqa-data/predictions/sempre-trec.txt",
"chars": 357820,
"preview": "How many stores does Wal-Mart operate world-wide?\tSpreadsheet Upload about Nobel Prize in LIterature nominees 1934-1936\t"
},
{
"path": "oqa-data/predictions/sempre-webquestions.txt",
"chars": 1721183,
"preview": "what does jamaican people speak?\tChinese Jamaicans\t7.457\tformula (fb:people.ethnicity.languages_spoken fb:en.jamaican_cr"
},
{
"path": "oqa-data/predictions/sempre-wikianswers.txt",
"chars": 330853,
"preview": "What language was the olympic motto written in?\tThe Nature of This Paradigm Dancing\t-4.647\tformula (and (fb:type.object."
},
{
"path": "oqa-data/src/main/scripts/download-oqa-data.sh",
"chars": 986,
"preview": "#!/usr/bin/env bash\n# Bash3 Boilerplate. Copyright (c) 2014, kvz.io\n\nset -o errexit\nset -o pipefail\nset -o nounset\n# set"
},
{
"path": "oqa-lm/README.md",
"chars": 1946,
"preview": "Language Model\n==============\nOQA uses a language model for scoring during inference. It uses the\n[KenLM](https://kheafi"
},
{
"path": "oqa-lm/src/main/scripts/build-lm.sh",
"chars": 774,
"preview": "#!/usr/bin/env bash \n# Bash3 Boilerplate. Copyright (c) 2014"
},
{
"path": "oqa-lm/src/main/scripts/install-kenlm.sh",
"chars": 645,
"preview": "#!/usr/bin/env bash\n# Bash3 Boilerplate. Copyright (c) 2014, kvz.io\n\nset -o errexit\nset -o pipefail\nset -o nounset\n# set"
},
{
"path": "oqa-lm/src/main/scripts/server.py",
"chars": 1037,
"preview": "#!/usr/bin/env python\n # -*- coding: utf-8 -*-\nimport web\nimport sys\nimport kenlm\nimport json\nimport os\ndir = os.path.di"
},
{
"path": "oqa-lm/src/main/scripts/start.sh",
"chars": 395,
"preview": "#!/bin/bash\n#set -u\n#set -e\n__dir=\"$(cd \"$(dirname \"${BASH_SOURCE[0]}\")\" && pwd)\"\npath=\"${__dir}/../../../\"\nscript=\"${pa"
},
{
"path": "oqa-lm/src/main/scripts/stop.sh",
"chars": 383,
"preview": "#!/bin/bash \nset -u "
},
{
"path": "oqa-solr/README.md",
"chars": 2039,
"preview": "OQA Solr Components\n===================\nOQA uses [Apache Solr](http://lucene.apache.org/solr/) for storing, indexing,\nan"
},
{
"path": "oqa-solr/paraphrase/README.txt",
"chars": 2992,
"preview": "# Licensed to the Apache Software Foundation (ASF) under one or more\n# contributor license agreements. See the NOTICE f"
},
{
"path": "oqa-solr/paraphrase/cloud-scripts/zkcli.bat",
"chars": 312,
"preview": "REM You can override pass the following parameters to this script:\r\nREM \r\n\r\nset JVM=java\r\n\r\nREM Find location of this s"
},
{
"path": "oqa-solr/paraphrase/cloud-scripts/zkcli.sh",
"chars": 279,
"preview": "#!/usr/bin/env bash\n\n# You can override pass the following parameters to this script:\n# \n\nJVM=\"java\"\n\n# Find location of"
},
{
"path": "oqa-solr/paraphrase/contexts/solr-jetty-context.xml",
"chars": 537,
"preview": "<?xml version=\"1.0\"?>\n<!DOCTYPE Configure PUBLIC \"-//Jetty//Configure//EN\" \"http://www.eclipse.org/jetty/configure.dtd\">"
},
{
"path": "oqa-solr/paraphrase/etc/create-solrtest.keystore.sh",
"chars": 1571,
"preview": "#!/bin/bash -ex\n\n# Licensed to the Apache Software Foundation (ASF) under one or more\n# contributor license agreements. "
},
{
"path": "oqa-solr/paraphrase/etc/jetty.xml",
"chars": 8430,
"preview": "<?xml version=\"1.0\"?>\n<!DOCTYPE Configure PUBLIC \"-//Jetty//Configure//EN\" \"http://www.eclipse.org/jetty/configure.dtd\">"
},
{
"path": "oqa-solr/paraphrase/etc/logging.properties",
"chars": 1482,
"preview": "#\n# Licensed to the Apache Software Foundation (ASF) under one or more\n# contributor license agreements. See the NOTICE"
},
{
"path": "oqa-solr/paraphrase/etc/webdefault.xml",
"chars": 24426,
"preview": "<?xml version=\"1.0\" encoding=\"ISO-8859-1\"?>\n\n <!-- ===================================================================="
},
{
"path": "oqa-solr/paraphrase/example-DIH/README.txt",
"chars": 1829,
"preview": "# Licensed to the Apache Software Foundation (ASF) under one or more\n# contributor license agreements. See the NOTICE f"
},
{
"path": "oqa-solr/paraphrase/example-DIH/hsqldb/ex.log",
"chars": 40,
"preview": "/*C1*/SET SCHEMA PUBLIC\nCONNECT USER SA\n"
},
{
"path": "oqa-solr/paraphrase/example-DIH/hsqldb/ex.properties",
"chars": 419,
"preview": "#HSQL Database Engine 1.8.0.5\n#Fri Aug 29 10:24:33 IST 2008\nhsqldb.script_format=0\nruntime.gc_interval=0\nsql.enforce_str"
},
{
"path": "oqa-solr/paraphrase/example-DIH/hsqldb/ex.script",
"chars": 723,
"preview": "CREATE SCHEMA PUBLIC AUTHORIZATION DBA\nCREATE CACHED TABLE ITEM(ID CHAR(8),NAME VARCHAR(100),MANU VARCHAR(50),WEIGHT REA"
},
{
"path": "oqa-solr/paraphrase/example-DIH/solr/db/conf/admin-extra.html",
"chars": 1094,
"preview": "<!--\n Licensed to the Apache Software Foundation (ASF) under one or more\n contributor license agreements. See the NOTIC"
},
{
"path": "oqa-solr/paraphrase/example-DIH/solr/db/conf/admin-extra.menu-bottom.html",
"chars": 38,
"preview": "<!-- admin-extra.menu-bottom.html -->\n"
},
{
"path": "oqa-solr/paraphrase/example-DIH/solr/db/conf/admin-extra.menu-top.html",
"chars": 35,
"preview": "<!-- admin-extra.menu-top.html -->\n"
},
{
"path": "oqa-solr/paraphrase/example-DIH/solr/db/conf/db-data-config.xml",
"chars": 1678,
"preview": "<dataConfig>\n <dataSource driver=\"org.hsqldb.jdbcDriver\" url=\"jdbc:hsqldb:./example-DIH/hsqldb/ex\" user=\"sa\" />\n <"
},
{
"path": "oqa-solr/paraphrase/example-DIH/solr/db/conf/elevate.xml",
"chars": 1274,
"preview": "<?xml version=\"1.0\" encoding=\"UTF-8\" ?>\n<!--\n Licensed to the Apache Software Foundation (ASF) under one or more\n contri"
},
{
"path": "oqa-solr/paraphrase/example-DIH/solr/db/conf/protwords.txt",
"chars": 873,
"preview": "# The ASF licenses this file to You under the Apache License, Version 2.0\n# (the \"License\"); you may not use this file e"
},
{
"path": "oqa-solr/paraphrase/example-DIH/solr/db/conf/schema.xml",
"chars": 18359,
"preview": "<?xml version=\"1.0\" encoding=\"UTF-8\" ?>\n<!--\n Licensed to the Apache Software Foundation (ASF) under one or more\n contri"
},
{
"path": "oqa-solr/paraphrase/example-DIH/solr/db/conf/scripts.conf",
"chars": 921,
"preview": "# Licensed to the Apache Software Foundation (ASF) under one or more\n# contributor license agreements. See the NOTICE f"
},
{
"path": "oqa-solr/paraphrase/example-DIH/solr/db/conf/solrconfig.xml",
"chars": 22121,
"preview": "<?xml version=\"1.0\" encoding=\"UTF-8\" ?>\n<!--\n Licensed to the Apache Software Foundation (ASF) under one or more\n contri"
},
{
"path": "oqa-solr/paraphrase/example-DIH/solr/db/conf/stopwords.txt",
"chars": 1171,
"preview": "# Licensed to the Apache Software Foundation (ASF) under one or more\n# contributor license agreements. See the NOTICE f"
},
{
"path": "oqa-solr/paraphrase/example-DIH/solr/db/conf/synonyms.txt",
"chars": 1132,
"preview": "# The ASF licenses this file to You under the Apache License, Version 2.0\n# (the \"License\"); you may not use this file e"
},
{
"path": "oqa-solr/paraphrase/example-DIH/solr/db/conf/xslt/example.xsl",
"chars": 4155,
"preview": "<?xml version='1.0' encoding='UTF-8'?>\n\n<!-- \n * Licensed to the Apache Software Foundation (ASF) under one or more\n * c"
},
{
"path": "oqa-solr/paraphrase/example-DIH/solr/db/conf/xslt/example_atom.xsl",
"chars": 2465,
"preview": "<?xml version='1.0' encoding='UTF-8'?>\n\n<!-- \n * Licensed to the Apache Software Foundation (ASF) under one or more\n * c"
},
{
"path": "oqa-solr/paraphrase/example-DIH/solr/db/conf/xslt/example_rss.xsl",
"chars": 2244,
"preview": "<?xml version='1.0' encoding='UTF-8'?>\n\n<!-- \n * Licensed to the Apache Software Foundation (ASF) under one or more\n * c"
},
{
"path": "oqa-solr/paraphrase/example-DIH/solr/db/conf/xslt/luke.xsl",
"chars": 14862,
"preview": "<?xml version=\"1.0\" encoding=\"UTF-8\"?>\n<!--\n Licensed to the Apache Software Foundation (ASF) under one or more\n c"
},
{
"path": "oqa-solr/paraphrase/example-DIH/solr/mail/conf/admin-extra.html",
"chars": 1094,
"preview": "<!--\n Licensed to the Apache Software Foundation (ASF) under one or more\n contributor license agreements. See the NOTIC"
},
{
"path": "oqa-solr/paraphrase/example-DIH/solr/mail/conf/admin-extra.menu-bottom.html",
"chars": 38,
"preview": "<!-- admin-extra.menu-bottom.html -->\n"
},
{
"path": "oqa-solr/paraphrase/example-DIH/solr/mail/conf/admin-extra.menu-top.html",
"chars": 35,
"preview": "<!-- admin-extra.menu-top.html -->\n"
},
{
"path": "oqa-solr/paraphrase/example-DIH/solr/mail/conf/data-config.xml",
"chars": 517,
"preview": "<dataConfig>\n <document>\n <!--\n Note - In order to index attachments, set processAttachement=\"true\" and dro"
},
{
"path": "oqa-solr/paraphrase/example-DIH/solr/mail/conf/protwords.txt",
"chars": 873,
"preview": "# The ASF licenses this file to You under the Apache License, Version 2.0\n# (the \"License\"); you may not use this file e"
},
{
"path": "oqa-solr/paraphrase/example-DIH/solr/mail/conf/schema.xml",
"chars": 19465,
"preview": "<?xml version=\"1.0\" encoding=\"UTF-8\" ?>\n<!--\n Licensed to the Apache Software Foundation (ASF) under one or more\n contri"
},
{
"path": "oqa-solr/paraphrase/example-DIH/solr/mail/conf/solrconfig.xml",
"chars": 30266,
"preview": "<?xml version=\"1.0\" encoding=\"UTF-8\" ?>\n<!--\n Licensed to the Apache Software Foundation (ASF) under one or more\n contri"
},
{
"path": "oqa-solr/paraphrase/example-DIH/solr/mail/conf/stopwords.txt",
"chars": 1171,
"preview": "# Licensed to the Apache Software Foundation (ASF) under one or more\n# contributor license agreements. See the NOTICE f"
},
{
"path": "oqa-solr/paraphrase/example-DIH/solr/mail/conf/synonyms.txt",
"chars": 1132,
"preview": "# The ASF licenses this file to You under the Apache License, Version 2.0\n# (the \"License\"); you may not use this file e"
},
{
"path": "oqa-solr/paraphrase/example-DIH/solr/rss/conf/admin-extra.html",
"chars": 1094,
"preview": "<!--\n Licensed to the Apache Software Foundation (ASF) under one or more\n contributor license agreements. See the NOTIC"
},
{
"path": "oqa-solr/paraphrase/example-DIH/solr/rss/conf/admin-extra.menu-bottom.html",
"chars": 38,
"preview": "<!-- admin-extra.menu-bottom.html -->\n"
},
{
"path": "oqa-solr/paraphrase/example-DIH/solr/rss/conf/admin-extra.menu-top.html",
"chars": 35,
"preview": "<!-- admin-extra.menu-top.html -->\n"
},
{
"path": "oqa-solr/paraphrase/example-DIH/solr/rss/conf/elevate.xml",
"chars": 1274,
"preview": "<?xml version=\"1.0\" encoding=\"UTF-8\" ?>\n<!--\n Licensed to the Apache Software Foundation (ASF) under one or more\n contri"
},
{
"path": "oqa-solr/paraphrase/example-DIH/solr/rss/conf/protwords.txt",
"chars": 873,
"preview": "# The ASF licenses this file to You under the Apache License, Version 2.0\n# (the \"License\"); you may not use this file e"
},
{
"path": "oqa-solr/paraphrase/example-DIH/solr/rss/conf/rss-data-config.xml",
"chars": 1306,
"preview": "<dataConfig>\n <dataSource type=\"URLDataSource\" />\n <document>\n <entity name=\"slashdot\"\n pk=\""
},
{
"path": "oqa-solr/paraphrase/example-DIH/solr/rss/conf/schema.xml",
"chars": 16947,
"preview": "<?xml version=\"1.0\" encoding=\"UTF-8\" ?>\n<!--\n Licensed to the Apache Software Foundation (ASF) under one or more\n contri"
},
{
"path": "oqa-solr/paraphrase/example-DIH/solr/rss/conf/scripts.conf",
"chars": 921,
"preview": "# Licensed to the Apache Software Foundation (ASF) under one or more\n# contributor license agreements. See the NOTICE f"
},
{
"path": "oqa-solr/paraphrase/example-DIH/solr/rss/conf/solrconfig.xml",
"chars": 22130,
"preview": "<?xml version=\"1.0\" encoding=\"UTF-8\" ?>\n<!--\n Licensed to the Apache Software Foundation (ASF) under one or more\n contri"
},
{
"path": "oqa-solr/paraphrase/example-DIH/solr/rss/conf/stopwords.txt",
"chars": 1171,
"preview": "# Licensed to the Apache Software Foundation (ASF) under one or more\n# contributor license agreements. See the NOTICE f"
},
{
"path": "oqa-solr/paraphrase/example-DIH/solr/rss/conf/synonyms.txt",
"chars": 1132,
"preview": "# The ASF licenses this file to You under the Apache License, Version 2.0\n# (the \"License\"); you may not use this file e"
},
{
"path": "oqa-solr/paraphrase/example-DIH/solr/solr/conf/admin-extra.html",
"chars": 1094,
"preview": "<!--\n Licensed to the Apache Software Foundation (ASF) under one or more\n contributor license agreements. See the NOTIC"
},
{
"path": "oqa-solr/paraphrase/example-DIH/solr/solr/conf/admin-extra.menu-bottom.html",
"chars": 38,
"preview": "<!-- admin-extra.menu-bottom.html -->\n"
},
{
"path": "oqa-solr/paraphrase/example-DIH/solr/solr/conf/admin-extra.menu-top.html",
"chars": 35,
"preview": "<!-- admin-extra.menu-top.html -->\n"
},
{
"path": "oqa-solr/paraphrase/example-DIH/solr/solr/conf/elevate.xml",
"chars": 1274,
"preview": "<?xml version=\"1.0\" encoding=\"UTF-8\" ?>\n<!--\n Licensed to the Apache Software Foundation (ASF) under one or more\n contri"
},
{
"path": "oqa-solr/paraphrase/example-DIH/solr/solr/conf/protwords.txt",
"chars": 873,
"preview": "# The ASF licenses this file to You under the Apache License, Version 2.0\n# (the \"License\"); you may not use this file e"
},
{
"path": "oqa-solr/paraphrase/example-DIH/solr/solr/conf/schema.xml",
"chars": 18361,
"preview": "<?xml version=\"1.0\" encoding=\"UTF-8\" ?>\n<!--\n Licensed to the Apache Software Foundation (ASF) under one or more\n contri"
},
{
"path": "oqa-solr/paraphrase/example-DIH/solr/solr/conf/scripts.conf",
"chars": 921,
"preview": "# Licensed to the Apache Software Foundation (ASF) under one or more\n# contributor license agreements. See the NOTICE f"
},
{
"path": "oqa-solr/paraphrase/example-DIH/solr/solr/conf/solr-data-config.xml",
"chars": 951,
"preview": "<!--\n Licensed to the Apache Software Foundation (ASF) under one or more\n contributor license agreements. See the NOT"
},
{
"path": "oqa-solr/paraphrase/example-DIH/solr/solr/conf/solrconfig.xml",
"chars": 22115,
"preview": "<?xml version=\"1.0\" encoding=\"UTF-8\" ?>\n<!--\n Licensed to the Apache Software Foundation (ASF) under one or more\n contri"
},
{
"path": "oqa-solr/paraphrase/example-DIH/solr/solr/conf/stopwords.txt",
"chars": 1171,
"preview": "# Licensed to the Apache Software Foundation (ASF) under one or more\n# contributor license agreements. See the NOTICE f"
},
{
"path": "oqa-solr/paraphrase/example-DIH/solr/solr/conf/synonyms.txt",
"chars": 1132,
"preview": "# The ASF licenses this file to You under the Apache License, Version 2.0\n# (the \"License\"); you may not use this file e"
},
{
"path": "oqa-solr/paraphrase/example-DIH/solr/solr.xml",
"chars": 493,
"preview": "<?xml version=\"1.0\" encoding=\"UTF-8\" standalone=\"yes\"?>\n<solr sharedLib=\"lib\" persistent=\"true\">\n\t<cores adminPath=\"/adm"
},
{
"path": "oqa-solr/paraphrase/example-DIH/solr/tika/conf/admin-extra.html",
"chars": 1094,
"preview": "<!--\n Licensed to the Apache Software Foundation (ASF) under one or more\n contributor license agreements. See the NOTIC"
},
{
"path": "oqa-solr/paraphrase/example-DIH/solr/tika/conf/admin-extra.menu-bottom.html",
"chars": 38,
"preview": "<!-- admin-extra.menu-bottom.html -->\n"
},
{
"path": "oqa-solr/paraphrase/example-DIH/solr/tika/conf/admin-extra.menu-top.html",
"chars": 35,
"preview": "<!-- admin-extra.menu-top.html -->\n"
},
{
"path": "oqa-solr/paraphrase/example-DIH/solr/tika/conf/schema.xml",
"chars": 10455,
"preview": "<?xml version=\"1.0\" encoding=\"UTF-8\" ?>\n<!--\n Licensed to the Apache Software Foundation (ASF) under one or more\n contri"
},
{
"path": "oqa-solr/paraphrase/example-DIH/solr/tika/conf/solrconfig.xml",
"chars": 15197,
"preview": "<?xml version=\"1.0\" encoding=\"UTF-8\" ?>\n<!--\n Licensed to the Apache Software Foundation (ASF) under one or more\n contri"
},
{
"path": "oqa-solr/paraphrase/example-DIH/solr/tika/conf/tika-data-config.xml",
"chars": 467,
"preview": "<dataConfig>\n <dataSource type=\"BinFileDataSource\" />\n <document>\n <entity name=\"tika-test\" processor=\"Tika"
},
{
"path": "oqa-solr/paraphrase/exampledocs/books.csv",
"chars": 959,
"preview": "id,cat,name,price,inStock,author,series_t,sequence_i,genre_s\n0553573403,book,A Game of Thrones,7.99,true,George R.R. Mar"
},
{
"path": "oqa-solr/paraphrase/exampledocs/books.json",
"chars": 1148,
"preview": "[\n {\n \"id\" : \"978-0641723445\",\n \"cat\" : [\"book\",\"hardcover\"],\n \"name\" : \"The Lightning Thief\",\n \"author\" : "
},
{
"path": "oqa-solr/paraphrase/exampledocs/gb18030-example.xml",
"chars": 1305,
"preview": "<?xml version=\"1.0\" encoding=\"GB18030\"?>\n<!--\n Licensed to the Apache Software Foundation (ASF) under one or more\n contr"
},
{
"path": "oqa-solr/paraphrase/exampledocs/hd.xml",
"chars": 2241,
"preview": "<!--\n Licensed to the Apache Software Foundation (ASF) under one or more\n contributor license agreements. See the NOTIC"
}
]
// ... and 865 more files (download for full content)
About this extraction
This page contains the full source code of the afader/oqa GitHub repository, extracted and formatted as plain text for AI agents and large language models (LLMs). The extraction includes 1065 files (249.1 MB), approximately 6.2M tokens, and a symbol index with 1365 extracted functions, classes, methods, constants, and types. Use this with OpenClaw, Claude, ChatGPT, Cursor, Windsurf, or any other AI tool that accepts text input. You can copy the full output to your clipboard or download it as a .txt file.
Extracted by GitExtract — free GitHub repo to text converter for AI. Built by Nikandr Surkov.