Showing papers on "Binary tree published in 2014"

Fast concurrent lock-free binary search trees

Abstract: We present a new lock-free algorithm for concurrent manipulation of a binary search tree in an asynchronous shared memory system that supports search, insert and delete operations. In addition to read and write instructions, our algorithm uses (single-word) compare-and-swap (CAS) and bit-test-and-set (SETB) atomic instructions, both of which are commonly supported by many modern processors including Intel~64 and AMD64.In contrast to existing lock-free algorithms for a binary search tree, our algorithm is based on marking edges rather than nodes. As a result, when compared to other lock-free algorithms, modify (insert and delete) operations in our algorithm work on a smaller portion of the tree, thereby reducing conflicts, and execute fewer atomic instructions (one for insert and three for delete). Our experiments indicate that our lock-free algorithm significantly outperforms all other algorithms for a concurrent binary search tree in many cases, especially when contention is high, by as much as 100%.

Activity representation with motion hierarchies

Abstract: Complex activities, e.g. pole vaulting, are composed of a variable number of sub-events connected by complex spatio-temporal relations, whereas simple actions can be represented as sequences of short temporal parts. In this paper, we learn hierarchical representations of activity videos in an unsupervised manner. These hierarchies of mid-level motion components are data-driven decompositions specific to each video. We introduce a spectral divisive clustering algorithm to efficiently extract a hierarchy over a large number of tracklets (i.e. local trajectories). We use this structure to represent a video as an unordered binary tree. We model this tree using nested histograms of local motion features. We provide an efficient positive definite kernel that computes the structural and visual similarity of two hierarchical decompositions by relying on models of their parent---child relations. We present experimental results on four recent challenging benchmarks: the High Five dataset (Patron-Perez et al., High five: recognising human interactions in TV shows, 2010), the Olympics Sports dataset (Niebles et al., Modeling temporal structure of decomposable motion segments for activity classification, 2010), the Hollywood 2 dataset (Marszalek et al., Actions in context, 2009), and the HMDB dataset (Kuehne et al., HMDB: A large video database for human motion recognition, 2011). We show that per-video hierarchies provide additional information for activity recognition. Our approach improves over unstructured activity models, baselines using other motion decomposition algorithms, and the state of the art.

A general technique for non-blocking trees

Abstract: We describe a general technique for obtaining provably correct, non-blocking implementations of a large class of tree data structures where pointers are directed from parents to children. Updates are permitted to modify any contiguous portion of the tree atomically. Our non-blocking algorithms make use of the LLX, SCX and VLX primitives, which are multi-word generalizations of the standard LL, SC and VL primitives and have been implemented from single-word CAS. To illustrate our technique, we describe how it can be used in a fairly straightforward way to obtain a non-blocking implementation of a chromatic tree, which is a relaxed variant of a red-black tree. The height of the tree at any time is O(c + log n), where n is the number of keys and c is the number of updates in progress. We provide an experimental performance analysis which demonstrates that our Java implementation of a chromatic tree rivals, and often significantly outperforms, other leading concurrent dictionaries.

Fast range query processing with strong privacy protection for cloud computing

Abstract: Privacy has been the key road block to cloud computing as clouds may not be fully trusted. This paper concerns the problem of privacy preserving range query processing on clouds. Prior schemes are weak in privacy protection as they cannot achieve index indistinguishability, and therefore allow the cloud to statistically estimate the values of data and queries using domain knowledge and history query results. In this paper, we propose the first range query processing scheme that achieves index indistinguishability under the indistinguishability against chosen keyword attack (IND-CKA). Our key idea is to organize indexing elements in a complete binary tree called PBtree, which satisfies structure indistinguishability (i.e., two sets of data items have the same PBtree structure if and only if the two sets have the same number of data items) and node indistinguishability (i.e., the values of PBtree nodes are completely random and have no statistical meaning). We prove that our scheme is secure under the widely adopted IND-CKA security model. We propose two algorithms, namely PBtree traversal width minimization and PBtree traversal depth minimization, to improve query processing efficiency. We prove that the worse case complexity of our query processing algorithm using PBtree is O(|R| log n), where n is the total number of data items and R is the set of data items in the query result. We implemented and evaluated our scheme on a real world data set with 5 million items. For example, for a query whose results contain ten data items, it takes only 0.17 milliseconds.

Practical concurrent binary search trees via logical ordering

Abstract: We present practical, concurrent binary search tree (BST) algorithms that explicitly maintain logical ordering information in the data structure, permitting clean separation from its physical tree layout. We capture logical ordering using intervals, with the property that an item belongs to the tree if and only if the item is an endpoint of some interval. We are thus able to construct efficient, synchronization-free and intuitive lookup operations. We present (i) a concurrent non-balanced BST with a lock-free lookup, and (ii) a concurrent AVL tree with a lock-free lookup that requires no synchronization with any mutating operations, including balancing operations. Our algorithms apply on-time deletion; that is, every request for removal of a node, results in its immediate removal from the tree. This new feature did not exist in previous concurrent internal tree algorithms.We implemented our concurrent BST algorithms and evaluated them against several state-of-the-art concurrent tree algorithms. Our experimental results show that our algorithms with lock-free contains and on-time deletion are practical and often comparable to the state-of-the-art.

Circuit for Reversible Quantum Multiplier Based on Binary Tree Optimizing Ancilla and Garbage Bits

Abstract: Reversible logic has emerged as a promising computing paradigm having applications in quantum computing, optical computing, dissipation less computing and low power computing etc. In reversible logic there exists a one to one mapping between the input and output vectors. Reversible circuits require constant ancilla inputs for reconfiguration of gate functions and garbage outputs that help in keeping reversibility. Quantum circuits of many qubits are extremely difficult to realize thus reduction in the number of ancilla inputs and the garbage outputs is the primary goal of optimization. In existing literature researchers have proposed several designs of reversible quantum multipliers based on reversible full adders and reversible half adders. The use of reversible full adders and the half adders for the addition of partial products increases the overhead in terms of number of ancilla inputs and number of garbage outputs. This paper presents a binary tree based design methodology for a NxN reversible quantum multiplier. The proposed binary tree based design methodology for NxN reversible quantum multiplier performs the addition of partial products in parallel using the reversible ripple quantum adders with no garbage output and ancilla bit, thereby minimizing the number of ancilla and garbage bits used in the design. The proposed design methodology shows the improvement of 17.86% to 60.34% in terms of ancilla inputs; and 21.43% to 52.17% in terms of garbage outputs compared to all the existing reversible quantum multiplier designs.

Tree Adaptive Approximation in the Hierarchical Tensor Format

Abstract: The hierarchical tensor format allows for the low-parametric representation of tensors even in high dimensions $d$. The efficiency of this representation strongly relies on an appropriate hierarchical splitting of the different directions $1,\ldots,d$ such that the associated ranks remain sufficiently small. This splitting can be represented by a binary tree which is usually assumed to be given. In this paper, we address the question of finding an appropriate tree from a subset of tensor entries without any a priori knowledge on the tree structure. We propose an agglomerative strategy that can be combined with rank-adaptive cross approximation techniques such that tensors can be approximated in the hierarchical format in an entirely black box way. Numerical examples illustrate the potential and the limitations of our approach.

A Uniform Paradigm to Succinctly Encode Various Families of Trees

Abstract: We propose a uniform method to encode various types of trees succinctly. These families include ordered (ordinal), k-ary (cardinal), and unordered (free) trees. We will show the approach is intrinsically suitable for obtaining entropy-based encodings of trees (such as the degree-distribution entropy). Previously-existing succinct encodings of trees use ad hoc techniques to encode each particular family of trees. Additionally, the succinct encodings obtained using the uniform approach improve upon the existing succinct encodings of each family of trees; in the case of ordered trees, it simplifies the encoding while supporting the full set of navigational operations. It also simplifies the implementation of many supported operations. The approach applied to k-ary trees yields a succinct encoding that supports both cardinal-type operations (e.g. determining the child label i) as well as the full set of ordinal-type operations (e.g. reporting the number of siblings to the left of a node). Previous work on succinct encodings of k-ary trees does not support both types of operations simultaneously (Benoit et al. in Algorithmica 43(4):275–292, 2005; Raman et al. in ACM-SIAM Symposium on Discrete Algorithms (SODA), pp. 233–242, 2002). For unordered trees, the approach achieves the first succinct encoding. The approach is based on two recursive decompositions of trees into subtrees. Recursive decomposition of a structure into substructures is a common technique in succinct encodings and has even been used to encode (ordered) trees (Geary et al. in ACM Trans. Algorithms 2(4):510–534, 2006; He et al. in ICALP, pp. 509–520, 2007) and dynamic binary trees (Munro et al. in ACM-SIAM Symposium on Discrete Algorithms (SODA), pp. 529–536, 2001; Storm in Representing dynamic binary trees succinctly, Master’s thesis, 2000). The main distinction of the approach in this paper is that a tree is decomposed into subtrees in a manner that the subtrees are maximally isolated from each other. This intermediate decomposition result is interesting in its own right and has proved useful in other applications (Farzan et al. in ICALP (1), pp. 451–462, 2009; Farzan and Munro in ICALP (1), pp. 439–450, 2009; Farzan and Kamali in ICALP, 2011).

On Cartesian Trees and Range Minimum Queries

Abstract: We present new results on Cartesian trees with applications in range minimum queries and bottleneck edge queries. We introduce a cache-oblivious Cartesian tree for solving the range minimum query problem, a Cartesian tree for the bottleneck edge query problem on trees and undirected graphs, and a proof that no Cartesian tree exists for the two-dimensional version of the range minimum query problem.

A Comprehensive Approach to Universal Piecewise Nonlinear Regression Based on Trees

Abstract: In this paper, we investigate adaptive nonlinear regression and introduce tree based piecewise linear regression algorithms that are highly efficient and provide significantly improved performance with guaranteed upper bounds in an individual sequence manner. We use a tree notion in order to partition the space of regressors in a nested structure. The introduced algorithms adapt not only their regression functions but also the complete tree structure while achieving the performance of the “best” linear mixture of a doubly exponential number of partitions, with a computational complexity only polynomial in the number of nodes of the tree. While constructing these algorithms, we also avoid using any artificial “weighting” of models (with highly data dependent parameters) and, instead, directly minimize the final regression error, which is the ultimate performance goal. The introduced methods are generic such that they can readily incorporate different tree construction methods such as random trees in their framework and can use different regressor or partitioning functions as demonstrated in the paper.

dendsort: modular leaf ordering methods for dendrogram representations in R.

Abstract: Dendrograms are graphical representations of binary tree structures resulting from agglomerative hierarchical clustering. In Life Science, a cluster heat map is a widely accepted visualization technique that utilizes the leaf order of a dendrogram to reorder the rows and columns of the data table. The derived linear order is more meaningful than a random order, because it groups similar items together. However, two consecutive items can be quite dissimilar despite proximity in the order. In addition, there are 2 n-1 possible orderings given n input elements as the orientation of clusters at each merge can be flipped without affecting the hierarchical structure. We present two modular leaf ordering methods to encode both the monotonic order in which clusters are merged and the nested cluster relationships more faithfully in the resulting dendrogram structure. We compare dendrogram and cluster heat map visualizations created using our heuristics to the default heuristic in R and seriation-based leaf ordering methods. We find that our methods lead to a dendrogram structure with global patterns that are easier to interpret, more legible given a limited display space, and more insightful for some cases. The implementation of methods is available as an R package, named ”dendsort”, from the CRAN package repository. Further examples, documentations, and the source code are available at [https://bitbucket.org/biovizleuven/dendsort/].

Description of the Translation-Invariant Splitting Gibbs Measures for the Potts Model on a Cayley Tree

Abstract: For the $$q$$ -state Potts model on a Cayley tree of order $$k\ge 2$$ it is well-known that at sufficiently low temperatures there are at least $$q+1$$ translation-invariant Gibbs measures which are also tree-indexed Markov chains. Such measures are called translation-invariant splitting Gibbs measures (TISGMs). In this paper we find all TISGMs, and show in particular that at sufficiently low temperatures their number is $$2^{q}-1$$ . We prove that there are $$[q/2]$$ (where $$[a]$$ is the integer part of $$a$$ ) critical temperatures at which the number of TISGMs changes and give the exact number of TISGMs for each intermediate temperature. For the binary tree we give explicit formulae for the critical temperatures and the possible TISGMs. While we show that these measures are never convex combinations of each other, the question which of these measures are extremals in the set of all Gibbs measures will be treated in future work.

Fast Algorithm of Attribute Reduction Based on the Complementation of Boolean Function

Abstract: In this chapter we propose a new method of solving the attribute reduction problem. Our method is different to the classical approach using the so-called discernibility function and its CNF into DNF transformation. We have proved that the problem is equivalent to very efficient unate complementation algorithm. That is why we propose new algorithm based on recursive execution of the procedure, which at every step of recursion selects the splitting variable and then calculates the cofactors with respect to the selected variables (Shannon expansion procedure). The recursion continues until at each leaf of the recursion tree the easily computable rules for complement process can be applied. The recursion process creates a binary tree so that the final result is obtained merging the results in the subtrees. The final matrix represents all the minimal reducts of a decision table or all the minimal dependence sets of input variables, respectively. According to the results of computer tests, better results can be achieved by application of our method in combination with the classical method.

A Universal Grammar-Based Code for Lossless Compression of Binary Trees

Abstract: We consider the problem of lossless compression of binary trees, with the aim of reducing the number of code bits needed to store or transmit such trees. A lossless grammar-based code is presented, which encodes each binary tree into a binary codeword in two steps. In the first step, the tree is transformed into a context-free grammar from which the tree can be reconstructed. In the second step, the context-free grammar is encoded into a binary codeword. The decoder of the grammar-based code decodes the original tree from its codeword by reversing the two encoding steps. It is shown that the resulting grammar-based binary tree compression code is a universal code on a family of probabilistic binary tree source models satisfying certain weak restrictions.

Model Selection by Linear Programming

Abstract: Budget constraints arise in many computer vision problems. Computational costs limit many automated recognition systems while crowdsourced systems are hindered by monetary costs. We leverage wide variability in image complexity and learn adaptive model selection policies. Our learnt policy maximizes performance under average budget constraints by selecting “cheap” models for low complexity instances and utilizing descriptive models only for complex ones. During training, we assume access to a set of models that utilize features of different costs and types. We consider a binary tree architecture where each leaf corresponds to a different model. Internal decision nodes adaptively guide model-selection process along paths on a tree. The learning problem can be posed as an empirical risk minimization over training data with a non-convex objective function. Using hinge loss surrogates we show that adaptive model selection reduces to a linear program thus realizing substantial computational efficiencies and guaranteed convergence properties.

Energy-Efficient Prefix-Free Codes for Wireless Nano-Sensor Networks Using OOK Modulation

Abstract: Wireless nano-sensor networks (WNSNs), which consist of nano-sensors a few hundred nanometers in size with the capability to detect and sense new types of events in nano-scale, are promising for many unique applications such as air pollution surveillance. The nano-sensors of WNSNs are highly energy-constrained, which makes it essential to develop energy-efficient communication techniques in such networks. In this paper, we focus on WNSNs employing on-off keying (OOK) modulation, whereby transmission energy minimization corresponds to the minimization of average codeword weight (ACW). We formulate an integer nonlinear programming problem to construct prefix-free codes with minimum ACW under the constraint of average codeword length (ACL) so as to minimize the transmission energy consumption while guaranteeing the throughput larger than a preset desired value. In addition, two efficient algorithms, called binary tree based weight decreasing (BT-WD) algorithm and binary tree based length decreasing (BT-LD) algorithm, are presented for constructing low-ACW prefix-free codes. The effectiveness of the proposed algorithms is verified through simulations and comparisons with the exhaustive search method. Compared with the available fixed-length low-weight codes, the designed prefix-free variable-length codes allow us to not only control the throughput more flexibly but also achieve lower transmission energy consumption in the scenarios with low or medium bit error rates.

A novel strategy for solving the stochastic point location problem using a hierarchical searching scheme.

Abstract: Stochastic point location (SPL) deals with the problem of a learning mechanism (LM) determining the optimal point on the line when the only input it receives are stochastic signals about the direction in which it should move. One can differentiate the SPL from the traditional class of optimization problems by the fact that the former considers the case where the directional information, for example, as inferred from an Oracle (which possibly computes the derivatives), suffices to achieve the optimization-without actually explicitly computing any derivatives. The SPL can be described in terms of a LM (algorithm) attempting to locate a point on a line. The LM interacts with a random environment which essentially informs it, possibly erroneously, if the unknown parameter is on the left or the right of a given point. Given a current estimate of the optimal solution, all the reported solutions to this problem effectively move along the line to yield updated estimates which are in the neighborhood of the current solution(1) This paper proposes a dramatically distinct strategy, namely, that of partitioning the line in a hierarchical tree-like manner, and of moving to relatively distant points, as characterized by those along the path of the tree. We are thus attempting to merge the rich fields of stochastic optimization and data structures. Indeed, as in the original discretized solution to the SPL, in one sense, our solution utilizes the concept of discretization and operates a uni-dimensional controlled random walk (RW) in the discretized space, to locate the unknown parameter. However, by moving to nonneighbor points in the space, our newly proposed hierarchical stochastic searching on the line (HSSL) solution performs such a controlled RW on the discretized space structured on a superimposed binary tree. We demonstrate that the HSSL solution is orders of magnitude faster than the original SPL solution proposed by Oommen. By a rigorous analysis, the HSSL is shown to be optimal if the effectiveness (or credibility) of the environment, given by p , is greater than the golden ratio conjugate. The solution has been both analytically solved and simulated, and the results obtained are extremely fascinating, as this is the first reported use of time reversibility in the analysis of stochastic learning. The learning automata extensions of the scheme are currently being investigated. As we shall see later, hierarchical solutions have been proposed in the field of LA.

Randomization in Automata on Infinite Trees

Abstract: We study finite automata running over infinite binary trees. A run of such an automaton over an input tree is a tree labeled by control states of the automaton: the labeling is built in a top-down fashion and should be consistent with the transitions of the automaton. A branch in a run is accepting if the ω-word obtained by reading the states along the branch satisfies some acceptance condition (typically an ω-regular condition such as a Buchi or a parity condition). Finally, a tree is accepted by the automaton if there exists a run over this tree in which every branch is accepting.In this article, we consider two relaxations of this definition, introducing a qualitative aspect. First, we relax the notion of accepting run by allowing a negligible set (in the sense of measure theory) of nonaccepting branches. In this qualitative setting, a tree is accepted by the automaton if there exists a run over this tree in which almost every branch is accepting. This leads to a new class of tree languages, qualitative tree languages. This class enjoys many good properties: closure under union and intersection (but not under complement), and emptiness is decidable in polynomial time. A dual class, positive tree languages, is defined by requiring that an accepting run contains a non-negligeable set of branches.The second relaxation is to replace the existential quantification (a tree is accepted if there exists some accepting run over the input tree) with a probabilistic quantification (a tree is accepted if almost every run over the input tree is accepting). For the run, we may use either classical acceptance or qualitative acceptance. In particular, for the latter, we exhibit a tight connection with partial observation Markov decision processes. Moreover, if we additionally restrict operation to the Buchi condition, we show that it leads to a class of probabilistic automata on infinite trees enjoying a decidable emptiness problem. To our knowledge, this is the first positive result for a class of probabilistic automaton over infinite trees.

Binary tree block partitioning structure

Abstract: A binary tree block partitioning structure is proposed. The proposed flexible block partitioning structure plays an important role in the substantial performance gains relative the HEVC.

Consensus tree method for generating master assembly sequence

Abstract: An assembly process plan for a given product provides the sequence of assembly operations, their times as well as the required tools and fixtures for each operation. Much research has been done on automating and optimizing assembly sequence generation as the most important part of an assembly process plan. A novel method for generating the assembly sequence of a given product based on available assembly sequence data of similar products is presented. The proposed method uses a binary tree form to represent the assembly sequences of an existing family of products. A Genetic Algorithm is employed to find the consensus tree that represents the set of all assembly sequence trees with minimum total dissimilarity distance. This is similar to defining Generic Bill-of-Material. The generated consensus tree serves as a master assembly sequence for the product family. The assembly sequence for a new product variant that falls within, or significantly overlaps with, the scope of the considered family of products can be directly extracted from the derived master assembly sequence tree. The developed method is demonstrated using a family of three control valves. This novel method greatly simplifies and enhances automatic assembly sequence generation and minimizes subsequent modifications, hence, reduces assembly planning cost and improves productivity.

Adaptive tree-based search for stochastic simulation algorithm.

Abstract: Stochastic modelling and simulation is a well-known approach for predicting the behaviour of biochemical systems. Its main applications lie in those systems wherein the inherently random fluctuations of some species are significant, as often is the case whenever just a few macromolecules have a large effect on the rest of the system. The Gillespie's stochastic simulation algorithm (SSA) is a standard method to properly realise the stochastic nature of reactions. In this paper we propose an improvement to SSA based on the Huffman tree, a binary tree which is used to define an optimal data compression algorithm. We exploit results from that area to devise an efficient search for next reactions, moving from linear time complexity to logarithmic complexity. We combine this idea with others from literature, and compare the performance of our algorithm with previous ones. Our experiments show that our algorithm is faster, especially on large models.

Unmanned aerial vehicle route planning method

Abstract: The invention discloses an unmanned aerial vehicle route planning method. The method comprises the following steps: firstly, initializing a task map, marking a Start (xstart, ystart), a Goal (xgoal, ygoal) and the coordinate of a barrier, and calculating the minimum safety turning radius R of and unmanned aerial vehicle; secondly, setting the Start as a Node [0] and the Goal as a Node [-1], finding the coordinates of other nodes, and establishing a binary tree by using a structural body; and thirdly, reading the binary tree by using a depth-first lvalue traversing method, sequentially recording the sequences of the nodes, and storing connecting lines between every two adjacent nodes and a route into a matrix Path[], wherein the route is generated by using a Dijkstra algorithm. Compared with the prior art, the invention provides a concrete node calibration method; the diversity of the route is increased through drawing a vertical line on any position on a connecting line between two points; and a non-evolutional calculating method is adopted, so that the calculating time is shortened, the storage space is reduced, and the stability of the algorithm is improved.

Topology Inference With Network Tomography Based on t-Test

Abstract: Network tomography is a promising inference technique for network topology from end-to-end measurements. In this letter, we propose a novel binary tree pruning algorithm based on t-test to infer the network topology. A binary tree topology is first inferred using the existing Agglomerative Likelihood Tree (ALT) method, and then two samples t-test is applied to prune the binary tree, thus a general tree corresponding to the real topology is obtained. A lower bound on the correctly identified probability of the proposed method is derived. Simulation results show that the pruning method based on t-test outperforms the method which prunes the binary tree using a fixed threshold.

Polytomy refinement for the correction of dubious duplications in gene trees

Abstract: Motivation: Large-scale methods for inferring gene trees are errorprone. Correcting gene trees for weakly supported features often results in non-binary trees, i.e. trees with polytomies, thus raising the natural question of refining such polytomies into binary trees. A feature pointing toward potential errors in gene trees are duplications that are not supported by the presence of multiple gene copies. Results: We introduce the problem of refining polytomies in a gene tree while minimizing the number of created non-apparent duplications in the resulting tree. We show that this problem can be described as a graph-theoretical optimization problem. We provide a bounded heuristic with guaranteed optimality for well-characterized instances. We apply our algorithm to a set of ray-finned fish gene trees from the Ensembl database to illustrate its ability to correct dubious duplications. Availability and implementation: The C++ source code for the algorithms and simulations described in the article are available at http://www-ens.iro.umontreal.ca/~lafonman/software.php.

Pairwise compatibility graphs of caterpillars

Abstract: A graph G = (V, E) is called a pairwise compatibility graph (PCG) if there exists an edge-weighted tree T and two non-negative real numbers dmin and dmax such that each leaf lu of T corresponds to a vertex u of V and there is an edge (u, v) in E if and only if dmin <= dT,w(lu, lv) <= dmax where dT,w(lu, lv) is the sum of the weights of the edges on the unique path from lu to lv in T. In this paper, we focus our attention on PCGs for which the witness tree is a caterpillar. We first give some properties of graphs that are PCGs of a caterpillar. We formulate this problem as an integer linear programming problem and we exploit this formulation to show that for the wheels on n vertices Wn, n = 7, ... , 11, the witness tree cannot be a caterpillar. Related to this result, we conjecture that no wheel is PCG of a caterpillar. Finally, we state a more general result proving that any pairwise compatibility graph admits a full binary tree as witness tree T.

Strip Steel Surface Defect Classification Method Based on Enhanced Twin Support Vector Machine

Abstract: The strip steel surface defect classification belongs to multi-class classification. It demands high classification accuracy and efficiency. However, traditional methods are not fit for abnormal datasets, such as the large-scale, sparse, unbalanced and corrupted dataset. So a novel classification method is proposed in this paper based on enhanced twin support vector machine (TWSVM) and binary tree. According to the density information, the large-scale dataset is pruned, the sparse dataset is added with unlabeled samples, and TWSVM is improved to multi-density TWSVM (MDTWSVM) which has efficient successive overrelaxation (SOR) algorithm. Finally, MDTWSVM and binary tree are combined together to realize multiclass classification. Some experiments are done on the strip steel surface defect datasets with the proposed algorithm. Experimental results show that MDTWSVM has higher accuracy and efficiency than the other methods of multi-class classification for the strip steel surface defect.