71,206 research outputs found
An approach to find dynamic slice for C++ Program
Object-oriented programming has been considered a most promising method in
program development and maintenance. An important feature of object-oriented
programs (OOPs) is their reusability which can be achieved through the
inheritance of classes or reusable components.Dynamic program slicing is an
effective technique for narrowing the errors to the relevant parts of a program
when debugging. Given a slicing criterion, the dynamic slice contains only
those statements that actually affect the variables in the slicing criterion.
This paper proposes a method to dynamically slice object-oriented (00) programs
based on dependence analysis. It uses the Control Dependency Graph for object
program and other static information to reduce the information to be traced
during program execution. In this paper we present a method to find the dynamic
Slice of object oriented programs where we are finding the slices for object
and in case of function overloading.Comment: Submitted to Journal of Computer Science and Engineering, see
http://sites.google.com/site/jcseuk/volume-1-issue-1-may-201
GMNN: Graph Markov Neural Networks
This paper studies semi-supervised object classification in relational data,
which is a fundamental problem in relational data modeling. The problem has
been extensively studied in the literature of both statistical relational
learning (e.g. relational Markov networks) and graph neural networks (e.g.
graph convolutional networks). Statistical relational learning methods can
effectively model the dependency of object labels through conditional random
fields for collective classification, whereas graph neural networks learn
effective object representations for classification through end-to-end
training. In this paper, we propose the Graph Markov Neural Network (GMNN) that
combines the advantages of both worlds. A GMNN models the joint distribution of
object labels with a conditional random field, which can be effectively trained
with the variational EM algorithm. In the E-step, one graph neural network
learns effective object representations for approximating the posterior
distributions of object labels. In the M-step, another graph neural network is
used to model the local label dependency. Experiments on object classification,
link classification, and unsupervised node representation learning show that
GMNN achieves state-of-the-art results.Comment: icml 201
HoTT formalisation in Coq: Dependency Graphs \& ML4PG
This note is a response to Bas Spitter's email of 28 February 2014 about
ML4PG:
"We (Jason actually) are adding dependency graphs to our HoTT library:
https://github.com/HoTT/HoTT/wiki
I seem to recall that finding the dependency graph was a main obstacle
preventing machine learning to be used in Coq. However, you seem to have made
progress on this. What tool are you using?
https://anne.pacalet.fr/dev/dpdgraph/ ? Or another tool? Would it be easy to
use your ML4PG on the HoTT library?"
This note gives explanation of how ML4PG can be used in the HoTT library and
how ML4PG relates to the two kinds of Dependency graphs available in Coq
Visualizing Object-oriented Software for Understanding and Documentation
Understanding or comprehending source code is one of the core activities of
software engineering. Understanding object-oriented source code is essential
and required when a programmer maintains, migrates, reuses, documents or
enhances source code. The source code that is not comprehended cannot be
changed. The comprehension of object-oriented source code is a difficult
problem solving process. In order to document object-oriented software system
there are needs to understand its source code. To do so, it is necessary to
mine source code dependencies in addition to quantitative information in source
code such as the number of classes. This paper proposes an automatic approach,
which aims to document object-oriented software by visualizing its source code.
The design of the object-oriented source code and its main characteristics are
represented in the visualization. Package content, class information,
relationships between classes, dependencies between methods and software
metrics is displayed. The extracted views are very helpful to understand and
document the object-oriented software. The novelty of this approach is the
exploiting of code dependencies and quantitative information in source code to
document object-oriented software efficiently by means of a set of graphs. To
validate the approach, it has been applied to several case studies. The results
of this evaluation showed that most of the object-oriented software systems
have been documented correctly
Data-Efficient Graph Embedding Learning for PCB Component Detection
This paper presents a challenging computer vision task, namely the detection
of generic components on a PCB, and a novel set of deep-learning methods that
are able to jointly leverage the appearance of individual components and the
propagation of information across the structure of the board to accurately
detect and identify various types of components on a PCB. Due to the expense of
manual data labeling, a highly unbalanced distribution of component types, and
significant domain shift across boards, most earlier attempts based on
traditional image processing techniques fail to generalize well to PCB images
with various quality, lighting conditions, etc. Newer object detection
pipelines such as Faster R-CNN, on the other hand, require a large amount of
labeled data, do not deal with domain shift, and do not leverage structure. To
address these issues, we propose a three stage pipeline in which a
class-agnostic region proposal network is followed by a low-shot similarity
prediction classifier. In order to exploit the data dependency within a PCB, we
design a novel Graph Network block to refine the component features conditioned
on each PCB. To the best of our knowledge, this is one of the earliest attempts
to train a deep learning based model for such tasks, and we demonstrate
improvements over recent graph networks for this task. We also provide in-depth
analysis and discussion for this challenging task, pointing to future research.Comment: Paper accepted in WACV 2019. See
https://drive.google.com/open?id=1VkS8n1mKvAWjEPkiOA28XgY6VNfrsWYo for
supplementary material
End-to-end Graph-based TAG Parsing with Neural Networks
We present a graph-based Tree Adjoining Grammar (TAG) parser that uses
BiLSTMs, highway connections, and character-level CNNs. Our best end-to-end
parser, which jointly performs supertagging, POS tagging, and parsing,
outperforms the previously reported best results by more than 2.2 LAS and UAS
points. The graph-based parsing architecture allows for global inference and
rich feature representations for TAG parsing, alleviating the fundamental
trade-off between transition-based and graph-based parsing systems. We also
demonstrate that the proposed parser achieves state-of-the-art performance in
the downstream tasks of Parsing Evaluation using Textual Entailments (PETE) and
Unbounded Dependency Recovery. This provides further support for the claim that
TAG is a viable formalism for problems that require rich structural analysis of
sentences.Comment: NAACL 201
Video Relationship Reasoning using Gated Spatio-Temporal Energy Graph
Visual relationship reasoning is a crucial yet challenging task for
understanding rich interactions across visual concepts. For example, a
relationship 'man, open, door' involves a complex relation 'open' between
concrete entities 'man, door'. While much of the existing work has studied this
problem in the context of still images, understanding visual relationships in
videos has received limited attention. Due to their temporal nature, videos
enable us to model and reason about a more comprehensive set of visual
relationships, such as those requiring multiple (temporal) observations (e.g.,
'man, lift up, box' vs. 'man, put down, box'), as well as relationships that
are often correlated through time (e.g., 'woman, pay, money' followed by
'woman, buy, coffee'). In this paper, we construct a Conditional Random Field
on a fully-connected spatio-temporal graph that exploits the statistical
dependency between relational entities spatially and temporally. We introduce a
novel gated energy function parametrization that learns adaptive relations
conditioned on visual observations. Our model optimization is computationally
efficient, and its space computation complexity is significantly amortized
through our proposed parameterization. Experimental results on benchmark video
datasets (ImageNet Video and Charades) demonstrate state-of-the-art performance
across three standard relationship reasoning tasks: Detection, Tagging, and
Recognition.Comment: CVPR 2019. Supplementary included. Fixing a small typ
OmniGraph: Rich Representation and Graph Kernel Learning
OmniGraph, a novel representation to support a range of NLP classification
tasks, integrates lexical items, syntactic dependencies and frame semantic
parses into graphs. Feature engineering is folded into the learning through
convolution graph kernel learning to explore different extents of the graph. A
high-dimensional space of features includes individual nodes as well as complex
subgraphs. In experiments on a text-forecasting problem that predicts stock
price change from news for company mentions, OmniGraph beats several benchmarks
based on bag-of-words, syntactic dependencies, and semantic trees. The highly
expressive features OmniGraph discovers provide insights into the semantics
across distinct market sectors. To demonstrate the method's generality, we also
report its high performance results on a fine-grained sentiment corpus
Why feature dependencies challenge the requirements engineering of automotive systems: An empirical study
Functional dependencies and feature interactions in automotive software
systems are a major source of erroneous and deficient behavior. To overcome
these problems, many approaches exist that focus on modeling these functional
dependencies in early stages of system design. However, there are only few
empirical studies that report on the extent of such dependencies in industrial
software systems and how they are considered in an industrial development
context. In this paper, we analyze the functional architecture of a real
automotive software system with the aim to assess the extent, awareness and
importance of interactions between features of a future vehicle. Our results
show that within the functional architecture at least 85% of the analyzed
vehicle features depend on each other. They furthermore show that the
developers are not aware of a large number of these dependencies when they are
modeled solely on an architectural level. Therefore, the developers mention the
need for a more precise specification of feature interactions, e.g., for the
execution of comprehensive impact analyses. These results challenge the current
development methods and emphasize the need for an extensive modeling of
features and their dependencies in requirements engineering
On Difficulties of Cross-Lingual Transfer with Order Differences: A Case Study on Dependency Parsing
Different languages might have different word orders. In this paper, we
investigate cross-lingual transfer and posit that an order-agnostic model will
perform better when transferring to distant foreign languages. To test our
hypothesis, we train dependency parsers on an English corpus and evaluate their
transfer performance on 30 other languages. Specifically, we compare encoders
and decoders based on Recurrent Neural Networks (RNNs) and modified
self-attentive architectures. The former relies on sequential information while
the latter is more flexible at modeling word order. Rigorous experiments and
detailed analysis shows that RNN-based architectures transfer well to languages
that are close to English, while self-attentive models have better overall
cross-lingual transferability and perform especially well on distant languages.Comment: Accepted by NAACL-201
- …