ppxscal/embedding_network huggingface dataset:
Error concealment using data hiding
Authors: Peng Yin
Venue: Proceedings of the Acoustics, Speech, and Signal Processing, 2001. on IEEE International Conference - Volume 03 (2001)

Error concealment plays an important role in combating transmission errors. Methods of error concealment that produce better quality are generally of higher complexity, thus making some of the more sophisticated algorithms not suitable for real-time applications or restricted to client devices with limited capability. We propose an approach to use data hiding to facilitate the error concealment at the decoder. A set of features are extracted at the encoder and embedded imperceptibly into the host media. If some part of the media data is damaged during the transmission, the embedded features can be extracted and used for recovery of lost data. The use of data hiding leads to reduced complexity at the decoder. Simulation shows that our approach has better image quality than some well-known conventional error concealment methods.
Pellet: A practical OWL-DL reasoner
Authors: Evren Sirin, Bijan Parsia, Bernardo Cuenca Grau, Aditya Kalyanpur, Yarden Katz
Venue: Web Semantics: Science, Services and Agents on the World Wide Web (2007)

In this paper, we present a brief overview of Pellet: a complete OWL-DL reasoner with acceptable to very good performance, extensive middleware, and a number of unique features. Pellet is the first sound and complete OWL-DL reasoner with extensive support for reasoning with individuals (including nominal support and conjunctive query), user-defined datatypes, and debugging support for ontologies. It implements several extensions to OWL-DL including a combination formalism for OWL-DL ontologies, a non-monotonic operator, and preliminary support for OWL/Rule hybrid reasoning. Pellet is written in Java and is open source.
Enhancing Freshman Engineering Education: Integrating Freshman English Composition With Engineering,
Authors: S. Duerden, M. Green
Venue: Proceedings of the Frontiers in Education Conference on 1995. Proceedings., 1995 vol 1. - Volume 01 (1995)

The paper documents the first year process and product evaluation of the NSF-sponsored Foundation Coalition (FC) project at Texas A&M University designed to integrate five courses taken by most freshman engineering students: physics, engineering design, calculus, English, and chemistry. In addition to the curriculum integration, the project emphasized cooperative learning, teaming, technology applied to learning, and active learning. One hundred students of the entering freshman engineering students who were calculus-ready were invited on a first-come, first-served basis to participate; all qualified women and minorities who applied were accepted, and others were accepted on a waiting list in order of application. Entry characteristics indicated that the students did not differ from the freshman class. FC student achievement in physics and calculus and attitudes toward coalition engineering goals were assessed both fall and spring. Separate comparison groups were selected fall and spring. Results indicated that the FC group scored almost identically to the comparison group on the initial testing. For the spring testing the FC group outscored the comparison group statistically on the physics and calculus tests, and all scales of the California Critical Thinking Test except Analysis (no difference). Student attitudes improved for the value of homework, lifelong learning, and decreased in their overall evaluation of engineering.
The global technology laboratory
Authors: Dietrich Brandt
Venue: AI Society (2007)

During the past two centuries, the impact of technology on society has been more fundamental and far-reaching than any visionary, philosopher or science fiction author of the past could have ever imagined. The world as a whole and all its societies have been changing through the processes of developing, adapting and implementing technology.
Enhancing the Effectiveness of Clustering with Spectra Analysis
Authors: Wenyuan Li Wee-Keong Ng, Ying Liu
Venue: IEEE Transactions on Knowledge and Data Engineering (2007)

For many clustering algorithms, such as K-Means, EM, and CLOPE, there is usually a requirement to set some parameters. Often, these parameters directly or indirectly control the number of clusters, that is, k, to return. In the presence of different data characteristics and analysis contexts, it is often difficult for the user to estimate the number of clusters in the data set. This is especially true in text collections such as Web documents, images, or biological data. In an effort to improve the effectiveness of clustering, we seek the answer to a fundamental question: How can we effectively estimate the number of clusters in a given data set? We propose an efficient method based on spectra analysis of eigenvalues (not eigenvectors) of the data set as the solution to the above. We first present the relationship between a data set and its underlying spectra with theoretical and experimental results. We then show how our method is capable of suggesting a range of k that is well suited to different analysis contexts. Finally, we conclude with further empirical results to show how the answer to this fundamental question enhances the clustering process for large text collections.
YETI: a graduallY extensible trace interpreter
Authors: Mathew Zaleski, Angela Demke Brown, Kevin Stoodley
Venue: Proceedings of the 3rd international conference on Virtual execution environments (2007)

The design of new programming languages benefits from interpretation, which can provide a simple initial implementation, flexibility to explore new language features, and portability to many platforms. The only downside is speed of execution, as there remains a large performance gap between even efficient interpreters and mixed-mode systems that include a just-in-time compiler (or JIT for short). Augmenting an interpreter with a JIT, however, is not a small task. Today, JITs used for Java™ are loosely-coupled with the interpreter, with callsites of methods being the only transition point between interpreted and native code. To compile whole methods, the JIT must duplicate a sizable amount of functionality already provided by the interpreter, leading to a "big bang" development effort before the JIT can be deployed. Instead, adding a JIT to an interpreter would be easier if it were possible to leverage the existing functionality. In earlier work we showed that packaging virtual instructions as lightweight callable routines is an efficient way to build an interpreter. In this paper we describe how callable bodies help our interpreter to efficiently identify and run traces. Our closely coupled dynamic compiler can fall back on the interpreter in various ways, permitting an incremental approach in which additional performance gains can be realized as it is extended in two dimensions: (i) generating code for more types of virtual instructions, and (ii) identifying larger compilation units. Currently, Yeti identifies straight line regions of code and traces, and generates non-optimized code for roughly 50 Java integer and object bytecodes. Yeti runs roughly twice as fast as a direct-threaded interpreter on SPECjvm98 benchmarks.
A tool for constructing safe extensible C++ systems
Authors: Christopher Small
Venue: Proceedings of the 3rd conference on USENIX Conference on Object-Oriented Technologies (COOTS) - Volume 3 (1997)

The boundary between application and system is becoming increasingly permeable. Extensible applications, such as web browsers, database systems, and operating systems, demonstrate the value of allowing end-users to extend and modify the behavior of what was formerly considered to be a static, inviolate system. Unfortunately, flexibility often comes with a cost: systems unprotected from misbehaved end-user extensions are fragile and prone to instability. Object-oriented programming models are a good fit for the development of this kind of system. An extensions can be designed as a refinement of an existing class, and loaded into a running system. In our model, when code is downloaded into the system, it is used to replace a virtual function on an existing C++ object. Because our tool is source-language neutral, it can be used to build safe extensible systems written in other languages as well. There are three methods commonly used to make end-user extensions safe: restrict the extension language (e.g., Java), interpret the extension language (e.g., Tcl), or combine run-time checks with a trusted environment. The third technique is the one discussed here; it offers the twin benefits of the flexibility to implement extensions in an unsafe language, such as C++, and the performance of compiled code. MiSFIT, the Minimal i386 Software Fault Isolation Tool, can be used as the central component of a tool set for building safe extensible systems in C++. MiSFIT transforms C++ code, compiled by g++, into safe binary code. Combined with a runtime support library, the overhead of MiSFIT is an order of magnitude lower than the overhead of interpreted Java, and permits safe extensible systems to be written in C++.
Design of multiple Gabor filters for texture segmentation
Authors: T. P. Weldon
Venue: Proceedings of the Acoustics, Speech, and Signal Processing, 1996. on Conference Proceedings., 1996 IEEE International Conference - Volume 04 (1996)

This paper presents a method for the design of multiple Gabor filters for segmenting multi-textured images. Although design methods for a single Gabor filter have been presented previously, the development of general multi-filter multi-texture design methods largely remains an open problem. Previous multi-filter design approaches required one filter per texture or were constrained to pairs of textures. Other approaches employed ad hoc banks of Gabor filters for texture segmentation, where the parameters of the constituent filters were restricted to fixed values and were not necessarily tuned for a specific texture-segmentation problem. The proposed method removes these restrictions on the number of filters and the number of textures. This offers the potential to improve the segmentation performance or to reduce the number of filters. Further, the development of the design method and mathematical models provide new insight into the design of multiple Gabor filters for texture segmentation. Results are presented that confirm the efficacy of our filter-design method and support underlying mathematical models.
Algorithms for satisfiability problems in linear integer arithmetic logic
Authors: Karem A. Sakallah
Venue:  (2006)

Recent advances in solving propositional satisfiability problems (SAT) have extended their applications to several domains including design verification and synthesis, program analysis, scheduling and temporal reasoning. Current methods for solving these problems mostly suffer from poor scalability especially when more expressive atoms from different theories are involved. In such cases methods such as abstraction or bit-vector conversion are adopted to translate the problem into a Boolean formula to be solved by a SAT solver. This conversion considerably affects the efficiency of the overall process. Nonetheless, the capability of SAT algorithms to solve large problems with tens of thousand of constraints over thousands of Boolean variables has brought them into the spotlight to be used for solving problems involving combination of different theories including linear and non-linear arithmetic.In this work, we present new scalable SAT-based algorithms for solving first-order linear integer arithmetic logic. We address problems involving arithmetic operations over Boolean variables (the so-called Pseudo-Boolean problems) as well as first-order formulas involving arithmetic operations over integer variables (the so-called Satisfiability Modulo Theories problems). In the latter case, we incorporate theory solvers for the conjunctions of "cheap" linear integer constraints, i.e. equalities and two-variable inequalities, within the SAT solver. These theory solvers are tightly but gradually integrated into the SAT solver and the problem is modeled such that the SAT solver is maximally utilized in order to leverage its power and efficiency. To curb the cost of processing "hard" constraints, i.e. general linear integer constraints, a subset of them are only added to the problem when/if the satisfiability of the rest of the problem is established. We also develop a set of algorithms to optimize the overall process taking into account special structures of the problems arising from design verification applications.These methods, implemented in our two solvers, Pueblo and Ario, have been applied to several problems in software verification, electronic design automation (EDA) and scheduling. In this work, we describe some of these applications and present advantages of our method in a few of them, mainly in hardware and software verification and temporal reasoning.
Experimental evaluation of protections against laser-induced faults and consequences on fault modeling
Authors: R. Leveugle, A. Ammari, V. Maingot, E. Teyssou, P. Moitrel, C. Mourtel, N. Feyt, J.-B. Rigaud, A. Tria
Venue: Proceedings of the conference on Design, automation and test in Europe (2007)

Lasers can be used by hackers to situations to inject faults in circuits and induce security flaws. On-line detection mechanisms are classically proposed to counter such attacks, and are often based on error detecting codes. However, the efficiency of such schemes has not been precisely validated against real attack conditions. This paper presents results showing that, with a given type of laser, a classical protection technique can leave open doors to an attacker. The results give also insights into the fault models to be taken into account when designing a secured circuit.
GReIC Data Storage: A Lightweight Disk Storage Management Solution for Bioinformatics "in silico" Experiments
Authors: Sandro Fiore, Maria Mirto, Massimo Cafaro, Giovanni Aloisio
Venue: Proceedings of the Twentieth IEEE International Symposium on Computer-Based Medical Systems (2007)

Data grids are middleware systems that offer secure shared storage of massive scientific datasets over wide area networks. In this paper we describe the GRelC Data Storage, a novel grid storage service which has been developed within the Grid Relational Catalog (GRelC) Project. The aim of this service is to manage efficiently, securely and transparently collections of bioinformatics data concerning "in silico" experiments on the grid promoting flexible, secure and coordinated storage resource sharing and publication across virtual organizations, taking into account current grid standards and specifications.
SIMD Optimizations in a Data Parallel C
Authors: Maya Gokhale, Phil Pfeiffer
Venue: Proceedings of the 1993 International Conference on Parallel Processing - Volume 02 (1993)

SIMD programs can devote substantial time to manipulating the underlying hardwares context registers status bits that determine whether processors in the SIMD array execute or skip the current instruction. This paper describes two optimizations, implemented in a compiler for a data parallel C, that reduce the overhead of manipulating and accessing context registers. The first optimization uses observations about a program's nesting structure to eliminate context register save/restore operations performed by guarded parallel control constructs. The second uses two-version code to eliminate context register acceaaes performed by individual instructions.
Codesign of a Computationally Intensive Problem in GF(3)
Authors: Kenneth B. Kent, Beatriz C. Iaderoza, Micaela Serra
Venue: Proceedings of the 18th IEEE/IFIP International Workshop on Rapid System Prototyping (2007)

A reprogrammable hardware platform is used for the co-design and implementation of a computational intensive mathematical problem, namely the listing of irreducible polynomials over Galois fields of order 3 (GF(3)). The main goal is to accelerate the performance compared to an existing software implementation. This project uses hardware/software co-design methodologies and techniques, and it is completely designed, implemented and evaluated on two distinct platforms, not simply by simulations. FPGAs are used as part of the reconfigurable hardware in both a PCI-based environment and in a more successful System-on-Chip (SOC) platform, which takes advantage of the closely-coupled interconnection between the hardware and software, thus minimizing the communication overhead. The case study, findings and general analysis lead to a possible ideal architecture for future approaches. Moreover, a more general detailed strategy can be seen for the transformation from software to a co-design paradigm, maximizing parallelism.
Kinematic Inbetweening along Implicit Curves for Motion Animations
Authors: Hai-Yin Xu, Dan Li, Shaomin Tang
Venue: Proceedings of the 16th International Conference on Artificial Reality and Telexistence--Workshops (2006)

While the parametric curve is overwhelmingly used in current character motion animation practice, the utilization of the implicit curve is recognized to be extremely potential for motion animation since the implicit surface have succeeded in application such as modeling, deformation and rendering. In this paper, we investigate the use of implicit curves in motion animation. Implicit curves for task specification in motion animation is proposed and further explored in this paper. An implicit curve is used to specify the motion path while a speed profile curve is adopted to describe the motion timing. Then an approach and algorithm to motion inbetweening along implicit curves is proposed. Based on the motion path and motion speed, inbetweening technique is utilized to generate inbetween motion sequences from which skeleton sequences for character animation are obtained by inverse kinematical technique.
Adaptive Self-optimization in Distributed Dynamic Environments
Authors: Wolfgang Trumler, Andreas Pietzowski, Benjamin Satzger, Theo Ungerer
Venue: Proceedings of the First International Conference on Self-Adaptive and Self-Organizing Systems (2007)

Grid and ubiquitous computing systems generally consist of a large number of networked nodes with applications implemented as distributed services or processes, respectively. A crucial point is the distribution of the services to balance the load within the system during runtime. In a former work we developed a self-optimization mechanism which shows outstanding performance in static environments where the services do not change their resource consumptions (e.g. CPU, memory, communication bandwidth). In this paper we present simulation results for the self-optimization within dynamic environments where the services change their load during runtime.
Optimized wavelets for fingerprint compression
Authors: B. G. Sherlock
Venue: Proceedings of the Acoustics, Speech, and Signal Processing, 1996. on Conference Proceedings., 1996 IEEE International Conference - Volume 03 (1996)

We present optimized biorthogonal and orthonormal wavelets for embedded zerotree wavelet compression of fingerprint images. These were obtained by simulated annealing over the wavelet filter coefficients using rms error between original and recovered images as the cost to be minimized. Linear-phase biorthogonal wavelets optimized for fingerprint image compression provide significantly improved fidelity compared either with standard wavelets or with wavelets optimized upon general images. These results are confirmed by psychovisual evaluation by two fingerprint experts whose independent rankings were in complete agreement. Filter coefficients for optimized orthonormal and linear-phase biorthogonal wavelets are tabulated.
Using Systems Dynamics to Explore Effects of Counterterrorism Policy
Authors: Tara Leweling, Otto Sieber
Venue: Proceedings of the 40th Annual Hawaii International Conference on System Sciences (2007)

This paper suggests that the effects of counterterrorism policy on Violent Non-State Actors can be explored via systems dynamics. Specifically, we create a descriptive model of the flow of persons through the terrorism field. We then demonstrate how the model can be extended to explore "what if" analyses of counterterrorism actions, assisting analysts with identifying fallacious logic chains or important knowledge gaps related to causal explanations. Our model instantiations suggest that developing and implementing counterterrorism policy requires continuous and active management to avoid undesirable long term outcomes.
Dealing with Some Conceptual Data Model Requirements for Biological Domains
Authors: Jose Antonio Fernandes de Macedo, Fabio Porto, Sergio Lifschitz, Philippe Picouet
Venue: Proceedings of the 21st International Conference on Advanced Information Networking and Applications Workshops - Volume 01 (2007)

Knowledge representation in the biological domain suffers from two main difficulties that make it hard to apply traditional conceptual modeling tools: the inherent domain complexity and its constant evolution. The former requires complex types and associations, whereas the latter calls for an expressive language. We list in this paper a set of requirements for conceptual data modeling that should fulfil biologists' needs. We discuss these requirements by analyzing representation problems using traditional conceptual modeling languages. We claim that the biological domain deserves an ad-hocmodeling approach that would help with activities such as data integration and database design.
FoxyTechnique: tricking operating system policies with a virtual machine monitor
Authors: Hiroshi Yamada, Kenji Kono
Venue: Proceedings of the 3rd international conference on Virtual execution environments (2007)

Integrating new resource management policies into operating systems (OSes) is an ongoing process. Despite innovative policy proposals being developed, it is quite difficult to deploy a new one widely because it is difficult, costly and often impractical endeavor to modify existing OSes to integrate a new policy. To address this problem, we explore the possibility of using virtual machine technology to incorporate a new policy into an existing OS without the need to make any changes to it. This paper describes FoxyTechnique, which virtualizes physical devices differently from real ones and tricks a guest OS into producing a behavior similar to a desired policy. FoxyTechnique offers several advantages. First, it allows us to implement a new policy without the need to make any changes to OS kernels. Second, Foxy-based policies are expected to be portable across different operating systems because they are isolated from guest OSes by stable virtual hardware interfaces. Finally, Foxy-based policies sometimes outperform guest OS policies because they can measure performance indicators more accurately than guest OSes. To demonstrate the usefulness of FoxyTechnique, we conducted two case studies, FoxyVegas and FoxyIdle, on the Xen virtual machine monitor. FoxyVegas and FoxyIdle tricked the original Linux and successfully mimicked TCP Vegas and Idletime scheduling, respectively.