nips nips2001 nips2001-56 knowledge-graph by maker-knowledge-mining

56 nips-2001-Convolution Kernels for Natural Language

Source: pdf

Author: Michael Collins, Nigel Duffy

Abstract: We describe the application of kernel methods to Natural Language Processing (NLP) problems. In many NLP tasks the objects being modeled are strings, trees, graphs or other discrete structures which require some mechanism to convert them into feature vectors. We describe kernels for various natural language structures, allowing rich, high dimensional representations of these structures. We show how a kernel over trees can be applied to parsing using the voted perceptron algorithm, and we give experimental results on the ATIS corpus of parse trees.

Reference: text

Summary: the most important sentenses genereted by tfidf model

sentIndex sentText sentNum sentScore

1 edu Abstract We describe the application of kernel methods to Natural Language Processing (NLP) problems. [sent-5, score-0.144]

2 In many NLP tasks the objects being modeled are strings, trees, graphs or other discrete structures which require some mechanism to convert them into feature vectors. [sent-6, score-0.196]

3 We describe kernels for various natural language structures, allowing rich, high dimensional representations of these structures. [sent-7, score-0.383]

4 We show how a kernel over trees can be applied to parsing using the voted perceptron algorithm, and we give experimental results on the ATIS corpus of parse trees. [sent-8, score-1.294]

5 ¡ ¢ ¥ £ ¤ This paper describes the application of kernel methods to Natural Language Processing (NLP) problems. [sent-13, score-0.144]

6 Instead, the objects being modeled are strings, trees or other discrete structures which require some mechanism to convert them into feature vectors. [sent-15, score-0.328]

7 We describe kernels for various NLP structures, and show that they allow computationally feasible representations in very high dimensional feature spaces, for example a parse tree representation that tracks all subtrees. [sent-16, score-0.899]

8 We show how a tree kernel can be applied to parsing using the perceptron algorithm, giving experimental results on the ATIS corpus of parses. [sent-17, score-0.947]

9 The kernels we describe are instances of “Convolution Kernels”, which were introduced by Haussler [10] and Watkins [16], and which involve a recursive calculation over the “parts” of a discrete structure. [sent-18, score-0.292]

10 Although we concentrate on NLP tasks in this paper, the kernels should also be useful in computational biology, which shares similar problems and structures. [sent-19, score-0.245]

11 We refer to tasks that involve trees as parsing problems, and tasks that involve hidden state sequences as tagging problems. [sent-28, score-0.717]

12 Probabilities are attached to rules in the grammar – context-free rules in the case of PCFGs, state transition probabilities and state emission probabilities for HMMs. [sent-31, score-0.243]

13 Instead of identifying parameters with rules of the grammar, we show how kernels can be used to form representations that are sensitive to larger sub-structures of trees or state sequences. [sent-36, score-0.434]

14 While we use the parsing problem as a running example in this paper, kernels over NLP structures could be used in many ways: for example, in PCA over discrete structures, or in classiﬁcation and regression problems. [sent-38, score-0.569]

15 Structured objects such as parse trees are so prevalent in NLP that convolution kernels should have many applications. [sent-39, score-0.922]

16 2 A Tree Kernel The previous section introduced PCFGs as a parsing method. [sent-40, score-0.268]

17 This approach essentially counts the relative number of occurences of a given rule in the training data and uses these counts to represent its learned knowledge. [sent-41, score-0.261]

18 In particular, it does not appear reasonable to assume that the rules applied at level in the parse tree are unrelated to those applied at level . [sent-43, score-0.612]

19 ¡ ¤ ¢ ¥£¡ As an alternative we attempt to capture considerably more structural information by considering all tree fragments that occur in a parse tree. [sent-44, score-0.698]

20 Conceptually we begin by enumerating all tree fragments that occur in the training data . [sent-48, score-0.464]

21 Each tree is represented by an dimensional vector where the ’th component counts the number of occurences of the ’th tree fragment. [sent-50, score-0.654]

22 Let us deﬁne the function to be the number of occurences of the ’th tree fragment in tree , so that is now represented as . [sent-51, score-0.605]

23 ¡ ¥ ©©§¤ ¦¨¨¨¦ ¡ a) S NP b) NP D N the V Jeff ate NP D N N NP the apple D NP N D the N apple N the D D apple VP N NP apple Figure 2: a) An example tree. [sent-53, score-0.316]

24 The tree in (a) contains all of these sub-trees, and many others. [sent-55, score-0.255]

25 We deﬁne a sub-tree to be any subgraph which includes more than one node, with the restriction that entire (not partial) rule productions must be included. [sent-56, score-0.138]

26 Note that will be huge (a given tree will have a number of subtrees that is exponential in its size). [sent-58, score-0.372]

27 However, the work in [2] involves training and decoding algorithms that depend computationally on the number of subtrees involved. [sent-61, score-0.205]

28 The methods we propose show that the score for a parse can be calculated in polynomial time in spite of an exponentially large number of subtrees, and that efﬁcient parameter estimation techniques exist which optimize discriminative criteria that have been well-studied theoretically. [sent-63, score-0.581]

29 ' Goodman [9] gives an ingenious conversion of the model in [2] to an equivalent PCFG whose number of rules is linear in the size of the training data, thus solving many of the computational issues. [sent-64, score-0.142]

30 An exact implementation of Bod’s parsing method is still infeasible, but Goodman gives an approximation that can be implemented efﬁciently. [sent-65, score-0.268]

31 We begin by examining the inner product between two trees and under this representation, . [sent-68, score-0.184]

32 To compute we ﬁrst deﬁne the set of nodes in trees and as and respectively. [sent-69, score-0.184]

33 In searching for the best parse, calculating the score for a parse in principle requires summing over an exponential number of derivations underlying a tree, and in practice is approximated using Monte-Carlo techniques. [sent-82, score-0.479]

34 / ) (¥ ' ) (¥ and ) (¥ Else if the productions at 6¦ ' ¥ © ¡ ' ¥ ¡ ' ¥ © ' ¥ 1¥ ) © ©(¥ §¥ # ' ¥ 1¥ © To see that this recursive deﬁnition is correct, note that simply counts the number of common subtrees that are found rooted at both and . [sent-85, score-0.477]

35 The last, recursive, deﬁnition follows because a common subtree for and can be formed by taking the production at / , together with a choice at each child of simply taking the non-terminal at that child, or any one of the common sub-trees at that child. [sent-87, score-0.173]

36 ) ¥ ' ¥ (¥ 1' ¥ c ) ¦ (¥ 1' ¥ c ) ¦ ) ¤ '' ¤ % ) ¥ ¦ ' ¥ & $ c This recursive kernel structure, where a kernel between two objects is deﬁned in terms of kernels between its parts is quite a general idea. [sent-102, score-0.65]

37 [12] examining the application of convolution kernels to strings provide some evidence that convolution kernels may provide an extremely useful tool for applying modern machine learning techniques to highly structured objects. [sent-107, score-0.9]

38 If one can construct kernels over the parts then one can combine these into a kernel over the whole object. [sent-109, score-0.372]

39 Clearly, this idea can be extended recursively so that one only needs to construct kernels over the “atomic” parts of a structured object. [sent-110, score-0.275]

40 The recursive combination of the kernels over parts of an object retains information regarding the structure of that object. [sent-111, score-0.327]

41 Several issues remain with the kernel we describe over trees and convolution kernels in general. [sent-112, score-0.731]

42 First, the value of will depend greatly on the size of the trees . [sent-113, score-0.184]

43 One may normalize the kernel by using which also satisﬁes the essential Mercer conditions. [sent-114, score-0.144]

44 Second, the value of the kernel when applied to two copies of the same tree can be extremely large (in our experiments on the order of ) while the value of the kernel between two different trees is typically much smaller (in our experiments the typical pairwise comparison is of order 100). [sent-115, score-0.727]

45 By analogy with a Gaussian kernel we say that the kernel is very peaked. [sent-116, score-0.288]

46 If one constructs a model which is a linear combination of trees, as one would with an SVM [6] or the perceptron, the output will be dominated by the most similar tree and so the model will behave like a nearest neighbor rule. [sent-117, score-0.255]

47 ) 61) 5 ( ¦ ' ¦ ' 1 0 # ¡ 2£) ¦ ' ¡ ") ¦ ' )¡ ) 6¦ ' ( ) ¦' ¡ ¡ 3 #g ¤ These problems motivate two simple modiﬁcations to the tree kernel. [sent-121, score-0.255]

48 Since there will be many more tree fragments of larger size – say depth four versus depth three – and symbols in Figure 2. [sent-122, score-0.595]

49 consequently less training data, it makes sense to downweight the contribution of larger tree fragments to the kernel. [sent-123, score-0.417]

50 The ﬁrst method for doing this is to simply restrict the depth of the tree fragments we consider. [sent-124, score-0.48]

51 The second method is to scale the relative importance of tree fragments with their size. [sent-125, score-0.405]

52 This kernel downweights the contribution of tree fragments exponentially with their size. [sent-127, score-0.509]

53 ¡ ¡ It is straightforward to design similar kernels for tagging problems (see ﬁgure 1) and for another common structure found in NLP, dependency structures. [sent-130, score-0.341]

54 In the tagging kernel, the implicit feature representation tracks all features consisting of a subsequence of state labels, each with or without an underlying word. [sent-132, score-0.198]

55 3 Linear Models for Parsing and Tagging This section formalizes the use of kernels for parsing and tagging problems. [sent-138, score-0.574]

56 It is also related to the Markov Random Field methods for parsing suggested in [13], and the boosting methods for parsing in [4]. [sent-140, score-0.536]

57 In parsing we would have training examples where each is a sentence and each is the correct tree for that sentence. [sent-142, score-0.639]

58 We use to denote the ’th candidate for the ’th sentence in training data, and to denote the set of candidates for . [sent-145, score-0.209]

59 ¨¨ %¦ % % to be the correct parse for # & ' % f Without loss of generality we take ). [sent-149, score-0.3]

60 This score is interpreted as an indication of the plausibility of the example as candidate. [sent-153, score-0.179]

61 ¢ % 23 When considering approaches to training the parameter vector , note that a ranking function that correctly ranked the correct parse above all competing candidates would satisfy . [sent-158, score-0.5]

62 Rather than explicitly calculating , the perceptron algorithm and Support Vector Machines can be formulated as a search ! [sent-161, score-0.233]

63 ¢ 2 3 V W2 3 23 c This can be achieved using a modiﬁed dynamic programming table where stores the number of common subtrees at nodes of depth or less. [sent-169, score-0.267]

64 A context-free grammar – perhaps taken straight from the training examples – is one way of enumerating candidates. [sent-171, score-0.228]

65 Another choice is to use a hand-crafted grammar (such as the LFG grammar in [13]) or to take the most probable parses from an existing probabilistic parser (as in [4]). [sent-172, score-0.294]

66 ©' (E% ¢ gh# § ¡ ¤ ¥¢ § ¡ # § ¡ ¨¨ (¥ ©¨ T§ ¨# E £I ' E % H % ¦ ¥ ©¨ ¤ # ¡ ¨¨ Figure 3: The perceptron algorithm for ranking problems. [sent-177, score-0.299]

67 ¦¤ ( § )¦' © § ¨¦¤ % § © &$#" © § ¥ ¨¦¤ Depth Score Improvement Table 1: Score shows how the parse score varies with the maximum depth of sub-tree considered by the perceptron. [sent-181, score-0.594]

68 It follows that the score of a parse can be calculated using the dual parameters, and inner products between feature vectors, without having to explicitly deal with feature or parameter vectors in the space : £ % ! [sent-187, score-0.612]

69 ¢ § ¡ ¤ § ¢ 3 # %¢ ¤ § ¢ ¦ V 23 For example, see ﬁgure 3 for the perceptron algorithm applied to this problem. [sent-191, score-0.233]

70 4 Experimental Results To demonstrate the utility of convolution kernels for natural language we applied our tree kernel to the problem of parsing the Penn treebank ATIS corpus [14]. [sent-192, score-1.313]

71 We split the treebank randomly into a training set of size 800, a development set of size 200 and a test set of size 336. [sent-193, score-0.189]

72 We applied a variant of the voted perceptron algorithm [7], which is a more robust version of the original perceptron algorithm with performance similar to that of SVMs. [sent-196, score-0.584]

73 The voted perceptron can be kernelized in the same way that SVMs can but it can be considerably more computationally efﬁcient. [sent-197, score-0.42]

74 We generated a ranking problem by having the PCFG generate its top 100 candidate parse trees for each sentence. [sent-198, score-0.593]

75 The voted perceptron was applied, using the tree kernel described previously, to this re-ranking problem. [sent-199, score-0.75]

76 It was trained on 20 trees selected randomly from the top 100 for each sentence and had to choose the best candidate from the top 100 on the test set. [sent-200, score-0.291]

77 We tested the sensitivity to two parameter settings: ﬁrst, the maximum depth of sub-tree examined, and second, the scaling factor used to down-weight deeper trees. [sent-201, score-0.183]

78 We report a parse score which combines precision and recall. [sent-204, score-0.511]

79 Table 2: Score shows how the parse score varies with the scaling factor for deeper sub-trees is varied. [sent-217, score-0.515]

80 proposed, and to be the number of constistuents in the true parse tree. [sent-221, score-0.3]

81 The score is then ¢ § ¨©§¢ 4 ¢ © © ¤ T & ¢ 3 ¡ §¢ ¦ ¥ £ g ¦¤©g ¤ ¤ The precision and recall on the ’th parse are / and / respectively. [sent-223, score-0.511]

82 The score is then the average precision recall, weighted by the size of the trees . [sent-224, score-0.435]

83 If the PCFG score is and the perceptron score is , the relative improvement is , i. [sent-226, score-0.631]

84 We used the best parameter settings (on the development sets) for each split to train on both the training and development sets, then tested on the test set. [sent-230, score-0.284]

85 This gave a relative goodness score of with the best choice of maximum depth and a score with the best choice of scaling factor. [sent-231, score-0.549]

86 of All of these results were obtained by running the perceptron through the training data only once. [sent-233, score-0.319]

87 As has been noted previously by Freund and Schapire [7], the voted perceptron often obtains better results when run multiple times through the training data. [sent-234, score-0.403]

88 Running through the data twice with a maximum depth of 3 yielded a relative goodness score of , while using a larger number of iterations did not improve the results signiﬁcantly. [sent-235, score-0.37]

89 #" ¤ £ g ¤ $"¤ £ In summary we observe that in these simple experiments the voted perceptron and an appropriate convolution kernel can obtain promising results. [sent-237, score-0.705]

90 However there are other methods which perform considerably better than a PCFG for NLP parsing – see [3] for an overview – future work will investigate whether the kernels in this paper give performance gains over these methods. [sent-238, score-0.494]

91 5 A Compressed Representation When used with algorithms such as the perceptron, convolution kernels may be even more computationally attractive than the traditional radial basis or polynomial kernels. [sent-239, score-0.439]

92 The linear combination of parse trees constructed by the perceptron algorithm can be viewed as a weighted forest. [sent-240, score-0.757]

93 One may then search for subtrees in this weighted forest that occur more than once. [sent-241, score-0.157]

94 Given a linear combination of two trees which contain a common subtree, we may construct a smaller weighted acyclic graph, in which the common subtree . [sent-242, score-0.407]

95 This process may be repeated until an arbitrary linear occurs only once and has weight combination of trees is collapsed into a weighted acyclic graph in which no subtree occurs more than once. [sent-243, score-0.337]

96 The perceptron may now be evaluated on a new tree by a straightforward generalization of the tree kernel to weighted acyclic graphs of the form produced by this procedure. [sent-244, score-0.968]

97 6 Conclusions In this paper we described how convolution kernels can be used to apply standard kernel based algorithms to problems in natural language. [sent-248, score-0.597]

98 Tree structures are ubiquitous in natural language problems and we illustrated the approach by constructing a convolution kernel over tree structures. [sent-249, score-0.843]

99 The problem of parsing English sentences provides an appealing example domain and our experiments demonstrate the effectiveness of kernel-based approaches to these problems. [sent-250, score-0.268]

100 Convolution kernels combined with such techniques as kernel PCA and spectral clustering may provide a computationally attractive approach to many other problems in natural language processing. [sent-251, score-0.533]

similar papers computed by tfidf model

tfidf for this paper:

wordName wordTfidf (topN-words)

[('parse', 0.3), ('parsing', 0.268), ('tree', 0.255), ('pcfg', 0.236), ('perceptron', 0.233), ('nlp', 0.215), ('convolution', 0.21), ('np', 0.2), ('kernels', 0.193), ('trees', 0.184), ('score', 0.179), ('kernel', 0.144), ('productions', 0.138), ('grammar', 0.129), ('voted', 0.118), ('subtrees', 0.117), ('depth', 0.115), ('tagging', 0.113), ('language', 0.11), ('fragments', 0.11), ('recursive', 0.099), ('goodman', 0.098), ('string', 0.079), ('apple', 0.079), ('bod', 0.079), ('pcfgs', 0.079), ('structures', 0.074), ('subtree', 0.072), ('development', 0.069), ('lou', 0.068), ('scored', 0.068), ('ranking', 0.066), ('sentence', 0.064), ('atis', 0.059), ('chairman', 0.059), ('occurences', 0.059), ('th', 0.058), ('rules', 0.057), ('counts', 0.055), ('haussler', 0.055), ('sp', 0.053), ('tasks', 0.052), ('training', 0.052), ('candidates', 0.05), ('gerstner', 0.05), ('tracks', 0.05), ('ef', 0.05), ('natural', 0.05), ('nition', 0.049), ('de', 0.048), ('hidden', 0.048), ('enumerating', 0.047), ('watkins', 0.047), ('strings', 0.047), ('corpus', 0.047), ('structured', 0.047), ('dop', 0.045), ('candidate', 0.043), ('ibm', 0.043), ('collins', 0.043), ('acyclic', 0.041), ('relative', 0.04), ('weighted', 0.04), ('cp', 0.04), ('tags', 0.039), ('ne', 0.039), ('santa', 0.038), ('discriminative', 0.038), ('mercer', 0.037), ('parses', 0.036), ('penn', 0.036), ('treebank', 0.036), ('duffy', 0.036), ('deeper', 0.036), ('entity', 0.036), ('fragment', 0.036), ('goodness', 0.036), ('computationally', 0.036), ('parts', 0.035), ('common', 0.035), ('feature', 0.035), ('objects', 0.035), ('running', 0.034), ('freund', 0.034), ('conversion', 0.033), ('rooted', 0.033), ('considerably', 0.033), ('precision', 0.032), ('parameter', 0.032), ('estimation', 0.032), ('split', 0.032), ('vp', 0.031), ('scholkopf', 0.031), ('constituents', 0.031), ('johnson', 0.031), ('production', 0.031), ('dual', 0.031), ('settings', 0.03), ('lodhi', 0.03), ('dimensional', 0.03)]

similar papers list:

simIndex simValue paperId paperTitle

same-paper 1 1.0000001 56 nips-2001-Convolution Kernels for Natural Language

Author: Michael Collins, Nigel Duffy

2 0.26952109 130 nips-2001-Natural Language Grammar Induction Using a Constituent-Context Model

Author: Dan Klein, Christopher D. Manning

Abstract: This paper presents a novel approach to the unsupervised learning of syntactic analyses of natural language text. Most previous work has focused on maximizing likelihood according to generative PCFG models. In contrast, we employ a simpler probabilistic model over trees based directly on constituent identity and linear context, and use an EM-like iterative procedure to induce structure. This method produces much higher quality analyses, giving the best published results on the ATIS dataset. 1 Overview To enable a wide range of subsequent tasks, human language sentences are standardly given tree-structure analyses, wherein the nodes in a tree dominate contiguous spans of words called constituents, as in ﬁgure 1(a). Constituents are the linguistically coherent units in the sentence, and are usually labeled with a constituent category, such as noun phrase (NP) or verb phrase (VP). An aim of grammar induction systems is to ﬁgure out, given just the sentences in a corpus S, what tree structures correspond to them. In this sense, the grammar induction problem is an incomplete data problem, where the complete data is the corpus of trees T , but we only observe their yields S. This paper presents a new approach to this problem, which gains leverage by directly making use of constituent contexts. It is an open problem whether entirely unsupervised methods can produce linguistically accurate parses of sentences. Due to the difﬁculty of this task, the vast majority of statistical parsing work has focused on supervised learning approaches to parsing, where one uses a treebank of fully parsed sentences to induce a model which parses unseen sentences [7, 3]. But there are compelling motivations for unsupervised grammar induction. Building supervised training data requires considerable resources, including time and linguistic expertise. Investigating unsupervised methods can shed light on linguistic phenomena which are implicit within a supervised parser’s supervisory information (e.g., unsupervised systems often have difﬁculty correctly attaching subjects to verbs above objects, whereas for a supervised parser, this ordering is implicit in the supervisory information). Finally, while the presented system makes no claims to modeling human language acquisition, results on whether there is enough information in sentences to recover their structure are important data for linguistic theory, where it has standardly been assumed that the information in the data is deﬁcient, and strong innate knowledge is required for language acquisition [4]. Node S VP NP NN1 NNS Factory payrolls VBD fell PP IN NN2 in September Constituent S NP VP PP NN 1 NNS VBD IN NN 2 NN NNS VBD IN NN NN NNS VBD IN NN IN NN NN NNS VBD IN NNS Context – – VBD NNS – VBD – – NNS NN – VBD NNS – IN VBD – NN IN – Empty 0 1 2 3 4 5 Context – NN – NNS – VBD – IN – NN – NN NNS VBD IN NN Figure 1: Example parse tree with the constituents and contexts for each tree node. 2 Previous Approaches One aspect of grammar induction where there has already been substantial success is the induction of parts-of-speech. Several different distributional clustering approaches have resulted in relatively high-quality clusterings, though the clusters’ resemblance to classical parts-of-speech varies substantially [9, 15]. For the present work, we take the part-ofspeech induction problem as solved and work with sequences of parts-of-speech rather than words. In some ways this makes the problem easier, such as by reducing sparsity, but in other ways it complicates the task (even supervised parsers perform relatively poorly with the actual words replaced by parts-of-speech). Work attempting to induce tree structures has met with much less success. Most grammar induction work assumes that trees are generated by a symbolic or probabilistic context-free grammar (CFG or PCFG). These systems generally boil down to one of two types. Some ﬁx the structure of the grammar in advance [12], often with an aim to incorporate linguistic constraints [2] or prior knowledge [13]. These systems typically then attempt to ﬁnd the grammar production parameters which maximize the likelihood P(S| ) using the inside-outside algorithm [1], which is an efﬁcient (dynamic programming) instance of the EM algorithm [8] for PCFG s. Other systems (which have generally been more successful) incorporate a structural search as well, typically using a heuristic to propose candidate grammar modiﬁcations which minimize the joint encoding of data and grammar using an MDL criterion, which asserts that a good analysis is a short one, in that the joint encoding of the grammar and the data is compact [6, 16, 18, 17]. These approaches can also be seen as likelihood maximization where the objective function is the a posteriori likelihood of the grammar given the data, and the description length provides a structural prior. The “compact grammar” aspect of MDL is close to some traditional linguistic argumentation which at times has argued for minimal grammars on grounds of analytical [10] or cognitive [5] economy. However, the primary weakness of MDL-based systems does not have to do with the objective function, but the search procedures they employ. Such systems end up growing structures greedily, in a bottom-up fashion. Therefore, their induction quality is determined by how well they are able to heuristically predict what local intermediate structures will ﬁt into good ﬁnal global solutions. A potential advantage of systems which ﬁx the grammar and only perform parameter search is that they do compare complete grammars against each other, and are therefore able to detect which give rise to systematically compatible parses. However, although early work showed that small, artiﬁcial CFGs could be induced with the EM algorithm [12], studies with large natural language grammars have generally suggested that completely unsupervised EM over PCFG s is ineffective for grammar acquisition. For instance, Carroll and Charniak [2] describe experiments running the EM algorithm from random starting points, which produced widely varying learned grammars, almost all of extremely poor quality. 1 1 We duplicated one of their experiments, which used grammars restricted to rules of the form x → x y | y x, where there is one category x for each part-of-speech (such a restricted CFG is isomorphic to a dependency grammar). We began reestimation from a grammar with uniform rewrite It is well-known that EM is only locally optimal, and one might think that the locality of the search procedure, not the objective function, is to blame. The truth is somewhere in between. There are linguistic reasons to distrust an ML objective function. It encourages the symbols and rules to align in ways which maximize the truth of the conditional independence assumptions embodied by the PCFG. The symbols and rules of a natural language grammar, on the other hand, represent syntactically and semantically coherent units, for which a host of linguistic arguments have been made [14]. None of these have anything to do with conditional independence; traditional linguistic constituency reﬂects only grammatical regularities and possibilities for expansion. There are expected to be strong connections across phrases (such as dependencies between verbs and their selected arguments). It could be that ML over PCFGs and linguistic criteria align, but in practice they do not always seem to. Experiments with both artiﬁcial [12] and real [13] data have shown that starting from ﬁxed, correct (or at least linguistically reasonable) structure, EM produces a grammar which has higher log-likelihood than the linguistically determined grammar, but lower parsing accuracy. However, we additionally conjecture that EM over PCFGs fails to propagate contextual cues efﬁciently. The reason we expect an algorithm to converge on a good PCFG is that there seem to be coherent categories, like noun phrases, which occur in distinctive environments, like between the beginning of the sentence and the verb phrase. In the inside-outside algorithm, the product of inside and outside probabilities α j ( p, q)β j ( p, q) is the probability of generating the sentence with a j constituent spanning words p through q: the outside probability captures the environment, and the inside probability the coherent category. If we had a good idea of what VPs and NPs looked like, then if a novel NP appeared in an NP context, the outside probabilities should pressure the sequence to be parsed as an NP . However, what happens early in the EM procedure, when we have no real idea about the grammar parameters? With randomly-weighted, complete grammars over a symbol set X, we have observed that a frequent, short, noun phrase sequence often does get assigned to some category x early on. However, since there is not a clear overall structure learned, there is only very weak pressure for other NPs, even if they occur in the same positions, to also be assigned to x, and the reestimation process goes astray. To enable this kind of constituent-context pressure to be effective, we propose the model in the following section. 3 The Constituent-Context Model We propose an alternate parametric family of models over trees which is better suited for grammar induction. Broadly speaking, inducing trees like the one shown in ﬁgure 1(a) can be broken into two tasks. One is deciding constituent identity: where the brackets should be placed. The second is deciding what to label the constituents. These tasks are certainly correlated and are usually solved jointly. However, the task of labeling chosen brackets is essentially the same as the part-of-speech induction problem, and the solutions cited above can be adapted to cluster constituents [6]. The task of deciding brackets, is the harder task. For example, the sequence DT NN IN DT NN ([the man in the moon]) is virtually always a noun phrase when it is a constituent, but it is only a constituent 66% of the time, because the IN DT NN is often attached elsewhere ([we [sent a man] [to the moon]]). Figure 2(a) probabilities. Figure 4 shows that the resulting grammar (DEP - PCFG) is not as bad as conventional wisdom suggests. Carroll and Charniak are right to observe that the search spaces is riddled with pronounced local maxima, and EM does not do nearly so well when randomly initialized. The need for random seeding in using EM over PCFGs is two-fold. For some grammars, such as one over a set X of non-terminals in which any x 1 → x2 x3 , xi ∈ X is possible, it is needed to break symmetry. This is not the case for dependency grammars, where symmetry is broken by the yields (e.g., a sentence noun verb can only be covered by a noun or verb projection). The second reason is to start the search from a random region of the space. But unless one does many random restarts, the uniform starting condition is better than most extreme points in the space, and produces superior results. 1.5 2 Usually a Constituent Rarely a Constituent 1 1 0.5 0 0 −1 −2 −3 −1.5 −1 −0.5 NP VP PP −1 −0.5 0 0.5 1 −1.5 −1 −0.5 0 0.5 1 1.5 (a) (b) Figure 2: The most frequent examples of (a) different constituent labels and (b) constituents and non-constituents, in the vector space of linear contexts, projected onto the ﬁrst two principal components. Clustering is effective for labeling, but not detecting constituents. shows the 50 most frequent constituent sequences of three types, represented as points in the vector space of their contexts (see below), projected onto their ﬁrst two principal components. The three clusters are relatively coherent, and it is not difﬁcult to believe that a clustering algorithm could detect them in the unprojected space. Figure 2(a), however, shows 150 sequences which are parsed as constituents at least 50% of the time along with 150 which are not, again projected onto the ﬁrst two components. This plot at least suggests that the constituent/non-constituent classiﬁcation is less amenable to direct clustering. Thus, it is important that an induction system be able to detect constituents, either implicitly or explicitly. A variety of methods of constituent detection have been proposed [11, 6], usually based on information-theoretic properties of a sequence’s distributional context. However, here we rely entirely on the following two simple assumptions: (i) constituents of a parse do not cross each other, and (ii) constituents occur in constituent contexts. The ﬁrst property is self-evident from the nature of the parse trees. The second is an extremely weakened version of classic linguistic constituency tests [14]. Let σ be a terminal sequence. Every occurrence of σ will be in some linear context c(σ ) = x σ y, where x and y are the adjacent terminals or sentence boundaries. Then we can view any tree t over a sentence s as a collection of sequences and contexts, one of each for every node in the tree, plus one for each inter-terminal empty span, as in ﬁgure 1(b). Good trees will include nodes whose yields frequently occur as constituents and whose contexts frequently surround constituents. Formally, we use a conditional exponential model of the form: exp( (σ,c)∈t λσ f σ + λc f c ) P(t|s, ) = t:yield(t)=s exp( (σ,c)∈t λσ f σ + λc f c ) We have one feature f σ (t) for each sequence σ whose value on a tree t is the number of nodes in t with yield σ , and one feature f c (t) for each context c representing the number of times c is the context of the yield of some node in the tree.2 No joint features over c and σ are used, and, unlike many other systems, there is no distinction between constituent types. We model only the conditional likelihood of the trees, P(T |S, ), where = {λ σ , λc }. We then use an iterative EM-style procedure to ﬁnd a local maximum P(T |S, ) of the completed data (trees) T (P(T |S, ) = t∈T ,s=yield(t) P(t|s, )). We initialize such that each λ is zero and initialize T to any arbitrary set of trees. In alternating steps, we ﬁrst ﬁx the parameters and ﬁnd the most probable single tree structure t ∗ for each sentence s according to P(t|s, ), using a simple dynamic program. For any this produces the 2 So, for the tree in ﬁgure 1(a), P(t|s) ∝ exp(λ NN NNS + λVBD IN NN + λIN NN + λ −VBD + λNNS− + λVBD− + λ −NNS + λNN−VBD + λNNS−IN + λVBD−NN + λIN− ). set of parses T ∗ which maximizes P(T |S, ). Since T ∗ maximizes this quantity, if T is the former set of trees, P(T ∗ |S, ) ≥ P(T |S, ). Second, we ﬁx the trees and estimate new parameters . The task of ﬁnding the parameters ∗ which maximize P(T |S, ) is simply the well-studied task of ﬁtting our exponential model to maximize the conditional likelihood of the ﬁxed parses. Running, for example, a conjugate gradient (CG) ascent on will produce the desired ∗ . If is the former parameters, then we will have P(T |S, ∗ ) ≥ P(T |S, ). Therefore, each iteration will increase P(T |S, ) until convergence.3 Note that our parsing model is not a generative model, and this procedure, though clearly related, is not exactly an instance of the EM algorithm. We merely guarantee that the conditional likelihood of the data completions is increasing. Furthermore, unlike in EM where each iteration increases the marginal likelihood of the ﬁxed observed data, our procedure increases the conditional likelihood of a changing complete data set, with the completions changing at every iteration as we reparse. Several implementation details were important in making the system work well. First, tiebreaking was needed, most of all for the ﬁrst round. Initially, the parameters are zero, and all parses are therefore equally likely. To prevent bias, all ties were broken randomly. Second, like so many statistical NLP tasks, smoothing was vital. There are features in our model for arbitrarily long yields and most yield types occurred only a few times. The most severe consequence of this sparsity was that initial parsing choices could easily become frozen. If a λσ for some yield σ was either 0 or 0, which was usually the case for rare yields, σ would either be locked into always occurring or never occurring, respectively. Not only did we want to push the λσ values close to zero, we also wanted to account for the fact that most spans are not constituents.4 Therefore, we expect the distribution of the λσ to be skewed towards low values.5 A greater amount of smoothing was needed for the ﬁrst few iterations, while much less was required in later iterations. Finally, parameter estimation using a CG method was slow and difﬁcult to smooth in the desired manner, and so we used the smoothed relative frequency estimates λ σ = count( fσ )/(count(σ ) + M) and λc = count( f c )/(count(c) + N). These estimates ensured that the λ values were between 0 and 1, and gave the desired bias towards non-constituency. These estimates were fast and surprisingly effective, but do not guarantee non-decreasing conditional likelihood (though the conditional likelihood was increasing in practice). 6 4 Results In all experiments, we used hand-parsed sentences from the Penn Treebank. For training, we took the approximately 7500 sentences in the Wall Street Journal (WSJ) section which contained 10 words or fewer after the removal of punctuation. For testing, we evaluated the system by comparing the system’s parses for those same sentences against the supervised parses in the treebank. We consider each parse as a set of constituent brackets, discarding all trivial brackets.7 We calculated the precision and recall of these brackets against the treebank parses in the obvious way. 3 In practice, we stopped the system after 10 iterations, but ﬁnal behavior was apparent after 4–8. 4 In a sentence of length n, there are (n + 1)(n + 2)/2 total (possibly size zero) spans, but only 3n constituent spans: n − 1 of size ≥ 2, n of size 1, and n + 1 empty spans. 5 Gaussian priors for the exponential model accomplish the former goal, but not the latter. 6 The relative frequency estimators had a somewhat subtle positive effect. Empty spans have no effect on the model when using CG ﬁtting, as all trees include the same empty spans. However, including their counts improved performance substantially when using relative frequency estimators. This is perhaps an indication that a generative version of this model would be advantageous. 7 We discarded both brackets of length one and brackets spanning the entire sentence, since all of these are impossible to get incorrect, and hence ignored sentences of length ≤ 2 during testing. S DT VP NN VBD σ NP σ VBD NP The screen was NP PP DT DT NN IN NP a VBD σ NN VBD σ σ DT σ was DT NN IN NN The screen a sea of DT red NN DT VBD DT was The screen DT a red (b) IN red DT NN of sea of NN (a) NN sea (c) Figure 3: Alternate parse trees for a sentence: (a) the Penn Treebank tree (deemed correct), (b) the one found by our system CCM, and (c) the one found by DEP - PCFG. Method LBRANCH RANDOM DEP - PCFG RBRANCH CCM UBOUND UP 20.5 29.0 39.5 54.1 60.1 78.2 UR 24.2 31.0 42.3 67.5 75.4 100.0 F1 22.2 30.0 40.9 60.0 66.9 87.8 (a) NP UR 28.9 42.8 69.7 38.3 83.8 100.0 PP UR 6.3 23.6 44.1 44.5 71.6 100.0 VP UR 0.6 26.3 22.8 85.8 66.3 100.0 System EMILE ABL CDC -40 RBRANCH CCM UP 51.6 43.6 53.4 39.9 54.4 UR 16.8 35.6 34.6 46.4 46.8 F1 25.4 39.2 42.0 42.9 50.3 CB 0.84 2.12 1.46 2.18 1.61 (b) Figure 4: Comparative accuracy on WSJ sentences (a) and on the ATIS corpus (b). UR = unlabeled recall; UP = unlabeled precision; F1 = the harmonic mean of UR and UP; CB = crossing brackets. Separate recall values are shown for three major categories. To situate the results of our system, ﬁgure 4(a) gives the values of several parsing strategies. CCM is our constituent-context model. DEP - PCFG is a dependency PCFG model [2] trained using the inside-outside algorithm. Figure 3 shows sample parses to give a feel for the parses the systems produce. We also tested several baselines. RANDOM parses randomly. This is an appropriate baseline for an unsupervised system. RBRANCH always chooses the right-branching chain, while LBRANCH always chooses the left-branching chain. RBRANCH is often used as a baseline for supervised systems, but exploits a systematic right-branching tendency of English. An unsupervised system has no a priori reason to prefer right chains to left chains, and LBRANCH is well worse than RANDOM. A system need not beat RBRANCH to claim partial success at grammar induction. Finally, we include an upper bound. All of the parsing strategies and systems mentioned here give fully binary-branching structures. Treebank trees, however, need not be fully binary-branching, and generally are not. As a result, there is an upper bound UBOUND on the precision and F1 scores achievable when structurally conﬁned to binary trees. Clearly, CCM is parsing much better than the RANDOM baseline and the DEP - PCFG induced grammar. Signiﬁcantly, it also out-performs RBRANCH in both precision and recall, and, to our knowledge, it is the ﬁrst unsupervised system to do so. To facilitate comparison with other recent systems, ﬁgure 4(b) gives results where we trained as before but used (all) the sentences from the distributionally different ATIS section of the treebank as a test set. For this experiment, precision and recall were calculated using the EVALB system of measuring precision and recall (as in [6, 17]) – EVALB is a standard for parser evaluation, but complex, and unsuited to evaluating unlabeled constituency. EMILE and ABL are lexical systems described in [17]. The results for CDC-40, from [6], reﬂect training on much more data (12M words). Our system is superior in terms of both precision and recall (and so F 1 ). These ﬁgures are certainly not all that there is to say about an induced grammar; there are a number of issues in how to interpret the results of an unsupervised system when comparing with treebank parses. Errors come in several kinds. First are innocent sins of commission. Treebank trees are very ﬂat; for example, there is no analysis of the inside of many short noun phrases ([two hard drives] rather than [two [hard drives]]). Our system gives a Sequence DT NN NNP NNP CD CD JJ NNS DT JJ NN DT NNS JJ NN CD NN IN NN IN DT NN NN NNS NN NN TO VB DT JJ IN DT PRP VBZ PRP VBP NNS VBP NN VBZ NN IN NNS VBD Example the man United States 4 1/2 daily yields the top rank the people plastic furniture 12 percent on Monday for the moment ﬁre trucks ﬁre truck to go ?the big *of the ?he says ?they say ?people are ?value is *man from ?people were CORRECT 1 2 3 4 5 6 7 8 9 10 11 22 26 78 90 95 180 =350 =532 =648 =648 FREQUENCY 2 1 9 7 – – 3 – – – – 8 – 6 4 – – – 10 5 – ENTROPY 2 – – 3 – – 7 – 9 – 6 10 1 – – – – 4 5 – 8 DEP - PCFG 1 2 5 4 7 – 3 – – – – – 6 – 10 8 9 – – – – CCM 1 2 5 4 6 10 3 9 – – 8 7 – – – – – – – – – Figure 5: Top non-trivial sequences by actual treebank constituent counts, linear frequency, scaled context entropy, and in DEP - PCFG and CCM learned models’ parses. (usually correct) analysis of the insides of such NPs, for which it is penalized on precision (though not recall or crossing brackets). Second are systematic alternate analyses. Our system tends to form modal verb groups and often attaches verbs ﬁrst to pronoun subjects rather than to objects. As a result, many VPs are systematically incorrect, boosting crossing bracket scores and impacting VP recall. Finally, the treebank’s grammar is sometimes an arbitrary, and even inconsistent standard for an unsupervised learner: alternate analyses may be just as good.8 Notwithstanding this, we believe that the treebank parses have enough truth in them that parsing scores are a useful component of evaluation. Ideally, we would like to inspect the quality of the grammar directly. Unfortunately, the grammar acquired by our system is implicit in the learned feature weights. These are not by themselves particularly interpretable, and not directly comparable to the grammars produced by other systems, except through their functional behavior. Any grammar which parses a corpus will have a distribution over which sequences tend to be analyzed as constituents. These distributions can give a good sense of what structures are and are not being learned. Therefore, to supplement the parsing scores above, we examine these distributions. Figure 5 shows the top scoring constituents by several orderings. These lists do not say very much about how long, complex, recursive constructions are being analyzed by a given system, but grammar induction systems are still at the level where major mistakes manifest themselves in short, frequent sequences. CORRECT ranks sequences by how often they occur as constituents in the treebank parses. DEP - PCFG and CCM are the same, but use counts from the DEP - PCFG and CCM parses. As a baseline, FREQUENCY lists sequences by how often they occur anywhere in the sentence yields. Note that the sequence IN DT (e.g., “of the”) is high on this list, and is a typical error of many early systems. Finally, ENTROPY is the heuristic proposed in [11] which ranks by context entropy. It is better in practice than FREQUENCY , but that isn’t self-evident from this list. Clearly, the lists produced by the CCM system are closer to correct than the others. They look much like a censored version of the FREQUENCY list, where sequences which do not co-exist with higher-ranked ones have been removed (e.g., IN DT often crosses DT NN). This observation may explain a good part of the success of this method. Another explanation for the surprising success of the system is that it exploits a deep fact about language. Most long constituents have some short, frequent equivalent, or proform, which occurs in similar contexts [14]. In the very common case where the proform is a single word, it is guaranteed constituency, which will be transmitted to longer sequences 8 For example, transitive sentences are bracketed [subject [verb object]] (The president [executed the law]) while nominalizations are bracketed [[possessive noun] complement] ([The president’s execution] of the law), an arbitrary inconsistency which is unlikely to be learned automatically. via shared contexts (categories like PP which have infrequent proforms are not learned well unless the empty sequence is in the model – interestingly, the empty sequence appears to act as the proform for PPs, possibly due to the highly optional nature of many PPs). 5 Conclusions We have presented an alternate probability model over trees which is based on simple assumptions about the nature of natural language structure. It is driven by the explicit transfer between sequences and their contexts, and exploits both the proform phenomenon and the fact that good constituents must tile in ways that systematically cover the corpus sentences without crossing. The model clearly has limits. Lacking recursive features, it essentially must analyze long, rare constructions using only contexts. However, despite, or perhaps due to its simplicity, our model predicts bracketings very well, producing higher quality structural analyses than previous methods which employ the PCFG model family. Acknowledgements. We thank John Lafferty, Fernando Pereira, Ben Taskar, and Sebastian Thrun for comments and discussion. This paper is based on work supported in part by the National Science Foundation under Grant No. IIS-0085896. References [1] James K. Baker. Trainable grammars for speech recognition. In D. H. Klatt and J. J. Wolf, editors, Speech Communication Papers for the 97th Meeting of the ASA, pages 547–550, 1979. [2] Glenn Carroll and Eugene Charniak. Two experiments on learning probabilistic dependency grammars from corpora. In C. Weir, S. Abney, R. Grishman, and R. Weischedel, editors, Working Notes of the Workshop Statistically-Based NLP Techniques, pages 1–13. AAAI Press, 1992. [3] Eugene Charniak. A maximum-entropy-inspired parser. In NAACL 1, pages 132–139, 2000. [4] Noam Chomsky. Knowledge of Language. Prager, New York, 1986. [5] Noam Chomsky & Morris Halle. The Sound Pattern of English. Harper & Row, NY, 1968. [6] Alexander Clark. Unsupervised induction of stochastic context-free grammars using distributional clustering. In The Fifth Conference on Natural Language Learning, 2001. [7] Michael John Collins. Three generative, lexicalised models for statistical parsing. In ACL 35/EACL 8, pages 16–23, 1997. [8] A.P. Dempster, N.M. Laird, and D.B. Rubin. Maximum likelihood from incomplete data via the EM algorithm. J. Royal Statistical Society Series B, 39:1–38, 1977. [9] Steven Finch and Nick Chater. Distributional bootstrapping: From word class to proto-sentence. In Proceedings of the Sixteenth Annual Conference of the Cognitive Science Society, pages 301– 306, Hillsdale, NJ, 1994. Lawrence Erlbaum. [10] Zellig Harris. Methods in Structural Linguistics. University of Chicago Press, Chicago, 1951. [11] Dan Klein and Christopher D. Manning. Distributional phrase structure induction. In The Fifth Conference on Natural Language Learning, 2001. [12] K. Lari and S. J. Young. The estimation of stochastic context-free grammars using the insideoutside algorithm. Computer Speech and Language, 4:35–56, 1990. [13] Fernando Pereira and Yves Schabes. Inside-outside reestimation from partially bracketed corpora. In ACL 30, pages 128–135, 1992. [14] Andrew Radford. Transformational Grammar. Cambridge University Press, Cambridge, 1988. [15] Hinrich Sch¨ tze. Distributional part-of-speech tagging. In EACL 7, pages 141–148, 1995. u [16] Andreas Stolcke and Stephen M. Omohundro. Inducing probabilistic grammars by Bayesian model merging. In Grammatical Inference and Applications: Proceedings of the Second International Colloquium on Grammatical Inference. Springer Verlag, 1994. [17] M. van Zaanen and P. Adriaans. Comparing two unsupervised grammar induction systems: Alignment-based learning vs. emile. Technical Report 2001.05, University of Leeds, 2001. [18] J. G. Wolff. Learning syntax and meanings through optimization and distributional analysis. In Y. Levy, I. M. Schlesinger, and M. D. S. Braine, editors, Categories and processes in language acquisition, pages 179–215. Lawrence Erlbaum, Hillsdale, NJ, 1988.

3 0.2208285 105 nips-2001-Kernel Machines and Boolean Functions

Author: Adam Kowalczyk, Alex J. Smola, Robert C. Williamson

Abstract: We give results about the learnability and required complexity of logical formulae to solve classiﬁcation problems. These results are obtained by linking propositional logic with kernel machines. In particular we show that decision trees and disjunctive normal forms (DNF) can be represented by the help of a special kernel, linking regularized risk to separation margin. Subsequently we derive a number of lower bounds on the required complexity of logic formulae using properties of algorithms for generation of linear estimators, such as perceptron and maximal perceptron learning.

4 0.16547455 5 nips-2001-A Bayesian Model Predicts Human Parse Preference and Reading Times in Sentence Processing

Author: S. Narayanan, Daniel Jurafsky

Abstract: Narayanan and Jurafsky (1998) proposed that human language comprehension can be modeled by treating human comprehenders as Bayesian reasoners, and modeling the comprehension process with Bayesian decision trees. In this paper we extend the Narayanan and Jurafsky model to make further predictions about reading time given the probability of difference parses or interpretations, and test the model against reading time data from a psycholinguistic experiment. 1

5 0.13635772 86 nips-2001-Grammatical Bigrams

Author: Mark A. Paskin

Abstract: Unsupervised learning algorithms have been derived for several statistical models of English grammar, but their computational complexity makes applying them to large data sets intractable. This paper presents a probabilistic model of English grammar that is much simpler than conventional models, but which admits an efficient EM training algorithm. The model is based upon grammatical bigrams, i.e. , syntactic relationships between pairs of words. We present the results of experiments that quantify the representational adequacy of the grammatical bigram model, its ability to generalize from labelled data, and its ability to induce syntactic structure from large amounts of raw text. 1

6 0.13606443 66 nips-2001-Efficiency versus Convergence of Boolean Kernels for On-Line Learning Algorithms

7 0.13481462 190 nips-2001-Thin Junction Trees

8 0.1300185 164 nips-2001-Sampling Techniques for Kernel Methods

9 0.12854536 38 nips-2001-Asymptotic Universality for Learning Curves of Support Vector Machines

10 0.12304697 58 nips-2001-Covariance Kernels from Bayesian Generative Models

11 0.11895403 118 nips-2001-Matching Free Trees with Replicator Equations

12 0.11087739 22 nips-2001-A kernel method for multi-labelled classification

13 0.10750828 149 nips-2001-Probabilistic Abstraction Hierarchies

14 0.10178249 110 nips-2001-Learning Hierarchical Structures with Linear Relational Embedding

15 0.10110959 134 nips-2001-On Kernel-Target Alignment

16 0.096991614 63 nips-2001-Dynamic Time-Alignment Kernel in Support Vector Machine

17 0.09059377 85 nips-2001-Grammar Transfer in a Second Order Recurrent Neural Network

18 0.089520156 15 nips-2001-A New Discriminative Kernel From Probabilistic Models

19 0.085341811 115 nips-2001-Linear-time inference in Hierarchical HMMs

20 0.082765169 170 nips-2001-Spectral Kernel Methods for Clustering

similar papers computed by lsi model

lsi for this paper:

topicId topicWeight

[(0, -0.256), (1, 0.106), (2, -0.029), (3, -0.002), (4, -0.052), (5, -0.028), (6, -0.095), (7, 0.013), (8, -0.337), (9, 0.094), (10, -0.347), (11, -0.185), (12, -0.021), (13, -0.029), (14, 0.099), (15, -0.114), (16, -0.082), (17, 0.076), (18, -0.091), (19, 0.017), (20, 0.056), (21, -0.107), (22, 0.047), (23, -0.051), (24, 0.095), (25, -0.055), (26, -0.016), (27, -0.057), (28, -0.055), (29, -0.058), (30, 0.044), (31, -0.041), (32, 0.027), (33, -0.043), (34, -0.115), (35, 0.024), (36, -0.034), (37, -0.008), (38, 0.015), (39, -0.017), (40, -0.063), (41, 0.072), (42, -0.025), (43, -0.037), (44, -0.083), (45, 0.024), (46, 0.059), (47, 0.063), (48, -0.046), (49, -0.058)]

similar papers list:

simIndex simValue paperId paperTitle

same-paper 1 0.94119072 56 nips-2001-Convolution Kernels for Natural Language

Author: Michael Collins, Nigel Duffy

2 0.76264924 130 nips-2001-Natural Language Grammar Induction Using a Constituent-Context Model

Author: Dan Klein, Christopher D. Manning

3 0.69663352 5 nips-2001-A Bayesian Model Predicts Human Parse Preference and Reading Times in Sentence Processing

Author: S. Narayanan, Daniel Jurafsky

4 0.59961468 105 nips-2001-Kernel Machines and Boolean Functions

Author: Adam Kowalczyk, Alex J. Smola, Robert C. Williamson

5 0.56871754 110 nips-2001-Learning Hierarchical Structures with Linear Relational Embedding

Author: Alberto Paccanaro, Geoffrey E. Hinton

Abstract: We present Linear Relational Embedding (LRE), a new method of learning a distributed representation of concepts from data consisting of instances of relations between given concepts. Its ﬁnal goal is to be able to generalize, i.e. infer new instances of these relations among the concepts. On a task involving family relationships we show that LRE can generalize better than any previously published method. We then show how LRE can be used effectively to ﬁnd compact distributed representations for variable-sized recursive data structures, such as trees and lists. 1 Linear Relational Embedding Our aim is to take a large set of facts about a domain expressed as tuples of arbitrary symbols in a simple and rigid syntactic format and to be able to infer other “common-sense” facts without having any prior knowledge about the domain. Let us imagine a situation in which we have a set of concepts and a set of relations among these concepts, and that our data consists of few instances of these relations that hold among the concepts. We want to be able to infer other instances of these relations. For example, if the concepts are the people in a certain family, the relations are kinship relations, and we are given the facts ”Alberto has-father Pietro” and ”Pietro has-brother Giovanni”, we would like to be able to infer ”Alberto has-uncle Giovanni”. Our approach is to learn appropriate distributed representations of the entities in the data, and then exploit the generalization properties of the distributed representations [2] to make the inferences. In this paper we present a method, which we have called Linear Relational Embedding (LRE), which learns a distributed representation for the concepts by embedding them in a space where the relations between concepts are linear transformations of their distributed representations. Let us consider the case in which all the relations are binary, i.e. involve two concepts. , and the problem In this case our data consists of triplets we are trying to solve is to infer missing triplets when we are given only few of them. Inferring a triplet is equivalent to being able to complete it, that is to come up with one of its elements, given the other two. Here we shall always try to complete the third element of the triplets 1 . LRE will then represent each concept in the data as a learned vector in a 2 0 £ § ¥ £ § ¥ %

6 0.54419971 66 nips-2001-Efficiency versus Convergence of Boolean Kernels for On-Line Learning Algorithms

7 0.50454348 149 nips-2001-Probabilistic Abstraction Hierarchies

8 0.47653338 86 nips-2001-Grammatical Bigrams

9 0.43978605 190 nips-2001-Thin Junction Trees

10 0.42270014 118 nips-2001-Matching Free Trees with Replicator Equations

11 0.36805993 164 nips-2001-Sampling Techniques for Kernel Methods

12 0.36698815 38 nips-2001-Asymptotic Universality for Learning Curves of Support Vector Machines

13 0.35455984 58 nips-2001-Covariance Kernels from Bayesian Generative Models

14 0.34658864 15 nips-2001-A New Discriminative Kernel From Probabilistic Models

15 0.32971585 85 nips-2001-Grammar Transfer in a Second Order Recurrent Neural Network

16 0.32515118 113 nips-2001-Learning a Gaussian Process Prior for Automatically Generating Music Playlists

17 0.31220272 115 nips-2001-Linear-time inference in Hierarchical HMMs

18 0.30822933 20 nips-2001-A Sequence Kernel and its Application to Speaker Recognition

19 0.29453042 63 nips-2001-Dynamic Time-Alignment Kernel in Support Vector Machine

20 0.28769398 92 nips-2001-Incorporating Invariances in Non-Linear Support Vector Machines

similar papers computed by lda model

lda for this paper:

topicId topicWeight

[(14, 0.052), (17, 0.021), (19, 0.028), (27, 0.094), (30, 0.105), (38, 0.019), (42, 0.201), (59, 0.033), (72, 0.062), (79, 0.05), (83, 0.055), (84, 0.078), (88, 0.014), (91, 0.12)]

similar papers list:

simIndex simValue paperId paperTitle

1 0.86357969 175 nips-2001-Stabilizing Value Function Approximation with the BFBP Algorithm

Author: Xin Wang, Thomas G. Dietterich

Abstract: We address the problem of non-convergence of online reinforcement learning algorithms (e.g., Q learning and SARSA(A)) by adopting an incremental-batch approach that separates the exploration process from the function fitting process. Our BFBP (Batch Fit to Best Paths) algorithm alternates between an exploration phase (during which trajectories are generated to try to find fragments of the optimal policy) and a function fitting phase (during which a function approximator is fit to the best known paths from start states to terminal states). An advantage of this approach is that batch value-function fitting is a global process, which allows it to address the tradeoffs in function approximation that cannot be handled by local, online algorithms. This approach was pioneered by Boyan and Moore with their GROWSUPPORT and ROUT algorithms. We show how to improve upon their work by applying a better exploration process and by enriching the function fitting procedure to incorporate Bellman error and advantage error measures into the objective function. The results show improved performance on several benchmark problems. 1

same-paper 2 0.83548617 56 nips-2001-Convolution Kernels for Natural Language

Author: Michael Collins, Nigel Duffy

3 0.7144382 130 nips-2001-Natural Language Grammar Induction Using a Constituent-Context Model

Author: Dan Klein, Christopher D. Manning

4 0.68814659 10 nips-2001-A Hierarchical Model of Complex Cells in Visual Cortex for the Binocular Perception of Motion-in-Depth

Author: Silvio P. Sabatini, Fabio Solari, Giulia Andreani, Chiara Bartolozzi, Giacomo M. Bisio

Abstract: A cortical model for motion-in-depth selectivity of complex cells in the visual cortex is proposed. The model is based on a time extension of the phase-based techniques for disparity estimation. We consider the computation of the total temporal derivative of the time-varying disparity through the combination of the responses of disparity energy units. To take into account the physiological plausibility, the model is based on the combinations of binocular cells characterized by different ocular dominance indices. The resulting cortical units of the model show a sharp selectivity for motion-indepth that has been compared with that reported in the literature for real cortical cells. 1

5 0.67949271 102 nips-2001-KLD-Sampling: Adaptive Particle Filters

Author: Dieter Fox

Abstract: Over the last years, particle ﬁlters have been applied with great success to a variety of state estimation problems. We present a statistical approach to increasing the efﬁciency of particle ﬁlters by adapting the size of sample sets on-the-ﬂy. The key idea of the KLD-sampling method is to bound the approximation error introduced by the sample-based representation of the particle ﬁlter. The name KLD-sampling is due to the fact that we measure the approximation error by the Kullback-Leibler distance. Our adaptation approach chooses a small number of samples if the density is focused on a small part of the state space, and it chooses a large number of samples if the state uncertainty is high. Both the implementation and computation overhead of this approach are small. Extensive experiments using mobile robot localization as a test application show that our approach yields drastic improvements over particle ﬁlters with ﬁxed sample set sizes and over a previously introduced adaptation technique.

6 0.67441869 149 nips-2001-Probabilistic Abstraction Hierarchies

7 0.67249584 63 nips-2001-Dynamic Time-Alignment Kernel in Support Vector Machine

8 0.66960311 161 nips-2001-Reinforcement Learning with Long Short-Term Memory

9 0.668037 77 nips-2001-Fast and Robust Classification using Asymmetric AdaBoost and a Detector Cascade

10 0.66786426 13 nips-2001-A Natural Policy Gradient

11 0.66666079 162 nips-2001-Relative Density Nets: A New Way to Combine Backpropagation with HMM's

12 0.6656394 52 nips-2001-Computing Time Lower Bounds for Recurrent Sigmoidal Neural Networks

13 0.663845 195 nips-2001-Variance Reduction Techniques for Gradient Estimates in Reinforcement Learning

14 0.66351569 46 nips-2001-Categorization by Learning and Combining Object Parts

15 0.66125631 22 nips-2001-A kernel method for multi-labelled classification

16 0.66013092 131 nips-2001-Neural Implementation of Bayesian Inference in Population Codes

17 0.65964997 27 nips-2001-Activity Driven Adaptive Stochastic Resonance

18 0.65961355 190 nips-2001-Thin Junction Trees

19 0.65910876 60 nips-2001-Discriminative Direction for Kernel Classifiers

20 0.65886009 182 nips-2001-The Fidelity of Local Ordinal Encoding