text
stringlengths 6.4k
846k
| label
int64 0
9
|
|---|---|
arXiv:1711.00549v4 [cs.CL] 2 Mar 2018
Just ASK:
Building an Architecture for Extensible Self-Service
Spoken Language Understanding
Anjishnu Kumar
Amazon.com
anjikum@amazon.com
Arpit Gupta
Amazon.com
arpgup@amazon.com
Julian Chan
Amazon.com
julichan@amazon.com
Sam Tucker
Amazon.com
samtuck@amazon.com
Bjorn Hoffmeister
Amazon.com
bjornh@amazon.com
Markus Dreyer
Amazon.com
mddreyer@amazon.com
Stanislav Peshterliev
Amazon.com
stanislp@amazon.com
Ariya Rastrow
Amazon.com
arastrow@amazon.com
Ankur Gandhe
Amazon.com
aggandhe@amazon.com
Christian Monson
Amazon.com
cmonson@amazon.com
Denis Filiminov
Amazon.com
denf@amazon.com
Agnika Kumar
Amazon.com
agnika@amazon.com
Abstract
This paper presents the design of the machine learning architecture that underlies
the Alexa Skills Kit (ASK) a large scale Spoken Language Understanding (SLU)
Software Development Kit (SDK) that enables developers to extend the capabilities of Amazon’s virtual assistant, Alexa. At Amazon, the infrastructure powers
over 25,000 skills deployed through the ASK, as well as AWS’s Amazon Lex SLU
Service. The ASK emphasizes flexibility, predictability and a rapid iteration cycle for third party developers. It imposes inductive biases that allow it to learn
robust SLU models from extremely small and sparse datasets and, in doing so, removes significant barriers to entry for software developers and dialogue systems
researchers.
1
Introduction
Amazon’s Alexa is a popular digital assistant that was not designed around a smart phone, but rather
as a service for ambient computing [1] in the home. Due to the intuitiveness of the Voice User
Interface (VUI), the demand from software engineering teams for voice controlled features far outstripped the pace at which the language experts designing Alexa’s SLU system could accommodate
them. Removing this dependency posed several challenges, the first was the need to build a self
service SLU architecture that could transform natural language queries into API calls, while ensuring that the architecture played well with Alexa’s existing user experience. This paper describes the
design and creation of this service.
The Alexa Skills Kit (ASK) was initially designed to empower internal Amazon developers to prototype new features independently of Alexa’s core Automatic Speech Recognition (ASR) and Natural
Language Understanding (NLU) systems, and then extended to give third-party developers the same
1
capabilities. In order to make Alexa a popular service for ambient computing, it was important
to enable external developers to build sophisticated experiences for Alexa similar to the common
operating systems of the smartphone era, Android and iOS.
An Alexa skill is an SLU subsystem that has two customized components corresponding to the SLU
stack - ASR and NLU. When the user speaks to a particular skill, the Alexa service handles the
conversion of speech into text, performs intent classification, and slot-filling according to a schema
defined by the skill developer. Besides writing the skill definition, the developer is also responsible
for creating a web service, which interacts with JSON requests sent by Alexa. Given the structured
request from Alexa, the developer’s web service can return text to be synthesized by Alexa’s textto-speech engine, an audio stream to be played back, with an optional graphical representation to be
displayed in case the Alexa endpoint supports the visual modality. Figure 1 illustrates the interaction
flow of a skill. A common practice for Alexa skill developers is to use a serverless endpoint such as
AWS’s Lambda product [2].
Figure 1: Interaction flow of an ASK skill
As of November 2017, there are over 25,000 Alexa Skills that have been built and deployed to
customers via ASK. The SLU architecture described in this paper is also at the foundation of the
Amazon Lex SLU service [3] and applications such as Amazon Connect, a hybrid human/AI customer service product which uses Amazon Lex to power virtual agents. In the year following the
launch of the ASK, competing SDKs following similar design principles have also been launched
by Google and Microsoft, namely Actions on Google and the Cortana Skills Kit.
ASK allows researchers to experiment on conversation and dialogue systems without the additional
overhead of maintaining their own ASR and NLU systems [4, 5, 6].
2
Related Work
Prior toolkits allowed users to build ASR and NLU models individually. For example, Kaldi [7]
and HTK [8] are popular toolkits for speech recognition. Stanford’s Core NLP [9] offers a suite
of NLP libraries. These toolkits allow a lot of flexibility to the developer. For example, CoreNLP
gives complete independence in selecting the libraries to use in the language understanding task.
Similarly, Kaldi offers pre-built recipes which can be used as is or modified according to need of
developer. However, this flexibility also poses challenges for the developer who is not well versed
with Speech and NLP literature and ML methodology. These toolkits did not provide speech and
language understanding capabilities in an open and self-service manner. At the other end of the
spectrum, standards such as VoiceXML have existed since the early 2000s. They support clearly
defined interfaces for software developers, but have supported only rigid command structures for
end users. The need to develop a set of portable tools to address domain specificity with small
datasets has long been considered a bottleneck for the large scale deployment of spoken language
technology [10].
In parallel to our work, SpeakToIt (now DialogFlow) launched Api.ai and Microsoft launched
LUIS.ai [11], both of which provided self-service SDKs to third party developers to voice enable
2
their applications in isolation. In our work, we attempt to close the gap by offering ASR and NLU
models that work together out of the box with limited training samples and do not require expertise in either field, as well as the capability to rapidly deploy these systems directly to a large and
growing audience by extending a widely available virtual assistant.
3
Design Considerations
As an SDK for a voice assistant, speech recognition and language understanding technologies are the
key value addition that Alexa can offer compared to existing frameworks. Since such a framework
had never been built for a large user base before, we had to look beyond the software design tenets
that were used to build largely monolithic high performance SLU systems in the past. Successful
modern software development frameworks such as Amazon Web Services, the Python programming
language, and Linux, have large developer communities and could provide relevant design tenets.
We describe some of these tenets below.
The system needs to offer modular and flexible building blocks. To enable maximum flexibility, we
chose to allow developers to specify commands they would want to support rather than limiting them
to a set of commands or intents designed by Amazon. We chose to implement decoupled, modular
subsystems that could be updated independently. We believe that decoupled systems are commonly
studied in software engineering, but remain an underexplored area in existing machine learning
research. In recent advances in deep learning research, there is a trend towards training complex
end-to-end (E2E) models directly from data, [12, 13, 14, 15]. These models offer improved performance and are sometimes easier to maintain by reducing the number of components as compared to
decomposed or cascaded architectures. However, joint modeling and end-to-end modeling can also
introduce dependencies between constituent systems, and make it harder to deploy improvements
independently [16].
A third party must not be allowed to degrade the first party user experience. The danger of customer
experience degradation was mitigated by sandboxing skills and allowing them to be used only once
enabled, either explicitly or implicitly. This design choice resulted in rapid adoption by developers
since they were no longer in direct competition with each other or with the first party system, but
made skill access more difficult for a customer by impairing the naturalness of the interaction.
The discoverable surface area for voice is limited, so the framework must prevent cybersquatting.
To prevent early developers from taking up valuable voice real-estate, a decision was made to allow
overlapping skill names, and allowing developers to choose any name of their choosing as long
as it does not reflect a brand protected by trademark or copyright which is not owned by them.
Namespace disambiguation would be performed by the user at enablement time. Other frameworks
chose to elect winners, by having a more rigorous vetting process and by awarding valuable real
estate to chosen vendors, which results in a more consistent user experience early on, but may limit
innovation in the long run.
The framework should allow fast iteration to support a rapid VUI development cycle. Since a skill
developer did not have any usage data while developing a skill, enabling a rapid iteration cycle
was important to enable them to quickly address issues. This requirement meant that SLU models
needed to be trained in minutes, not hours, and created a tradeoff with the demand for highly accurate
models.
The framework must remain relevant in the face of rapid advances in machine learning. Since the
system used machine learning extensively, the state of the art models implementing its underlying
ASR and NLU technologies were changing rapidly. The API contract thus had to be independent of
the our initial model choice. We chose a lightweight shallow semantic parsing formalism comprised
just of intents and slots. This formalism is analogous to an API call, the intent representing the
function and slots representing parameters to that function. The choice of this simple interface for
communicating between the language understanding system and software developers meant that the
underlying systems could be updated to use arbitrarily complex models and representations, which
could then be compiled back into the API call representation. Since model architectures become
outdated quickly, it was necessary to build up a repertoire of techniques that treat model choices
as black boxes, in order to enable the rapid deployment of new model architectures without having
cascading effects on other functionality.
3
Since a developer could only provide a limited number of samples, any model trained on these
utterances was unlikely to be of high quality. It thus became important to build components to
leverage transfer learning and low resource learning techniques while remaining primarily model
agnostic.
This can be done in several ways. Firstly, data-based transfer, that is, the curation of data resources that can be used generically. Secondly, representation-based transfer, the creation of a label
space that encapsulates prior knowledge about how different entities relate to each other. Thirdly,
feature-based transfer such as in [17, 18] or aided by unsupervised representation learning techniques [19, 20]. Investments in these transfer learning strategies are likely to remain relevant even
when the state of the art model architecture changes. Once gains from generic techniques start to
stagnate, it is imperative to invest in model-based transfer learning strategies that exploit the specific
characteristics of the machine-learning models being used [21, 22, 23, 24]. In order to develop and
deploy these strategies in a fast changing research landscape, it was critical to develop an infrastructure designed for the rapid deployment of research, we discuss these tradeoffs in subsequent
sections.
4
Customer Experience
Customers primarily interact with skills primarily in 3 different ways. Modal interactions are explicit
invocations where the customer first invokes a skill or service e.g. “Open Twitter” then issues a
command “Search for trending tweets”. One-shot invocation targets a skill or service and issues a
command simulatenously, for example, ”What is trending on twitter”.
Both the modal and one-shot invocation modalities are supported by a combination of deterministic
systems and statistical shallow parsing models. The one-shot modality is only available for the set
of skills a customer has enabled previously, in order to prevent unintended collisions. The explicit
launch functionality, for example “Open the Twitter skill” attempts to disambiguate skills and do an
implicit enablement if there is no ambiguity.
A recently launched third modality is skill suggestion. This allows for customers to be suggested
a skill and routed to it when they issue a command that cannot be serviced by Alexa’s first party
systems but can likely be handled by a skill. This can be done by performing statistical matching
between user utterances and relevant skills by using techniques derived from information retrieval
or using semantic matching performed by deep neural networks [25].
Once a skill is invoked, a skill context is established, effectively sandboxing the interaction and
preventing a customer from accessing any of Alexa’s native capabilities until the skill exits, either
gracefully after task completion or because the customer ceases to interact with the device.
5
BlueFlow: A Flexible Model Building Infrastructure
Our modeling infrastructure is developed using BlueFlow, a Python framework intended to accelerate the pace at which ML projects could be brought from research to production by using a shared
codebase. We developed an internal design paradigm called CLI-to-Server. The paradigm ensures
that every API call defined by BlueFlow is also executable locally via a programmatically generated
Command Line Interface (CLI) in order to ensure that it is possible to reproduce the production stack
during experimentation. Using autogenerated CLIs for the APIs adds an extra layer of abstraction
to the codebase but helps mitigate a common machine learning anti-pattern in which production
services and research tooling are implemented separately and go out of sync after a period of time.
BlueFlow is designed to enforce a clean separation between operational concerns and system logic
using the constructs of artifacts, components, activities and recipes. In a manner similar to some
open source deep learning libraries [26], BlueFlow uses python code constructs as a declarative
language to define a symbolic computational graph for data flow management. This computational
graph is a directed acyclic graph (DAG) and can be serialized, then optimized and executed by a
compatible executor locally or in a distributed manner. Refer to Appendix A for details on the
BlueFlow architecture and its syntax.
4
BlueFlow runs model building in production, but can also run it ad-hoc on a research cluster for
conducting experiments. Having both research and production services use the same system allows
us to quickly deploy new modeling techniques to production without spending significant time on
productizing throwaway research code. The use of Python allows for rapid experimentation and
a concise codebase, with an option to optimize bottlenecks in by using C++ bindings. However
Python’s type system increases reliance on unit test coverage. Along with the BlueFlow task execution framework, we extensively leverage technologies developed by AWS. All static artifacts needed
for a model build are stored in Amazon’s Simple Storage Service (S3) [27] and all artifacts that are
loaded at runtime are stored in Amazon’s highly performant key value store DynamoDB [28].
6
Skill Definition and Query Representation
To create a new skill for Alexa, a developer begins by defining an interaction model, which includes defining an intent schema, slot types, providing sample utterances corresponding to a simple
grammar, and an invocation phrase.
A wide variety of utilities exist to help developers define interaction model for an Alexa Skill, including but not limited to Skill Builder, a rich web interface with hints and completions and a testing
console; AWS’s Lex UI, which has an ‘export-as-skill’ option; and programmatic skill management
via the command-line using the Alexa Skill Management API - which also enables third party developers to start building skill development tooling.
ASK gives developers full freedom when defining a voice experience; however, a skill developer
cannot realistically be expected to provide large and representative data samples that reflect real
world usage. While this can be addressed in part by using transfer learning techniques, we also
directly expose concepts from Alexa’s internal domains in the form of builtin intents and builtin slot
types for the developer to pick and choose from.
Figure 2: An utterance represented in AlexaMRL
6.1
The Alexa Meaning Representation Language
In this section we briefly describe the Alexa Meaning Representation Language (AlexaMRL) [29],
which is necessary to understand builtin intents. The AlexaMRL is a decomposable semantic parsing
formalism for defining spoken language commands, which allows for concepts to be efficiently
reused across different SLU domains.
AlexaMRL is composed of Actions, Entities, and Properties. Actions are a higher order abstraction
than the intents that are typically used in natural language tasks, and can be viewed as a templating
system for intents. An Entity from the Alexa Ontology is analogous to a slot from an ASK developer’s perspective. Properties are completely transparent to a skill developer, but under the hood,
they tie Actions and Entities together by making certain Entity Types compatible with certain Ac5
tions. Entities possess Properties similar to object attributes in Object Oriented Programming. For
example, LocalBusiness is an Entity Type. It has Properties such as business hours, address, phone
number etc. Actions require Properties, i.e. they require for Entities to possess certain Properties in
order to be compatible, a CallAction cannot be completed unless it is operating on an Entity with a
Callable Property.
An intent represents an action the user wants to take. This could be searching or information, or
playing a media object. For example, a FindPlaceIntent intent would internally route to an API call
for a location search engine. The reason an Action is more abstract than an NLU intent is because an
intent needs to be aware of the surface forms (string representations) of the Entities it operates on,
but an Action does not. Instead, an Action operates on abstract interfaces that fulfill certain criteria.
For example, An AddAction requires an object Entity which can be added and a target Entity which
can be added to. This is specified using the required Properties of the Action. AddAction has a
required property targetCollection which identifies the type of list to add to and an object Property
that marks the type of the object to be added.
6.2
Exposing Query Representation to Skills
Thus developers have an option to compile builtin intents by filling an Action template with compatible Entity Types, which allows us to reuse data from Alexa’s ontology via AlexaMRL. The skills that
use compiled intents use shared deterministic models and efficiently reuse internal data resources
for their stochastic models. We will discuss statistical modeling in greater detail in Section 7.
Developers that choose to design their own intents with Alexa’s builtin slot types, instead of Action
templates, do not benefit from AlexaMRL’s ability to automatically derive semantic roles, and cannot
fully reuse shared deterministic models. In this case, only the shared data for an Entity Type can
be reused, and the semantic roles of the Entities in an utterance must be derived from developer
provided samples.
7
Statistical Modelling
In order for Alexa to turn user requests into structured representations, we need to build models
based on the developer’s definition for both the ASR and NLU systems. The first step to this process
is to efficiently represent the grammars provided by the developer.
7.1
Weighted Finite State Transducers
Weighted Finite-State Transducers (wFST) provide an easy way to represent data under a weighted
grammar. A path through the FST encodes an input string (or sequence) into output string. We
generate FSTs for both ASR and NLU. ASR uses a skill specific FST to decode utterances into
sentences defined by the developer, whereas NLU uses an FST to recognize intent and slot values.
Both can be generated from the developer-provided sample utterances, intents, and slots. Most of
the FST-generation code is shared between the ASR and NLU. Fig. 3 shows an FST that recognizes
the GetHoroscope intent along with its Date slot from an utterance.
This representation is powerful because we can impose arbitrary distributional priors on the grammar. We infer a distribution over intents and slots from the sample utterances. As the data in sample
utterances is often imbalanced, we follow the principle of maximum entropy to impose uniform priors over intents and then slots on the grammar. This is a configurable switch that can be turned off
when the wFST is generated from the usage pattern of a skill.
The weighted FST representation can be used directly by common sequence models designed to
work with text such as CRFs [30] and LSTMs [31] by sampling utterances according to the distributional priors and feeding them into the respective models as training data via a data recombination
technique similar to [32]. One can also train directly on the lattice itself [33].
7.2
Automatic Speech Recognition
The ASR system uses weighted finite-state transducers (WFST) to represent the Hidden Markov
Model (HMM) transducer (H), phone context-dependency transducer (C), pronunciation lexicon
6
Figure 3: wFST states are represented by circles and marked with their unique number. The input
label i, the output label o, and weight w of a transition are marked on the arcs.
(L), and word-level grammar (G). These FSTs are composed to form an end-to-end recognition
transducer. We refer the reader to Mohri et al. [34] for details on these transducers and their role in
ASR. The goal of the ASR recipe is to generate a word-level grammar (G) that guides the system
to recognize utterances directed to the skill [35]. The (G) decoder for ASK is a hybrid decoder that
uses a skill-specific grammar as well as a main n-gram based Statistical Language Model (SLM)
that shares data with other skills.
Continuous improvements are key to any machine learning product. In addition to regularly ingesting human-transcribed skill-directed utterances to the training corpus of the main SLM, we also
ingest ASR recognition results directly as a form of semi-supervised training [36]. In order to reduce the risk of reinforcing recognition error, we employ weighted language model training [37]
where each semi-supervised sentence is weighted according to its confidence value given by the
ASR system. These semi-supervised learning techniques ameliorate ASR errors due to distributional misallocations during the initial build phase.
7.3
Natural Language Understanding
In this section we describe the Language Understanding component of the Alexa Skills Kit. Given
an utterance, our NLU system aims to recognize its intent and relevant parameters as slots, a task
known as shallow semantic parsing. The NLU system is divided into deterministic and stochastic
subsystems.
The deterministic NLU subsystem uses FST data representation to compile sample utterances provided by developer into a recognizer model. This recognizer guarantees coverage on all utterances
specified by a skill developer while designing her grammar, allowing for predictable experience for
both the developer and the customer.
The stochastic system uses BlueFlow to lend flexibility to the choice of model. We have built individual algorithmic components which implement a linear chain CRF [38], and a maximum entropy
classifier [39], an updated pipeline using LSTMs for each task [40] and joint neural models for entity
and intent prediction [41, 42]. This allowed us to experiment with different configurations as long
as it conforms to the API of receiving a sentence and returning a semantic frame. In fig 4 we show
a traditional NLU system which performs entity recognition followed by intent classification and
finally slot resolution.
7.3.1
Knowledge Injection
The performance of statistical models can be greatly improved by using features derived from
Knowledge-Base (KB) lookups, but it is infeasible to perform expensive queries at runtime. By
using efficient data structures to encode sketches of relevant portions of a knowledge base, we can
7
Figure 4: Overview of the hybrid NLU pipeline.
make them available to statistical models as feature extractors. This is done by encoding ontologically derived word-clusters as bloom filters during training time [43, 44], including those from
custom types defined by developers. These features can be extremely useful for training models in
a low data regime since they encourage feature generalization to classes or categories, with a small
probability of false positives. This can massively increase the effective vocabulary of a small model
without blowing up its feature-space, and has added benefit of enabling class coverage improvements
to deploy asynchronously without needing to retrain statistical models.
Training with KB features can lead to language feature under-training, the models learn to rely too
heavily on KB features to distinguish entities. This can be addressed by introducing a knowledge
dropout regularization parameter to prevent the model from overfitting [45].
7.3.2
Model Optimization for Deployment
Skill models are stored in DynamoDB [28] and loaded at runtime, and network calls account for the
bulk of added latency. We use standard techniques like feature hashing [46], weight quantization,
[47] and sparsity constraints via modified elastic net regularization [48] to ensure that our models
are small enough to be stored cheaply and can be transferred over network calls quickly with no
statistically significant loss in accuracy.
8
Dialogue Subroutines
ASK supports the specification of dialogue subroutines for common tasks, a unified dialogue model
automates simple procedural dialogue capabilities, such as slot elicitation (e.g., User: Get me a cab
– Alexa: Where do you want to go?) confirmation questions (e.g., User: Portland – Alexa: You
want to go to Portland, Oregon, right?) and other easily specified mechanisms. These procedural
subroutines can either be invoked by developers to issue a dialogue act directive during the course of
interaction, or defined as part of the interaction model. Although this system fulfills many usecases,
we recognize the limitations of having a simple dialogue system.
9
Conclusions and Future Work
We described the ASK SLU service which allows third party developers to expand the capability of
the Alexa Voice Service. Our system abstracts away the intricacies of ASR and NLU, and provides
developers with an interface based on structured request data. The ASK service now hosts over
25,000 consumer facing SLU subsystems that improve over time, with hundreds of new Skills being
added every week. This implies that we have made significant progress towards our goal of building
a fully extensible SLU architecture. However challenges still remain in building a seamless user
experience, and to enable the creation of useful and engaging agents. In order to seed research in
this area, Amazon has introduced the Alexa Prize, a 2.5 million dollar university competition to
advance conversational AI through voice. Alexa prize bots were launched to customers as a skill
using ASK, and early results have shown promise [6].
8
References
[1] Fariba Sadri, “Ambient intelligence: A survey,” ACM Computing Surveys (CSUR), vol. 43, no.
4, pp. 36, 2011.
[2] Amazon Web Services, “AWS Serverless Multi-Tier Architectures,” AWS Whitepapers, 2017.
[3] Amazon Web Services, “Amazon Lex Developer Guide,” AWS Whitepapers, 2017.
[4] Gabriel Lyons, Vinh Tran, Carsten Binnig, Ugur Cetintemel, and Tim Kraska, “Making the
case for query-by-voice with echoquery,” in Proceedings of the 2016 International Conference
on Management of Data. ACM, 2016, pp. 2129–2132.
[5] Prasetya Utama, Nathaniel Weir, Carsten Binnig, and Ugur Çetintemel, “Voice-based data
exploration: Chatting with your database,” Proceedings of the 2017 workshop on SearchOriented Conversational AI, 2017.
[6] Iulian V Serban, Chinnadhurai Sankar, Mathieu Germain, Saizheng Zhang, Zhouhan Lin,
Sandeep Subramanian, Taesup Kim, Michael Pieper, Sarath Chandar, Nan Rosemary Ke, et al.,
“A deep reinforcement learning chatbot,” arXiv preprint arXiv:1709.02349, 2017.
[7] Daniel Povey, Arnab Ghoshal, Gilles Boulianne, Lukas Burget, Ondrej Glembek, Nagendra
Goel, Mirko Hannemann, Petr Motlicek, Yanmin Qian, Petr Schwarz, et al., “The kaldi speech
recognition toolkit,” in IEEE 2011 workshop on automatic speech recognition and understanding. IEEE Signal Processing Society, 2011, number EPFL-CONF-192584.
[8] Steve J Young, The HTK hidden Markov model toolkit: Design and philosophy, University of
Cambridge, Department of Engineering, 1993.
[9] Christopher D Manning, Mihai Surdeanu, John Bauer, Jenny Rose Finkel, Steven Bethard, and
David McClosky, “The stanford corenlp natural language processing toolkit.,” 2014.
[10] Victor W Zue and James R Glass, “Conversational interfaces: Advances and challenges,”
Proceedings of the IEEE, vol. 88, no. 8, pp. 1166–1180, 2000.
[11] Jason D Williams and Eslam Kamal, “Fast and easy language understanding for dialog systems
with microsoft language understanding intelligent service (LUIS),” 2015.
[12] Jason D. Williams, Kavosh Asadi, and Geoffrey Zweig, “Hybrid code networks: practical and
efficient end-to-end dialog control with supervised and reinforcement learning,” in ACL, 2017.
[13] Dzmitry Bahdanau, Kyunghyun Cho, and Yoshua Bengio, “Neural machine translation by
jointly learning to align and translate,” arXiv preprint arXiv:1409.0473, 2014.
[14] Yonghui Wu, Mike Schuster, Zhifeng Chen, Quoc V. Le, Mohammad Norouzi, Wolfgang
Macherey, Maxim Krikun, Yuan Cao, Qin Gao, Klaus Macherey, Jeff Klingner, Apurva Shah,
Melvin Johnson, Xiaobing Liu, ukasz Kaiser, Stephan Gouws, Yoshikiyo Kato, Taku Kudo,
Hideto Kazawa, Keith Stevens, George Kurian, Nishant Patil, Wei Wang, Cliff Young, Jason
Smith, Jason Riesa, Alex Rudnick, Oriol Vinyals, Greg Corrado, Macduff Hughes, and Jeffrey
Dean, “Google’s neural machine translation system: Bridging the gap between human and
machine translation,” CoRR, vol. abs/1609.08144, 2016.
[15] Iulian V Serban, Alessandro Sordoni, Yoshua Bengio, Aaron Courville, and Joelle Pineau,
“Building end-to-end dialogue systems using generative hierarchical neural network models,”
in Thirtieth AAAI Conference on Artificial Intelligence, 2016.
[16] D. Sculley, Gary Holt, Daniel Golovin, Eugene Davydov, Todd Phillips, Dietmar Ebner, Vinay
Chaudhary, and Michael Young, “Machine learning: The high interest credit card of technical
debt,” in SE4ML: Software Engineering for Machine Learning (NIPS 2014 Workshop), 2014.
[17] Hal Daumé III, “Frustratingly easy domain adaptation,” ACL 2007, p. 256, 2007.
[18] Young-Bum Kim, Karl Stratos, Ruhi Sarikaya, and Minwoo Jeong, “New transfer learning
techniques for disparate label sets,” in ACL, 2015.
[19] Jeffrey Pennington, Richard Socher, and Christopher D Manning, “Glove: Global vectors for
word representation,” in In EMNLP. Citeseer, 2014.
[20] Tomas Mikolov, Ilya Sutskever, Kai Chen, Greg S Corrado, and Jeff Dean, “Distributed representations of words and phrases and their compositionality,” in Advances in neural information
processing systems, 2013, pp. 3111–3119.
9
[21] Ankur Bapna, Gokhan Tur, Dilek Hakkani-Tur, and Larry Heck, “Towards zero shot frame
semantic parsing for domain scaling,” in Interspeech 2017, 2017.
[22] Young-Bum Kim, Karl Stratos, and Ruhi Sarikaya, “Frustratingly easy neural domain adaptation,” in COLING, 2016.
[23] Jan Trmal, Jan Zelinka, and Luděk Müller, “Adaptation of a feedforward artificial neural
network using a linear transform,” in International Conference on Text, Speech and Dialogue.
Springer, 2010, pp. 423–430.
[24] Andrei A Rusu, Neil C Rabinowitz, Guillaume Desjardins, Hubert Soyer, James Kirkpatrick,
Koray Kavukcuoglu, Razvan Pascanu, and Raia Hadsell, “Progressive neural networks,” arXiv
preprint arXiv:1606.04671, 2016.
[25] Anjishnu Kumar, Pavankumar Reddy Muddireddy, Markus Dreyer, and Bjorn Hoffmeister,
“Zero-shot learning across heterogeneous overlapping domains,” in Proc. Interspeech 2017,
2017, pp. 2914–2918.
[26] Tianqi Chen, Mu Li, Yutian Li, Min Lin, Naiyan Wang, Minjie Wang, Tianjun Xiao, Bing Xu,
Chiyuan Zhang, and Zheng Zhang, “Mxnet: A flexible and efficient machine learning library
for heterogeneous distributed systems,” arXiv preprint arXiv:1512.01274, 2015.
[27] Amazon Web Services, “AWS Storage Services Overview,” AWS Whitepapers, 2015.
[28] Giuseppe DeCandia, Deniz Hastorun, Madan Jampani, Gunavardhan Kakulapati, Avinash Lakshman, Alex Pilchin, Swaminathan Sivasubramanian, Peter Vosshall, and Werner Vogels, “Dynamo: Amazon’s highly available key-value store,” in ACM SIGOPS Operating Systems Review. 2007, vol. 41, pp. 205–220, ACM.
[29] Xing Fan, Emilio Monti, Lambert Mathias, and Markus Dreyer, “Transfer learning for neural
semantic parsing,” in Proceedings of the 2nd Workshop on Representation Learning for NLP,
Vancouver, Canada, August 2017, pp. 48–56, Association for Computational Linguistics.
[30] John Lafferty, Andrew McCallum, and Fernando CN Pereira, “Conditional random fields:
Probabilistic models for segmenting and labeling sequence data,” in Proceedings of the 18th
International Conference on Machine Learning, 2001, vol. 951, pp. 282–289.
[31] Guillaume Lample, Miguel Ballesteros, Sandeep Subramanian, Kazuya Kawakami, and Chris
Dyer, “Neural architectures for named entity recognition,” in Proceedings of NAACL-HLT,
2016, pp. 260–270.
[32] Robin Jia and Percy Liang, “Data recombination for neural semantic parsing,” Proceedings of
ACL, 2016.
[33] Faisal Ladhak, Ankur Gandhe, Markus Dreyer, Lambert Mathias, Ariya Rastrow, and Björn
Hoffmeister, “LatticeRnn: Recurrent neural networks over lattices,” Interspeech 2016, pp.
695–699, 2016.
[34] Mehryar Mohri, Fernando Pereira, and Michael Riley, “Weighted finite-state transducers in
speech recognition,” Computer Speech & Language, vol. 16, no. 1, pp. 69–88, 2002.
[35] Petar Aleksic, Mohammadreza Ghodsi, Assaf Michaely, Cyril Allauzen, Keith Hall, Brian
Roark, David Rybach, and Pedro Moreno, “Bringing contextual information to google speech
recognition,” in Sixteenth Annual Conference of the International Speech Communication
Association, 2015.
[36] Thomas Drugman, Janne Pylkkönen, and Reinhard Kneser, “Active and semi-supervised learning in asr: Benefits on the acoustic and language models.,” in INTERSPEECH, 2016, pp.
2318–2322.
[37] Hui Zhang and David Chiang, “Kneser-ney smoothing on expected counts,” in ACL, 2014.
[38] J. Lafferty, A. McCallum, and F. Pereira, “Conditional random fields: Probabilistic models
for segmenting and labeling sequence data,” in Proc. 18th International Conf. on Machine
Learning, 2001, pp. 282–289.
[39] A. L Berger, V. J.D Pietra, and S. A.D Pietra, “A maximum entropy approach to natural
language processing,” Computational Linguistics, vol. 22, no. 1, pp. 71, 1996.
[40] Kaisheng Yao, Baolin Peng, Yu Zhang, Dong Yu, Geoffrey Zweig, and Yangyang Shi, “Spoken
language understanding using long short-term memory neural networks,” in Spoken Language
Technology Workshop (SLT), 2014 IEEE. IEEE, 2014, pp. 189–194.
10
[41] Bing Liu and Ian Lane, “Attention-based recurrent neural network models for joint intent
detection and slot filling,” arXiv preprint arXiv:1609.01454, 2016.
[42] Dilek Hakkani T ur, G okhan T ur, Asli Celikyilmaz, Yun Nung Chen, Jianfeng Gao, Li Deng,
and Ye Yi Wang, “Multi domain joint semantic frame parsing using bi directional rnn lstm.,”
in INTERSPEECH, 2016, p. 715 719.
[43] Xiaohu Liu, Ruhi Sarikaya, Liang Zhao, Yong Ni, and Yi-Cheng Pan, “Personalized natural
language understanding.,” 2016.
[44] Jan A. Botha, Emily Pitler, Ji Ma, Anton Bakalov, Alex Salcianu, David Weiss, Ryan
Mcdonald, and Slav Petrov, “Natural language processing with small feed-forward networks,” in Proceedings of the 2017 Conference on Empirical Methods in Natural Language Processing, Copenhagen, Denmark, 2017, p. 28692875, Supplementary material:
http://aclweb.org/anthology/attachments/D/D17/D17-1308.Attachment.zip.
[45] Eunsuk Yang, Young-Bum Kim, Ruhi Sarikaya, and Yu-Seop Kim, “Drop-out conditional
random fields for twitter with huge mined gazetteer,” in Proceedings of NAACL-HLT, 2016,
pp. 282–288.
[46] Kilian Weinberger, Anirban Dasgupta, John Langford, Alex Smola, and Josh Attenberg, “Feature hashing for large scale multitask learning,” in Proceedings of the 26th Annual International Conference on Machine Learning. ACM, 2009, pp. 1113–1120.
[47] Armand Joulin, Edouard Grave, and Piotr Bojanowski Tomas Mikolov, “Bag of tricks for
efficient text classification,” EACL 2017, p. 427, 2017.
[48] Hui Zou and Trevor Hastie, “Regularization and variable selection via the elastic net,” Journal
of the Royal Statistical Society: Series B (Statistical Methodology), vol. 67, no. 2, pp. 301–320,
2005.
11
Appendix A
BlueFlow Architecture
Architecture. The fundamental units of BlueFlow are components. Component are wrapped in
activities. Activities are chained together into recipes. Recipes are executed by an executor.
Components. A component is a function that solves a defined task. This can be simple (convert
from format A to format B) or complex (train a classifier). In either case, a component is the smallest
unit that other scientists would expect to reuse. Components are normal Python code and can be used
independently of BlueFlow.
Activities. Activities are lightweight wrappers around components, responsible for fetching data
from artifacts and then running a component. Artifacts are lazy file like objects that support a
uniform interface for reading and writing data from heterogeneous data sources such as local files,
DynamoDB [28] and S3 [27]. Activities are expressed as regular Python, but they specify input and
output via an annotation syntax.
Below we show a simple activity to train a Maximum Entropy Classifier.
@Activity(inputs=(’features_artifact’),
outputs=(’model_artifact’))
def train_classifier(features_artifact, model_artifact):
model_file = components.train_maxent(features_artifact.fetch())
model_artifact.put(model_file)
Recipes. A recipe is a chained together set of activities. Recipe code is no longer normal Python, but
rather uses Python language constructs to define a symbolic graph of data flowing through Activities
as Artifacts, and can be serialized as a Directed Acyclic Graph (DAG). Then, we can execute the
independent paths of the DAG in parallel either on the same machine or on a cluster.
Below we show a recipe for training a Maximum Entropy Classifier.
@Recipe
def build_ic_model(data_file, executor):
data_artifact = executor.new_artifact(data_file)
features_artifact = executor.new_artifact()
model_artifact = DynamoDBArtifact(’models/classifier’)
extract_features(data_artifact, features_artifact)
train_classifier(features_artifact, model_artifact)
Executors. An executor abstracts the details of a recipe execution. It is responsible for vending appropriate artifacts and for taking the appropriate actions when executing specific activities. Thus, a
local executor vends local files as intermediate artifacts and runs recipe’s activities on the same machine, whereas a remote executor vends S3 files as intermediate artifacts and runs recipe’s activities
on a cluster.
The executor is also responsible for performing recipe optimizations, via improved scheduling, IO
or smart object caching. The local executor can be used for low latency model builds such as the
ASK model builds. For offline experiments with higher throughput requirements we use the remote
executor to run jobs on a cluster. Switching from a naive local executor to a multithreaded local
executor results in model build speed increases of about 50 percent.
Other than recipe execution, executors add important features for production code such as logging,
metrics, and retries, that would otherwise result in significant boilerplate. Every Recipe is automatically converted into an equivalent command line tool for local execution and reproduction.
Appendix B
Intent Schema and Custom Slot Types
The intent schema specifies the intents supported by a skill and the expected slots for an intent.
An intent is the intended action for an utterance. Developers may define their own intents or use the
Amazon provided built-in intents. An intent may accept a slot as an argument to represent an entity
along with it’s semantic role in the sentence. The data type of the slot is captured by the slot type,
which corresponds to entity types from the ontology.
12
Developers may use the Amazon provided built-in slot types or define their own custom slot types.
Each custom slot type requires a list of representative values.
Listing 1: Sample Intent Schema for a Horoscope skill from the ASK Documentation
1
{
"intents": [
{
"intent": "GetHoroscope",
"slots": [
{
"name": "Sign",
"type": "ZODIAC_SIGNS"
},
{
"name": "Date",
"type": "AMAZON.DATE"
}
]
}
]
2
3
4
5
6
7
8
9
10
11
12
13
14
15
16
17
}
Sample utterances form the training data used for building spoken language understanding models.
Each sample is labelled with an intent followed by an utterance corresponding to the intent.
Listing 2: Sample Utterances for a Horoscope skill
1
2
3
4
GetHoroscope
GetHoroscope
GetHoroscope
GetHoroscope
what is the horoscope for {Sign}
what will the horoscope for {Sign} be on {Date}
get me my horoscope
{Sign}
13
| 2 |
GENERATING THE IDEALS DEFINING UNIONS OF SCHUBERT VARIETIES
arXiv:1405.2945v1 [math.AG] 12 May 2014
ANNA BERTIGER
A BSTRACT. This note computes a Gröbner basis for the ideal defining a union of Schubert varieties.
More precisely, it computes a Gröbner basis for unions of schemes given by northwest rank conditions on the space of all matrices of a fixed size. Schemes given by northwest rank conditions include
classical determinantal varieties and matrix Schubert varieties–closures of Schubert varieties lifted
from the flag manifold to the space of matrices.
1. I NTRODUCTION
We compute a Gröbner basis, and hence ideal generating set, for the ideal defining a union of
schemes each given by northwest rank conditions with respect to an “antidiagonal term order.”
A scheme defined by northwest rank conditions is any scheme whose defining equations are of
the form “all k × k minors in the northwest i × j sub-matrix of a matrix of variables,” where i, j,
and k can take varying values. These schemes represent a generalization of classical determinantal
varieties–those varieties with defining equations all (r+1)×(r+1) minors of a matrix of variables.
One geometrically important collection of schemes defined by northwest rank conditions is the set
of matrix Schubert varieties. Matrix Schubert varieties are closures of the lift of Schubert varieties
from the complete flag manifold to matrix space [Ful92]. In general, a matrix Schubert variety
for a partial permutation π is the subvariety of matrix space given by the rank conditions that
the northwest i × j sub-matrix must have rank at most the number of 1s in the northwest i × j
sub-matrix of the partial permutation matrix for π. Notice that the set of matrix Schubert varieties
contains the set of classical determinantal varieties, which are the zero locus of all minors of a
fixed size on the space of all matrices of fixed size.
Matrix Schubert varieties associated to honest, that is non-partial, permutations are the closures
of the lifts of the corresponding Schubert varieties in the flag manifold, B− \GLn . If Xπ is the matrix
Schubert variety for an honest permutation π the projection
{full rank matrices} B− \ GLn C = F`Cn
sends Xπ ∩ GLn C onto the Schubert variety Xπ ⊆ F`Cn . Schubert varieties, orbits of B+ , stratify
F`Cn and give a basis for H∗ (F`Cn ). It is this application that led to the introduction of matrix
Schubert varieties in [Ful92]. Knutson and Miller showed that matrix Schubert varieties have a
rich algebro-geometric structure corresponding to beautiful combinatorics [KM05]. Fulton’s generators are a Gröbner basis with respect to any antidiagonal term order and their initial ideal is
the Stanley-Reisner ideal of the “pipe dream complex.” Further, Knutson and Miller show that
the pipe dream complex is shellable, hence the original ideal is Cohen-Macaulay. Pipe dreams,
the elements of the pipe dream complex, were originally called RC graphs and were developed
by Bergeron and Billey [BB93] to describe the monomials in polynomial representatives for the
classes corresponding to Schubert varieties in H∗ (F`Cn ).
The importance of Schubert varieties, and hence matrix Schubert varieties, to other areas of
geometry has become increasing evident. For example, Zelevinsky [Zel85] showed that certain
quiver varieties, sequences of vector space maps with fixed rank conditions, are isomorphic to
Date: May 14, 2014.
1
Schubert varieties. Knutson, Miller and Shimozono, [KMS06] produce combinatorial formulae for
quiver varieties using many combinatorial tools reminiscent of those for Schubert varieties.
1.1. Notation and Background. Much of the background surveyed here can be found in [MS05].
Let B− (respectively B+ ) denote the group of invertible lower triangular (respectively upper triangular) n × n matrices. Let M = (mi,j ) be a matrix of variables. In what follows π will be a possibly
partial permutation, written in one-line notation π(1) . . . π(n), with entries for π(i) undefined are
written ?. We shall write permutation even when we mean partial permutation in cases where
there is no confusion. A matrix Schubert variety Xπ is the closure B− πB+ in the affine space of all
matrices, where π is a permutation matrix and B− and B+ act by downward row and rightward
column operations respectively. Notice that for π an honest permutation Xπ is the closure of the
lift of Xπ = B− \B− πB+ ⊆ B− \GLn C to the space of n × n matrices.
The Rothe diagram of a permutation is found by looking at the permutation matrix and crossing
out all of the cells weakly below, and the cells weakly to the right of, each cell containing a 1. The
remaining empty boxes form the Rothe diagram. The essential boxes [Ful92] of a permutation are
those boxes in the Rothe diagram that do not have any boxes of the diagram immediately south
or east of them. The Rothe diagrams for 2143 and 15432 are given in Figure 1.1. In both cases the
essential boxes are marked with the letter e.
1
e
e
1
e
1
e
e
1
1
1
1
1
1
F IGURE 1.1. The Rothe diagrams and essential sets of 2143 (left) and 15432 (right).
The rank matrix of a permutation π, denoted r(π), gives in each cell r(π)ij the rank of the i × j
northwest-justified sub-matrix of the permutation matrix for π. For example, the rank matrix of
15432 is
1 1 1 1 1
1 1 1 1 2
1 1 1 2 3 .
1 1 2 3 4
1 2 3 4 5
Theorem 1.1 ( [Ful92]). Matrix Schubert varieties have radical ideal I(Xπ ) = Iπ given by determinants
representing conditions given in the rank matrix r(π), that is, the (r(π)ij + 1) × (r(π)ij + 1) determinants
of the northwest i × j sub-matrix of a matrix of variables. In fact, it is sufficient to impose only those rank
conditions r(π)ij such that (i, j) is an essential box for π.
Hereafter we call the determinants corresponding the to essential rank conditions, or the analogous determinants for any ideal generated by northwest rank conditions, the Fulton generators.
One special form of ideal generating set is a Gröbner basis. To define a Gröbner basis we set
a total ordering on the monomials in a polynomial ring such that 1 ≤ m and m < n implies
mp < np for all monomials m, n and p. Let init f denote the largest monomial that appears in the
polynomial f. A Gröbner basis for the ideal I is a set {f1 , . . . fr } ⊆ I such that init I := hinit f : f ∈
Ii = hinit f1 , . . . init fr i. Notice that a Gröbner basis for I is necessarily a generating set for I.
2
The antidiagonal of a matrix is the diagonal series of cells in the matrix running from the most
northeast to the most southwest cell. The antidiagonal term (or antidiagonal) of a determinant
is the product of the entries in the antidiagonal. For example, the antidiagonal of ac db is the
cells occupied by b and c, and correspondingly, in the determinant ad − bc the antidiagonal term
is bc. Term orders that select antidiagonal terms from a determinant, called antidiagonal term
orders have proven especially useful in understanding ideals of matrix Schubert varieties. There
are several possible implementations of an antidiagonal term order on an n×n matrix of variables,
any of which would suit the purposes of this paper. One example is weighting the top right entry
highest and decreasing along the top row before starting deceasing again at the right of the next
row; monomials are then ordered by their total weight.
Theorem 1.2 ( [KM05]). The Fulton generators for Iπ form a Gröbner basis under any antidiagonal term
order.
Typically we will denote the cells of a matrix that form antidiagonals by A or B. In what follows if A is the antidiagonal of a sub-matrix of M we will use the notation det(A) to denote the
determinant of this sub-matrix. We shall be fairly liberal in exchanging antidiagonal cells and the
corresponding antidiagonal terms, thus, for any antidiagonal term order, A = init det(A).
1.2. Statement of Result. Let I1 , . . . Ir be ideals defined by northwest rank conditions. We will
produce a Gröbner basis, and hence ideal generating set, for I1 ∩ · · · ∩ Ir . For each list of antidiagonals A1 , . . . , Ar , where Ai is the antidiagonal of a Fulton generator of Ii , we will produce a
Gröbner basis element gA1 ,...,Ar for ∩Ii . The generators gA1 ,...,Ar will be products of determinants,
though not simply the product of the r determinants corresponding to the Ai . For a fixed list of
antidiagonals A1 , . . . , Ar , build the generator gA1 ,...,Ar by:
(1) Begin with gA1 ,...,Ar = 1
(2) Draw a diagram with a dot of color i in each box of Ai and connect the consecutive dots of
color i with a line segment of color i.
(3) Break the diagram into connected components. Two dots are connected if they are either
connected by lines or are connected by lines to dots that occupy the same box.
(4) For each connected component, remove the longest series of boxes B such that there is
exactly one box in each row and column and the boxes are all in the same connected component. If there is a tie use the most northwest of the longest series of boxes. Note that B
need not be any of A1 , . . . , Ar . Multiply gA1 ,...,Ar by det(B). Remove this antidiagonal from
the diagram of the connected component, break the remaining diagram into components
and repeat.
Theorem 1.3. {gA1 ...Ar : Ai is an antidiagonal of a Fulton generator of Ii , 1 ≤ i ≤ r} form a Gröbner
basis, and hence a generating set, for ∩ri=1 Ii .
1.3. Acknowledgements. This work constitutes a portion of my PhD thesis completed at Cornell
University under the direction of Allen Knutson. I wish to thank Allen for his help, advice and
encouragement in completing this project. Thanks also go to Jenna Rajchgot for helpful discussions in the early stages of this work. I’d also like to thank the authors of computer algebra system
Macaulay2, [GS] which powered the computational experiments nessecary to do this work. I’m especially grateful to Mike Stillman who patiently answered many of my Macaulay2 questions over
the course of this work. Kevin Purbhoo gave very helpful comments on drafts of this manuscript
for which I cannot thank him enough.
2. E XAMPLES
We delay the proof of Theorem 1.3 to Section 3 and first give some examples of the generators
produced for given sets of antidiagonals. These examples are given by pictures of the antidiagonals on the left and corresponding determinantal equations on the right. Note that we only give
3
particular generators, rather than entire generating sets, which might be quite large. We then give
entire ideal generating sets for two smaller intersections.
If r = 1 then for each Fulton generator with antidiagonal A the algorithm produces the generator gA = det(A). Therefore, if we intersect only one ideal the algorithm returns the original set of
Fulton generators. The generator for the antidiagonal shown is exactly the determinant of the one
antidiagonal pictured:
m1,1 m1,2 m1,4
m3,1 m3,2 m3,4
m4,1 m4,2 m4,4
.
The generator for two disjoint antidiagonals is the product of the determinants corresponding
to the two disjoint antidiagonals:
m1,1 m1,2
m2,1 m3,2
m1,1 m1,2 m1,4
m3,1 m3,2 m3,4
m4,1 m4,2 m4,4
.
In general, if A1 , . . . Ar are disjoint antidiagonals then the then the algorithm looks at each Ai separately as they are part of separate components and the result is that gA1 ,...Ar = det(A1 ) · · · det(Ar ).
If A1 , . . . Ar overlap to form one antidiagonal X then the last step of the algorithm will occur
only once and will produce gA1 ,...Ar = det(X). For example,
m1,1
m2,1
m3,1
m4,1
m1,2
m2,2
m3,2
m4,2
m1,3
m2,3
m3,3
m4,3
m1,4
m2,4
m3,4
m4,4
.
In this example, there are two longest possible antidiagonals, the three cells occupied by the
green dots and the three cells occupied by the red dots. The ones occupied by the green dots are
more northwest, hence the generator for the three antidiagonals shown below is
4
m1,1 m1,2
m2,1 m2,2
m1,2 m1,3 m1,3
m2,2 m2,3 m2,3
m3,2 m3,3 m3,4
m4,2 m4,3
m5,2 m2,2
.
In the picture below, the longest possible anti diagonal uses all of the cells in the green anti
diagonal but only some of the cells in the red antidiagonal, however, there is only one possible
longest antidiagonal. Thus the generator is
m1,1 m1,2
m2,1 m2,2
m1,1
m2,1
m3,1
m4,1
m1,2
m2,2
m3,2
m4,2
m1,4
m2,4
m3,4
m4,4
m1,5
m2,5
m3,5
m4,5
m5,1
.
We now give two examples where the complete ideals are comparatively small. Firstly, we
calculate I(X231 ∪ X312 ) = I(X231 ) ∩ I(X312 ). I(X231 ) = hm1,1 , m2,1 i and I(X312 ) = hm1,1 , m1,2 i. The
antidiagonals and corresponding generators are shown below with antidiagonals from generators
of I(X231 ) shown in red and antidiagonals of generators of I(X312 ) shown in blue. Note that the
antidiagonals are only one cell each in this case.
m1,1
m1,1 m1,2
m1,1 m2,1
m1,2 m2,1
Theorem 1.3 results in
I(X231 ∪ X312 ) = I(X231 ) ∩ I(X312 ) = hm1,1 , m1,1 m1,2 , m1,1 m2,1 , m1,2 m2,1 i.
As a slightly larger example, consider I(X1423 ∪ X1342 ) = I(X1423 ) ∩ I(X1342 ). These generators
are given below in the order that the antidiagonals are displayed reading left to right and top to
bottom. The antidiagonals for I(X1423 are shown in red while the antidigaonals I(X1342 ) are shown
in blue. for Note that the full 4 × 4 grid is not displayed, but only the northwest 3 × 3 portion
where antidiagonals for these two ideals may lie.
5
Here Theorem 1.3 produces
m1,1
m1,1 m1,2
,
m2,1
m2,1 m2,2
m1,1 m1,2
m1,1
+
m3,1 m2,2
m1,1 m1,2
m1,2
+
m2,1 m3,2
m2,2
m1,2
m2,2
m1,1
m1,1 m1,3
,
m2,1 m2,3
m1,3
m2,2
m2,1 m2,2
m3,1 m2,2
m3,1 m1,2
,
m2,1 m2,2
m1,1 m1,3
m3,1 m3,2
m1,1 m1,2
,
m3,1 m2,3
m1,1 m1,3
,
m3,1 m2,3
m1,2 m1,3
m2,2 m2,2
m2,1 m2,2
m3,1 m2,3
m1,1 m1,2 m1,3
, m2,1 m2,2 m2,3
m3,1 m3,2 m3,4
3. P ROOF OF T HEOREM 1.3
We now prove the main result of this paper, Theorem 1.3, which states that the gA1 ,...,Ar generate
I1 ∩ · · · ∩ Ir .
We begin with a few fairly general statements:
Theorem 3.1 ( [Knu]). If {Ii : i ∈ S} are ideals generated by northwest rank conditions then init(∩i∈S Ii ) =
∩i∈S (init Ii ).
Lemma 3.2 ( [KM05]). If J ⊆ K are homogeneous ideals in a polynomial ring such that init J = init K
then J = K.
Lemma 3.3. Let IA and IB be ideals that define schemes of northwest rank conditions and let det(A) ∈ IA
and det(B) ∈ IB be determinants with antidiagonals A and B respectively such that A ∪ B = X and
A ∩ B 6= ∅. Then det(X) is in IA ∩ IB .
Proof. Let VX = V(det(X)), VA = V(IA ) and VB = V(IB ) be the varieties corresponding to the ideals
hdet(X)i, IA and IB . It is enough to show that VA ⊆ VX and VB ⊆ VX .
We will show that given a matrix with antidiagonal X with a sub-matrix with antidiagonal
A ⊆ X where the sub-matrix northwest of the cells occupied by A has rank at most length(A) − 1
then the full matrix has rank at most length(X) − 1. The corresponding statement for sub-matrix
with antidiagonal B can be proven by replacing A with B everywhere.
The basic idea of this proof is that we know the rank conditions on the rows and columns northwest of those occupied by A. The rank conditions given by A then imply other rank conditions as
adding either a row or a column to a sub-matrix can increase its rank by at most one.
6
column t + 1 column c
rank at most l
northwest of row k − t column c
rank at most l + k − c ≤ k − t − 2
northwest of column k row k − t
rank at most k − 2
row k − t
northwest of column k row k
row k
F IGURE 3.1. The proof of Lemma 3.3. The antidiagonal cells in A are marked in
black and the antidiagonal cells in X − A ⊆ B are marked in white.
Let k be the number of rows, also the number of columns in the antidiagonal X. Let the length
of A be l + 1, so the rank condition on all rows and columns northwest of those occupied by A
is at most l. Assume that the rightmost column of A is c and the leftmost column of A is t + 1.
Notice that this implies that the bottom row occupied by A is k − t, as the antidiagonal element in
column t + 1 is in row k − t. Thus, the northwest (k − t) × c of matrices in VA has rank at most l.
Notice c ≥ (t+1)+(l+1), with equality if A occupies a continuous set of columns, so matrices in
VA have rank at most l in the northwest (k−t)×(t+l+2). Adding k−c ≤ k−(n−t−l−2) columns to
this sub-matrix gives a (k−t)×k sub-matrix with rank at most l+k−c ≤ r+(k−t−l−2) = k−t−2.
Further, by the same principle, moving down t rows, the northwest k × k, i.e. the whole matrix
with antidiagonal X, has rank at most k − t − 2 + t = k − 2, hence has rank at most k − 1 and so is
in VX .
For a visual explanation of the proof of Lemma 3.3 see Figure 3.1.
Lemma 3.4. gA1 ,...,Ar ∈ Ii for 1 ≤ i ≤ r and hence
hgA1 ,...,Ar : Ai ranges over all antidiagonals for Fulton generators of Ii i ⊆ ∩ri=1 Ii .
Proof. Fix i. Let S be the first antidiagonal containing a box occupied by a box contained in Ai
added to gA1 ,...,Ar . We shall show that det(S) is in Ii and hence gA1 ,...,Ar ∈ Ii as it is a multiple of
det(S). If Ai ⊆ S then det(S) ∈ Ii either because S = Ai or S ( Ai in which case we apply Lemma
3.3. Otherwise, |S| ≥ |Ai | and S is weakly to the northwest of Ai . Therefore, there is a subset B
of S such that |B| = |Ai |, and B is weakly northwest of Ai . Hence, B is an antidiagonal for some
determinant in Ii , and again by Lemma 3.3 det(S) ∈ Ii .
Lemma 3.5. init gA1 ,...,Ar = A1 ∪ · · · ∪ Ar under any antidiagonal term order.
Proof. init gA1 ,...,Ar is a product of determinants, with collective antidiagonals A1 ∪ · · · ∪ Ar .
When we combine Lemma 3.5 and Theorem 3.1 we see that inithgA1 ,...Ar i = init(∩Ii ). Then,
Lemmas 3.2 and 3.4 combine to complete the proof of Theorem 1.3.
7
Note that Theorem 1.3 may produce an oversupply of generators. For example, if I1 = I2 , then
inputting the same set of p Fulton generators twice results in a Gröbner basis of p2 polynomials
for I1 ∩ I2 = I1 = I2 .
R EFERENCES
Nantel Bergeron and Sara Billey, RC-graphs and Schubert polynomials, Experiment. Math. 2 (1993), no. 4, 257–
269. MR 1281474 (95g:05107)
[Ful92] William Fulton, Flags, Schubert polynomials, degeneracy loci, and determinantal formulas, Duke Math. J. 65 (1992),
no. 3, 381–420. MR 1154177 (93e:14007)
[GS]
Daniel R. Grayson and Michael E. Stillman, Macaulay2, a software system for research in algebraic geometry,
Available at http://www.math.uiuc.edu/Macaulay2/.
[KM05] Allen Knutson and Ezra Miller, Gröbner geometry of Schubert polynomials, Ann. of Math. (2) 161 (2005), no. 3,
1245–1318. MR 2180402 (2006i:05177)
[KMS06] Allen Knutson, Ezra Miller, and Mark Shimozono, Four positive formulae for type A quiver polynomials, Invent.
Math. 166 (2006), no. 2, 229–325. MR 2249801 (2007k:14098)
[Knu]
Allen Knutson, Frobenius splitting, point-counting and degeneration, Preprint, arXiv:0911.4941v1.
[MS05] Ezra Miller and Bernd Sturmfels, Combinatorial commutative algebra, Graduate Texts in Mathematics, vol. 227,
Springer-Verlag, New York, 2005. MR 2110098 (2006d:13001)
[Zel85] A. V. Zelevinskiı̆, Two remarks on graded nilpotent classes, Uspekhi Mat. Nauk 40 (1985), no. 1(241), 199–200.
MR 783619 (86e:14027)
[BB93]
8
| 0 |
Improving Scalability of Inductive Logic Programming
via Pruning and Best-Effort Optimisation
Mishal Kazmi1 , Peter Schüller2,C , and Yücel Saygın1
arXiv:1706.05171v1 [cs.AI] 16 Jun 2017
1
Faculty of Engineering and Natural Science,
Sabanci University,
Istanbul, Turkey
{mishalkazmi,ysaygin}@sabanciuniv.edu
2
Faculty of Engineering,
Marmara University,
Istanbul, Turkey
peter.schuller@marmara.edu.tr / schueller.p@gmail.com
Technical Report: manuscript accepted for publication at Expert Systems With Applications (Elsevier).
c 2017. This manuscript version is made available under the CC-BY-NC-ND 4.0 license.
http://creativecommons.org/licenses/by-nc-nd/4.0/ .
Abstract
Inductive Logic Programming (ILP) combines rule-based and statistical artificial intelligence
methods, by learning a hypothesis comprising a set of rules given background knowledge and constraints for the search space. We focus on extending the XHAIL algorithm for ILP which is based
on Answer Set Programming and we evaluate our extensions using the Natural Language Processing
application of sentence chunking. With respect to processing natural language, ILP can cater for the
constant change in how we use language on a daily basis. At the same time, ILP does not require
huge amounts of training examples such as other statistical methods and produces interpretable results, that means a set of rules, which can be analysed and tweaked if necessary. As contributions we
extend XHAIL with (i) a pruning mechanism within the hypothesis generalisation algorithm which
enables learning from larger datasets, (ii) a better usage of modern solver technology using recently
developed optimisation methods, and (iii) a time budget that permits the usage of suboptimal results.
We evaluate these improvements on the task of sentence chunking using three datasets from a recent
SemEval competition. Results show that our improvements allow for learning on bigger datasets
with results that are of similar quality to state-of-the-art systems on the same task. Moreover, we
compare the hypotheses obtained on datasets to gain insights on the structure of each dataset.
1
Introduction
Inductive Logic Programming (ILP) (Muggleton and De Raedt, 1994) is a formalism where a set of logical rules is learned from a set of examples and a background knowledge theory. By combining rule-based
and statistical artificial intelligence, ILP overcomes the brittleness of pure logic-based approaches and the
lack of interpretability of models of most statistical methods such as neural networks or support vector
machines. We here focus on ILP that is based on Answer Set Programming (ASP) as our underlying
logic programming language because we aim to apply ILP to Natural Language Processing (NLP) applications such as Machine Translation, Summarization, Coreference Resolution, or Parsing that require
nonmonotonic reasoning with exceptions and complex background theories.
In our work, we apply ILP to the NLP task of sentence chunking. Chunking, also known as ‘shallow parsing’, is the identification of short phrases such as noun phrases which mainly rely on Part of
Speech (POS) tags. In our experiments on sentence chunking (Tjong Kim Sang and Buchholz, 2000) we
encountered several problems with state-of-the-art ASP-based ILP systems XHAIL (Ray, 2009), ILED
1
(Katzouris et al., 2015), and ILASP2 (Law et al., 2015). XHAIL and ILASP2 showed scalability issues
already with 100 sentences as training data. ILED is designed to be highly scalable but failed in the
presence of simple inconsistencies in examples. We decided to investigate the issue in the XHAIL system,
which is open-source and documented well, and we made the following observations:
(i) XHAIL only terminates if it finds a provably optimal hypothesis,
(ii) the hypothesis search is done over all potentially beneficial rules that are supported by at least one
example, and
(iii) XHAIL contains redundancies in hypothesis search and uses outdated ASP technology.
In larger datasets, observation (i) is unrealistic, because finding a near-optimal solution is much easier
than proving optimality of the best solution, moreover in classical machine learning suboptimal solutions
obtained via non-exact methods routinely provide state-of-the-art results. Similarly, observation (ii)
makes it harder to find a hypothesis, and it generates an overfitting hypotheses which contains rules that
are only required for a single example. Observation (iii) points out an engineering problem that can be
remedied with little theoretical effort.
To overcome the above issues, we modified the XHAIL algorithm and software, and we performed
experiments on a simple NLP chunking task to evaluate our modifications.
In detail, we make the following contributions.
• We extend XHAIL with best-effort optimisation using the newest ASP optimisation technology of unsat-core optimisation (Andres et al., 2012) with stratification (Alviano et al., 2015b;
Ansótegui et al., 2013) and core shrinking (Alviano and Dodaro, 2016) using the WASP2 (Alviano et al.,
2013, 2015a) solver and the Gringo (Gebser et al., 2011) grounder. We also extend XHAIL to provide information about the optimality of the hypothesis.
• We extend the XHAIL algorithm with a parameter Pr for pruning, such that XHAIL searches for
hypotheses without considering rules that are supported by fewer than Pr examples.
• We eliminate several redundancies in XHAIL by changing its internal data structures.
• We describe a framework for chunking with ILP, based on preprocessing with Stanford Core NLP
(Manning et al., 2014) tools.
• We experimentally analyse the relationship between the pruning parameter, number of training
examples, and prediction score on the sentence chunking (Tjong Kim Sang and Buchholz, 2000)
subtask of iSTS at SemEval 2016 (Agirre et al., 2016).
• We discuss the best hypothesis found for each of the three datasets in the SemEval task, and we
discuss what can be learned about the dataset from these hypotheses.
Only if we use all the above modifications together, XHAIL becomes applicable in this chunking task.
By learning a hypothesis from 500 examples, we can achieve results competitive with state-of-the-art
systems used in the SemEval 2016 competition.
Our extensions and modifications of the XHAIL software are available in a public fork of the official
XHAIL Git repository (Bragaglia and Schüller, 2016).
In Section 2 we provide an overview of logic programming and ILP. Section 3 gives an account of
related work and available ILP tools. In Section 4 we describe the XHAIL system and our extensions of
pruning, best-effort optimisation, and further improvements. Section 5 gives details of our representation
of the chunking task. In Section 6 we discuss empirical experiments and results. We conclude in Section
7 with a brief outlook on future work.
2
Background
We next introduce logic programming and based on that inductive logic programming.
2
2.1
Logic Programming
A logic programs theory normally comprises of an alphabet (variable, constant, quantifier, etc), vocabulary, logical symbols, a set of axioms and inference rules (Lloyd, 2012). A logic programming system
consists of two portions: the logic and control. Logic describes what kind of problem needs to be solved
and control is how that problem can be solved. An ideal of logic programming is for it to be purely
declarative. The popular Prolog (Clocksin and Mellish, 2003) system evaluates rules using resolution,
which makes the result of a Prolog program depending on the order of its rules and on the order of
the bodies of its rules. Answer Set Programming (ASP) (Brewka et al., 2011; Gebser et al., 2012a) is a
more recent logic programming formalism, featuring more declarativity than Prolog by defining semantics based on Herbrand models (Gelfond and Lifschitz, 1988). Hence the order of rules and the order
of the body of the rules does not matter in ASP. Most ASP programs follow the Generate-Define-Test
structure (Lifschitz, 2002) to (i) generate a space of potential solutions, (ii) define auxiliary concepts,
and (iii) test to invalidate solutions using constraints or incurring a cost on non-preferred solutions.
An ASP program consists of rules of the following structure:
a ← b1 , . . . , bm , not bm+1 , . . . , not bn
where a, bi are atoms from a first-order language, a is the head and b1 , . . . , not bn is the body of the rule,
and not is negation as failure. Variables start with capital letters, facts (rules without body condition)
are written as ‘a.’ instead of ‘a ← ’. Intuitively a is true if all positive body atoms are true and no
negative body atom is true.
The formalism can be understood more clearly by considering the following sentence as a simple
example:
Computers are normally fast machines unless they are old.
This would be represented as a logical rule as follows:
fastmachine(X) ← computer(X), not old(X).
where X is a variable, fastmachine, computer , and old are predicates, and old (X ) is a negated atom.
Adding more knowledge results in a change of a previous understanding, this is common in human
reasoning. Classical First Order Logic does not allow such non-monotonic reasoning, however, ASP was
designed as a commonsense reasoning formalism: a program has zero or more answer sets as solutions,
adding knowledge to the program can remove answer sets as well as produce new ones. Note that ASP
semantics rule out self-founded truths in answer sets. We use the ASP formalism due to its flexibility
and declarativity. For formal details and a complete description of syntax and semantics see the ASPCore-2 standard (Calimeri et al., 2012). ASP has been applied to several problems related to Natural
Language Processing, see for example (Mitra and Baral, 2016; Schüller, 2013, 2014, 2016; Schwitter,
2012; Sharma et al., 2015). An overview of applications of ASP in general can be found in (Erdem et al.,
2016).
2.2
Inductive Logic Programming
Processing natural language based on hand-crafted rules is impractical because human language is constantly evolving, partially due to the human creativity of language use. An example of this was recently
noticed on UK highways where they advised drivers, ‘Don’t Pokémon Go and drive’. Pokémon Go is being
informally used here as a verb even though it was only introduced as a game a few weeks before the sign
was put up. To produce robust systems, it is necessary to use statistical models of language. These models
are often pure Machine Learning (ML) estimators without any rule components (Manning and Schütze,
1999). ML methods work very well in practice, however, they usually do not provide a way for explaining
why a certain prediction was made, because they represent the learned knowledge in big matrices of real
numbers. Some popular classifiers used for processing natural language include Naive Bayes, Decision
Trees, Neural Networks, and Support Vector Machines (SVMs) (Dumais et al., 1998).
In this work, we focus on an approach that combines rule-based methods and statistics and provides interpretable learned models: Inductive Logic Programming (ILP). ILP is differentiated from ML
techniques by its use of an expressive representation language and its ability to make use of logically
3
encoded background knowledge (Muggleton and De Raedt, 1994). An important advantage of ILP over
ML techniques such as neural networks is, that a hypothesis can be made readable by translating it
into piece of English text. Furthermore, if annotated corpora of sufficient size are not available or too
expensive to produce, deep learning or other data intense techniques are not applicable. However, we
can still learn successfully with ILP.
Formally, ILP takes as input a set of examples E, a set B of background knowledge rules, and a set
of mode declarations M , also called mode bias. As output, ILP aims to produce a set of rules H called
hypothesis which entails E with respect to B. The search for H with respect to E and B is restricted
by M , which defines a language that limits the shape of rules in the hypothesis candidates and therefore
the complexity of potential hypotheses.
Example 1. Consider the following example ILP instance (M, E, B) (Ray, 2009).
#modeh flies(+bird).
M = #modeb penguin(+bird).
#modeb not penguin(+bird).
#example flies(a).
#example flies(b).
E=
#example flies(c).
#example not flies(d).
bird(X) :- penguin(X).
bird(a).
B = bird(b).
bird(c).
penguin(d).
(1)
(2)
(3)
Based on this, an ILP system would ideally find the following hypothesis.
H=
3
flies(X) :- bird(X), not penguin(X).
(4)
Related Work
Inductive Logic Programming (ILP) is a rather multidisciplinary field which extends to domains such
as computer science, artificial intelligence, and bioinformatics. Research done in ILP has been greatly
impacted by Machine Learning (ML), Artificial Intelligence (AI) and relational databases. Quite a few
surveys (Gulwani et al., 2015; Kitzelmann, 2009; Muggleton et al., 2012) mention about the systems and
applications of ILP in interdisciplinary areas. We next give related work of ILP in general and then focus
on ILP applied in the field of Natural Language Processing (NLP).
The foundations of ILP can be found in research by Plotkin (Plotkin, 1970, 1971), Shapiro (Shapiro,
1983) and Sammut and Banerji (Sammut and Banerji, 1986). The founding paper of Muggleton (Muggleton,
1991) led to the launch of the first international workshop on ILP. The strength of ILP lay in its ability to
draw on and extend the existing successful paradigms of ML and Logic Programming. At the beginning,
ILP was associated with the introduction of foundational theoretical concepts which included Inverse
Resolution (Muggleton, 1995; Muggleton and Buntine, 1992) and Predicate Invention (Muggleton, 1991;
Muggleton and Buntine, 1992). A number of ILP systems were developed along with learning about
the theoretical concepts of ILP such as FOIL (Quinlan, 1990) and Golem (Muggleton et al., 1990). The
widely-used ILP system Progol (Muggleton, 1995) introduced a new logically-based approach to refinement graph search of the hypothesis space based on inverting the entailment relation. Meanwhile,
the TILDE system (De Raedt, 1997) demonstrated the efficiency which could be gained by upgrading
decision-tree learning algorithms to first-order logic, this was soon extended towards other ML problems.
Some limitations of Prolog-based ILP include requiring extensional background and negative examples,
lack of predicate invention, search limitations and inability to handle cuts. Integrating bottom-up and
top-down searches, incorporating predicate invention, eliminating the need for explicit negative examples
and allowing restricted use of cuts helps in solving these issues (Mooney, 1996).
4
Probabilistic ILP (PILP) also gained popularity (Cussens, 2001a; De Raedt and Kersting, 2008;
Muggleton et al., 1996), its Prolog-based systems such as PRISM (Sato et al., 2005) and FAM (Cussens,
2001b) separate the actual learning of the logic program from the probabilistic parameters estimation
of the individual clauses. However in practice, learning the structure and parameters of probabilistic
logic representation simultaneously has proven to be a challenge (Muggleton, 2002). PILP is mainly a
unification of the probabilistic reasoning of Machine Learning with the relational logical representations
offered by ILP.
Meta-interpretive learning (MIL) (Muggleton et al., 2014) is a recent ILP method which learns recursive definitions using Prolog and ASP-based declarative representations. MIL is an extension of the
Prolog meta-interpreter; it derives a proof by repeatedly fetching the first-order Prolog clauses and additionally fetching higher-order meta-rules whose heads unify with a given goal, and saves the resulting
meta-substitutions to form a program.
Most ILP research has been aimed at Horn programs which exclude Negation as Failure (NAF).
Negation is a key feature of logic programming and provides a means for monotonic commonsense
reasoning under incomplete information. This fails to exploit the full potential of normal programs that
allow NAF.
We next give an overview of ILP systems based on ASP that are designed to operate in the presence
of negation. Then we give an overview of ILP literature related to NLP.
3.1
ASP-based ILP Systems
The eXtended Hybrid Abductive Inductive Learning system (XHAIL) is an ILP approach based on ASP
that generalises techniques of language and search bias from Horn clauses to normal logic programs with
full usage of NAF (Ray, 2009). Like its predecessor system Hybrid Abductive Inductive Learning (HAIL)
which operated on Horn clauses, XHAIL is based on Abductive Logic Programming (ALP) (Kakas et al.,
1992), we give more details on XHAIL in Section 4.
The Incremental Learning of Event Definitions (ILED) algorithm (Katzouris et al., 2015) relies on
Abductive-Inductive learning and comprises of a scalable clause refinement methodology based on a
compressive summarization of clause coverage in a stream of examples. Previous ILP learners were batch
learners and required all training data to be in place prior to the initiation of the learning process. ILED
learns incrementally by processing training instances when they become available and altering previous
inferred knowledge to fit new observation, this is also known as theory revision. It exploits previous
computations to speed-up the learning since revising the hypothesis is considered more efficient than
learning from scratch. ILED attempts to cover a maximum of examples by re-iterating over previously
seen examples when the hypothesis has been refined. While XHAIL can ensure optimal example coverage
easily by processing all examples at once, ILED does not preserve this property due to a non-global view
on examples.
When considering ASP-based ILP, negation in the body of rules is not the only interesting addition
to the overall concept of ILP. An ASP program can have several independent solutions, called answer
sets, of the program. Even the background knowledge B can admit several answer sets without any
addition of facts from examples. Therefore, a hypothesis H can cover some examples in one answer set,
while others are covered by another answer set. XHAIL and ILED approaches are based on finding a
hypothesis that is covering all examples in a single answer set.
The Inductive Learning of Answer Set Programs approach (ILASP) is an extension of the notion
of learning from answer sets (Law et al., 2014). Importantly, it covers positive examples bravely (i.e.,
in at least one answer set) and ensures that the negation of negative examples is cautiously entailed
(i.e., no negative example is covered in any answer set). Negative examples are needed to learn Answer
Set Programs with non-determinism otherwise there is no concept of what should not be in an Answer
Set. ILASP conducts a search in multiple stages for brave and cautious entailment and processes all
examples at once. ILASP performs a less informed hypothesis search than XHAIL or ILED, that means
large hypothesis spaces are infeasible for ILASP while they are not problematic for XHAIL and ILED,
on the other hand, ILASP supports aggregates and constraints while the older systems do not support
these. ILASP2 (Law et al., 2015) extends the hypothesis space of ILASP with choice rules and weak
constraints. This permits searching for hypotheses that encode preference relations.
5
3.2
ILP and NLP
From NLP point of view, the hope of ILP is to be able to steer a mid-course between these two alternatives
of large-scale but shallow levels of analysis and small scale but deep and precise analysis. ILP should
produce a better ratio between breadth of coverage and depth of analysis (Muggleton, 1999). ILP has
been applied to the field of NLP successfully; it has not only been shown to have higher accuracies
than various other ML approaches in learning the past tense of English but also shown to be capable of
learning accurate grammars which translate sentences into deductive database queries (Law et al., 2014).
Except for one early application (Wirth, 1989) no application of ILP methods surfaced until the system
CHILL (Mooney, 1996) was developed which learned a shift-reduce parser in Prolog from a training
corpus of sentences paired with the desired parses by learning control rules and uses ILP to learn control
strategies within this framework. This work also raised several issues regarding the capabilities and
testing of ILP systems. CHILL was also used for parsing database queries to automate the construction
of a natural language interface (Zelle and Mooney, 1996) and helped in demonstrating its ability to learn
semantic mappings as well.
An extension of CHILL, CHILLIN (Zelle et al., 1994) was used along with an extension of FOIL,
mFOIL (Tang and Mooney, 2001) for semantic parsing. Where CHILLIN combines top-down and
bottom-up induction methods and mFOIL is a top-down ILP algorithm designed keeping imperfect
data in mind, which portrays whether a clause refinement is significant for the overall performance with
the help of a pre-pruning algorithm. This emphasised on how the combination of multiple clause constructors helps improve the overall learning; which is a rather similar concept to Ensemble Methods in
standard ML. Note that CHILLIN pruning is based on probability estimates and has the purpose of dealing with inconsistency in the data. Opposed to that, XHAIL already supports learning from inconsistent
data, and the pruning we discuss in Section 4.1 aims to increase scalability.
Previous work ILP systems such as TILDE and Aleph (Srinivasan, 2001) have been applied to preference learning which addressed learning ratings such as good, poor and bad. ASP expresses preferences
through weak constraints and may also contain weak constraints or optimisation statements which impose
an ordering on the answer sets (Law et al., 2015).
The system of Mitra and Baral (Mitra and Baral, 2016) uses ASP as primary knowledge representation and reasoning language to address the task of Question Answering. They use a rule layer that is
partially learned with XHAIL to connect results from an Abstract Meaning Representation parser and
an Event Calculus theory as background knowledge.
4
Extending XHAIL algorithm and system
Initially, we intended to use the latest ILP systems (ILASP2 or ILED) in our work. However, preliminary
experiments with ILASP2 showed a lack in scalability (memory usage) even for only 100 sentences due to
the unguided hypothesis search space. Moreover, experiments with ILED uncovered several problematic
corner cases in the ILED algorithm that led to empty hypotheses when processing examples that were
mutually inconsistent (which cannot be avoided in real-life NLP data). While trying to fix these problems
in the algorithm, further issues in the ILED implementation came up. After consulting the authors of
(Mitra and Baral, 2016) we learned that they had the same issues and used XHAIL, therefore we also
opted to base our research on XHAIL due to it being the most robust tool for our task in comparison to
the others.
Although XHAIL is applicable, we discovered several drawbacks and improved the approach and the
XHAIL system. We provide an overview of the parts we changed and then present our modifications.
Figure 1 shows in the middle the original XHAIL components and on the right our extension.
XHAIL finds a hypothesis using several steps. Initially the examples E plus background knowledge
B are transformed into a theory of Abductive Logic Programming (Kakas et al., 1992). The Abduction
part of XHAIL explains observations with respect to a prior theory, which yields the Kernel Set, ∆. ∆
is a set of potential heads of rules given by M such that a maximum of examples E is satisfied together
with B.
Example 2 (continued). Given (M, E, B) from Example 1, XHAIL uses B, E, and the head part of M ,
6
Examples E
Background Knowledge B
Mode Bias M (Head)
Abduction
∆ (Kernet Set)
Mode Bias M (Body)
Replaced
Modified
ground K program
Deduction
ground K program
Generalisation
(counting)
Generalisation
non-ground K’ program with support counts
non-ground K’ program
Pruning
Induction
subset of K’
Hypothesis
Figure 1: XHAIL architecture. The dotted line shows the replaced module with our version represented
by the thick solid line.
to generate the Kernel Set ∆ by abduction.
flies(a)
flies(b)
∆=
flies(c)
The Deduction part uses ∆ and the body part of the mode bias M to generate a ground program K.
K contains rules which define atoms in ∆ as true based on B and E.
The Generalisation part replaces constant terms in K with variables according to the mode bias M ,
which yields a non-ground program K ′ .
Example 3 (continued). From the
following K and K ′ .
K=
K′ =
above ∆ and M from (1), deduction and generalisation yield the
flies(a) :- bird(a), not penguin(a)
flies(b) :- bird(b), not penguin(b)
flies(c) :- bird(c), not penguin(c)
flies(X) :- bird(X), not penguin(X)
flies(Y) :- bird(Y), not penguin(Y)
flies(Z) :- bird(Z), not penguin(Z)
The Induction part searches for the smallest part of K ′ that entails as many examples of E as possible
given B. This part of K ′ which can contain a subset of the rules of K ′ and for each rule a subset of body
atoms is called a hypothesis H.
Example 4 (continued). The smallest hypothesis that covers all examples E in (2) is (4).
We next describe our modifications of XHAIL.
4.1
Kernel Pruning according to Support
The computationally most expensive part of the search in XHAIL is Induction. Each non-ground rule
in K ′ is rewritten into a combination of several guesses, one guess for the rule and one additional guess
for each body atom in the rule.
We moreover observed that some non-ground rules in K ′ are generalisations of many different ground
rules in K, while some non-ground rules correspond with only a single instance in K. In the following,
we say that the support of r in K is the number of ground rules in K that are transformed into r ∈ K ′
in the Generalisation module of XHAIL (see Figure 1).
7
Intuitively, the higher the support, the more examples can be covered with that rule, and the more
likely that rule or a part of it will be included in the optimal hypothesis.
Therefore we modified the XHAIL algorithm as follows.
• During Generalisation, we keep track of the support of each rule r ∈ K ′ by counting how often a
generalisation yields the same rule r.
• We add an integer pruning parameter P r to the algorithm and use only those rules from K ′ in the
Induction component that have a support higher than P r.
This modification is depicted as bold components which replace the dotted Generalisation module in
Figure 1.
Pruning has several consequences. From a theoretical point of view, the algorithm becomes incomplete
for P r > 0, because Induction searches in a subset of the relevant hypotheses. Hence Induction might not
be able to find a hypothesis that covers all examples, although such a hypothesis might exist with P r = 0.
From a practical point of view, pruning realises something akin to regularisation in classical ML; only
strong patterns in the data will find their way into Induction and have the possibility to be represented
in the hypothesis. A bit of pruning will therefore automatically prevent overfitting and generate more
general hypotheses. As we will show in Experiments in Section 6, the pruning allows to configure a
trade-off between considering low-support rules instead of omitting them entirely, as well as, finding a
more optimal hypothesis in comparison to a highly suboptimal one.
4.2
Unsat-core based and Best-effort Optimisation
We observed that ASP search in XHAIL Abduction and Induction components progresses very slowly
from a suboptimal to an optimal solution. XHAIL integrates version 3 of Gringo (Gebser et al., 2011)
and Clasp (Gebser et al., 2012b) which are both quite outdated. In particular Clasp in this version does
not support three important improvements that have been found for ASP optimisation: (i) unsat-core
optimisation (Andres et al., 2012), (ii) stratification for obtaining suboptimal answer sets (Alviano et al.,
2015b; Ansótegui et al., 2013), and (iii) unsat-core shrinking (Alviano and Dodaro, 2016).
Method (i) inverts the classical branch-and-bound search methodology which progresses from worst
to better solutions. Unsat-core optimisation assumes all costs can be avoided and finds unsatisfiable cores
of the problem until the assumption is true and a feasible solution is found. This has the disadvantage of
providing only the final optimal solution, and to circumvent this disadvantage, stratification in method
(ii) was developed which allows for combining branch-and-bound with method (i) to approach the optimal
value both from cost 0 and from infinite cost. Furthermore, unsat-core shrinking in method (iii), also
called ‘anytime ASP optimisation’, has the purpose of providing suboptimal solutions and aims to find
smaller cores which can speed up the search significantly by cutting more of the search space (at the cost
of searching for a smaller core). In experiments with the inductive encoding of XHAIL we found that all
three methods have a beneficial effect.
Currently, only the WASP solver (Alviano et al., 2013, 2015a) supports all of (i), (ii), and (iii), therefore we integrated WASP into XHAIL, which has a different output than Clasp. We also upgraded XHAIL
to use Gringo version 4 which uses the new ASP-Core-2 standard and has some further (performance)
advantages over older versions.
Unsat-core optimisation often finds solutions with a reasonable cost, near the optimal value, and
then takes a long time to find the true optimum or prove optimality of the found solution. Therefore,
we extended XHAIL as follows:
• a time budget for search can be specified on the command line,
• after the time budget is elapsed the best-known solution at that point is used and the algorithm
continues, furthermore
• the distance from the optimal value is provided as output.
This affects the Induction step in Figure 1 and introduces a best-effort strategy; along with the obtained
hypothesis we also get the distance from the optimal hypothesis, which is zero for optimal solutions.
Using a suboptimal hypothesis means, that either fewer examples are covered by the hypothesis than
possible, or that the hypothesis is bigger than necessary. In practice, receiving a result is better than
8
Preprocessing
Stanford
Core-NLP
tools
Learning
ILP tool
XHAIL
Testing
Chunking
with ASP
Figure 2: General overview of our framework
receiving no result at all, and our experiments show that XHAIL becomes applicable to reasonably-sized
datasets using these extensions.
4.3
Other Improvements
We made two minor engineering contributions to XHAIL. A practically effective improvement of XHAIL
concerns K ′ . As seen in Example 3, three rules that are equivalent modulo variable renaming are
contained in K ′ . XHAIL contains canonicalization algorithms for avoiding such situations, based on
hashing body elements of rules. However, we found that for cases with more than one variable and for
cases with more than one body atom, these algorithms are not effective because XHAIL (i) uses a set data
structure that maintains an order over elements, (ii) the set data structure is sensitive to insertion order,
and (iii) hashing the set relies on the order to be canonical. We made this canonicalization algorithm
applicable to a far wider range of cases by changing the data type of rule bodies in XHAIL to a set that
maintains an order depending on the value of set elements. This comes at a very low additional cost for
set insertion and often reduces size of K ′ (and therefore computational effort for Induction step) without
adversely changing the result of induction.
Another improvement concerns debugging the ASP solver. XHAIL starts the external ASP solver
and waits for the result. During ASP solving, no output is visible, however, ASP solvers provide output
that is important for tracking the distance from optimality during a search. We extended XHAIL so
that the output of the ASP solver can be made visible during the run using a command line option.
5
Chunking with ILP
We evaluate the improvements of the previous section using the NLP task of chunking. Chunking
(Tjong Kim Sang and Buchholz, 2000) or shallow parsing is the identification of short phrases such as
noun phrases or prepositional phrases, usually based heavily on Part of Speech (POS) tags. POS provides
only information about the token type, i.e., whether words are nouns, verbs, adjectives, etc., and chunking
derives from that a shallow phrase structure, in our case a single level of chunks.
Our framework for chunking has three main parts as shown in Figure 2. Preprocessing is done using
the Stanford CoreNLP tool from which we obtain the facts that are added to the background knowledge
of XHAIL or used with a hypothesis to predict the chunks of an input. Using XHAIL as our ILP solver we
learn a hypothesis (an ASP program) from the background knowledge, mode bias, and from examples
which are generated using the gold-standard data. We predict chunks using our learned hypothesis
and facts from preprocessing, using the Clingo (Gebser et al., 2008) ASP solver. We test by scoring
predictions against gold chunk annotations.
Example 5. An example sentence in the SemEval iSTS dataset (Agirre et al., 2016) is as follows.
Former Nazi death camp guard Demjanjuk dead at 91
(5)
The chunking present in the SemEval gold standard is as follows.
[ Former Nazi death camp guard Demjanjuk ] [ dead ] [ at 91 ]
5.1
(6)
Preprocessing
Stanford CoreNLP tools (Manning et al., 2014) are used for tokenisations and POS-tagging of the input.
Using a shallow parser (Bohnet et al., 2013) we obtain the dependency relations for the sentences. Our
ASP representation contains atoms of the following form:
9
pos (c_NNP, 1 ) . head ( 2 , 1 ) . form ( 1 , " Former " ) . r e l (c_NAME, 1 ) .
pos (c_NNP, 2 ) . head ( 5 , 2 ) . form ( 2 , " Nazi " ) . r e l (c_NMOD, 2 ) .
pos (c_NN, 3 ) . head ( 4 , 3 ) . form ( 3 , " death " ) . r e l (c_NMOD, 3 ) .
pos (c_NN, 4 ) . head ( 5 , 4 ) . form ( 4 , "camp" ) . r e l (c_NMOD, 4 ) .
pos (c_NN, 5 ) . head ( 7 , 5 ) . form ( 5 , " guard " ) . r e l ( c_SBJ , 5 ) .
pos (c_NNP, 6 ) . head ( 5 , 6 ) . form ( 6 , " Demjanjuk" ) . r e l (c_APPO, 6 ) .
pos (c_VBD, 7 ) . head ( r o o t , 7 ) . form ( 7 , " dead " ) . r e l (c_ROOT, 7 ) .
pos ( c_IN , 8 ) . head ( 7 , 8 ) . form ( 8 , " a t " ) . r e l (c_ADV, 8 ) .
pos (c_CD, 9 ) . head ( 8 , 9 ) . form ( 9 , " 91 " ) . r e l (c_PMOD, 9 ) .
(a) Preprocessing Output
p o s t y p e (X) :− pos (X,_) .
tok en (X) :− pos (_,X) .
n e x t p o s (P ,X) :− pos (P ,X+1).
(b) Background Knowledge
#modeh s p l i t (+ tok en ) .
#modeb pos ( $posty pe ,+ tok en ) .
#modeb n e x t p o s ( $posty pe ,+ tok en ) .
(c) Mode Restrictions
goodchunk ( 1 ) :− not s p l i t ( 1 ) , not s p l i t ( 2 ) , not s p l i t ( 3 ) ,
not s p l i t ( 4 ) , not s p l i t ( 5 ) , s p l i t ( 6 ) .
goodchunk ( 7 ) :− s p l i t ( 6 ) , s p l i t ( 7 ) .
goodchunk ( 8 ) :− s p l i t ( 7 ) , not s p l i t ( 8 ) .
#example goodchunk ( 1 ) .
#example goodchunk ( 7 ) .
#example goodchunk ( 8 ) .
(d) Examples
Figure 3: XHAIL input for the sentence ’Former Nazi death camp guard Demjanjuk dead at 91’ from
the Headlines Dataset
• pos(P , T ) which represents that token T has POS tag P ,
• form(T , Text ) which represents that token T has surface form Text ,
• head (T1 , T2 ) and rel (R, T ) which represent that token T2 depends on token T1 with dependency
relation R.
Example 6 (continued). Figure 3a shows the result of preprocessing performed on sentence (5), which
is a set of ASP facts.
We use Penn Treebank POS-tags as they are provided by Stanford CoreNLP. To form valid ASP
constant terms from POS-tags, we prefix them with ‘c_’, replace special characters with lowercase
letters (e.g., ‘PRP$’ becomes ‘c_PRPd’). In addition, we create specific POS-tags for punctuation (see
Section 6.4).
5.2
Background Knowledge and Mode Bias
Background Knowledge we use is shown in Figure 3b. We define which POS-tags can exist in predicate
postype/1 and which tokens exist in predicate token/1. Moreover, we provide for each token the POS-tag
of its successors token in predicate nextpos/2.
Mode bias conditions are shown in Figure 3c, these limit the search space for hypothesis generation.
Hypothesis rules contain as head atoms of the form
split (T )
10
which indicates, that a chunk ends at token T and a new chunk starts at token T + 1. The argument of
predicates split /1 in the head is of type token.
The body of hypothesis rules can contain pos/2 and nextpos/2 predicates, where the first argument
is a constant of type postype (which is defined in Figure 3b) and the second argument is a variable of
type token. Hence this mode bias searches for rules defining chunk splits based on POS-tag of the token
and the next token.
We deliberately use a very simple mode bias that does not make use of all atoms in the facts obtained
from preprocessing. This is discussed in Section 6.5.
5.3
Learning with ILP
Learning with ILP is based on examples that guide the search. Figure 3d shows rules that recognise gold
standard chunks and #example instructions that define for XHAIL which atoms must be true to entail
an example. These rules with goodchunk /1 in the head define what a good (i.e., gold standard) chunk is
in each example based on where a split in a chunk occurs in the training data to help in the learning of
a hypothesis for chunking.
Note that negation is present only in these rules, although we could use it anywhere else in the
background knowledge. Using the background knowledge, mode bias, and examples, XHAIL is then able
to learn a hypothesis.
5.4
Chunking with ASP using Learned Hypothesis
The hypothesis generated by XHAIL can then be used together with the background knowledge specified
in Figure 3b, and with the preprocessed input of a new sentence. Evaluating all these rules yields a set
of split points in the sentence, which corresponds to a predicted chunking of the input sentence.
Example 7 (continued). Given sentence (5) with token indices 1, . . . , 9, an answer set that contains the
atoms {split (6), split (7)} and no other atoms for predicate split /1 yields the chunking shown in (6).
6
6.1
Evaluation and Discussion
Datasets
We are using the datasets from the SemEval 2016 iSTS Task 2 (Agirre et al., 2016), which included two
separate files containing sentence pairs. Three different datasets were provided: Headlines, Images, and
Answers-Students. The Headlines dataset was mined by various news sources by European Media Monitor. The Images dataset was a collection of captions obtained from the Flickr dataset (Rashtchian et al.,
2010). The Answers-Students corpus consists of the interactions between students and the BEETLE II
tutorial dialogue system which is an intelligent tutoring engine that teaches students in basic electricity and electronics. In the following, we denote S1 and S2, by sentence 1 and sentence 2 respectively,
of sentence pairs in these datasets. Regarding the size of the SemEval Training dataset, Headlines and
Images datasets are larger and contained 756 and 750 sentence pairs, respectively. However, the AnswersStudents dataset was smaller and contained only 330 sentence pairs. In addition, all datasets contain a
Test portion of sentence pairs.
We use k-fold cross-validation to evaluate chunking with ILP, which yields k learned hypotheses and
k evaluation scores for each parameter setting. We test each of these hypotheses also on the Test portion
of the respective dataset. From the scores obtained this way we compute mean and standard deviation,
and perform statistical tests to find out whether observed score differences between parameter settings
is statistically significant.
Table 1 shows which portions of the SemEval Training dataset we used for 11-fold cross-validation.
In the following, we call these datasets Cross-Validation Sets. We chose the first 110 and 550 examples
to use for 11-fold cross-validation which results in training set sizes 100 and 500, respectively. As the
Answers-Students dataset was smaller, we merged its sentence pairs in order to obtain a Cross-Validation
Set size of 110 sentences, using the first 55 sentences from S1 and S2; and for 550 sentences, using the
first 275 sentences from S1 and S2 each. As Test portions we only use the original SemEval Test datasets
and we always test S1 and S2 separately.
11
Dataset
Cross-Validation Set
Size
Examples
S1
S2
H/I
100
500
100
500
S1
S1
S2
S2
all
all
*
*
*
*
all
all
A-S
100
500
S1 first 55 + S2 first 55
S1 first 275 + S2 first 275
all
all
all
all
first
first
first
first
110
550
110
550
Test Set
Table 1: Dataset partitioning for 11-fold cross-validation experiments. Size indicates the training set
size in cross-validation. Fields marked with * are not applicable, because we do not evaluate hypotheses
learned from the S1 portion of the Headlines (H) and Images (I) datasets on the (independent) S2 portion
of these datasets and vice versa. For the Answers-Students (A-S) dataset we need to merge S1 and S2
to obtain a training set size of 500 from the (small) SemEval Training dataset.
6.2
Scoring
We use difflib.SequenceMatcher in Python to match the sentence chunks obtained from learning in ILP
against the gold-standard sentence chunks. From the matchings obtained this way, we compute precision,
recall, and F1-score as follows.
P recision =
Recall =
No. of Matched Sequences
No. of ILP-learned Chunks
No. of Matched Sequences
No. of Gold Chunks
Score = 2 ×
Precision × Recall
Precision + Recall
To investigate the effectivity of our mode bias for learning a hypothesis that can correctly classify
the dataset, we perform cross-validation (see above) and measure correctness of all hypotheses obtained
in cross-validation also on the Test set.
Because of differences in S1/S2 portions of datasets, we report results separately for S1 and S2. We
also evaluate classification separately for S1 and S2 for the Answers-Students dataset, although we train
on a combination of S1 and S2.
6.3
Experimental Methodology
We use Gringo version 4.5 (Gebser et al., 2011) and we use WASP version 2 (Git hash a44a95) (Alviano et al.,
2015a) configured to use unsat-core optimisation with disjunctive core partitioning, core trimming, a budget of 30 seconds for computing the first answer set and for shrinking unsatisfiable cores with progressive
shrinking strategy. These parameters were found most effective in preliminary experiments. We configure
our modified XHAIL solver to allocate a budget of 1800 seconds for the Induction part which optimises
the hypothesis (see Section 4.2). Memory usage never exceeded 5 GB.
Tables 4–6 contains the experimental results for each Dataset, where columns Size, P r, and So respectively, show the number of sentences used to learn the hypothesis, the pruning parameter for generalising
the learned hypothesis (see Section 4.1), and the rate of how close the learned hypothesis is to the optimal
,
result, respectively. So is computed according to the following formula: So = Upperbound−Lowerbound
Lowerbound
which is based on upper and lower bounds on the cost of the answer set. An So value of zero means
optimality, and values above zero mean suboptimality; so the higher the value, the further away from
optimality. Our results comprise of the mean and standard deviation of the F1-scores obtained from our
11-fold cross-validation test set of S1 and S2 individually (column CV). Due to lack of space, we opted
to leave out the scores of precision and recall, but these values show similar trends as in the Test set.
For the Test sets of both S1 and S2, we include the mean and standard deviation of the Precision, Recall
and F1-scores (column group T).
12
When testing machine-learning based systems, comparing results obtained on a single test set is often
not sufficient, therefore we performed cross-validation to obtain mean and standard deviation about our
benchmark metrics. To obtain even more solid evidence about the significance of the measured results,
we additionally performed a one-tailed paired t-test to check if a measured F1 score is significantly
higher in one setting than in another one. We consider a result significant if p < 0.05, i.e., if there is
a probability of less than 5 % that the result is due to chance. Our test is one-tailed because we check
whether one result is higher than another one, and it is a paired test because we test different parameters
on the same set of 11 training/test splits in cross-validation. There are even more powerful methods for
proving significance of results such as bootstrap sampling (Efron and Tibshirani, 1986), however these
methods require markedly higher computational effort in experiments and our experiments already show
significance with the t-test.
Rows of Tables 4–6 contain results for learning from 100 resp. 500 example sentences, and for different
pruning parameters. For both learning set sizes, we increased pruning stepwise starting from value 0
until we found an optimal hypothesis (So = 0) or until we saw a clear peak in classification score in
cross-validation (in that case, increasing the pruning is pointless because it would increase optimality of
the hypothesis but decrease the prediction scores).
Note that datasets have been tokenised very differently, and that also state-of-the-art systems in
SemEval used separate preprocessing methods for each dataset. We follow this strategy to allow a fair
comparison. One example for such a difference is the Images dataset, where the ‘.’ is considered as
a separate token and is later defined as a separate chunk, however in Answers-Students dataset it is
integrated onto neighboring tokens.
6.4
Results
We first discuss the results of experiments with varying training set size and varying pruning parameter,
then compare our approach with the state-of-the-art systems, and finally inspect the optimal hypotheses.
Training Set Size and Pruning Parameter Tables 4–6 show results of experiments, where T
denotes the Test portion of the respective dataset.
We observe that by increasing the size of the training set to learn the hypothesis, our scores improved
considerably. Due to more information being provided, the learned hypothesis can predict with higher
F1 score. We also observed that for the smaller training set size (100 sentences), lower pruning numbers
(in rare cases even P r=0) resulted in achieving the optimal solution. For a bigger training set size (500
sentences), without pruning the ILP procedure does not find solutions close to the optimal solution.
However, by using pruning values up to P r=10 we can reduce the size of the search space and find
hypotheses closer to the optimum, which predict chunks with a higher F1 score. Our statistical test
shows that, in many cases, several increments of the P r parameter yield significantly better results, up
to a point where prediction accuracy degrades because too many examples are pruned away. To select
the best hypothesis, we increase the pruning parameter Pr until we reach the peak in the F1 score in
cross-validation.
Finding optimal hypotheses in the Inductive search of XHAIL (where So=0) is easily attained when
learning from 100 sentences. For learning from 500 sentences, very higher pruning results in a trivial
optimal hypothesis (i.e., every token is a chunk) which has no predictive power, hence we do not increase
P r beyond a value of 10.
Note that we never encountered timeouts in the Abduction component of XHAIL, only in the Induction part. The original XHAIL tool without our improvements yields only timeouts for learning from 500
examples, and few hypotheses for learning from 100 examples. Therefore we do not show these results
in tables.
State-of-the-art comparison Table 2 shows a comparison of our results with the baseline and the
three best systems from the chunking subtask of Task 2 from SemEval2016 Task2 (Agirre et al., 2016):
DTSim (Banjade et al., 2016), FBK-HLT-NLP (Magnolini et al., 2016) and runs 1 and 2 of IISCNLP
(Tekumalla and Jat, 2016). We also compare with results of our own system ‘Inspire-Manual’ (Kazmi and Schüller,
2016).
13
S1
P
R
F1
Headlines
Baseline
DTSim
FBK-HLT-NLP
IISCNLP - Run1
IISCNLP - Run2
Inspire - Manual
Inspire - Learned
60.5
72.5
63.6
61.9
67.6
64.5
68.1±2.5
36.6
74.3
51.3
68.5
68.5
70.4
70.6±2.5
Images
S2
Baseline
DTSim
FBK-HLT-NLP
IISCNLP - Run1
IISCNLP - Run2
Inspire - Manual
Inspire - Learned
19.0
77.8
41.0
61.6
65.8
74.5
66.4±15.5
Answers-Students
Data System
Baseline
DTSim
FBK-HLT-NLP
IISCNLP - Run1
IISCNLP - Run2
Inspire - Manual
Inspire - Learned
62.1
78.5
70.3
67.9
63.0
66.8
66.8±2.8
Rank
P
R
F1
Rank
37.6
71.3
*
51.5
61.4
64.5
***
62.4
65.4±2.6 **
63.6
72.1
57.1
61.1
71.4
64.3
67.2±1.3
42.5
74.3
51.1
65.7
71.9
68.4
68.2±2.4
42.8
70.5
*
48.3
60.1
68.9
**
62.2
64.0±1.8 ***
15.7
77.4
39.2
60.9
65.6
74.2
74.3±0.7
16.4
77.5
*
38.8
60.7
65.4
74.2
**
73.7±0.7 ***
13.6
79.5
40.5
66.1
67.7
73.8
71.1±0.8
17.5
79.1
43.1
66.2
67.2
73.6
71.1±0.8
13.5
79.2
*
40.8
65.9
67.3
73.6
**
70.9±0.8 ***
30.9
73.6
52.5
63.9
59.8
64.4
70.5±2.5
34.6
72.5
*
52.8
60.7
***
56.9
59.7
63.5±2.4 **
59.2
83.3
72.4
65.7
66.2
71.2
89.3±3.0
33.4
79.2
59.1
55.0
52.5
62.5
80.1±0.7
36.6
77.8
**
59.3
54.0
52.8
62.1
***
80.3±1.7 *
Table 2: Comparison with systems from SemEval 2016 Task 2. The number of stars shows the rank of
the system.
• The baseline makes use of the automatic probabilistic chunker from the IXA-pipeline which provides
Perceptron models (Collins, 2002) for chunking and is trained on CONLL2000 corpora and corrected
manually,
• DTSim uses a Conditional Random Field (CRF) based chunking tool using only POS-tags as
features,
• FBK-HLT-NLP obtains chunks using a Python implementation of MBSP chunker which uses a
Memory-based part-of-speech tagger generator (Daelemans et al., 1996),
• Run 1 of IISCNLP uses OpenNLP chunker which divides the sentence into syntactically correlated
parts of words, but does not specify their internal structure, nor their role in the main sentence.
Run 2 uses Stanford NLP Parser to create parse trees and then uses a perl script to create chunks
based on the parse trees, and
• Inspire-Manual (our previous system) makes use of manually set chunking rules (Abney, 1991)
using ASP (Kazmi and Schüller, 2016).
Using the gold-standard chunks provided by the organisers we were able to compute the precision,
recall, and F1-scores for analysis on the Headlines, Images and Answers-Students datasets.
For the scores of our system ‘Inspire-Learned’, we used the mean and average of the best configuration
of our system as obtained in cross-validation experiments on the Test set and compared against the other
systems’ Test set results. Our system’s performance is quite robust: it is always scores within the top
three best systems.
Inspection of Hypotheses Table 3 shows the rules that are obtained from the hypothesis generated
by XHAIL from Sentence 1 files of all the datasets. We have also tabulated the common rules present
between the datasets and the extra rules which differentiate the datasets from each other. POS-tags for
14
Rules
split(V)
split(V)
split(V)
split(V)
split(V)
split(V)
split(V)
split(V)
split(V)
split(V)
split(V)
split(V)
split(V)
split(V)
split(V)
split(V)
split(V)
split(V)
split(V)
split(V)
split(V)
split(V)
split(V)
split(V)
split(V)
split(V)
split(V)
split(V)
split(V)
split(V)
split(V)
split(V)
split(V)
split(V)
split(V)
split(V)
split(V)
split(V)
split(V)
split(V)
split(V)
split(V)
split(V)
split(V)
split(V)
split(V)
::::::::::::::::::::::::::::::::::::::::::::::-
token(V),
token(V),
token(V),
token(V),
token(V),
token(V),
token(V),
token(V),
token(V),
token(V),
token(V),
token(V),
token(V),
token(V),
token(V),
token(V),
token(V),
token(V),
token(V),
token(V),
token(V),
token(V),
token(V),
token(V),
token(V),
token(V),
token(V),
token(V),
token(V),
token(V),
token(V),
token(V),
token(V),
token(V),
token(V),
token(V),
token(V),
token(V),
token(V),
token(V),
token(V),
token(V),
token(V),
token(V),
token(V),
token(V),
pos(c_VBD,V).
nextpos(c_IN,V).
nextpos(c_VBZ,V).
pos(c_VB,V).
nextpos(c_TO,V).
nextpos(c_VBD,V).
nextpos(c_VBP,V).
pos(c_VBZ,V), nextpos(c_DT,V).
pos(c_NN,V), nextpos(c_RB,V).
pos(c_NNS,V).
pos(c_VBP,V).
pos(c_VBZ,V).
pos(c_c,V).
nextpos(c_POS,V).
nextpos(c_VBN,V).
nextpos(c_c,V).
pos(c_PRP,V).
pos(c_RP,V).
pos(c_p,V).
nextpos(c_p,V).
pos(c_CC,V), nextpos(c_VBG,V).
pos(c_NN,V), nextpos(c_VBD,V).
pos(c_NN,V), nextpos(c_VBG,V).
pos(c_NN,V), nextpos(c_VBN,V).
pos(c_NNS,V), nextpos(c_VBG,V).
pos(c_RB,V), nextpos(c_IN,V).
pos(c_VBG,V), nextpos(c_DT,V).
pos(c_VBG,V), nextpos(c_JJ,V).
pos(c_VBG,V), nextpos(c_PRPd,V).
pos(c_VBG,V), nextpos(c_RB,V).
pos(c_VBZ,V), nextpos(c_IN,V).
pos(c_EX,V).
pos(c_RB,V).
pos(c_VBG,V).
pos(c_WDT,V).
pos(c_WRB,V).
nextpos(c_EX,V).
nextpos(c_MD,V).
nextpos(c_VBG,V).
nextpos(c_RB,V).
pos(c_IN,V), nextpos(c_NNP,V).
pos(c_NN,V), nextpos(c_WDT,V).
pos(c_NN,V), nextpos(c_IN,V).
pos(c_NNS,V), nextpos(c_IN,V).
pos(c_NNS,V), nextpos(c_VBP,V).
pos(c_RB,V), nextpos(c_DT,V).
H
I
A-S
X
X
X
X
X
X
X
X
X
X
X
X
X
X
X
X
X
X
X
X
X
X
X
X
X
X
X
X
X
X
X
X
X
X
X
X
X
X
X
X
X
X
X
X
X
X
X
X
X
X
X
X
X
X
X
X
X
X
Table 3: Rules in the best hypotheses obtained from training on 500 sentences (S1), where X marks the
presence of the rule in a given dataset.
punctuation are ‘c_p’ for sentence-final punctuation (‘.’, ‘ ?’, and ‘ !’) and ‘c_c’ for sentence-separating
punctuation (‘,’, ‘;’, and ‘:’).
Rules which occur in all learned hypotheses can be interpreted as follows (recall the meaning of
split (X) from Section 5.2): (i) chunks end at past tense verbs (VBD, e.g., ‘walked’), (ii) chunks begin at
subordinating conjunctions and prepositions (IN, e.g., ‘in’), and (iii) chunks begin at 3rd person singular
present tense verbs (VBZ, e.g., ‘walks’). Rules that are common to H and AS datasets are as follows:
(i) chunks end at base forms of verbs (VB, e.g., ‘[to] walk’), (ii) chunks begin at ‘to’ prepositions (TO),
and (iii) chunks begin at past tense verbs (VBD). The absence of (i) in hypotheses for the Images dataset
can be explained by the rareness of such verbs in captions of images. Note that (iii) together with the
common rule (i) means that all VBD verbs become separate chunks in H and AS datasets. Rules that
are common to I and AS datasets are as follows: (i) chunks begin at non-3rd person verbs in present
tense (VBP, e.g., ‘[we] walk’), (ii) chunk boundaries are between a determiner (DT, e.g., ‘both’) and a
15
3rd person singular present tense verb (VBZ), and (iii) chunk boundaries are between adverbs (RB, e.g.,
‘usually’) and common, singular, or mass nouns (NN, e.g., ‘humor’). Interestingly, there are no rules
common to H and I datasets except for the three rules mutual to all three datasets.
For rules occurring only in single datasets, we only discuss a few interesting cases in the following.
Rules that are unique to the Headlines dataset include rules which indicate that the sentence separators
‘,’, ‘;’, and ‘:’, become single chunks, moreover chunks start at genitive markers (POS, ‘’s’). Both is
not the case for the other two data sets. Rules unique to the Images dataset include that sentencefinal punctuation (‘.’, ‘ ?’, and ‘ !’) become separate chunks, rules for chunk boundaries between verb
(VB_) and noun (NN_) tokens, and chunk boundaries between possessive pronouns (PRP$, encoded
as ‘c_PRPd’, e.g., ‘their’) and participles/gerunds (VBG, e.g., ‘falling’). Rules unique to AnswersStudents dataset include chunks containing ‘existential there’ (EX), adverb tokens (RB), gerunds (VBG),
and several rules for splits related to WH-determiners (WDT, e.g., ‘which’), WH-adverbs (WRB, e.g.,
‘how’), and prepositions (IN).
We see that learned hypotheses are interpretable, which is not the case in classical machine learning
techniques such as Neural Networks (NN), Conditional Random Fields (CRF), and Support Vector
Machines (SVM).
6.5
Discussion
We next discuss the potential impact of our approach in NLP and in other applications, outline the
strengths and weaknesses, and discuss reasons for several design choices we made.
Impact and Applicability ILP is applicable to many problems of traditional machine learning, but
usually only applicable for small datasets. Our addition of pruning enables learning from larger datasets
at the cost of obtaining a more coarse-grained hypothesis and potentially suboptimal solutions.
The main advantage of ILP is interpretability and that it can achieve good results already with small
datasets. Interpretability of the learned rule-based hypothesis makes the learned hypothesis transparent
as opposed to black-box models of other approaches in the field such as Conditional Random Fields,
Neural Networks, or Support Vector Machines. These approaches are often purely statistical, operate on
big matrices of real numbers instead of logical rules, and are not interpretable. The disadvantage of ILP
is that it often does not achieve the predictive performance of purely statistical approaches because the
complexity of ILP learning limits the number of distinct features that can be used simultaneously.
Our approach allows finding suboptimal hypotheses which yield a higher prediction accuracy than
an optimal hypothesis trained on a smaller training set. Learning a better model from a larger dataset
is exactly what we would expect in machine learning. Before our improvement of XHAIL, obtaining any
hypothesis from larger datasets was impossible: the original XHAIL tool does not return any hypothesis
within several hours when learning from 500 examples.
Our chunking approach learns from a small portion of the full SemEval Training dataset, based
on only POS-tags, but it still achieves results close to the state-of-the-art. Additionally it provides an
interpretable model that allowed us to pinpoint non-uniform annotation practices in the three datasets of
the SemEval 2016 iSTS competition. These observations give direct evidence for differences in annotation
practice for three datasets with respect to punctuation and genitives, as well as differences in the content
of the datasets
Strengths and weaknesses Our additions of pruning and the usage of suboptimal answer sets make
ILP more robust because it permits learning from larger datasets and obtaining (potentially suboptimal)
solutions faster.
Our addition of a time budget and usage of suboptimal answer sets is a purely beneficial addition to
the XHAIL approach. If we disregard the additional benefits of pruning, i.e., if we disable pruning by
setting P r=0, then within the same time budget, the same optimal solutions are to be found as if using
the original XHAIL approach. In addition, before finding the optimal solution, suboptimal hypotheses
are provided in an online manner, together with information about their distance from the optimal
solution.
The strength of pruning before the Induction phase is, that it permits learning from a bigger set of
examples, while still considering all examples in the dataset. A weakness of pruning is, that a hypothesis
16
which fits perfectly to the data might not be found anymore, even if the mode bias could permit such a
perfect fit. In NLP applications this is not a big disadvantage, because noise usually prevents a perfect fit
anyways, and overfitting models is indeed often a problem. However, in other application domains such
as learning to interpret input data from user examples (Gulwani et al., 2015), a perfect fit to the input
data might be desired and required. Note that pruning examples to learn from inconsistent data as done
by Tang and Mooney (Tang and Mooney, 2001) is not necessary for our approach. Instead, non-covered
examples incur a cost that is optimised to be as small as possible.
Design decisions In our study, we use a simple mode bias containing only the current and next POS
tags, which is a deliberate choice to make results easier to compare. We performed experiments with
additional body atoms head /2 and rel /2 in the body mode bias, moreover with negation in the body
mode bias. However, these experiments yielded significantly larger hypotheses with only small increases
in accuracy. Therefore we here limit the analysis to the simple case and consider more complex mode
biases as future work. Note that the best state-of-the-art system (DTSim) is a CRF model solely based
on POS-tags, just as our hypothesis is only making use of POS-tags. By considering more than the
current and immediately succeeding POS tag, DTSim can achieve better results than we do.
The representation of examples is an important part of our chunking case as described in Section 5.
We define predicate goodchunk with rules that consider presence and absence of splits for each chunk. We
make use of the power of NAF in these rules. We also experimented with an example representation that
just gave all desired splits as #example split(X) and all undesired splits as #example not split(Y).
This representation contains an imbalance in the split versus not split class, moreover, chunks are not
represented as a concept that can be optimised in the inductive search for the best hypothesis. Hence,
it is not surprising that this simpler representation of examples gave drastically worse scores, and we do
not report any of these results in detail.
7
Conclusion and Future Work
Inductive Logic Programming combines logic programming and machine learning, and it provides interpretable models, i.e., logical hypotheses, which are learned from data. ILP has been applied to a variety
of NLP and other problems such as parsing (Tang and Mooney, 2001; Zelle and Mooney, 1996), automatic construction of biological knowledge bases from scientific abstracts (Craven and Kumlien, 1999),
automatic scientific discovery (King et al., 2004), and in Microsoft Excel Gulwani et al. (2015) where
users can specify data extraction rules using examples. Therefore, ILP research has the potential for
being used in a wide range of applications.
In this work, we explored the usage of ILP for the NLP task of chunking and extend the XHAIL ILP
solver to increase its scalability and applicability for this task. Results indicate that ILP is competitive to
state-of-the-art ML techniques for this task and that we successfully extended XHAIL to allow learning
from larger datasets than previously possible. Learning a hypothesis using ILP has the advantage of an
interpretable representation of the learned knowledge, such that we know exactly which rule has been
learned by the program and how it affects our NLP task. In this study, we also gain insights about the
differences and common points of datasets that we learned a hypothesis from. Moreover, ILP permits
learning from small training sets where techniques such as Neural Networks fail to provide good results.
As a first contribution to the ILP tool XHAIL we have upgraded the software so that it uses the newest
solver technology, and that this technology is used in a best-effort manner that can utilise suboptimal
search results. This is effective in practice, because finding the optimal solution can be disproportionately
more difficult than finding a solution close to the optimum. Moreover, the ASP technique we use here
provides a clear information about the degree of suboptimality. During our experiments, a new version of
Clingo was published which contains most techniques in WASP (except for core shrinking). We decided
to continue using WASP for this study because we saw that core shrinking is also beneficial to search.
Extending XHAIL to use Clingo in a best-effort manner is quite straight-forward.
As a second contribution to XHAIL we have added a pruning parameter to the algorithm that
allows fine-tuning the search space for hypotheses by filtering out rule candidates that are supported
by fewer examples than other rules. This addition is a novel contribution to the algorithm, which leads
to significant improvements in efficiency, and increases the number of hypotheses that are found in a
given time budget. While pruning makes the method incomplete, it does not reduce expressivity. The
17
hypotheses and background knowledge may still contain unrestricted Negation as Failure. Pruning in
our work is similar to the concept of the regularisation in ML and is there to prevent overfitting in
the hypothesis generation. Pruning enables the learning of logical hypotheses with dataset sizes that
were not feasible before. We experimentally observed a trade-off between finding an optimal hypothesis
that considers all potential rules on one hand, and finding a suboptimal hypothesis that is based on
rules that are supported by few examples. Therefore the pruning parameter has to be adjusted on an
application-by-application basis.
Our work has focused on providing comparable results to ML techniques and we have not utilised the
full power of ILP with NAF in rule bodies and predicate invention. As future work, we plan to extend
the predicates usable in hypotheses to provide a more detailed representation of the NLP task, moreover
we plan to enrich the background knowledge to aid ILP in learning a better hypothesis with a deeper
structure representing the boundaries of chunks.
We provide the modified XHAIL system in a public repository fork (Bragaglia and Schüller, 2016).
Acknowledgments
This research has been supported by the Scientific and Technological Research Council of Turkey
(TUBITAK) [grant number 114E777] and by the Higher Education Commission of Pakistan (HEC).
We are grateful to Carmine Dodaro for providing us with support regarding the WASP solver.
References
Abney, S. P. (1991). Parsing by chunks. In Principle-based parsing, pages 257–278.
Agirre, E., Gonzalez-Agirre, A., Lopez-Gazpio, I., Maritxalar, M., Rigau, G., and Uria, L. (2016).
SemEval-2016 task 2: Interpretable Semantic Textual Similarity. In Proceedings of SemEval, pages
512–524.
Alviano, M. and Dodaro, C. (2016). Anytime answer set optimization via unsatisfiable core shrinking.
Theory and Practice of Logic Programming, 16(5-6):533–551.
Alviano, M., Dodaro, C., Faber, W., Leone, N., and Ricca, F. (2013). WASP: A native ASP solver based
on constraint learning. In Logic Programming and Nonmonotonic Reasoning, pages 54–66.
Alviano, M., Dodaro, C., Leone, N., and Ricca, F. (2015a). Advances in WASP. In Logic Programming
and Nonmonotonic Reasoning , pages 40–54.
Alviano, M., Dodaro, C., Marques-Silva, J., and Ricca, F. (2015b). Optimum stable model search:
algorithms and implementation. Journal of Logic and Computation, page exv061.
Andres, B., Kaufmann, B., Matheis, O., and Schaub, T. (2012). Unsatisfiability-based optimization in
clasp. In International Conference on Logic Programming, Technical Communications, pages 212–221.
Ansótegui, C., Bonet, M. L., and Levy, J. (2013). SAT-based MaxSAT algorithms. Artificial Intelligence,
196:77–105.
Banjade, R., Maharjan, N., Niraula, N. B., and Rus, V. (2016). DTSim at SemEval-2016 task 2:
Interpreting Similarity of Texts Based on Automated Chunking, Chunk Alignment and Semantic
Relation Prediction. In Proceedings of SemEval, pages 809–813.
Bohnet, B., Nivre, J., Boguslavsky, I., Farkas, R., Ginter, F., and Hajič, J. (2013). Joint morphological
and syntactic analysis for richly inflected languages. Transactions of the Association for Computational
Linguistics, 1:415–428.
Bragaglia, S. and Schüller, P. (2016). XHAIL (Version 4c5e0b8) [System for eXtended Hybrid Abductive
Inductive Learning]. Retrieved from https://github.com/knowlp/XHAIL.
Brewka, G., Eiter, T., and Truszczyński, M. (2011). Answer set programming at a glance. Communications of the ACM, 54(12):92–103.
Calimeri, F., Faber, W., Gebser, M., Ianni, G., Kaminski, R., Krennwallner, T., Leone, N., Ricca, F.,
18
and Schaub, T. (2012). ASP-Core-2 Input language format. Technical report, ASP Standardization
Working Group.
Clocksin, W. and Mellish, C. S. (2003). Programming in PROLOG. Springer Science & Business Media.
Collins, M. (2002). Discriminative training methods for hidden markov models: Theory and experiments
with perceptron algorithms. In Proceedings of the ACL-02 conference on Empirical methods in natural
language processing-Volume 10, pages 1–8. Association for Computational Linguistics.
Craven, M. and Kumlien, J. (1999). Constructing biological knowledge bases by extracting information
from text sources. In International Conference on Intelligent Systems for Molecular Biology (ISMB),
pages 77–86.
Cussens, J. (2001a). Integrating probabilistic and logical reasoning. In Foundations of Bayesianism,
pages 241–260.
Cussens, J. (2001b). Parameter estimation in stochastic logic programs. Machine Learning, 44(3):245–
271.
Daelemans, W., Zavrel, J., Berck, P., and Gillis, S. (1996). Mbt: A memory-based part of speech
tagger-generator. arXiv preprint cmp-lg/9607012.
De Raedt, L. (1997). Logical settings for concept-learning. Artificial Intelligence, 95(1):187–201.
De Raedt, L. and Kersting, K. (2008). Probabilistic inductive logic programming. In Probabilistic
Inductive Logic Programming, pages 1–27.
Dumais, S., Platt, J., Heckerman, D., and Sahami, M. (1998). Inductive learning algorithms and representations for text categorization. In Proceedings of the Seventh International Conference on Information
and Knowledge Management, pages 148–155.
Efron, B. and Tibshirani, R. (1986). Bootstrap Methods for Standard Errors, Confidence Intervals, and
Other Measures of Statistical Accuracy. Statistical Science, 1(1):54–75.
Erdem, E., Gelfond, M., and Leone, N. (2016). Applications of Answer Set Programming. AI Magazine,
37(3):53–68.
Gebser, M., Kaminski, R., Kaufmann, B., Ostrowski, M., Schaub, T., and Thiele, S. (2008). A user’s
guide to gringo, clasp, clingo, and iclingo. Technical report, University of Potsdam.
Gebser, M., Kaminski, R., Kaufmann, B., and Schaub, T. (2012a). Answer set solving in practice.
Synthesis Lectures on Artificial Intelligence and Machine Learning, 6(3):1–238.
Gebser, M., Kaminski, R., König, A., and Schaub, T. (2011). Advances in gringo series 3. In International
Conference on Logic Programming and Non-monotonic Reasoning, pages 345–351.
Gebser, M., Kaufmann, B., and Schaub, T. (2012b). Conflict-driven answer set solving: From theory to
practice. Artificial Intelligence, 187:52–89.
Gelfond, M. and Lifschitz, V. (1988). The Stable Model Semantics for Logic Programming. In International Conference and Symposium on Logic Programming, pages 1070–1080.
Gulwani, S., Hernandez-Orallo, J., Kitzelmann, E., Muggleton, S. H., Schmid, U., and Zorn, B. (2015).
Inductive programming meets the real world. Communications of the ACM, 58(11):90–99.
Kakas, A. C., Kowalski, R. A., and Toni, F. (1992). Abductive Logic Programming. Journal of Logic
and Computation, 2(6):719–770.
Katzouris, N., Artikis, A., and Paliouras, G. (2015). Incremental learning of event definitions with
inductive logic programming. Machine Learning, 100(2-3):555–585.
Kazmi, M. and Schüller, P. (2016). Inspire at SemEval-2016 task 2: Interpretable semantic textual
similarity alignment based on answer set programming. In Proceedings of SemEval, pages 1109–1115.
King, R. D., Whelan, K. E., Jones, F. M., Reiser, P. G. K., Bryant, C. H., Muggleton, S. H., Kell, D. B.,
and Oliver, S. G. (2004). Functional genomic hypothesis generation and experimentation by a robot
scientist. Nature, 427(6971):247–252.
Kitzelmann, E. (2009). Inductive programming: A survey of program synthesis techniques. In International Workshop on Approaches and Applications of Inductive Programming, pages 50–73.
19
Law, M., Russo, A., and Broda, K. (2014). Inductive learning of answer set programs. In European
Workshop on Logics in Artificial Intelligence, pages 311–325.
Law, M., Russo, A., and Broda, K. (2015). Learning weak constraints in answer set programming.
Theory and Practice of Logic Programming, 15(4-5):511–525.
Lifschitz, V. (2002). Answer set programming and plan generation. Artificial Intelligence, 138(1-2):39–54.
Lloyd, J. W. (2012). Foundations of logic programming. Springer Science & Business Media.
Magnolini, S., Feltracco, A., and Magnini, B. (2016). FBK-HLT-NLP at SemEval-2016 task 2: A
multitask, deep learning approach for interpretable semantic textual similarity. In Proceedings of
SemEval, pages 783–789.
Manning, C. D. and Schütze, H. (1999). Foundations of statistical natural language processing (Vol.
999). Cambridge:MIT Press.
Manning, C. D., Surdeanu, M., Bauer, J., Finkel, J. R., Bethard, S., and McClosky, D. (2014). The
Stanford CoreNLP natural language processing toolkit. In ACL System Demonstrations, pages 55–60.
Mitra, A. and Baral, C. (2016). Addressing a question answering challenge by combining statistical
methods with inductive rule learning and reasoning. In Association for the Advancement of Artificial
Intelligence, pages 2779–2785.
Mooney, R. J. (1996). Inductive logic programming for natural language processing. In Inductive Logic
Programming, pages 1–22.
Muggleton, S. (1991). Inductive logic programming. New generation computing, 8(4):295–318.
Muggleton, S. (1995). Inverse entailment and Progol. New generation computing, 13(3-4):245–286.
Muggleton, S. (1999). Inductive logic programming: issues, results and the challenge of learning language
in logic. Artificial Intelligence, 114(1-2):283–296.
Muggleton, S. (2002). Learning structure and parameters of stochastic logic programs. In International
Conference on Inductive Logic Programming, pages 198–206.
Muggleton, S. and Buntine, W. (1992). Machine invention of first-order predicates by inverting resolution.
In Proceedings of the Fifth International Conference on Machine Learning, pages 339–352.
Muggleton, S. and De Raedt, L. (1994). Inductive logic programming: Theory and methods. The Journal
of Logic Programming, 19:629–679.
Muggleton, S., De Raedt, L., Poole, D., Bratko, I., Flach, P., Inoue, K., and Srinivasan, A. (2012). ILP
turns 20. Machine Learning, 86(1):3–23.
Muggleton, S. et al. (1996). Stochastic logic programs. Advances in Inductive Logic Programming,
32:254–264.
Muggleton, S., Feng, C., et al. (1990). Efficient induction of logic programs. The Turing Institute.
Muggleton, S. H., Lin, D., Pahlavi, N., and Tamaddoni-Nezhad, A. (2014). Meta-interpretive learning:
application to grammatical inference. Machine Learning, 94(1):25–49.
Plotkin, G. D. (1970). A note on inductive generalization. Machine intelligence, 5(1):153–163.
Plotkin, G. D. (1971). A further note on inductive generalization. Machine intelligence, 6:101–124.
Quinlan, J. R. (1990). Learning logical definitions from relations. Machine Learning, 5(3):239–266.
Rashtchian, C., Young, P., Hodosh, M., and Hockenmaier, J. (2010). Collecting image annotations using
Amazon’s Mechanical Turk. In Proceedings of the NAACL HLT 2010 Workshop on Creating Speech
and Language Data with Amazon’s Mechanical Turk, pages 139–147.
Ray, O. (2009). Nonmonotonic abductive inductive learning. Journal of Applied Logic, 7(3):329–340.
Sammut, C. and Banerji, R. B. (1986). Learning concepts by asking questions. Machine Learning: An
artificial intelligence approach, 2:167–192.
Sato, T., Kameya, Y., and Zhou, N.-F. (2005). Generative modeling with failure in PRISM. In International Joint Conference on Artificial Intelligence, pages 847–852.
20
Schüller, P. (2013). Flexible Combinatory Categorial Grammar Parsing using the CYK Algorithm and
Answer Set Programming. In International Conference on Logic Programming and Non-monotonic
Reasoning, pages 499–511.
Schüller, P. (2014). Tackling Winograd Schemas by Formalizing Relevance Theory in Knowledge Graphs.
In International Conference on Principles of Knowledge Representation and Reasoning (KR), pages
358–367. AAAI Press.
Schüller, P. (2016). Modeling Variations of First-Order Horn Abduction in Answer Set Programming.
Fundamenta Informaticae, 149:159–207.
Schwitter, R. (2012). Answer Set Programming via Controlled Natural Language Processing. In Controlled Natural Language, pages 26–43.
Shapiro, E. Y. (1983). Algorithmic program debugging. MIT press.
Sharma, A., Vo, N. H., Aditya, S., and Baral, C. (2015). Towards addressing the winograd schema
challenge - Building and using a semantic parser and a knowledge hunting module. In International
Joint Conference on Artificial Intelligence (IJCAI), pages 1319–1325.
Srinivasan,
A.
(2001).
The
aleph
manual.
http://www.cs.ox.ac.uk/activities/machinelearning/Aleph/aleph.html.
Retrieved
from
Tang, L. R. and Mooney, R. J. (2001). Using multiple clause constructors in inductive logic programming
for semantic parsing. In European Conference on Machine Learning, pages 466–477.
Tekumalla, L. and Jat, S. (2016). IISCNLP at SemEval-2016 task 2: Interpretable STS with ILP based
Multiple Chunk Aligner. In Proceedings of SemEval, pages 790–795.
Tjong Kim Sang, E. F. and Buchholz, S. (2000). Introduction to the CoNLL-2000 shared task: Chunking.
In Workshop on Learning Language in Logic and Conference on Computational Natural Language
Learning, pages 127–132.
Wirth, R. (1989). Completing logic programs by inverse resolution. In European Working Session on
Learning, pages 239–250.
Zelle, J. M. and Mooney, R. J. (1996). Learning to parse database queries using inductive logic programming. In Proceedings of the National Conference on Artificial Intelligence, pages 1050–1055.
Zelle, J. M., Mooney, R. J., and Konvisser, J. B. (1994). Combining top-down and bottom-up techniques
in inductive logic programming. In Proceedings of the Eleventh International Conference on Machine
Learning, pages 343–351.
21
S1
Size
Pr
So
CV
F1
S2
T
P
R
CV
F1
T
F1
P
R
F1
22
100
0
1
2
3
172.8±46.2
10.9±5.0
0.3±0.8
0.0±0.0
66.3±10.1
|
71.1±13.3 *
73.1±8.0
65.9±5.9
63.0±2.2
69.4±2.0
69.3±0.7
66.6±3.4
64.9±3.3
67.1±2.0
69.2±1.1
69.7±1.7
59.4±3.3
|
63.8±2.2 *
|
65.0±0.4 *
63.0±2.9
70.7±14.2
69.3±15.7
66.5±15.4
65.1±15.6
65.5±2.4
67.3±0.5
65.9±1.5
64.7±0.9
64.6±2.7
66.2±1.4
68.2±0.5
68.5±0.3
60.5±2.6
|
62.4±1.0 *
62.7±1.1
61.6±0.5
500
0
1
2
3
4
5
6
7
8
9
10
31954.4±7057.7
17855.1±6866.0
6238.5±1530.8
4260.9±792.4
1598.6±367.1
1117.2±211.3
732.6±130.4
561.4±81.8
475.0±142.3
312.7±111.2
220.3±59.9
39.4±18.1
39.1±14.9
|
55.8±10.5 *
52.5±11.4
|
65.7±3.8 *
67.0±4.6
69.7±4.0
68.2±4.5
68.9±4.5
69.3±6.2
67.8±4.5
50.9±9.8
51.9±9.2
59.6±4.2
59.2±5.0
65.2±3.3
66.8±3.1
67.5±1.9
67.2±1.9
67.0±2.6
68.1±2.5
67.3±2.1
34.8±18.7
39.0±17.9
57.0±9.2
52.4±11.8
66.3±3.0
67.8±3.1
69.5±2.4
70.5±1.5
69.0±5.8
70.6±2.5
70.9±2.8
35.7±14.0
38.3±13.9
|
53.2±6.8 *
|
49.6±9.3 *
|
61.1±3.0 *
62.9±3.0
64.3±2.1
64.5±1.8
63.8±4.4
65.4±2.6
65.0±2.4
39.2±12.7
40.7±12.6
|
53.0±14.3 *
59.2±7.8
|
67.1±8.4 *
|
73.3±7.3 *
71.7±5.7
71.2±7.1
71.8±5.7
71.2±5.5
73.4±6.7
53.2±8.0
53.4±8.7
59.4±5.7
62.1±2.9
63.3±2.0
65.5±2.3
65.3±1.6
66.5±1.0
67.2±1.3
66.6±1.4
66.1±1.7
38.4±14.1
40.0±14.7
52.0±11.9
58.5±4.6
64.7±4.1
66.4±3.6
67.4±4.4
68.0±1.7
68.2±2.4
67.5±2.3
68.6±2.1
38.9±11.7
39.7±11.9
49.4±9.5
54.7±3.5
|
59.7±3.0 *
|
62.1±2.7 *
|
62.7±2.9 *
63.6±1.0
64.0±1.8
63.3±2.0
63.7±1.6
Table 4: Experimental Results for Headlines Dataset, where * indicates statistical significance (p < 0.05). Additionally, for Size = 500, the F1 scores for
all pruning values P r > 1 are significantly better than P r = 0 (p < 0.05).
S1
Size
Pr
So
23
100
0
1
2
3
0.5±1.0
0.0±0.0
0.0±0.0
0.0±0.0
500
0
1
2
3
4
5
6
7
8
9
10
3797.3±1019.9
670.1±153.1
286.2±90.2
159.1±36.4
83.4±25.8
23.8±11.0
10.8±4.5
3.4±3.6
1.5±1.4
1.2±1.4
0.7±0.8
CV
S2
T
CV
T
F1
P
R
F1
F1
P
R
F1
81.8±12.7
80.9±14.4
78.2±15.3
72.7±14.2
66.4±15.5
64.5±10.8
64.5±13.7
66.4±16.7
74.3±0.7
72.7±1.4
69.2±1.4
67.0±0.5
73.7±0.7
72.1±1.4
68.9±0.8
67.8±0.5
73.9±0.7
72.3±1.4
68.9±1.2
67.1±0.5
60.1±9.5
50.2±5.6
47.5±1.8
47.3±1.5
60.1±9.6
50.0±5.6
47.3±1.8
47.1±1.5
60.1±9.5
50.1±5.6
47.4±1.8
47.2±1.5
47.6±8.6
|
64.2±8.2 *
|*
69.5±4.9
70.9±6.8
74.7±5.7
74.2±6.6
75.3±5.9
74.4±5.9
74.5±5.3
74.5±5.3
74.2±5.2
45.9±12.5
68.1±7.4
73.8±7.1
70.1±7.0
68.8±6.4
70.7±4.7
73.2±4.5
72.1±4.2
72.3±5.8
71.9±5.8
71.8±5.5
47.1±8.8
57.1±11.1
66.4±6.6
66.0±7.6
70.2±2.0
71.9±1.5
71.7±0.4
71.2±0.3
71.2±0.0
71.2±0.0
70.9±0.9
46.2±8.9
|
56.1±11.1 *
|*
65.6±6.6
65.4±7.8
69.6±1.9
|
71.1±1.4 *
71.0±0.4
70.5±0.3
70.4±0.0
70.4±0.0
70.1±0.9
46.4±8.9
|
56.4±11.1 *
|*
65.8±6.6
65.4±7.7
69.7±1.9
71.3±1.4
71.2±0.4
70.7±0.3
70.6±0.0
70.6±0.0
70.4±0.9
45.0±12.9
63.1±9.2
68.4±6.0
69.8±3.7
67.0±7.2
71.0±1.7
71.1±0.8
69.7±1.4
68.6±0.8
68.4±0.5
68.6±0.0
45.5±12.8
63.1±9.5
68.4±6.0
69.7±3.6
66.7±7.2
70.9±1.8
71.1±0.8
69.7±1.4
68.6±0.7
68.3±0.5
68.5±0.0
44.6±13.2
|
62.9±9.4 *
|*
68.2±6.0
69.6±3.7
66.7±7.2
70.8±1.8
70.9±0.8
69.6±1.4
68.4±0.7
68.2±0.5
68.3±0.0
Table 5: Experimental Results for Images Dataset, where * indicates statistical significance (p < 0.05). Additionally, for Size = 500, the F1 scores for all
pruning values P r > 0 are significantly better than P r = 0 (p < 0.05).
Size
Pr
So
24
100
0
1
2
3
93.2±22.6
5.3±4.6
0.0±0.0
0.0±0.0
500
0
1
2
3
4
5
6
7
8
9
10
20723.5±3996.9
6643.4±1131.1
4422.2±734.7
2782.2±626.9
1541.6±311.3
1072.4±155.5
789.1±158.0
634.7±184.0
449.8±87.4
317.0±89.7
225.5±45.7
S1+S2
S1
S2
CV
T
T
F1
P
R
F1
P
R
F1
66.1±12.9
67.0±11.5
65.0±10.8
64.8±10.4
69.3±1.5
67.9±1.3
67.7±0.7
66.8±0.4
63.2±3.2
61.6±1.8
64.9±1.4
63.0±1.4
61.0±2.6
59.4±1.7
61.2±0.8
59.9±0.5
89.3±3.0
87.7±1.0
86.3±1.5
86.6±1.5
80.1±0.7
79.7±0.8
80.2±0.5
80.7±0.3
80.3±1.7
79.5±1.0
78.4±1.4
78.9±1.4
36.3±10.6
|
49.3±8.7 *
54.5±9.7
57.5±10.6
|
65.5±4.1 *
63.6±7.8
64.8±6.5
66.3±7.8
63.9±6.6
63.9±6.4
63.4±5.1
54.2±5.5
60.0±4.9
62.6±2.4
62.2±3.0
66.8±2.8
66.1±2.7
65.5±1.9
65.9±2.2
65.0±2.5
64.1±2.4
66.6±1.7
39.8±13.2
51.3±10.1
60.6±8.1
62.4±8.7
70.5±2.5
67.6±5.1
64.2±4.9
64.6±3.5
64.5±6.5
64.3±4.0
65.3±2.6
38.7±9.9
48.7±7.2
|
56.1±5.5 *
56.7±5.7
|
63.5±2.4 *
61.7±3.5
59.4±3.6
59.7±2.6
59.1±4.5
58.3±3.4
60.1±1.8
51.2±10.8
62.9±9.9
66.4±7.0
67.6±10.8
78.9±2.0
80.8±3.4
83.3±2.7
82.9±3.4
80.3±4.4
82.3±4.3
82.4±5.2
37.2±15.0
53.4±15.6
59.9±11.7
62.2±15.5
79.5±2.0
77.1±3.3
75.9±4.0
75.2±5.2
74.2±8.2
74.9±5.5
74.1±8.0
36.0±12.4
|
52.1±13.8 *
|
57.6±10.8 *
59.4±14.5
|
76.0±2.0 *
74.5±3.0
74.4±3.3
74.2±4.0
72.2±6.8
72.9±5.3
72.7±7.4
Table 6: Experimental Results for Answers-Students Dataset, where * indicates statistical significance (p < 0.05). Additionally, for Size = 500, the F1
scores for all pruning values P r > 0 are significantly better than P r = 0 (p < 0.05).
| 2 |
"Robust Probabilistic Modeling with Bayesian Data Reweighting\n\nYixin Wang 1 Alp Kucukelbir 1 David(...TRUNCATED) | 2 |
"LOCALLY ADAPTIVE CONFIDENCE BANDS∗\nBy Tim Patschkowski and Angelika Rohde\n\narXiv:1610.08929v2 (...TRUNCATED) | 1 |
"Multivariate Fine-Grained Complexity\nof Longest Common Subsequence∗\n\narXiv:1803.00938v1 [cs.CC(...TRUNCATED) | 0 |
"Inter-Subject Analysis: Inferring Sparse Interactions\nwith Dense Intra-Graphs\narXiv:1709.07036v1 (...TRUNCATED) | 1 |
"On Oscillations in the Social Force Model\nTobias Kretz\nPTV Group, D-76131 Karlsruhe, Germany\nTob(...TRUNCATED) | 5 |
"arXiv:1708.00078v2 [math.ST] 28 Nov 2017\n\nBayesian Dyadic Trees and Histograms for Regression\n\n(...TRUNCATED) | 2 |
"Estimating the second-order parameter of regular\nvariation and bias reduction in tail index estima(...TRUNCATED) | 1 |
End of preview. Expand
in Dataset Viewer.
Please note that this is subset of ccdv/arxiv-classification annotated by anyclassifier.
- Downloads last month
- 40