ppxscal/embedding_network huggingface dataset:
Classification Accuracy: Machine Learning vs. Explicit Knowledge Acquisition
Authors: Arie Ben-David, Janice Mandel
Venue: Machine Learning (1995)

This empirical study provides evidence that machine learning models can provide better classification accuracy than explicit knowledge acquisition techniques. The findings suggest that the main contribution of machine learning to expert systems is not just cost reduction, but rather the provision of tools for the development of better expert systems.
Convex potentials and their conjugates in analog mean-field optimization
Authors: I. M. Elfadel
Venue: Neural Computation (1995)

This paper deals with the problem of mapping hybrid (i.e., both discrete and continuous) constrained optimization problems onto analog networks. The saddle-point paradigm of mean-field methods in statistical physics provides a systematic procedure for finding such a mapping via the notion of effective energy. Specifically, it is shown that within this paradigm, to each closed bounded constraint set is associated a smooth convex potential function. Using the conjugate (or the Legendre-Fenchel transform) of the convex potential, the effective energy can be transformed to yield a cost function that is a natural generalization of the analog Hopfield energy. Descent dynamics and deterministic annealing can then be used to find the global minimum of the original minimization problem. When the conjugate is hard to compute explicitly, it is shown that a minimax dynamics, similar to that of Arrow and Hurwicz in Lagrangian optimization, can be used to find the saddle points of the effective energy. As an illustration of its wide applicability, the effective energy framework is used to derive Hopfield-like energy functions and descent dynamics for two classes of networks previously considered in the literature, winner-take-all networks and rotor networks, even when the cost function of the original optimization problem is not quadratic.
Variable Block CG Algorithms for Solving Large Sparse Symmetric Positive Definite Linear Systems on Parallel Computers, I: General Iterative Scheme
Authors: A. A. Nikishin, A. Yu. Yeremin
Venue: SIAM Journal on Matrix Analysis and Applications (1995)

This paper considers a new approach to construction of efficient parallel solution methods of large sparse SPD linear systems. This approach is based on the so-called variable block CG method, a generalization of the standard block CG method, where it is possible to reduce the iteration block size adaptively (at any iteration) by construction of an $A$-orthogonal projector without restarts and without algebraic convergence of residual vectors. It enables one to find the constructive compromise between the required resource of parallelism, the resulting convergence rate, and the serial arithmetic costs of one block iteration to minimize the total parallel solution time. The orthogonality and minimization properties of the variable CG method are established and the theoretical analysis of the convergence rate is presented. The results of numerical experiments with large FE systems coming from $h$- and $p$-approximations of three-dimensional equilibrium equations for linear elastic orthotropic materials show that the convergence rate of the variable block CG method is comparable to that of the standard block CG method even when utilizing a large block size, while the total serial arithmetic costs of the variable block CG method are comparable or even smaller than those of the corresponding point CG method.
2-1 Addition and Related Arithmetic Operations with Threshold Logic
Authors: Stamatis Vassiliadis, Sorin Cotofana, Koen Bertels
Venue: IEEE Transactions on Computers (1996)

In this paper we investigate the reduction of the size for small depth feed-forward linear threshold networks performing binary addition and related functions. For n bit operands we propose a depth-3 $O({\textstyle{{n^2} \over {\log\,n}}})$ asymptotic size network for the binary addition with polynomially bounded weights. We propose also a depth-3 addition of optimal O(n) asymptotic size network and a depth-2 comparison of $O({\sqrt n})$ asymptotic size network, both with $O(2^{\sqrt n})$ asymptotic size of weight values. For existing architectural formats we show that our schemes, with equal or smaller depth networks, substantially outperform existing schemes in terms of size and fan-in requirements and on occasions in weight requirements.
EEL: machine-independent executable editing
Authors: James R. Larus, Eric Schnarr
Venue: ACM SIGPLAN Notices (1995)

EEL (Executable Editing Library) is a library for building tools to analyze and modify an executable (compiled) program. The systems and languages communities have built many tools for error detection, fault isolation, architecture translation, performance measurement, simulation, and optimization using this approach of modifying executables. Currently, however, tools of this sort are difficult and time-consuming to write and are usually closely tied to a particular machine and operating system. EEL supports a machine- and system-independent editing model that enables tool builders to modify an executable without being aware of the details of the underlying architecture or operating system or being concerned with the consequences of deleting instructions or adding foreign code.
Algorithm 642: A fast procedure for calculating minimum cross-validation cubic smoothing splines
Authors: M. F. Hutchinson
Venue: ACM Transactions on Mathematical Software (TOMS) (1986)

The procedure CUBGCV is an implementation of a recently developed algorithm for fast O(n) calculation of a cubic smoothing spline fitted to n noisy data points, with the degree of smoothing chosen to minimize the expected mean square error at the data points when the variance of the error associated with the data is known, or, to minimize the generalized cross validation (GCV) when the variance of the error associated with the data is unknown. The data may be unequally spaced and nonuniformly weighted. The algorithm exploits the banded structure of the matrices associated with the cubic smoothing spline problem. Bayesian point error estimates are also calculated in O(n) operations.
Automatic alignment of array data and processes to reduce communication time on DMPPs
Authors: Michael Philippsen
Venue: ACM SIGPLAN Notices (1995)

This paper investigates the problem of aligning array data and processes in a distributed-memory implementation. We present complete algorithms for compile-time analysis, the necessary program restructuring, and subsequent code-generation, and discuss their complexity. We finally evaluate the practical usefulness by quantitative experiments.The technique presented analyzes complete programs, including branches, loops, and nested parallelism. Alignment is determined with respect to offset, stride, and general axis relations. Placement of both data and processes are computed in a unifying framework based on an extended preference graph and its analysis. Dynamic redistributions are derived.The experimental results are very encouraging. The optimization algorithms implemented in our Modula-2* compiler improved the execution times of the programs by an average over 40% on a MasPar MP-1 with 16384 processors.
Analysis Of Camera Movement Errors In Vision-Based Vehicle Tracking
Authors: W. Sohn, N. D. Kehtarnavaz
Venue: IEEE Transactions on Pattern Analysis and Machine Intelligence (1995)

When a camera is used to provide the navigational parameters in autonomous vehicle operations, it is subjected to unexpected movements or vibrations of the mounting platform. This paper presents a framework for analyzing the effect of uncontrollable camera movements on the navigational parameters, in particular on the range and heading angle in vision-based vehicle tracking. The noise introduced by the platform movements is modeled in two ways: camera noise approach and image noise approach. The parameter space of the camera is divided into a controllable subspace consisting of its height and depression angle, and an uncontrollable subspace consisting of the tracked object coordinates and rotation angle errors. A consistent detectable region is then obtained such that the tracked object is always seen by the camera. Based on this region, a reliable region consisting of no singularity points is established so that the range error does not become infinity. The optimum parameters of the controllable subspace with respect to the uncontrollable subspace are found by employing two estimation schemes: (a) The mini-max estimator to provide the worst case effect, and (b) the minimum-mean-square estimator to provide the average or overall effect. From the results obtained, it is shown how an optimum imaging geometry of a monocular vision-based tracking system can be designed in order to satisfy prescribed levels of range and heading angle errors.
A Practical Upper Bound for Departure from Normality
Authors: Steven L. Lee
Venue: SIAM Journal on Matrix Analysis and Applications (1995)

The departure from normality of a matrix is a real scalar that is impractical to compute if the matrix is large and its eigenvalues are unknown. A simple formula is presented for computing an upper bound for departure from normality in the Frobenius norm. This new upper bound is cheaper to compute than the one derived by Henrici [Numer. Math., 4 (1962), pp. 24-40}]. Moreover, the new bound is sharp for Hermitian matrices, skew-Hermitian matrices and, in general, any matrix with eigenvalues that are horizontally or vertically aligned in the complex plane. In terms of applications, the new bound can be used in computing bounds for the spectral norm of matrix functions or bounds for the sensitivity of eigenvalues to matrix perturbations.
Two-Dimensional Minimal Cubature Formulas and Matrix Equations
Authors: Hans Joachim Schmid
Venue: SIAM Journal on Matrix Analysis and Applications (1995)

For strictly positive, linear, and centrally symmetric functionals in two dimensions the existence of cubature formulas attaining the known lower bounds is equivalent to the solvability of certain matrix equations under some constraints. Any solution generates a real ideal the common roots of which are the nodes of the cubature formula. These results are applied to construct an infinite number of minimal positive cubature formulas of an arbitrary degree of exactness for one special, but classical, integral.
A Fast Parallel Algorithm for Routing Unicast Assignments in Benes Networks
Authors: Ching-Yi Lee, A. Yavuz Oruç
Venue: IEEE Transactions on Parallel and Distributed Systems (1995)

This paper presents a new parallel algorithm for routing unicast (one-to-one) assignments in Bene\u s networks. Parallel routing algorithms for such networks were reported earlier, but these algorithms were designed primarily to route permutation assignments. The routing algorithm presented in this paper removes this restriction without an increase in the order of routing cost or routing time. We realize this new routing algorithm on two different topologies. The algorithm routes a unicast assignment involving $O(k)$ pairs of inputs and outputs in $O(\lg^2\,k + \lg\,n)$ time on a completely connected network of $n$ processors and in $O(\lg^4\,k + \lg^2k\,\lg\,n)$ time on an extended shuffle-exchange network of $n$ processors. Using $O(n\,\lg\,n)$ processors, the same algorithm can be pipelined to route $\alpha$ unicast assignments, each involving $O(k)$ pairs of inputs and outputs, in $O(\lg^2\,k + \lg\, n + (\alpha - 1)\,\lg\,k)$ time on a completely connected network and in $O(\lg^4\,k + \lg^2\,k\,\lg\,n + (\alpha - 1)(\lg^3\,k + \lg\,k\,\lg\, n))$ time on the extended shuffle-exchange network. These yield an average routing time of $O(\lg\,k)$ in the first case, and $O(\lg^3\,k + \lg\,k\lg\,n)$ in the second case, for all $\alpha\,\ge\,\lg\,n.$ These complexities indicate that the algorithm given in this paper is as fast as Nassimi and Sahni's algorithm for unicast assignments, and with pipelining, it is faster than the same algorithm at least by a factor of $O(\lg\,n)$ on both topologies. Furthermore, for sparse assignments, i.e., when $k = O(1),$ it is the first algorithm which has an average routing time of $O(\lg\,n)$ on a topology with $O(n)$ links.Index Terms¿Connector, packet switching network, permutation network, unicast assignment.
Infix, cut and finite automata
Authors: Clifford A. Reiter
Venue: ACM SIGAPL APL Quote Quad (1995)

The behavior of one and two dimensional automata are displayed in two and three dimensions and via animations. Implementations of finite automata in J using &ldquo;infix&rdquo; and &ldquo;cut&rdquo; to distribute local definitions of finite automata are compared. Abstract automata are considered along with applications to image processing and surface plotting.
Don't use the page number, but a pointer to it
Authors: André Seznec
Venue: Proceedings of the 23rd annual international symposium on Computer architecture (1996)

Most newly announced high performance microprocessors support 64-bit virtual addresses and the width of physical addresses is also growing. As a result, the size of the address tags in the L1 cache is increasing. The impact of on chip area is particularly dramatic when small block sizes are used. At the same time, the performance of high performance microprocessors depends more and more on the accuracy of branch prediction and for reasons similar to those in the case of caches the size of the Branch Target Buffer is also increasing linearly with the address width.In this paper, we apply the simple principle stated in the title for limiting the tag size of on-chip caches. In the resulting indirect-tagged cache, the duplication of the page number in processors (in TLB and in cache tags) is removed. The tag check is then simplified and the tag cost does not depend on the address width. Applying the same principle to Branch Target Buffers, we propose the Reduced Branch Target Buffer. The storage size in a Reduced Branch Target Buffer does not depend on the address width and is dramatically smaller than the size of the conventional implementation of a Branch Target Buffer.
Applying update streams in a soft real-time database system
Authors: B. Adelberg, H. Garcia-Molina, B. Kao
Venue: Proceedings of the 1995 ACM SIGMOD international conference on Management of data (1995)

Many papers have examined how to efficiently export a materialized view but to our knowledge none have studied how to efficiently import one. To import a view, i.e., to install a stream of updates, a real-time database system must process new updates in a timely fashion to keep the database "fresh," but at the same time must process transactions and ensure they meet their time constraints. In this paper, we discuss the various properties of updates and views (including staleness) that affect this tradeoff. We also examine, through simulation, four algorithms for scheduling transactions and installing updates in a soft real-time database.
Algorithm 752: SRFPACK: software for scattered data fitting with a constrained surface under tension
Authors: R. J. Renka
Venue: ACM Transactions on Mathematical Software (TOMS) (1996)

SRFPACK is a Fortran 77 software package that constructs a smooth interpolatory or approximating surface to data values associated with arbitrarily distributed points in the plane. It employs automatically selected tension factors to preserve shape properties of the data and to avoid overshoot and undershoot associated with steep gradients. The domain of the fitting function may be nonconvex or multiply connected, and the surface may be constrained to have discontinuous value or derivative across a user-specified curve representing, for example, a geological fault line. Although triangle based, the method provides a means of avoiding the inaccuracy associated with long thin triangles on the boundary of the convex hull of the data abscissae.
Architectural Tradeoffs for a Meaning-Preserving Program Restructuring Tool
Authors: William G. Griswold, David Notkin
Venue: IEEE Transactions on Software Engineering (1995)

Maintaining the consistency of multiple program representations¿such as abstract syntax trees and program dependence graphs¿in a program manipulation tool is difficult. This paper describes a hybrid software architecture for a meaning-preserving program restructuring tool. Layering is the primary architectural paradigm, which successively provides increasingly integrated and unified abstract machines to implement the tool. However, layering does not provide adequate control over extensibility or the independence of components. Consequently, we also adopted the paradigm of keeping the key program abstractions separate throughout the layering, providing independent ¿columns¿ of abstract data types. A pair of columns is integrated by a mapping column that translates elements in one column's data type into related elements in the other column's data type. Thus integration of function and separation of representation can be achieved simultaneously in this complex domain.This hybrid architecture was crucial in overcoming severe performance problems¿classic in traditional layered systems¿ that became apparent once the basic tool was completed. By taking advantage of the independence of the columns and the special characteristics of meaning-preserving restructuring, it was possible to extend one representation column of the architecture to the uppermost layer to provide the required access for efficient update without compromising independence. The cost of the extended architecture is that the upper layers are no longer as simple because they expose operations that only guarantee consistency under careful usage. However, the structural constraints of the hybrid architecture and provided models for building the more complicated layers minimizes the negative impact of this tradeoff.
Distributed Hardwired Barrier Synchronization for Scalable Multiprocessor Clusters
Authors: Shisheng Shang, Kai Hwang
Venue: IEEE Transactions on Parallel and Distributed Systems (1995)

Conventional multiprocessors mostly use centralized, memory-based barriers to synchronize concurrent processes created in multiple processors. These centralized barriers often become the bottleneck or hot spots in the shared memory. In this paper, we overcome the difficulty by presenting a distributed and hardwired barrier architecture, that is hierarchically constructed for fast synchronization in cluster-structured multiprocessors. The hierarchical architecture enables the scalability of cluster-structured multiprocessors. A special set of synchronization primitives is developed for explicit use of distributed barriers dynamically. To show the application of the hardwired barriers, we demonstrate how to synchronize Doall and Doacross loops using a limited number of hardwired barriers. Timing analysis shows an $O(10^2)$ to $O(10^5)$ reduction in synchronization overhead, compared with the use of software-controlled barriers implemented in a shared memory. The hardwired architecture is effective in implementing any partially ordered set of barriers or fuzzy barriers with extended synchronization regions. The versatility, scalability, programmability, and low overhead make the distributed barrier architecture attractive in constructing fine-grain, massively parallel MIMD systems using multiprocessor clusters with distributed shared memory.Index Terms¿Barrier synchronization, distributed shared memory, Doacross loops, Doall loops, fuzzy barriers, parallel processing, partially ordered barriers, scalable multiprocessors, wired-NOR logic.
Beyond induction variables: detecting and classifying sequences using a demand-driven SSA form
Authors: Michael P. Gerlek, Eric Stoltz, Michael Wolfe
Venue: ACM Transactions on Programming Languages and Systems (TOPLAS) (1995)

Linear induction variable detection is usually associated with the strength reduction optimization. For restructuring compilers, effective data dependence analysis requires that the compiler detect and accurately describe linear and nonlinear induction variables as well as more general sequences. In this article we present a practical technique for detecting a broader class of linear induction variables than is usually recognized, as well as several other sequence forms, including periodic, polynomial, geometric, monotonic, and wrap-around variables. Our method is based on Factored Use-Def (FUD) chains, a demand-driven representation of the popular Static Single Assignment (SSA) form. In this form, strongly connected components of the associated SSA graph correspond to sequences in the source program: we describe a simple yet efficient algorithm for detecting and classifying these sequences. We have implemented this algorithm in Nascent, our restructuring Fortran 90+ compiler, and we present some results showing the effectiveness of our approach.
An Integration of Rule Induction and Exemplar-Based Learning for Graded Concepts
Authors: Jianping Zhang, Ryszard S. Michalski
Venue: Machine Learning (1995)

This paper presents a method for learning graded concepts. Our method uses a hybrid concept representation that integrates numeric weights and thresholds with rules and combines rules with exemplars. Concepts are learned by constructing general descriptions to represent common cases. These general descriptions are in the form of decision rules with weights on conditions, interpreted by a similarity measure and numeric thresholds. The exceptional cases are represented as exemplars. This method was implemented in the Flexible Concept Learning System (FCLS) and tested on a variety of problems. The testing problems included practical concepts, concepts with graded structures, and concepts that can be defined in the classic view. For comparison, a decision tree learning system, an instance-based learning system, and the basic rule learning variant of FCLS were tested on the same problems. The results have shown a statistically meaningful advantage of the proposed method over others both in terms of classification accuracy and description simplicity on several problems.
Umbriel&mdash;imperative programming for unsophisticated students
Authors: P. D. Terry
Venue: ACM SIGCSE Bulletin (1995)

This article discusses an experiment in designing and using Umbriel, a minimal imperative programming language in the Pascal tradition, for teaching the rudiments of programming in situations where the overwhelming complexities of many modern language implementations have become intolerable.
Why computer algebra systems sometimes can't solve simple equations
Authors: Richard J. Fateman
Venue: ACM SIGSAM Bulletin (1996)

Among the basic equations one might wish a computer to solve symbolically is the inverse of the power function, solving y = zw for z. (Note: zw equiv; exp(w ln z)). While many special cases, easily solved, abound, the general question is fraught with implications: if this is so hard, how can we expect success in other ventures? Having solved this, we can naturally use it in a "composition" of solution methods for expressions of the form y = f(z)w.Can't we already do this? Is it not the case that the solution of y = za+bi is trivially z = y1/(a+bi)) ?Not so. if this were the case, then a plot of the function t(y) := y - (y1/(1+i)))1+i would be indistinguishable from t(y) equiv; 0. For many values, t(y) is (allowing for round-off error), zero. But if your computer system correctly computes with values in the complex plane, then, (to pick two complex points from a region described later), t(-10000 + 4000i) is not zero, but about -9981 + 3993i and t(-0.01 + 0.002i) is about 5.34 - 1.06i. These strange numbers are not the consequence of round-off error or some other numerical phenomena. The alleged solution is just not mathematically correct.Computer algebra systems as usually programmed lack the expressive capability to return the exact and complete set of solutions, in general.