Showing papers on "Interval tree published in 1998"

Tree based discretization for continuous state space reinforcement learning

Abstract: Reinforcement learning is an effective technique for learning action policies in discrete stochastic environments, but its efficiency can decay exponentially with the size of the state space. In many situations significant portions of a large state space may be irrelevant to a specific goal and can be aggregated into a few, relevant, states. The U Tree algorithm generates a tree based state discretization that efficiently finds the relevant state chunks of large propositional domains. In this paper, we extend the U Tree algorithm to challenging domains with a continuous state space for which there is no initial discretization. This Continuous U Tree algorithm transfers traditional regression tree techniques to reinforcement learning. We have performed experiments in a variety of domains that show that Continuous U Tree effectively handles large continuous state spaces. In this paper, we report on results in two domains, one gives a clear visualization of the algorithm and another empirically demonstrates an effective state discretization in a simple multi-agent environment.

Fast string searching and indexing using a search tree having a plurality of linked nodes

Abstract: A fast string indexing method efficiently stores, searches, and removes alphanumeric or binary strings utilizing a compacted search tree. The number of levels in the search tree is minimized by having a node represent more than one character when possible. Each inner node of the tree contains a hash table array for successive hashing, which also minimizes the time required to traverse a given node. Searches may be performed for partial matches, such as wild cards at the character level. Multiple indices may be opened independently and concurrently on the same table of string entries.

Inducing Cost-Sensitive Trees via Instance Weighting

Abstract: We introduce an instance-weighting method to induce costsensitive trees in this paper. It is a generalization of the standard tree induction process where only the initial instance weights determine the type of tree to be induced—minimum error trees or minimum high cost error trees. We demonstrate that it can be easily adapted to an existing tree learning algorithm. Previous research gave insufficient evidence to support the fact that the greedy divide-and-conquer algorithm can effectively induce a truly cost-sensitive tree directly from the training data. We provide this empirical evidence in this paper. The algorithm incorporating the instance-weighting method is found to be better than the original algorithm in terms of total misclassification costs, the number of high cost errors and tree size in two-class datasets. The instanceweighting method is simpler and more effective in implementation than a previous method based on altered priors.

The LSD/sup h/-tree: an access structure for feature vectors

Abstract: Efficient access structures for similarity queries on feature vectors are an important research topic for application areas such as multimedia databases, molecular biology or time series analysis. Different access structures for high dimensional feature vectors have been proposed, namely: the SS-tree, the VAMSplit R-tree, the TV-tree, the SR-tree and the X-tree. All these access structures are derived from the R-tree. As a consequence, the fanout of the directory of these access structures decreases drastically for higher dimensions. Therefore we argue that the R-tree is not the best possible starting point for the derivation of an access structure for high-dimensional data. We show that k-d-tree-based access structures are at least as well suited for this application area and we introduce the LSD/sup h/-tree as an example for such a k-d-tree-based access structure for high-dimensional feature vectors. We describe the algorithms for the LSD/sup h/-tree and present experimental results comparing the LSD/sup h/-tree and the X-tree.

Method, apparatus, and embodied data structures for optimal anytime winner determination in combinatorial auction-type problems

Abstract: Disclosed is a method and data structures for solution of problems of the class equivalent to optimal allocation determination in a combinatorial auction. The method stores bids in a binary tree which is searched in conjunction with a stopmask data structure which allows, in effect, parts of the binary tree to be instantly pruned during search and in place. Depth-first search in this tree can be done in place without an open list or recursive calls. The main search method operates via recursive call and generates each allocation of positive value once but does not generate others.

Interactive out-of-core isosurface extraction

Abstract: We present a novel out-of-core technique for the interactive computation of isosurfaces from volume data. Our algorithm minimizes the main memory and disk space requirements on the visualization workstation, while speeding up isosurface extraction queries. Our overall approach is a two-level indexing scheme. First, by our meta-cell technique, we partition the original dataset into clusters of cells, called meta-cells. Secondly, we produce meta-intervals associated with the meta-cells, and build an indexing data structure on the meta-intervals. We separate the cell information, kept only in meta-cells on disk, from the indexing structure, which is also on disk and only contains pointers to meta-cells. Our meta-cell technique is an I/O-efficient approach for computing a k-d-tree-like partition of the dataset. Our indexing data structure, the binary blocked I/O interval tree, is a new I/O-optimal data structure to perform stabbing queries that report from a set of meta-intervals (or intervals) those containing a query value q. Our tree is simpler to implement, and is also more space-efficient in practice than existing structures. To perform an isosurface query, we first query the indexing structure, and then use the reported meta-cell pointers to read from disk the active meta-cells intersected by the isosurface. The isosurface itself can then be generated from active meta-cells. Rather than being a single cost indexing approach, our technique exhibits a smooth trade-off between query time and disk space.

The effect of buffering on the performance of R-trees

Abstract: Past R tree studies have focused on the number of nodes visited as a metric of query performance. Since database systems usually include a buffering mechanism, we propose that the number of disk accesses is a more realistic measure of performance. We develop a buffer model to analyze the number of disk accesses required for spatial queries using R trees. The model can be used to evaluate the quality of R tree update operations, such as various node splitting and tree restructuring policies, as measured by query performance on the resulting tree. We use our model to study the performance of three well known R tree packing algorithms. We show that ignoring buffer behavior and using number of nodes accessed as a performance metric can lead to incorrect conclusions, not only quantitatively, but also qualitatively. In addition, we consider the problem of how many levels of the R tree should be pinned in the buffer.

Two Heuristics for the Euclidean Steiner Tree Problem

Abstract: The Euclidean Steiner tree problem is to find the tree with minimal Euclidean length spanning a set of fixed points in the plane, allowing the addition of auxiliary points to the set (Steiner points). The problem is NP-hard, so polynomial-time heuristics are desired. We present two such heuristics, both of which utilize an efficient method for computing a locally optimal tree with a given topology. The first systematically inserts Steiner points between edges of the minimal spanning tree meeting at angles less than 120 degrees, performing a local optimization at the end. The second begins by finding the Steiner tree for three of the fixed points. Then, at each iteration, it introduces a new fixed point to the tree, connecting it to each possible edge by inserting a Steiner point, and minimizes over all connections, performing a local optimization for each. We present a variety of test cases that demonstrate the strengths and weaknesses of both algorithms.

Efficient algorithms for embedded rendering of terrain models

Abstract: Digital terrains are generally large files and need to be simplified to be rendered efficiently. We propose to build an adaptive embedded triangulation based on a binary tree structure to generate multiple levels of details. We present a O(nlogn) decimation algorithm and a O(nlogn) refinement algorithm, where n is the number of elevation points. We compare them in a rate-distortion (RD) framework. The algorithms are based on an improved version of the optimal tree pruning algorithm G-BFOS allowing one to deal with constrained tree structures and non-monotonic tree functionals.

An encoding method and apparatus

Abstract: An apparatus for the encoding of a series of wavelet coefficients of a predetermined size into a compact representation of the coefficients is disclosed, the apparatus comprising tree building means for constructing a tree form representation of the coefficients with leaf nodes representing coefficient values and internal nodes representing the number of bits needed to encode leaf nodes and child nodes of a current internal node, the tree building means storing the tree form representation in a tree buffer means; tree buffer means for storing the tree form representation; tree coding means interconnected to the tree buffer means and adapted to read a current tree form representation and to output the encoding from the tree form representation. The tree buffer means can include means for storing at least two tree form representations and the tree building means can be adapted to form a first of the representations while the tree coding means can be adapted to read a second of the tree form representations previously created by the tree building means.

Z-trees: adaptive pyramid-algorithms for image segmentation

Abstract: This paper introduces a direction-sensitive and locally reorientable compact binary tree, called the Z-tree, for representing digital images. A rotation operation is defined on a subset of its node, called square nodes, to spatially reorganize the four grand children of any given square-node. The goal is to adapt the Z-tree in order to produce a minimal cutset representation of homogeneous regions. This will enhance a tree-based dynamic programming approach to image segmentation. The tree transformation, tree rotation, and tree inverse transformation, as a sequence is compactly expressed in the algebraic form of pseudo inverses. Such an expression is conjectured to be universal for segmentation. Experimental results are included to illustrate the effectiveness of the adaptively orientable trees for image segmentation, including a discussion on the choice of metrics that would warrant a local rotation. Natural extension of this approach to 3-D images, and higher dimensional grids is also outlined.

The average diameter of general tree structures

Abstract: In this paper, we study the static behavior of distributed memory architecture with general tree structures. After defining and discussing the notion of average diameter, we first show that the average time it takes to send messages between any two arbitrary processors in a binary tree structure with n processors is e(log n), through combinatorial analysis. We will also show that we can extend this result to general tree structures with n nodes, with a reasonable assumption, i.e., when m = o(n), where m is the maximum number of children any node could have. We believe that the results presented in this paper have captured some important inter-processor data transmission behavior of computers with distributed memory architectures, particularly those with (binary) tree structured inter-processor networks. As an application of combinatorial and a- symptotic analysis, this paper solves yet another average path length problem, thus is also theoreti- cally interesting. Finally, some of the techniques we have developed in this paper might also be useful in the study of similar problems. (~) 1998 Elsevier Science Ltd. All rights reserved.

All searches are divided into three parts: string searches using ternary trees

Abstract: This paper considers the problem of searching for strings in a dictionary or symbol table. It presents a data structure which can be used for this purpose---the Ternary Tree. It considers the theoretical properties of this structure, compared with other possible structures for the same purpose. It presents an implementation of this structure in APL, including code to do a variety of operations on it.

The generating power of total deterministic tree transducer

Abstract: Attributed tree transducers are abstract models used to study properties of attribute grammars. One abstraction which occurs when modeling attribute grammars by attributed tree transducers is that arbitrary trees over a ranked alphabet are taken as input, instead of derivation trees of a context-free grammar. In this paper we show that with respect to the generating power this is not an abstraction; i.e., we show that attributed tree transducers and attribute grammars generate the same class of term (or tree) languages. To prove this, a number of results concerning the generating power of top-down tree transducers are established, which are interesting in their own. We also show that the classes of output languages of attributed tree transducers form a hierarchy with respect to the number of attributes. The latter result is achieved by proving a hierarchy of classes of tree languages generated by context-free hypergraph grammars with respect to their rank.

Diets for fat sets

Abstract: In this paper we describe the discrete interval encoding tree for storing subsets of types having a total order and a predecessor and a successor function. In the following, we consider for simplicity only the case for integer sets; the generalization is not difficult.The discrete interval encoding tree is based on the observation that the set of integers {imalilb} can be perfectly represented by the closed interval la, br. The general idea is to represent a set by a binary search tree of integers in which maximal adjacent subsets are each represented by an interval. For example, inserting the sequence of numbers 6, 9, 2, 13, 8, 14, 10, 7, 5 into a binary search tree, respectively, into a discrete interval encoding tree results in the tree structures shown in figure 1.The efficiency of the interval representation, both in terms of space and time, improves with the density of the set, i.e. with the number of adjacencies between set elements. So what we propose is a ‘diet’ (discrete interval encoding tree) for ‘fat’ sets in the sense of ‘the same amount of information with less nodes’.

Robust morphological scale-space trees

Abstract: This paper derives a new tree representation of an image and shows how the tree may be derived from graph morphology and connected-set, alternating sequential, filters. The resulting scale tree forms a pyramid of increasing size objects where the nodes correspond to features of a particular scale. The tree structure itself may be made fairly insensitive to geometrical changes in the image. By parsing the tree and using attributes associated with the nodes, image processing operations such as filtering, segmentation and detection can be performed.

Indexed Tree Matching with Complete Answer Representations

Abstract: This paper picks up the Tree Matching approach to integrate the paradigm of structured documents into the field of Information Retrieval. The concept of Tree Matching is extended by the notion of complete answer representations (CARs), which makes it possible to avoid the combinatorial explosion in the number of solutions (and thus complexity). An algorithm is presented that combines a class of Tree Matching problems with index-based search and returns a CAR in linear time.

A new parallel algorithm for rooting a tree

Abstract: When an undirected tree,T, and a vertex,r, in the tree are given, the problem to transformT into a rooted tree withr as its root is considered. Using Euler tour and prefix sum, an optimal algorithm has been developed [2, 3]. We will present another parallel algorithm which is optimal also on EREW PRAM. Our approach reduces the given tree step by step by pruning and pointer jumping. That is, the tree structure is retained during algorithm processing such that another tree computations can be carried out in parallel.

Scalable classifiers with dynamic pruning

Abstract: The paper presents an algorithm to solve the problem of classification for data mining applications. This is a decision tree classifier which uses modified gini index as the partitioning criteria. A pre-sorting technique is used to overcome the problem of sorting at each node of the tree. This technique is integrated with a breadth first tree growth strategy which enables us to calculate the best partition for each of the leaf nodes in a single scan of a database. We have implemented this algorithm using depth first tree growth strategy also. The algorithm uses a dynamic pruning approach which reduces the number of scans of the database and does away with a separate tree pruning phase. The proof of correctness, analysis and performance study are also presented.

Context tree algorithm method and system

Abstract: Known methods for construct a tree, for a context tree algorithm for coding symbols, construct trees by adding nodes. These methods need a giant memory capacity, which can be reduced in case unnecessary nodes are not added to the tree. This should be done through dependence on values of parameters belonging to a node where each parameter defines a number of symbols received that have a certain value.

Self-organization and evolution on large computer data structures

Abstract: We study the long time evolution of a large data structure while inserting new items. It is implemented using a well known computer science approach based on 2-3 trees. We have seen self-organized critical behavior on this data structure. To tackle this problem we have introduced and studied experimentally three statistical magnitudes: the stress of a tree, the sequence of jump points and the distribution of subtrees inside a tree. The stress measures the amount of free space inside the 2-3 tree. When the stress increases some part of the tree is restructured in a way close to an avalanche. Experimentally we obtain a potential law for stress distribution. When the tree does not have more free space in any internal node, needs to grow up. When this happens, the height of the whole tree increases by one and we have a jump point. Experimentally these points have good expected behavior.A 2-3 tree is composed from a great number of other 2-3 trees called their subtrees. We have studied experimentally the distribution of the different subtrees inside the tree. Finally we analyze these results using simple theoretical models based on fringe analysis, Markov and branching processes. These models give us a quite good description of the long term process.

Multiplexing periodic sources in a tree network of ATM multiplexers

Abstract: We obtain the queue length distribution in a tree of discrete time queues with constant service time whose input is periodic traffic. In the context of ATM the study could be applied to CBR sources. The tree consists of M-stages. To solve this system, we first solve a 2-stage tree network. Given this configuration, a more complex tree network can be easily solved making use of the properties of the discrete time queues with identical service times. We also give closed formulas for the average waiting time and average number of cells in any queue of the tree network.

Constructing Additive Trees When the Error Is Small

Abstract: We consider the problem of constructing an additive tree from a given matrix of pairwise distances, when observation errors are allowed. We give conditions under which the tree topology is unique and semi-unique. We also design an efficient algorithm to construct a tree when the error is relatively small.