waashk/dblp huggingface dataset:
on support thresholds in associative classification. associative classification is a well-known technique for structured data classification. most previous works on associative classification use support based pruning for rule extraction, and usually set the threshold value to 1%. this threshold allows rule extraction to be tractable and on the average yields a good accuracy. we believe that this threshold may be not accurate in some cases, since the class distribution in the dataset is not taken into account. in this paper we investigate the effect of support threshold on classification accuracy. lower support thresholds are often unfeasible with current extraction algorithms, or may cause the generation of a huge rule set. to observe the effect of varying the support threshold, we first propose a compact form to encode a complete rule set. we then develop a new classifier, named l3g, based on the compact form. taking advantage of the compact form, the classifier can be built also with rather low support rules. we ran a variety of experiments with different support thresholds on datasets from the uci machine learning database repository. the experiments showed that the optimal accuracy is obtained for variable threshold values, sometime lower than 1%.
learning query languages of web interfaces. this paper studies the problem of automatic acquisition of the query languages supported by a web information resource. we describe a system that automatically probes the search interface of a resource with a set of test queries and analyses the returned pages to recognize supported query operators. the automatic acquisition assumes the availability of the number of matches the resource returns for a submitted query. the match numbers are used to train a learning system and to generate classification rules that recognize the query operators supported by a provider and their syntactic encodings. these classification rules are employed during the automatic probing of new providers to determine query operators they support. we report on results of experiments with a set of real web resources.
associative text categorization exploiting negated words. associative classification has been recently applied to text document categorization. however, differently from classification of structured data, the quality of the generated classifier is rather low. this effect is mainly due to the poor precision of generated rules.to increase the precision of associative classifiers we propose the use of classification rules including negated words, i.e. words that the considered document should not contain. rules are in the form "if a document includes words a and b, but not word z, then it belongs to class c1". mining classification rules with negated words becomes quickly intractable when decreasing the support threshold. we tackle this problem by means of an opportunistic approach, where negated words are only generated to specialize rules that may wrongly classify training documents. hence precision is increased, without losing recall.experiments on the reuters corpus show that our classifier based on negated words achieves good precision and recall results, while yielding an easily interpretable model typical of associative classifiers.
imprecise rdql: towards generic retrieval in ontologies using similarity joins. traditional semantic web query languages support a logic-based access to the semantic web. they offer a retrieval (or reasoning) of data based on facts. on the traditional web and in databases, however, exact querying often provides an incomplete answer as queries are overspecified or the mix of multiple ontologies/modelling differences requires "interpretational flexibility." therefore, similarity measures or ranking approaches are frequently used to extend the reach of a query. this paper extends this idea to the semantic web. it introduces irdql---a semantic web query language with support for similarity joins. it is an extension of traditional rdql (rdf data query language) that enables the users to query for similar resources ranking the results using a similarity measure. we show how irdql allows to extend the reach of a query by finding additional results. we quantitatively evaluated four similarity measures for their usefulness in irdql in the context of an owl-s semantic web service retrieval test collection and compared the results to a specialized owl-s matchmaker. initial results of irdql indicate that it is indeed useful for extending the reach of queries and that it is able to improve recall without overly sacrificing precision. we also found that our generic irdql approach was only slightly outperformed by the specialized algorithm.
integrated resource management for data stream systems. data stream systems have to deal with massive data volumes. to perform several queries in parallel or to perform even a single query, resources must be planned carefully and the resulting quality-of-service (qos) is lower than the best one. typical qos measures are the output delay and the amount of data in the stream used for the processing. in this paper, we introduce a model which allows to describe stream operators and the streams between the operators of an operator graph belonging to a stream query. the model allows us to calculate the resources consumed by a query graph given a certain result quality. furthermore, it can be used to determine in advance if the quality-of-service requirement of a given query can be met with the actual available system resources. this model is the basis for building qos-guaranteeing systems.
checking security of java bytecode by abstract interpretation. we present a method to certify a subset of the java bytecode, with respect to security. the method is based on abstract interpretation of the operational semantics of the language. we define a concrete small-step enhanced semantics of the language, able to keep information on the flow of data and control during execution. a main point of this semantics is the handling of the influence of the information flow on the operand stack. we then define an abstract semantics, keeping only the security information and forgetting the actual values. this semantics can be used as a static analysis tool to check security of programs. the use of abstract interpretation allows, on one side, being semantics based, to accept as secure a wide class of programs, and, on the other side, being rule based, to be fully automated.
dynamic context adaptation in multimedia documents. multimedia documents are collections of media objects, synchronized by means of sets of temporal and spatial constraints. any multimedia document definition is valid as long as the referred media objects are available and the constraints are satisfiable. document validity depends on the context in which the document has to be presented. in this paper, we introduce a framework to characterize context adaptation, in the presence of both physical and user oriented context requirements. we define semantically equivalent presentation fragments as alternative to undeliverable ones. in the absence of equivalence, undeliverable media are replaced with candidates that minimize the loss of information/quality in the presentation.
java bytecode verification on java cards. a java program is usually translated into an intermediate language, known as java virtual machine language (jvml), which is then executed by a java virtual machine (jvm). before its execution a jvml program is verified to prevent a wide range of run-time errors. nowadays, java applets are available for various kinds of portable devices, including modern java smart cards. however, java cards cannot execute the classical verification algorithms, due to their very small amount of working memory.we present a new algorithm to verify a subset of the java bytecode language, suitable to be executed in low-memory environments, such as java smart cards. the method is based on abstract interpretation of the language operational semantics. we define an abstract small-step semantics of the language, able to keep information regarding the modifications of data during java constructs execution. we state the equivalence between our verification algorithm and the "standard" one. moreover, we discuss the low memory requirements of the algorithm.
applications of context-aware computing in hospital work: examples and design principles. context-awareness is a key concept in ubiquitous computing, which sometimes seems to be a technology looking for a purpose. in this paper we report on the application of context-aware computing for medical work in hospitals, which has appeared to be a strong case for applying context-aware computing. we present the design of a context-aware pill container and a context-aware hospital bed, both of which reacts and adapts according to what is happening in their context. the applications have been evaluated in a number of workshop with clinicians and patients. based on this empirical work of designing, developing, and evaluating context-aware clinical applications, the paper outlines some key design principles for a context-awareness framework, supporting the development and deployment of context-aware clinical computer applications.
first experiences on constraining consistency and adaptivity of w2000 models. the complexity of web applications is increasing almost every day. besides impacting the implementation phase, this complexity must also be suitably managed while modeling the application. the paper argues that a pure modeling notation, like w2000, is not enough to cope with such complexity and proposes an approach, based on meta-modeling and graph transformation, to enforce the consistency of produced artifacts and adapt them in a controlled way. the paper describes the approach, exemplifies it on some simple examples, and sketches the supporting framework on which we are working.
lessons from industrial design for software engineering through constraints identification, solution space optimisation and reuse. design is a complex activity that can be analysed from a wide variety of perspectives. this paper attempts to look at the individual problem solving process, taking into account psychological arguments. we characterise some of the phases involved in the design process, namely the constraints identification, the optimisation of solution space and the reuse process. we highlight a three-dimensional framework of how the constraints identification impacts on the solution space which, in turn, determines the range of the components that will be eligible for reuse. we discuss this argument through examples from both inside and outside the software engineering field.
graph transformation to infer schemata from xml documents. semi-structured data are characterized by the lack of a predefined schema. this heterogeneity simplifies the management of such data, but analysis and queries become more difficult and demand for schemata that describe these data. super-imposed structures cannot be as general as predefined ones, but ease the retrieval of the information embedded in such data. the paper adopts xml as the language to render semi-structured data and proposes an approach - based on graph transformation techniques - to infer the schemata of xml documents.
benefits of document maps for text access in knowledge management: a comparative study. analyzing, structuring and organizing documented knowledge is an important aspect of knowledge management. in order to ease the access to text collections, in literature so-called document maps have been proposed which visualize the inherently vague semantic similarity structure of a corpus of documents. in this paper we investigate a document map system which is specifically designed for typical text access tasks in knowledge management. based on an empirical task-model we present design, realization and results of a comparative laboratory study which evaluates the document map concept against an alternative text-access interface. we show that the graphical overview offers significant benefits over a text-based access interface for certain knowledge management tasks. we also discuss its drawbacks and point to further system improvements which promise to make the technology even more effective.
a structured documents retrieval method supporting attribute-based structure information. there are many studies on retrieval methods for structured documents but most of the studies are for those whose structure information is expressed by elements. but when elements are used to describe a document structure, the structure becomes static and difficult to expand. so describing a document structure using attributes is used in many standards. but most of the existing systems support mainly element-based structured documents and do not consider attribute-based ones. hence they do not support attribute-based structured documents well. so, we propose a new indexing method that supports attribute-based structured documents. in our index scheme, element-based structure information and attribute-based structure information are seamlessly integrated to describe a general document structure. also, we consider possible searching methods under the proposed index, and implement each method. and then, we experiment each method using the document actually being used in business, then analyze the results.
bts: a byzantine fault-tolerant tuple space. generative coordination is one of the most prominent coordination models for implementing open systems due to its spatial and temporal decoupling. recently, a coordination community effort have been trying to integrate security mechanisms to this model aiming to improve its robustness. in this context, this paper presents the bts coordination model, which provides a byzantine fault-tolerant tuple space. byzantine faults are commonly used to represent both process crashes and intrusions. as far as we know. bts is the first coordination model that supports this dependability level.
an xforms based solution for adaptable documents editing. the diversity of internet enabled terminals is increasing continuously. layout adaptation is becoming a crucial issue for the content providers. they have to support different client devices with minimal effort. this paper presents a document editing system that supports dynamic adaptation. it is implemented as a client-server application and uses cutting edge xml technologies.
the employment of xml standards in electronic judicial proceedings. the electronic court proceedings would provide many advantages: reducing time of justice, such a method to promote ease of transport, facilitating the drafting of subsequent judgements, at least, allowing a uniform and homogeneous judgement. the issue involves the knowledge of experts both in legal science and in computer science all over the world. this work would be analyse the role of xml standards and the xml signature standards in these electronic proceedings. the paper has to be seen as an attempt to identify the possible advantages offered by this technology, taking into consideration the "on line civil trial".
dynamic solver selection for an internet simulation backbone. this current research is to develop automated solver selection capabilities necessary to achieve a "simulation backbone" in which domain experts can plug in simulation solvers they have developed and have these automatically available for use to designers and researchers whose simulation requirements take them into that discipline. the ultimate goal is a one-button press execution of a simulation performed using the correct simulation solvers on machines distributed over the internet using software automatically taken from the internet.in order to achieve this objective, we have started to develop a framework to identify and characterize a system of computer-interpretable rules that describe when a theoretical and computational model is applicable to a design simulation. for example, if a design model comprises some geometric volume and fluid flow conditions are specified, a rule can indicate that the problem is in the discipline of fluid dynamics. depending on the specific shape and size of the volume and the velocity and viscosity of the fluid, rules can be used to further distinguish the problem as being in the sub-discipline of, for example, laminar, turbulent, or compressible flow. the existence of side effects, such as changes in heat transfer properties or aero-elastic effects, can also be inferred using rules that consider the results from a fluid dynamics simulation. the research scope has been limited to selected disciplines in mechanical engineering.
probabilistic multi-path vs. deterministic single-path protocols for dynamic ad-hoc network scenarios. we investigate the performance of different protocol stacks under various application scenarios. our method of choice is a full-fledged simulation in qualnet, testing the complete protocol stack over fairly large-scale networks. we find that the relative ranking of protocols strongly depends on the network scenario, the session load, the mobility level, and the choice of protocol parameters. we show that the parametric probabilistic protocols, which we generalize from their original definition, can outperform standard routing protocols, such as aodv or gossiping or shortest-path, in a variety of realistic scenarios.
a core calculus of higher-order mixins and classes. we present an object-oriented calculus based on higher-order mixin construction via mixin composition, where some software engineering requirements are modelled in a formal setting, allowing to prove the absence of message-not-understood run-time errors.
a mobility and traffic generation framework for modeling and simulating ad hoc communication networks. we present a generic mobility and traffic generation framework that can be incorporated into a tool for modeling and simulating large scale ad hoc networks. the basic framework consists of the following components:1. a mobility data generator (mdg) that generates positions and states of transceivers at specified times of the simulation clock. this module can support a variety of mobility models.2. a graph structure generator (gsg) that constructs the graph corresponding to the ad hoc network from the mobility data provided by mdg. this module can generate directed or undirected graphs depending on the radio range and propagation models.3. a terrain modification tool (tmt) that modifies the connectivity of the graph produced by gsg to allow for terrain effects or arbitrary obstructions.4. an activity data generator (adg) that generates sessions (i.e., packet transmission activities) for a specified fraction of the transceivers that are active at specified times of the simulation clock.the design allows a user to incorporate various realistic parameters crucial in simulating and modeling ad hoc communication networks. we illustrate the utility of our tool with two examples. the first example shows how purely synthetic movement patterns can be used in driving a simulation. the second example shows realistic movement patterns obtained via an urban population mobility modeling tool developed at los alamos.
safe and flexible objects. we design a calculus where objects are created by instantiating classes, as well as mixins. mixin-instantiated objects are "incomplete objects", that can be completed in object-based fashion. the combination of class-based features with object-based ones offers some flexible programming solutions. the fact that all objects are created from fully-typed constructs is a guarantee of controlled (therefore reasonably safe) behavior.
limited assignments: a new cutoff strategy for incomplete depth-first search. in this paper, we propose an extension of three incomplete depth-first search techniques, namely depth-bounded backtrack search, credit search, and iterative broadening, towards producing incomplete solutions. we also propose a new cutoff strategy for incomplete depth-first search motivated by a human style of problem solving. this technique, called limited assignment number (lan) search, is based on limiting the number of attempts tried to assign a value to the variable. a linear worst-case time complexity of lan search leads to promising stable time behavior in all accomplished experiments. the techniques are studied in the context of constraint satisfaction problems.
an infrastructure language for open nets. the structure of open nets, like the internet, is highly dynamic, as the topology of component networks continuously evolves. in this context, node connectivity is a key aspect and a language for distributed network-aware mobile applications should provide explicit mechanisms to handle it. in this paper, we address the problem of expressing dynamic changes of node connectivity at linguistic level and, in particular, we focus on a slight extension of the language klaim, that is targeted to this aim. the extension consists of the introduction of a new category of processes that, in addition to the standard process operations, can execute a few new coordination operations for establishing new connections, accepting connection requests and removing connections. our extension puts forward a clean separation between the coordinator level and the user level and, hence, it is modular enough to be easily applicable also to other network-aware languages. we will also show that our approach can be used as a guide for actual distributed (i.e. without a single centralized server) implementations of mobile systems.
software update via mobile agent based programming. we describe a system that permits maintaining the software installed on several heterogeneous computers distributed over a network by taking advantage of the mobile agent paradigm. the applications are installed and updated only on the central server. when a new release of an application is installed on the server, agents are scattered along the network to update the application on the clients.to build a prototype system we use x-klaim, a programming language specifically designed to program distributed systems composed of several components interacting through multiple tuple spaces and mobile code.
adapting software components by structure fragmentation. we present in this paper an approach aiming at adapting software components. it focuses on adapting component structures instead of adapting component services. among the motivations of this kind of adaptation, we note its possible application to permit flexible deployment of software components and flexible loading of component code according to the available resources (cpu, memory). our adaptation process is based on the analysis and the instrumentation of component codes. it respects the black-box property when it is implemented as a service provided by the component to be adapted. to support this structural adaptation technique, we developed an adaptation process which we have experimented using the java framework of the fractal component model.
method overloading and overriding cause encapsulation flaw: an experiment on assembly of heterogeneous components. based on an experiment using three languages under .net, this paper argues that the semantic differences between these languages regarding method overloading and overriding give rise to significant complexity and break encapsulation. we first recalls the various interpretations of overriding and overloading in object oriented languages through what we call language signatures. then, we realize an experimentation with .net components coded in different programming languages in order to observe the global behavior. from this, we show that overriding and overloading are not compatible with a key property of components: encapsulation. we conclude that, in the current state of the art, in order to build predictable assembly, components must expose their internal structure! we propose a solution to this problem.