Neural sequence-to-sequence models have proven to be accurate and robust for many sequence prediction tasks, and have become the standard approach for automatic translation of text. The models work with a five-stage b...
详细信息
Neural sequence-to-sequence models have proven to be accurate and robust for many sequence prediction tasks, and have become the standard approach for automatic translation of text. The models work with a five-stage blackbox pipeline that begins with encoding a source sequence to a vector space and then decoding out to a new target sequence. This process is now standard, but like many deep learning methods remains quite difficult to understand or debug. In this work, we present a visual analysis tool that allows interaction and "what if"-style exploration of trained sequence-to-sequence models through each stage of the translation process. The aim is to identify which patterns have been learned. to detect model errors, and to probe the model with counterfactual scenario. We demonstrate the utility of our tool through several real-world sequence-to-sequence use cases on large-scale models.
Regular expressions are a widely used programming technique, but seem to be neglected by software engineering research. Encoding complex string parsing in a very compact notation, their complexity and compactness, how...
详细信息
ISBN:
(纸本)9781450327688
Regular expressions are a widely used programming technique, but seem to be neglected by software engineering research. Encoding complex string parsing in a very compact notation, their complexity and compactness, however, introduce particular challenges with respect to program comprehension. In this paper, we present RegViz, an approach to visually augment regular expressions without changing their original textual notation. The visual encoding clarifies the structure of the regular expressions and clearly discerns included tokens by function. The approach also provides advanced visual highlighting of matches in a sample text and defining test cases therein. We implemented RegViz as a Web-based tool for JavaScript regular expressions. Expert feedback suggests that the approach is intuitive to apply and increases the readability of regular expressions.
The visual Debugger is an IntelliJ IDEA plugin that presents debug information as an object diagram to enhance program understanding. Reflecting on our past development, we detail the lessons learned and roadblocks we...
详细信息
ISBN:
(纸本)9798400705809
The visual Debugger is an IntelliJ IDEA plugin that presents debug information as an object diagram to enhance program understanding. Reflecting on our past development, we detail the lessons learned and roadblocks we have experienced while implementing and integrating the visual Debugger into the IntelliJ IDEA. Furthermore, we describe recent improvements to the visual Debugger, greatly enhancing the plugin in the present. Looking into the future, we propose solutions to overcome the roadblocks encountered while developing the plugin and further plans for the visual Debugger.
The rapid development of deep natural language processing (NLP) models for text classification has led to an urgent need for a unified understanding of these models proposed individually. Existing methods cannot meet ...
详细信息
The rapid development of deep natural language processing (NLP) models for text classification has led to an urgent need for a unified understanding of these models proposed individually. Existing methods cannot meet the need for understanding different models in one framework due to the lack of a unified measure for explaining both low-level (e.g., words) and high-level (e.g., phrases) features. We have developed a visual analysis tool, DeepNLPVis, to enable a unified understanding of NLP models for text classification. The key idea is a mutual information-based measure, which provides quantitative explanations on how each layer of a model maintains the information of input words in a sample. We model the intra- and inter-word information at each layer measuring the importance of a word to the final prediction as well as the relationships between words, such as the formation of phrases. A multi-level visualization, which consists of a corpus-level, a sample-level, and a word-level visualization, supports the analysis from the overall training set to individual samples. Two case studies on classification tasks and comparison between models demonstrate that DeepNLPVis can help users effectively identify potential problems caused by samples and model architectures and then make informed improvements.
debugging is an essential part of software maintenance and evolution since it allows software developers to analyze program execution step by step. Understanding a program is required to fix potential flaws, alleviate...
详细信息
ISBN:
(数字)9781665479561
ISBN:
(纸本)9781665479561
debugging is an essential part of software maintenance and evolution since it allows software developers to analyze program execution step by step. Understanding a program is required to fix potential flaws, alleviate bottlenecks, and implement new desired features. Thus, software developers spend a large percentage of their time validating and debugging software, resulting in high software maintenance and evolution cost. We aim to reduce this cost by providing a novel visual debugging tool to software developers to foster program comprehension during debugging. Our debugging tool visualizes program execution information graphically as an object diagram and is fully integrated into the popular Java development environment IntelliJ IDEA. Moreover, the object diagram allows interactions to explore program execution information in more detail. A demonstration of our tool is available at https://***. com/watch?v=lU_OgotweRk.
The Obstacle Tower Challenge is the task to master a procedurally generated chain of levels that subsequently get harder to complete. Whereas the most top performing entries of last year's competition used human d...
详细信息
ISBN:
(纸本)9781728145334
The Obstacle Tower Challenge is the task to master a procedurally generated chain of levels that subsequently get harder to complete. Whereas the most top performing entries of last year's competition used human demonstrations or reward shaping to learn how to cope with the challenge, we present an approach that performed competitively (placed 7th) but starts completely from scratch by means of Deep Reinforcement Learning with a relatively simple feed-forward deep network structure. We especially look at the generalization performance of the taken approach concerning different seeds and various visual themes that have become available after the competition, and investigate where the agent fails and why. Note that our approach does not possess a short-term memory like employing recurrent hidden states. With this work, we hope to contribute to a better understanding of what is possible with a relatively simple, flexible solution that can be applied to learning in environments featuring complex 3D visual input where the abstract task structure itself is still fairly simple.
Data analysis and visualization are an essential part of the scientific discovery process. As HPC simulations have grown, I/O has become a bottleneck, which has required scientists to turn to in situ tools for simulat...
详细信息
ISBN:
(纸本)9783030024659;9783030024642
Data analysis and visualization are an essential part of the scientific discovery process. As HPC simulations have grown, I/O has become a bottleneck, which has required scientists to turn to in situ tools for simulation data exploration. Incorporating additional data, such as runtime performance data, into the analysis or I/O phases of a workflow is routinely avoided for fear of excaberting performance issues. The paper presents how the Uintah Framework, a suite of HPC libraries and applications for simulating complex chemical and physical reactions, was coupled with VisIt, an interactive analysis and visualization toolkit, to allow scientists to perform parallel in situ visualization of simulation and runtime performance data. An additional benefit of the coupling made it possible to create a "simulation dashboard" that allowed for in situ computational steering and visual debugging.
Hard real-time systems have stringent timing and resource requirements. As such, debugging and tracing such systems often requires low-level hardware support, and online debugging is usually precluded entirely. In oth...
详细信息
Hard real-time systems have stringent timing and resource requirements. As such, debugging and tracing such systems often requires low-level hardware support, and online debugging is usually precluded entirely. In other areas, however, visual debugging has greatly improved program understanding and late cycle development times for nonreal-time applications. In this paper, we introduce a visual test and debug framework for hard real-time Java applications built around the JIVE platform and realized in the Fiji virtual machine. Our framework, called *** ["dZIfi], provides high-level debugging support over low-level execution traces. *** provides both powerful visualizations and real-time centric temporal query support. To ensure preservation of the real-time characteristics of the application being tested and debugged, *** leverages a real-time event log infrastructure that logs only relevant application and virtual machine level events, such as synchronization and modifications to priorities or thread state. Our performance results indicate that our logging infrastructure is suitable for hard real-time systems, as the performance impact is both uniform and quantifiable. Copyright (C) 2013 John Wiley & Sons, Ltd.
An important challenge in teaching object-oriented (OO) programming and methodology in introductory Computer Science courses is explaining the run-time of OO programs. This is largely due to the OO methodology, which ...
详细信息
ISBN:
(纸本)9781450310987
An important challenge in teaching object-oriented (OO) programming and methodology in introductory Computer Science courses is explaining the run-time of OO programs. This is largely due to the OO methodology, which encourages the use of features such as polymorphism and design patterns, resulting in object interactions and control flow that are hard to grasp, especially for novice programmers. We present an approach to program comprehension in which students use storyboards and visual debugging to build a clear mental model of the dynamic behavior of OO programs. In this context, a storyboard consists of a sequence of figures representing run-time aspects of interest (e.g. states or interactions) and an explanatory narrative in terms of OO concepts and source elements. The selected visual debugger must render execution histories and run-time states using visual notations consistent with the OO methodology (e.g., objects, member fields, method calls within object contexts). Instructors create storyboards using figures exported from the debugger and incorporate them in course materials. Further, storyboards included in specifications of programming assignments alongside test cases provide students with a detailed account of their programs' run-time at interesting points in execution. By executing their programs under the visual debugger, students can compare the observed run-time states with those illustrated in the storyboards and effectively assess the behavioral correctness of their programs. Hence, the combined use of storyboards and visual debugging can benefit students during the coding phase by guiding them towards writing code that closely adheres to the OO methodology from the outset.
Program visualization systems use graphics and animation to represent the behavior of software programs. These systems represent different aspects of the program such as source code, control flow, data structures, run...
详细信息
Program visualization systems use graphics and animation to represent the behavior of software programs. These systems represent different aspects of the program such as source code, control flow, data structures, runtime state of the program. Representing the actual runtime state of the program finds its use in a variety of applications including program understanding, visual debugging, and pedagogy. However, existing state-of-the-art program visualization systems are limited in : (1) not providing sufficient interactive capabilities to the user; (2) not faithfully representing the runtime state of the program; (3) not allowing users to apply different layout strategies to the visualization; (4) being tied to a specific programming language.
To address these limitations, this thesis presents HDPV, a program state visualization system that visualizes any C, C++, or Java program. HDPV is based on a canonical state model that represents the memory layout of the program as a graph of memory blocks. It decouples the visualization of the program from the actual programming language in which it is written, thereby making the system language independent. HDPV supports a host of interactive features that allow the user to selectively explore different parts of the programâ s runtime state. Novel layout strategies support customization through user interaction. We provide a list of use-cases to show that HDPV can be applied to a wide variety of applications including - but not limited to - understanding programs that use basic concepts in computer science, demonstrating algorithm implementations, and debugging software programs.
暂无评论