Search Results for author:
Found 50 papers, 15 papers with code
Generating Programmatic Referring Expressions via Program Synthesis
The policy neural network employs a program interpreter that provides immediate feedback on the consequences of the decisions made by the policy, and also takes into account the uncertainty in the symbolic representation of the image.
Platt-Bin: Efficient Posterior Calibrated Training for NLP Classifiers
Modern NLP classifiers are known to return uncalibrated estimations of class posteriors.
Measuring The Impact Of Programming Language Distribution
Training a model on a balanced corpus results in, on average, 12. 34% higher $pass@k$ across all tasks and languages compared to the baseline.
Robust Dependence Measure using RKHS based Uncertainty Moments and Optimal Transport
Being based on the Gaussian RKHS, our approach is robust towards outliers and monotone transformations of data, while the multiple moments of uncertainty provide high resolution and interpretability of the type of dependence being quantified.
Quantifying Model Uncertainty for Semantic Segmentation using Operators in the RKHS
We present a simple framework for high-resolution predictive uncertainty quantification of semantic segmentation models that leverages a multi-moment functional definition of uncertainty associated with the model's feature space in the reproducing kernel Hilbert space (RKHS).
Learning Semantic Representations to Verify Hardware Designs
We evaluate Design2Vec on three real-world hardware designs, including an industrial chip used in commercial data centers.
A Physics inspired Functional Operator for Model Uncertainty Quantification in the RKHS
The RKHS projection of model weights yields a potential field based interpretation of model weight PDF which consequently allows the definition of a functional operator, inspired by perturbation theory in physics, that performs a moment decomposition of the model weight PDF (the potential field) at a specific model output to quantify its uncertainty.
Deep Geospatial Interpolation Networks
Spatio-Temporal interpolation is highly challenging due to the complex spatial and temporal relationships.
SpreadsheetCoder: Formula Prediction from Semi-structured Context
In this work, we present the first approach for synthesizing spreadsheet formulas from tabular context, which includes both headers and semi-structured tabular data.
Image to Image Translation : Generating maps from satellite images
Generation of maps from satellite images is conventionally done by a range of tools.
Generative Adversarial Network
Image-to-Image Translation
+1
A Kernel Framework to Quantify a Model's Local Predictive Uncertainty under Data Distributional Shifts
We therefore propose a framework for predictive uncertainty quantification of a trained neural network that explicitly estimates the PDF of its raw prediction space (before activation), p(y'|x, w), which we refer to as the model PDF, in a Gaussian reproducing kernel Hilbert space (RKHS).
Latent Programmer: Discrete Latent Codes for Program Synthesis
The latent codes are learned using a self-supervised learning principle, in which first a discrete autoencoder is trained on the output sequences, and then the resulting latent codes are used as intermediate targets for the end-to-end sequence prediction task.
Learning Discrete Energy-based Models via Auxiliary-variable Local Exploration
In this paper we propose ALOE, a new algorithm for learning conditional and unconditional EBMs for discrete structured data, where parameter gradients are estimated using a learned sampler that mimics local search.
Deep Learning & Software Engineering: State of Research and Future Directions
The intent of this report is to serve as a potential roadmap to guide future work that sits at the intersection of SE & DL.
BUSTLE: Bottom-Up Program Synthesis Through Learning-Guided Exploration
Program synthesis is challenging largely because of the difficulty of search in a large space of programs.
Scaling Symbolic Methods using Gradients for Neural Model Explanation
In this work, we propose a technique for combining gradient-based methods with symbolic techniques to scale such analyses and demonstrate its application for model explanation.
Neural Program Synthesis with a Differentiable Fixer
We present a new program synthesis approach that combines an encoder-decoder based synthesis architecture with a differentiable program fixer.
Global Relational Models of Source Code
By studying a popular, non-trivial program repair task, variable-misuse identification, we explore the relative merits of traditional and hybrid model families for code representation.
TF-Coder: Program Synthesis for Tensor Manipulations
The success and popularity of deep learning is on the rise, partially due to powerful deep learning frameworks such as TensorFlow and PyTorch that make it easier to develop deep learning models.
Towards Modular Algorithm Induction
Main consists of a neural controller that interacts with a variable-length input tape and learns to compose modules together with their corresponding argument choices.
Towards a Kernel based Uncertainty Decomposition Framework for Data and Models
This paper introduces a new framework for quantifying predictive uncertainty for both data and models that relies on projecting the data into a Gaussian reproducing kernel Hilbert space (RKHS) and transforming the data probability density function (PDF) in a way that quantifies the flow of its gradient as a topological potential field quantified at all points in the sample space.
Synthetic Datasets for Neural Program Synthesis
The goal of program synthesis is to automatically generate programs in a particular language from corresponding specifications, e. g. input-output behavior.
Learning Transferable Graph Exploration
We propose a `learning to explore' framework where we learn a policy from a distribution of environments.
MoET: Interpretable and Verifiable Reinforcement Learning via Mixture of Expert Trees
We propose MoET, a more expressive, yet still interpretable model based on Mixture of Experts, consisting of a gating function that partitions the state space, and multiple decision tree experts that specialize on different partitions.
MoËT: Mixture of Expert Trees and its Application to Verifiable Reinforcement Learning
By training Mo\"ET models using an imitation learning procedure on deep RL agents we outperform the previous state-of-the-art technique based on decision trees while preserving the verifiability of the models.
Neural Program Repair by Jointly Learning to Localize and Repair
We show that it is beneficial to train a model that jointly and directly localizes and repairs variable-misuse bugs.
Neural-Guided Symbolic Regression with Asymptotic Constraints
The second part, which we call Neural-Guided Monte Carlo Tree Search, uses the network during a search to find an expression that conforms to a set of data points and desired leading powers.
Robust Text-to-SQL Generation with Execution-Guided Decoding
We consider the problem of neural semantic parsing, which translates natural language questions into executable SQL queries.
Towards Mixed Optimization for Reinforcement Learning with Program Synthesis
Deep reinforcement learning has led to several recent breakthroughs, though the learned policies are often based on black-box neural networks.
Leveraging Grammar and Reinforcement Learning for Neural Program Synthesis
Program synthesis is the task of automatically generating a program consistent with a specification.
Programmatically Interpretable Reinforcement Learning
Unlike the popular Deep Reinforcement Learning (DRL) paradigm, which represents policies by neural networks, PIRL represents policies using a high-level, domain-specific programming language.
Learning and analyzing vector encoding of symbolic representations
We present a formal language with expressions denoting general symbol structures and queries which access information in those structures.
Natural Language to Structured Query Generation via Meta-Learning
In conventional supervised training, a model is trained to fit all the training examples.
Ranked #7 on
Code Generation
on WikiSQL
Interpreting Neural Network Judgments via Minimal, Stable, and Symbolic Corrections
We argue that such a correction is a useful way to provide feedback to a user when the network's output is different from a desired output.
Deep Reinforcement Fuzzing
Fuzzing is the process of finding security vulnerabilities in input-processing code by repeatedly testing the code with modified inputs.
Pointing Out SQL Queries From Text
We present a system that allows for querying data tables using natural language questions, where the system translates the question into an executable SQL query.
Dynamic Neural Program Embeddings for Program Repair
Our evaluation results show that the semantic program embeddings significantly outperform the syntactic program embeddings based on token sequences and abstract syntax trees.
SyGuS-Comp 2017: Results and Analysis
Syntax-Guided Synthesis (SyGuS) is the computational problem of finding an implementation f that meets both a semantic constraint given by a logical formula phi in a background theory T, and a syntactic constraint given by a grammar G, which specifies the allowed set of candidate implementations.
Dynamic Neural Program Embedding for Program Repair
Evaluation results show that our new semantic program embedding significantly outperforms the syntactic program embeddings based on token sequences and abstract syntax trees.
Not all bytes are equal: Neural byte sieve for fuzzing
Fuzzing is a popular dynamic program analysis technique used to find vulnerabilities in complex software.
Semantic Code Repair using Neuro-Symbolic Transformation Networks
We study the problem of semantic code repair, which can be broadly defined as automatically fixing non-syntactic bugs in source code.
Neural Program Meta-Induction
In our first proposal, portfolio adaptation, a set of induction models is pretrained on a set of related tasks, and the best model is adapted towards the new task using transfer learning.
Deep API Programmer: Learning to Program with APIs
We then present a novel neural synthesis algorithm to search for programs in the DSL that are consistent with a given set of examples.
RobustFill: Neural Program Learning under Noisy I/O
Recently, two competing approaches for automatic program learning have received significant attention: (1) neural program synthesis, where a neural network is conditioned on input/output (I/O) examples and learns to generate a program, and (2) neural program induction, where a neural network generates new outputs directly using a latent program representation.
Learn&Fuzz: Machine Learning for Input Fuzzing
Fuzzing consists of repeatedly testing an application with modified, or fuzzed, inputs with the goal of finding security vulnerabilities in input-parsing code.
Summary - TerpreT: A Probabilistic Programming Language for Program Induction
A TerpreT model is composed of a specification of a program representation and an interpreter that describes how programs map inputs to outputs.
SyGuS-Comp 2016: Results and Analysis
Syntax-Guided Synthesis (SyGuS) is the computational problem of finding an implementation f that meets both a semantic constraint given by a logical formula $\varphi$ in a background theory T, and a syntactic constraint given by a grammar G, which specifies the allowed set of candidate implementations.
Neuro-Symbolic Program Synthesis
While achieving impressive results, these approaches have a number of important limitations: (a) they are computationally expensive and hard to train, (b) a model has to be trained for each task (program) separately, and (c) it is hard to interpret or verify the correctness of the learnt mapping (as it is defined by a neural network).
TerpreT: A Probabilistic Programming Language for Program Induction
TerpreT is similar to a probabilistic programming language: a model is composed of a specification of a program representation (declarations of random variables) and an interpreter describing how programs map inputs to outputs (a model connecting unknowns to observations).
Automated Correction for Syntax Errors in Programming Assignments using Recurrent Neural Networks
We present a technique for providing feedback on syntax errors that uses Recurrent neural networks (RNNs) to model syntactically valid token sequences.
