Show details- Abstract: Learning multiple tasks sequentially is important for the development of AI and lifelong learning systems. However, standard neural network architectures suffer from catastrophic forgetting which makes it difficult for them to learn a sequence of tasks. Several continual learning methods have been proposed to address the problem. In this paper, we propose a very different approach, called Parameter Generation and Model Adaptation (PGMA), to dealing with the problem. The proposed approach learns to build a model, called the solver, with two sets of parameters. The first set is shared by all tasks learned so far and the second set is dynamically generated to adapt the solver to suit each test example in order to classify it. Extensive experiments have been carried out to demonstrate the effectiveness of the proposed approach.
- Keywords: overcoming forgetting, model adaptation, continual learning
-
Analysis of Quantized Models
Show details- Abstract: Deep neural networks are usually huge, which significantly limits the deployment on low-end devices. In recent years, many weight-quantized models have been proposed. They have small storage and fast inference, but training can still be time-consuming. This can be improved with distributed learning. To reduce the high communication cost due to worker-server synchronization, recently gradient quantization has also been proposed to train deep networks with full-precision weights. In this paper, we theoretically study how the combination of both weight and gradient quantization affects convergence. We show that (i) weight-quantized models converge to an error related to the weight quantization resolution and weight dimension; (ii) quantizing gradients slows convergence by a factor related to the gradient quantization resolution and dimension; and (iii) clipping the gradient before quantization renders this factor dimension-free, thus allowing the use of fewer bits for gradient quantization. Empirical experiments confirm the theoretical convergence results, and demonstrate that quantized networks can speed up training and have comparable performance as full-precision networks.
- Keywords: weight quantization, gradient quantization, distributed learning
- TL;DR: In this paper, we studied efficient training of loss-aware weight-quantized networks with quantized gradient in a distributed environment, both theoretically and empirically.
-
Deep learning generalizes because the parameter-function map is biased towards simple functions
Show details- Abstract: Deep neural networks (DNNs) generalize remarkably well without explicit regularization even in the strongly over-parametrized regime where classical learning theory would instead predict that they would severely overfit. While many proposals for some kind of implicit regularization have been made to rationalise this success, there is no consensus for the fundamental reason why DNNs do not strongly overfit. In this paper, we provide a new explanation. By applying a very general probability-complexity bound recently derived from algorithmic information theory (AIT), we argue that the parameter-function map of many DNNs should be exponentially biased towards simple functions. We then provide clear evidence for this strong simplicity bias in a model DNN for Boolean functions, as well as in much larger fully connected and convolutional networks trained on CIFAR10 and MNIST. As the target functions in many real problems are expected to be highly structured, this intrinsic simplicity bias helps explain why deep networks generalize well on real world problems. This picture also facilitates a novel PAC-Bayes approach where the prior is taken over the DNN input-output function space, rather than the more conventional prior over parameter space. If we assume that the training algorithm samples parameters close to uniformly within the zero-error region then the PAC-Bayes theorem can be used to guarantee good expected generalization for target functions producing high-likelihood training sets. By exploiting recently discovered connections between DNNs and Gaussian processes to estimate the marginal likelihood, we produce relatively tight generalization PAC-Bayes error bounds which correlate well with the true error on realistic datasets such as MNIST and CIFAR10 and for architectures including convolutional and fully connected networks.
- Keywords: generalization, deep learning theory, PAC-Bayes, Gaussian processes, parameter-function map, simplicity bias
- TL;DR: The parameter-function map of deep networks is hugely biased; this can explain why they generalize. We use PAC-Bayes and Gaussian processes to obtain nonvacuous bounds.
-
Learning when to Communicate at Scale in Multiagent Cooperative and Competitive Tasks
Show details- Abstract: Learning when to communicate and doing that effectively is essential in multi-agent tasks. Recent works show that continuous communication allows efficient training with back-propagation in multi-agent scenarios, but have been restricted to fully-cooperative tasks. In this paper, we present Individualized Controlled Continuous Communication Model (IC3Net) which has better training efficiency than simple continuous communication model, and can be applied to semi-cooperative and competitive settings along with the cooperative settings. IC3Net controls continuous communication with a gating mechanism and uses individualized rewards foreach agent to gain better performance and scalability while fixing credit assignment issues. Using variety of tasks including StarCraft BroodWars explore and combat scenarios, we show that our network yields improved performance and convergence rates than the baselines as the scale increases. Our results convey that IC3Net agents learn when to communicate based on the scenario and profitability.
- Keywords: multiagent, communication, competitive, cooperative, continuous, emergent, reinforcement learning
- TL;DR: We introduce IC3Net, a single network which can be used to train agents in cooperative, competitive and mixed scenarios. We also show that agents can learn when to communicate using our model.
-
Synthetic Datasets for Neural Program Synthesis
Show details- Abstract: The goal of program synthesis is to automatically generate programs in a particular language from corresponding specifications, e.g. input-output behavior. Many current approaches achieve impressive results after training on randomly generated I/O examples in limited domain-specific languages (DSLs), as with string transformations in RobustFill. However, we empirically discover that applying test input generation techniques for languages with control flow and rich input space causes deep networks to generalize poorly to certain data distributions; to correct this, we propose a new methodology for controlling and evaluating the bias of synthetic data distributions over both programs and specifications. We demonstrate, using the Karel DSL and a small Calculator DSL, that training deep networks on these distributions leads to improved cross-distribution generalization performance.
-
DPSNet: End-to-end Deep Plane Sweep Stereo
Show details- Abstract: Multiview stereo aims to reconstruct scene depth from images acquired by a camera under arbitrary motion. Recent methods address this problem through deep learning, which can utilize semantic cues to deal with challenges such as textureless and reflective regions. In this paper, we present a convolutional neural network called DPSNet (Deep Plane Sweep Network) whose design is inspired by best practices of traditional geometry-based approaches. Rather than directly estimating depth and/or optical flow correspondence from image pairs as done in many previous deep learning methods, DPSNet takes a plane sweep approach that involves building a cost volume from deep features using the plane sweep algorithm, regularizing the cost volume via a context-aware cost aggregation, and regressing the depth map from the cost volume. The cost volume is constructed using a differentiable warping process that allows for end-to-end training of the network. Through the effective incorporation of conventional multiview stereo concepts within a deep learning framework, DPSNet achieves state-of-the-art reconstruction results on a variety of challenging datasets.
- Keywords: Deep Learning, Stereo, Depth, Geometry
- TL;DR: A convolution neural network for multi-view stereo matching whose design is inspired by best practices of traditional geometry-based approaches
-
Conditional Network Embeddings
Show details- Abstract: Network Embeddings (NEs) map the nodes of a given network into $d$-dimensional Euclidean space $\mathbb{R}^d$. Ideally, this mapping is such that 'similar' nodes are mapped onto nearby points, such that the NE can be used for purposes such as link prediction (if 'similar' means being 'more likely to be connected') or classification (if 'similar' means 'being more likely to have the same label'). In recent years various methods for NE have been introduced, all following a similar strategy: defining a notion of similarity between nodes (typically some distance measure within the network), a distance measure in the embedding space, and a loss function that penalizes large distances for similar nodes and small distances for dissimilar nodes. A difficulty faced by existing methods is that certain networks are fundamentally hard to embed due to their structural properties: (approximate) multipartiteness, certain degree distributions, assortativity, etc. To overcome this, we introduce a conceptual innovation to the NE literature and propose to create \emph{Conditional Network Embeddings} (CNEs); embeddings that maximally add information with respect to given structural properties (e.g. node degrees, block densities, etc.). We use a simple Bayesian approach to achieve this, and propose a block stochastic gradient descent algorithm for fitting it efficiently. We demonstrate that CNEs are superior for link prediction and multi-label classification when compared to state-of-the-art methods, and this without adding significant mathematical or computational complexity. Finally, we illustrate the potential of CNE for network visualization.
- Keywords: Network embedding, graph embedding, learning node representations, link prediction, multi-label classification of nodes
- TL;DR: We introduce a network embedding method that accounts for prior information about the network, yielding superior empirical performance.
-
Defensive Quantization: When Efficiency Meets Robustness
Show details- Abstract: Neural network quantization is becoming an industry standard to efficiently deploy deep learning models on hardware platforms, such as CPU, GPU, TPU, and FPGAs. However, we observe that the conventional quantization approaches are vulnerable to adversarial attacks. This paper aims to raise people's awareness about the security of the quantized models, and we designed a novel quantization methodology to jointly optimize the efficiency and robustness of deep learning models. We first conduct an empirical study to show that vanilla quantization suffers more from adversarial attacks. We observe that the inferior robustness comes from the error amplification effect, where the quantization operation further enlarges the distance caused by amplified noise. Then we propose a novel Defensive Quantization (DQ) method by controlling the Lipschitz constant of the network during quantization, such that the magnitude of the adversarial noise remains non-expansive during inference. Extensive experiments on CIFAR-10 and SVHN datasets demonstrate that our new quantization method can defend neural networks against adversarial examples, and even achieves superior robustness than their full-precision counterparts, while maintaining the same hardware efficiency as vanilla quantization approaches. As a by-product, DQ can also improve the accuracy of quantized models without adversarial attack.
- Keywords: defensive quantization, model quantization, adversarial attack, efficiency, robustness
- TL;DR: We designed a novel quantization methodology to jointly optimize the efficiency and robustness of deep learning models.
-
GO Gradient for Expectation-Based Objectives
Show details- Abstract: Within many machine learning algorithms, a fundamental problem concerns efficient calculation of an unbiased gradient wrt parameters $\boldsymbol{\gamma}$ for expectation-based objectives $\mathbb{E}_{q_{\boldsymbol{\gamma}} (\boldsymbol{y})} [f (\boldsymbol{y}) ]$. Most existing methods either ($i$) suffer from high variance, seeking help from (often) complicated variance-reduction techniques; or ($ii$) they only apply to reparameterizable continuous random variables and employ a reparameterization trick. To address these limitations, we propose a General and One-sample (GO) gradient that ($i$) applies to many distributions associated with non-reparameterizable continuous {\em or} discrete random variables, and ($ii$) has the same low-variance as the reparameterization trick. We find that the GO gradient often works well in practice based on only one Monte Carlo sample (although one can of course use more samples if desired). Alongside the GO gradient, we develop a means of propagating the chain rule through distributions, yielding statistical back-propagation, coupling neural networks to common random variables.
- Keywords: generalized reparameterization gradient, variance reduction, non-reparameterizable, discrete random variable, GO gradient, general and one-sample gradient, expectation-based objective, variable nabla, statistical back-propagation, hierarchical, graphical model
- TL;DR: a Rep-like gradient for non-reparameterizable continuous/discrete distributions; further generalized to deep probabilistic models, yielding statistical back-propagation
-
h-detach: Modifying the LSTM Gradient Towards Better Optimization
Show details- Abstract: Recurrent neural networks are known for their notorious exploding and vanishing gradient problem (EVGP). This problem becomes more evident in tasks where the information needed to correctly solve them exist over long time scales, because EVGP prevents important gradient components from being back-propagated adequately over a large number of steps. We introduce a simple stochastic algorithm (\textit{h}-detach) that is specific to LSTM optimization and targeted towards addressing this problem. Specifically, we show that when the LSTM weights are large, the gradient components through the linear path (cell state) in the LSTM computational graph get suppressed. Based on the hypothesis that these components carry information about long term dependencies (which we show empirically), their suppression can prevent LSTMs from capturing them. Our algorithm\footnote{Our code is available at https://github.com/bhargav104/h-detach.} prevents gradients flowing through this path from getting suppressed, thus allowing the LSTM to capture such dependencies better. We show significant improvements over vanilla LSTM gradient based training in terms of convergence speed, robustness to seed and learning rate, and generalization using our modification of LSTM gradient on various benchmark datasets.
- Keywords: LSTM, Optimization, Long term dependencies, Back-propagation through time
- TL;DR: A simple algorithm to improve optimization and handling of long term dependencies in LSTM
-
An analytic theory of generalization dynamics and transfer learning in deep linear networks
Show details- Abstract: Much attention has been devoted recently to the generalization puzzle in deep learning: large, deep networks can generalize well, but existing theories bounding generalization error are exceedingly loose, and thus cannot explain this striking performance. Furthermore, a major hope is that knowledge may transfer across tasks, so that multi-task learning can improve generalization on individual tasks. However we lack analytic theories that can quantitatively predict how the degree of knowledge transfer depends on the relationship between the tasks. We develop an analytic theory of the nonlinear dynamics of generalization in deep linear networks, both within and across tasks. In particular, our theory provides analytic solutions to the training and testing error of deep networks as a function of training time, number of examples, network size and initialization, and the task structure and SNR. Our theory reveals that deep networks progressively learn the most important task structure first, so that generalization error at the early stopping time primarily depends on task structure and is independent of network size. This suggests any tight bound on generalization error must take into account task structure, and explains observations about real data being learned faster than random data. Intriguingly our theory also reveals the existence of a learning algorithm that proveably out-performs neural network training through gradient descent. Finally, for transfer learning, our theory reveals that knowledge transfer depends sensitively, but computably, on the SNRs and input feature alignments of pairs of tasks.
- Keywords: Generalization, Theory, Transfer, Multi-task, Linear
- TL;DR: We provide many insights into neural network generalization from the theoretically tractable linear case.
-
Differentiable Learning-to-Normalize via Switchable Normalization
Show details- Abstract: We address a learning-to-normalize problem by proposing Switchable Normalization (SN), which learns to select different normalizers for different normalization layers of a deep neural network. SN employs three distinct scopes to compute statistics (means and variances) including a channel, a layer, and a minibatch. SN switches between them by learning their importance weights in an end-to-end manner. It has several good properties. First, it adapts to various network architectures and tasks (see Fig.1). Second, it is robust to a wide range of batch sizes, maintaining high performance even when small minibatch is presented (e.g. 2 images/GPU). Third, SN does not have sensitive hyper-parameter, unlike group normalization that searches the number of groups as a hyper-parameter. Without bells and whistles, SN outperforms its counterparts on various challenging benchmarks, such as ImageNet, COCO, CityScapes, ADE20K, and Kinetics. Analyses of SN are also presented. We hope SN will help ease the usage and understand the normalization techniques in deep learning. The code of SN will be released.
- Keywords: normalization, deep learning, CNN, computer vision
-
SOM-VAE: Interpretable Discrete Representation Learning on Time Series
Show details- Abstract: High-dimensional time series are common in many domains. Since human cognition is not optimized to work well in high-dimensional spaces, these areas could benefit from interpretable low-dimensional representations. However, most representation learning algorithms for time series data are difficult to interpret. This is due to non-intuitive mappings from data features to salient properties of the representation and non-smoothness over time. To address this problem, we propose a new representation learning framework building on ideas from interpretable discrete dimensionality reduction and deep generative modeling. This framework allows us to learn discrete representations of time series, which give rise to smooth and interpretable embeddings with superior clustering performance. We introduce a new way to overcome the non-differentiability in discrete representation learning and present a gradient-based version of the traditional self-organizing map algorithm that is more performant than the original. Furthermore, to allow for a probabilistic interpretation of our method, we integrate a Markov model in the representation space. This model uncovers the temporal transition structure, improves clustering performance even further and provides additional explanatory insights as well as a natural representation of uncertainty. We evaluate our model in terms of clustering performance and interpretability on static (Fashion-)MNIST data, a time series of linearly interpolated (Fashion-)MNIST images, a chaotic Lorenz attractor system with two macro states, as well as on a challenging real world medical time series application on the eICU data set. Our learned representations compare favorably with competitor methods and facilitate downstream tasks on the real world data.
- Keywords: deep learning, self-organizing map, variational autoencoder, representation learning, time series, machine learning, interpretability
- TL;DR: We present a method to learn interpretable representations on time series using ideas from variational autoencoders, self-organizing maps and probabilistic models.
-
Hierarchical Generative Modeling for Controllable Speech Synthesis
Show details- Abstract: This paper proposes a neural end-to-end text-to-speech (TTS) model which can control latent attributes in the generated speech that are rarely annotated in the training data, such as speaking style, accent, background noise, and recording conditions. The model is formulated as a conditional generative model with two levels of hierarchical latent variables. The first level is a categorical variable, which represents attribute groups (e.g. clean/noisy) and provides interpretability. The second level, conditioned on the first, is a multivariate Gaussian variable, which characterizes specific attribute configurations (e.g. noise level, speaking rate) and enables disentangled fine-grained control over these attributes. This amounts to using a Gaussian mixture model (GMM) for the latent distribution. Extensive evaluation demonstrates its ability to control the aforementioned attributes. In particular, it is capable of consistently synthesizing high-quality clean speech regardless of the quality of the training data for the target speaker.
- Keywords: speech synthesis, representation learning, deep generative model, sequence-to-sequence model
- TL;DR: Building a TTS model with Gaussian Mixture VAEs enables fine-grained control of speaking style, noise condition, and more.
-
Learning Factorized Multimodal Representations
Show details- Abstract: Learning multimodal representations is a fundamentally complex research problem due to the presence of multiple heterogeneous sources of information. Although the presence of multiple modalities provides additional valuable information, there are two key challenges to address when learning from multimodal data: 1) models must learn the complex intra-modal and cross-modal interactions for prediction and 2) models must be robust to unexpected missing or noisy modalities during testing. In this paper, we propose to optimize for a joint generative-discriminative objective across multimodal data and labels. We introduce a model that factorizes representations into two sets of independent factors: multimodal discriminative and modality-specific generative factors. Multimodal discriminative factors are shared across all modalities and contain joint multimodal features required for discriminative tasks such as sentiment prediction. Modality-specific generative factors are unique for each modality and contain the information required for generating data. Experimental results show that our model is able to learn meaningful multimodal representations that achieve state-of-the-art or competitive performance on six multimodal datasets. Our model demonstrates flexible generative capabilities by conditioning on independent factors and can reconstruct missing modalities without significantly impacting performance. Lastly, we interpret our factorized representations to understand the interactions that influence multimodal learning.
- Keywords: multimodal learning, representation learning
- TL;DR: We propose a model to learn factorized multimodal representations that are discriminative, generative, and interpretable.
-
Composing Complex Skills by Learning Transition Policies
Show details- Abstract: Humans acquire complex skills by exploiting previously learned skills and making transitions between them. To empower machines with this ability, we propose a method that can learn transition policies which effectively connect primitive skills to perform sequential tasks without handcrafted rewards. To efficiently train our transition policies, we introduce proximity predictors which induce rewards gauging proximity to suitable initial states for the next skill. The proposed method is evaluated on a set of complex continuous control tasks in bipedal locomotion and robotic arm manipulation which traditional policy gradient methods struggle at. We demonstrate that transition policies enable us to effectively compose complex skills with existing primitive skills. The proposed induced rewards computed using the proximity predictor further improve training efficiency by providing more dense information than the sparse rewards from the environments. We make our environments, primitive skills, and code public for further research at https://youngwoon.github.io/transition .
- Keywords: reinforcement learning, hierarchical reinforcement learning, continuous control, modular framework
- TL;DR: Transition policies enable agents to compose complex skills by smoothly connecting previously acquired primitive skills.
-
Human-level Protein Localization with Convolutional Neural Networks
Show details- Abstract: Localizing a specific protein in a human cell is essential for understanding cellular functions and biological processes of underlying diseases. A promising, low-cost,and time-efficient biotechnology for localizing proteins is high-throughput fluorescence microscopy imaging (HTI). This imaging technique stains the protein of interest in a cell with fluorescent antibodies and subsequently takes a microscopic image. Together with images of other stained proteins or cell organelles and the annotation by the Human Protein Atlas project, these images provide a rich source of information on the protein location which can be utilized by computational methods. It is yet unclear how precise such methods are and whether they can compete with human experts. We here focus on deep learning image analysis methods and, in particular, on Convolutional Neural Networks (CNNs)since they showed overwhelming success across different imaging tasks. We pro-pose a novel CNN architecture “GapNet-PL” that has been designed to tackle the characteristics of HTI data and uses global averages of filters at different abstraction levels. We present the largest comparison of CNN architectures including GapNet-PL for protein localization in HTI images of human cells. GapNet-PL outperforms all other competing methods and reaches close to perfect localization in all 13 tasks with an average AUC of 98% and F1 score of 78%. On a separate test set the performance of GapNet-PL was compared with three human experts and 25 scholars. GapNet-PL achieved an accuracy of 91%, significantly (p-value 1.1e−6) outperforming the best human expert with an accuracy of 72%.
- Keywords: Convolutional Neural Networks, High-resolution images, Multiple-Instance Learning, Microscopy Imaging, Protein Localization
-
Environment Probing Interaction Policies
Show details- Abstract: A key challenge in reinforcement learning (RL) is environment generalization: a policy trained to solve a task in one environment often fails to solve the same task in a slightly different test environment. A common approach to improve inter-environment transfer is to learn policies that are invariant to the distribution of testing environments. However, we argue that instead of being invariant, the policy should identify the specific nuances of an environment and exploit them to achieve better performance. In this work, we propose the “Environment-Probing” Interaction (EPI) policy, a policy that probes a new environment to extract an implicit understanding of that environment’s behavior. Once this environment-specific information is obtained, it is used as an additional input to a task-specific policy that can now perform environment-conditioned actions to solve a task. To learn these EPI-policies, we present a reward function based on transition predictability. Specifically, a higher reward is given if the trajectory generated by the EPI-policy can be used to better predict transitions. We experimentally show that EPI-conditioned task-specific policies significantly outperform commonly used policy generalization methods on novel testing environments.
- Keywords: Reinforcement Learning
-
Lagging Inference Networks and Posterior Collapse in Variational Autoencoders
Show details- Abstract: The variational autoencoder (VAE) is a popular combination of deep latent variable model and accompanying variational learning technique. By using a neural inference network to approximate the model's posterior on latent variables, VAEs efficiently parameterize a lower bound on marginal data likelihood that can be optimized directly via gradient methods. In practice, however, VAE training often results in a degenerate local optimum known as "posterior collapse" where the model learns to ignore the latent variable and the approximate posterior mimics the prior. In this paper, we investigate posterior collapse from the perspective of training dynamics. We find that during the initial stages of training the inference network fails to approximate the model's true posterior, which is a moving target. As a result, the model is encouraged to ignore the latent encoding and posterior collapse occurs. Based on this observation, we propose an extremely simple modification to VAE training to reduce inference lag: depending on the model's current mutual information between latent variable and observation, we aggressively optimize the inference network before performing each model update. Despite introducing neither new model components nor significant complexity over basic VAE, our approach is able to avoid the problem of collapse that has plagued a large amount of previous work. Empirically, our approach outperforms strong autoregressive baselines on text and image benchmarks in terms of held-out likelihood, and is competitive with more complex techniques for avoiding collapse while being substantially faster.
- Keywords: variational autoencoders, posterior collapse, generative models
- TL;DR: To address posterior collapse in VAEs, we propose a novel yet simple training procedure that aggressively optimizes inference network with more updates. This new training procedure mitigates posterior collapse and leads to a better VAE model.
-
A2BCD: Asynchronous Acceleration with Optimal Complexity
Show details- Abstract: In this paper, we propose the Asynchronous Accelerated Nonuniform Randomized Block Coordinate Descent algorithm (A2BCD). We prove A2BCD converges linearly to a solution of the convex minimization problem at the same rate as NU_ACDM, so long as the maximum delay is not too large. This is the first asynchronous Nesterov-accelerated algorithm that attains any provable speedup. Moreover, we then prove that these algorithms both have optimal complexity. Asynchronous algorithms complete much faster iterations, and A2BCD has optimal complexity. Hence we observe in experiments that A2BCD is the top-performing coordinate descent algorithm, converging up to 4-5x faster than NU_ACDM on some data sets in terms of wall-clock time. To motivate our theory and proof techniques, we also derive and analyze a continuous-time analog of our algorithm and prove it converges at the same rate.
- Keywords: asynchronous, optimization, parallel, accelerated, complexity
- TL;DR: We prove the first-ever convergence proof of an asynchronous accelerated algorithm that attains a speedup.
-
Learning to Infer and Execute 3D Shape Programs
Show details- Abstract: Human perception of 3D shapes goes beyond reconstructing them as a set of points or a composition of geometric primitives: we also effortlessly understand higher-level shape structure such as the repetition and reflective symmetry of object parts. In contrast, recent advances in 3D shape sensing focus more on low-level geometry but less on these higher-level relationships. In this paper, we propose 3D shape programs, integrating bottom-up recognition systems with top-down, symbolic program structure to capture both low-level geometry and high-level structural priors for 3D shapes. Because there are no annotations of shape programs for real shapes, we develop neural modules that not only learn to infer 3D shape programs from raw, unannotated shapes, but also to execute these programs for shape reconstruction. After initial bootstrapping, our end-to-end differentiable model learns 3D shape programs by reconstructing shapes in a self-supervised manner. Experiments demonstrate that our model accurately infers and executes 3D shape programs for highly complex shapes from various categories. It can also be integrated with an image-to-shape module to infer 3D shape programs directly from an RGB image, leading to 3D shape reconstructions that are both more accurate and more physically plausible.
- Keywords: Program Synthesis, 3D Shape Modeling, Self-supervised Learning
- TL;DR: We propose 3D shape programs, a structured, compositional shape representation. Our model learns to infer and execute shape programs to explain 3D shapes.
-
Deep Decoder: Concise Image Representations from Untrained Non-convolutional Networks
Show details- Abstract: Deep neural networks, in particular convolutional neural networks, have become highly effective tools for compressing images and solving inverse problems including denoising, inpainting, and reconstruction from few and noisy measurements. This success can be attributed in part to their ability to represent and generate natural images well. Contrary to classical tools such as wavelets, image-generating deep neural networks have a large number of parameters---typically a multiple of their output dimension---and need to be trained on large datasets. In this paper, we propose an untrained simple image model, called the deep decoder, which is a deep neural network that can generate natural images from very few weight parameters. The deep decoder has a simple architecture with no convolutions and fewer weight parameters than the output dimensionality. This underparameterization enables the deep decoder to compress images into a concise set of network weights, which we show is on par with wavelet-based thresholding. Further, underparameterization provides a barrier to overfitting, allowing the deep decoder to have state-of-the-art performance for denoising. The deep decoder is simple in the sense that each layer has an identical structure that consists of only one upsampling unit, pixel-wise linear combination of channels, ReLU activation, and channelwise normalization. This simplicity makes the network amenable to theoretical analysis, and it sheds light on the aspects of neural networks that enable them to form effective signal representations.
- Keywords: natural image model, image prior, under-determined neural networks, untrained network, non-convolutional network, denoising, inverse problem
- TL;DR: We introduce an underparameterized, nonconvolutional, and simple deep neural network that can, without training, effectively represent natural images and solve image processing tasks like compression and denoising competitively.
-
SNAS: stochastic neural architecture search
Show details- Abstract: We propose Stochastic Neural Architecture Search (SNAS), an economical end-to-end solution to Neural Architecture Search (NAS) that trains neural operation parameters and architecture distribution parameters in same round of back-propagation, while maintaining the completeness and differentiability of the NAS pipeline. In this work, NAS is reformulated as an optimization problem on parameters of a joint distribution for the search space in a cell. To leverage the gradient information in generic differentiable loss for architecture search, a novel search gradient is proposed. We prove that this search gradient optimizes the same objective as reinforcement-learning-based NAS, but assigns credits to structural decisions more efficiently. This credit assignment is further augmented with locally decomposable reward to enforce a resource-efficient constraint. In experiments on CIFAR-10, SNAS takes less epochs to find a cell architecture with state-of-the-art accuracy than non-differentiable evolution-based and reinforcement-learning-based NAS, which is also transferable to ImageNet. It is also shown that child networks of SNAS can maintain the validation accuracy in searching, with which attention-based NAS requires parameter retraining to compete, exhibiting potentials to stride towards efficient NAS on big datasets.
- Keywords: Neural Architecture Search
-
Revealing interpretable object representations from human behavior
Show details- Abstract: To study how mental object representations are related to behavior, we estimated sparse, non-negative representations of objects using human behavioral judgments on images representative of 1,854 object categories. These representations predicted a latent similarity structure between objects, which captured most of the explainable variance in human behavioral judgments. Individual dimensions in the low-dimensional embedding were found to be highly reproducible and interpretable as conveying degrees of taxonomic membership, functionality, and perceptual attributes. We further demonstrated the predictive power of the embeddings for explaining other forms of human behavior, including categorization, typicality judgments, and feature ratings, suggesting that the dimensions reflect human conceptual representations of objects beyond the specific task.
- Keywords: category representation, sparse coding, representation learning, interpretable representations
- TL;DR: Human behavioral judgments are used to obtain sparse and interpretable representations of objects that generalize to other tasks
-
AntisymmetricRNN: A Dynamical System View on Recurrent Neural Networks
Show details- Abstract: Recurrent neural networks have gained widespread use in modeling sequential data. Learning long-term dependencies using these models remains difficult though, due to exploding or vanishing gradients. In this paper, we draw connections between recurrent networks and ordinary differential equations. A special form of recurrent networks called the AntisymmetricRNN is proposed under this theoretical framework, which is able to capture long-term dependencies thanks to the stability property of its underlying differential equation. Existing approaches to improving RNN trainability often incur significant computation overhead. In comparison, AntisymmetricRNN achieves the same goal by design. We showcase the advantage of this new architecture through extensive simulations and experiments. AntisymmetricRNN exhibits much more predictable dynamics. It outperforms regular LSTM models on tasks requiring long-term memory and matches the performance on tasks where short-term dependencies dominate despite being much simpler.
-
Global-to-local Memory Pointer Networks for Task-Oriented Dialogue
Show details- Abstract: End-to-end task-oriented dialogue is challenging since knowledge bases are usually large, dynamic and hard to incorporate into a learning framework. We propose the global-to-local memory pointer (GLMP) networks to address this issue. In our model, a global memory encoder and a local memory decoder are proposed to share external knowledge. The encoder encodes dialogue history, modifies global contextual representation, and generates a global memory pointer. The decoder first generates a sketch response with unfilled slots. Next, it passes the global memory pointer to filter the external knowledge for relevant information, then instantiates the slots via the local memory pointers. We empirically show that our model can improve copy accuracy and mitigate the common out-of-vocabulary problem. As a result, GLMP is able to improve over the previous state-of-the-art models in both simulated bAbI Dialogue dataset and human-human Stanford Multi-domain Dialogue dataset on automatic and human evaluation.
- Keywords: pointer networks, memory networks, task-oriented dialogue systems, natural language processing
- TL;DR: GLMP: Global memory encoder (context RNN, global pointer) and local memory decoder (sketch RNN, local pointer) that share external knowledge (MemNN) are proposed to strengthen response generation in task-oriented dialogue.
-
InstaGAN: Instance-aware Image-to-Image Translation
Show details- Abstract: Unsupervised image-to-image translation has gained considerable attention due to the recent impressive progress based on generative adversarial networks (GANs). However, previous methods often fail in challenging cases, in particular, when an image has multiple target instances and a translation task involves significant changes in shape, e.g., translating pants to skirts in fashion images. To tackle the issues, we propose a novel method, coined instance-aware GAN (InstaGAN), that incorporates the instance information (e.g., object segmentation masks) and improves multi-instance transfiguration. The proposed method translates both an image and the corresponding set of instance attributes while maintaining the permutation invariance property of the instances. To this end, we introduce a context preserving loss that encourages the network to learn the identity function outside of target instances. We also propose a sequential mini-batch inference/training technique that handles multiple instances with a limited GPU memory and enhances the network to generalize better for multiple instances. Our comparative evaluation demonstrates the effectiveness of the proposed method on different image datasets, in particular, in the aforementioned challenging cases. Code and results are available in https://github.com/sangwoomo/instagan
- Keywords: Image-to-Image Translation, Generative Adversarial Networks
- TL;DR: We propose a novel method to incorporate the set of instance attributes for image-to-image translation.
-
Deep Layers as Stochastic Solvers
Show details- Abstract: We provide a novel perspective on the forward pass through a block of layers in a deep network. In particular, we show that a forward pass through a standard dropout layer followed by a linear layer and a non-linear activation is equivalent to optimizing a convex objective with a single iteration of a $\tau$-nice Proximal Stochastic Gradient method. We further show that replacing standard Bernoulli dropout with additive dropout is equivalent to optimizing the same convex objective with a variance-reduced proximal method. By expressing both fully-connected and convolutional layers as special cases of a high-order tensor product, we unify the underlying convex optimization problem in the tensor setting and derive a formula for the Lipschitz constant $L$ used to determine the optimal step size of the above proximal methods. We conduct experiments with standard convolutional networks applied to the CIFAR-10 and CIFAR-100 datasets and show that replacing a block of layers with multiple iterations of the corresponding solver, with step size set via $L$, consistently improves classification accuracy.
- Keywords: deep networks, optimization
- TL;DR: A framework that links deep network layers to stochastic optimization algorithms; can be used to improve model accuracy and inform network design.
-
Learning Multi-Level Hierarchies with Hindsight
Show details- Abstract: Multi-level hierarchies have the potential to accelerate learning in sparse reward tasks because they can divide a problem into a set of short horizon subproblems. In order to realize this potential, Hierarchical Reinforcement Learning (HRL) algorithms need to be able to learn the multiple levels within a hierarchy in parallel, so these simpler subproblems can be solved simultaneously. Yet most existing HRL methods that can learn hierarchies are not able to efficiently learn multiple levels of policies at the same time, particularly in continuous domains. To address this problem, we introduce a framework that can learn multiple levels of policies in parallel. Our approach consists of two main components: (i) a particular hierarchical architecture and (ii) a method for jointly learning multiple levels of policies. The hierarchies produced by our framework are comprised of a set of nested, goal-conditioned policies that use the state space to decompose a task into short subtasks. All policies in the hierarchy are learned simultaneously using two types of hindsight transitions. We demonstrate experimentally in both grid world and simulated robotics domains that our approach can significantly accelerate learning relative to other non-hierarchical and hierarchical methods. Indeed, our framework is the first to successfully learn 3-level hierarchies in parallel in tasks with continuous state and action spaces. We also present a video ( https://www.youtube.com/watch?v=DYcVTveeNK0 ) of our results and software ( https://github.com/andrew-j-levy/Hierarchical-Actor-Critc-HAC- ) to implement our framework.
- Keywords: Hierarchical Reinforcement Learning, Reinforcement Learning, Deep Reinforcement Learning
- TL;DR: We introduce the first Hierarchical RL approach to successfully learn 3-level hierarchies in parallel in tasks with continuous state and action spaces.


Industry-leading best-practices, company-specific optimizations and custom business insights to drive actionable performance. Click here to learn about how our Advisory Solution team can help you
Best-in-class audit, implementation and maintenance support of analytics software and databases. Click here to learn about our Technical Solution team can help you


public abstract class BluetoothReader
extends java.lang.Object
BluetoothReader
class represents ACS Bluetooth readers.| Modifier and Type | Class and Description |
|---|---|
static interface |
BluetoothReader.OnAtrAvailableListener
Interface definition for a callback to be invoked when the ATR string is
available.
|
static interface |
BluetoothReader.OnAuthenticationCompleteListener
Interface definition for a callback to be invoked when the authentication
is completed.
|
static interface |
BluetoothReader.OnCardPowerOffCompleteListener
Interface definition for a callback to be invoked when the reader powers
off the card.
|
static interface |
BluetoothReader.OnCardStatusAvailableListener
Interface definition for a callback to be invoked when the card status is
available.
|
static interface |
BluetoothReader.OnCardStatusChangeListener
Interface definition for a callback to be invoked when the card status is
changed.
|
static interface |
BluetoothReader.OnDeviceInfoAvailableListener
Interface definition for a callback to be invoked when the device
information is available.
|
static interface |
BluetoothReader.OnEnableNotificationCompleteListener
Interface definition for a callback to be invoked when the reader get the
result of enable notification.
|
static interface |
BluetoothReader.OnEscapeResponseAvailableListener
Interface definition for a callback to be invoked when the escape
response is available.
|
static interface |
BluetoothReader.OnResponseApduAvailableListener
Interface definition for a callback to be invoked when the response APDU
is available.
|
| Modifier and Type | Field and Description |
|---|---|
static int |
BATTERY_STATUS_FULL
The battery is full.
|
static int |
BATTERY_STATUS_NONE
No battery.
|
static int |
BATTERY_STATUS_USB_PLUGGED
The USB is plugged.
|
static int |
CARD_STATUS_ABSENT
No card is present.
|
static int |
CARD_STATUS_POWER_SAVING_MODE
The reader is in power saving mode.
|
static int |
CARD_STATUS_POWERED
Card is present and active.
|
static int |
CARD_STATUS_PRESENT
Card is present but inactive.
|
static int |
CARD_STATUS_UNKNOWN
The card status is unknown.
|
static int |
DEVICE_INFO_FIRMWARE_REVISION_STRING
Identifier for firmware revision string.
|
static int |
DEVICE_INFO_HARDWARE_REVISION_STRING
Identifier for hardware revision string.
|
static int |
DEVICE_INFO_MANUFACTURER_NAME_STRING
Identifier for manufacturer name string.
|
static int |
DEVICE_INFO_MODEL_NUMBER_STRING
Identifier for model number string.
|
static int |
DEVICE_INFO_SERIAL_NUMBER_STRING
Identifier for serial number string.
|
static int |
DEVICE_INFO_SOFTWARE_REVISION_STRING
Identifier for software revision string.
|
static int |
DEVICE_INFO_SYSTEM_ID
Identifier for system ID.
|
static int |
ERROR_AUTHENTICATION_FAILED
Authentication is failed.
|
static int |
ERROR_AUTHENTICATION_REQUIRED
Authentication is required.
|
static int |
ERROR_CARD_OPERATION
The card operation failed.
|
static int |
ERROR_CHARACTERISTIC_NOT_FOUND
The characteristic is not found.
|
static int |
ERROR_INVALID_CHECKSUM
The checksum is invalid.
|
static int |
ERROR_INVALID_COMMAND
The command is invalid.
|
static int |
ERROR_INVALID_DATA
Received data error.
|
static int |
ERROR_INVALID_DATA_LENGTH
The data length is invalid.
|
static int |
ERROR_LOW_BATTERY
The battery is low.
|
static int |
ERROR_READ_CHARACTERISTIC_FAILED
The characteristic is unable to read.
|
static int |
ERROR_SET_NOTIFCIATION_FAILED
Fail to enable or disable the notification.
|
static int |
ERROR_SUCCESS
No error.
|
static int |
ERROR_TIMEOUT
Timeout.
|
static int |
ERROR_UNDEFINED
Undefined error.
|
static int |
ERROR_UNKNOWN_COMMAND_ID
The command ID is unknown.
|
static int |
ERROR_WRITE_DATA
Writing command to reader is failed.
|
static int |
STATE_CONNECTED
The reader is in connected state.
|
static int |
STATE_CONNECTING
The reader is in connecting state.
|
static int |
STATE_DISCONNECTED
The reader is in disconnected state.
|
static int |
STATE_DISCONNECTING
The reader is in disconnecting state.
|
| Constructor and Description |
|---|
BluetoothReader()
Creates an instance of
BluetoothReader . |
| Modifier and Type | Method and Description |
|---|---|
abstract boolean |
authenticate(byte[] masterKey)
Authenticates the reader.
|
abstract boolean |
enableNotification(boolean enabled)
Enables the reader's battery status or level, card status and response
notifications.
|
abstract boolean |
getCardStatus()
Gets the card status.
|
abstract boolean |
getDeviceInfo(int infoId)
Gets the device information.
|
abstract boolean |
powerOffCard()
Powers off the card.
|
abstract boolean |
powerOnCard()
Powers on the card.
|
void |
setOnAtrAvailableListener(BluetoothReader.OnAtrAvailableListener listener)
Registers a callback to be invoked when the card is powered on and the
ATR string is available.
|
void |
setOnAuthenticationCompleteListener(BluetoothReader.OnAuthenticationCompleteListener listener)
Registers a callback to be invoked when the authentication result is
available.
|
void |
setOnCardPowerOffCompleteListener(BluetoothReader.OnCardPowerOffCompleteListener listener)
Registers a callback to be invoked when the card power off result is
available.
|
void |
setOnCardStatusAvailableListener(BluetoothReader.OnCardStatusAvailableListener listener)
Registers a callback to be invoked when the card status is available.
|
void |
setOnCardStatusChangeListener(BluetoothReader.OnCardStatusChangeListener listener)
Registers a callback to be invoked when the card status change
notification is received.
|
void |
setOnDeviceInfoAvailableListener(BluetoothReader.OnDeviceInfoAvailableListener listener)
Registers a callback to be invoked when the device information response
is available.
|
void |
setOnEnableNotificationCompleteListener(BluetoothReader.OnEnableNotificationCompleteListener listener) |
void |
setOnEscapeResponseAvailableListener(BluetoothReader.OnEscapeResponseAvailableListener listener)
Registers a callback to be invoked when the escape command response is
available.
|
void |
setOnResponseApduAvailableListener(BluetoothReader.OnResponseApduAvailableListener listener)
Registers a callback to be invoked when the response APDU is available.
|
abstract boolean |
transmitApdu(byte[] apdu)
Transmits the APDU.
|
abstract boolean |
transmitEscapeCommand(byte[] escapeCommand)
Transmits the escape command.
|
public static final int ERROR_SUCCESS
public static final int ERROR_INVALID_CHECKSUM
public static final int ERROR_INVALID_DATA_LENGTH
public static final int ERROR_INVALID_COMMAND
public static final int ERROR_UNKNOWN_COMMAND_ID
public static final int ERROR_CARD_OPERATION
public static final int ERROR_AUTHENTICATION_REQUIRED
public static final int ERROR_LOW_BATTERY
public static final int ERROR_AUTHENTICATION_FAILED
public static final int ERROR_CHARACTERISTIC_NOT_FOUND
public static final int ERROR_WRITE_DATA
public static final int ERROR_TIMEOUT
public static final int ERROR_SET_NOTIFCIATION_FAILED
public static final int ERROR_READ_CHARACTERISTIC_FAILED
public static final int ERROR_UNDEFINED
public static final int ERROR_INVALID_DATA
public static final int BATTERY_STATUS_NONE
public static final int BATTERY_STATUS_FULL
public static final int BATTERY_STATUS_USB_PLUGGED
public static final int CARD_STATUS_UNKNOWN
public static final int CARD_STATUS_ABSENT
public static final int CARD_STATUS_PRESENT
public static final int CARD_STATUS_POWERED
public static final int CARD_STATUS_POWER_SAVING_MODE
public static final int STATE_DISCONNECTED
public static final int STATE_DISCONNECTING
public static final int STATE_CONNECTING
public static final int STATE_CONNECTED
public static final int DEVICE_INFO_SYSTEM_ID
public static final int DEVICE_INFO_MODEL_NUMBER_STRING
public static final int DEVICE_INFO_SERIAL_NUMBER_STRING
public static final int DEVICE_INFO_FIRMWARE_REVISION_STRING
public static final int DEVICE_INFO_HARDWARE_REVISION_STRING
public static final int DEVICE_INFO_SOFTWARE_REVISION_STRING
public static final int DEVICE_INFO_MANUFACTURER_NAME_STRING
public abstract boolean authenticate(byte[] masterKey)
setOnAuthenticationCompleteListener()
method.masterKey
- the master key. The length must be 16 bytes.true
if the reader is connected, otherwise
false
.java.lang.IllegalArgumentException
- if the length of masterKey
is not equal to 16
bytes long.public abstract boolean enableNotification(boolean enabled)
setOnEnableNotificationCompleteListener()
method. If you want to receive
these status change notifications, you need to register callback.enabled
- true
if start to listen reader's status change,
otherwise false
.true
if this operation was initiated successfully,
otherwise false
.public abstract boolean getCardStatus()
setOnCardStatusResponseAvailableListener()
method.true
if the reader is connected, otherwise
false
.public abstract boolean getDeviceInfo(int infoId)
setOnDeviceInfoAvailableListener()
method.infoId
- the identity of the information to be read.true
if the reader is connected, otherwise
false
.public abstract boolean powerOffCard()
setOnCardPowerOffCompleteListener()
method.true
if the reader is connected, otherwise
false
.public abstract boolean powerOnCard()
setOnAtrAvailableListener()
method.true
if the reader is connected, otherwise
false
.public void setOnAtrAvailableListener(BluetoothReader.OnAtrAvailableListener listener)
listener
- the callback that will run.public void setOnAuthenticationCompleteListener(BluetoothReader.OnAuthenticationCompleteListener listener)
listener
- the callback that will run.public void setOnCardPowerOffCompleteListener(BluetoothReader.OnCardPowerOffCompleteListener listener)
listener
- the callback that will run.public void setOnCardStatusAvailableListener(BluetoothReader.OnCardStatusAvailableListener listener)
listener
- the callback that will run.public void setOnCardStatusChangeListener(BluetoothReader.OnCardStatusChangeListener listener)
listener
- the callback that will run.public void setOnDeviceInfoAvailableListener(BluetoothReader.OnDeviceInfoAvailableListener listener)
listener
- the callback that will run.public void setOnEnableNotificationCompleteListener(BluetoothReader.OnEnableNotificationCompleteListener listener)
public void setOnEscapeResponseAvailableListener(BluetoothReader.OnEscapeResponseAvailableListener listener)
listener
- the callback that will run.public void setOnResponseApduAvailableListener(BluetoothReader.OnResponseApduAvailableListener listener)
listener
- the callback that will run.public abstract boolean transmitApdu(byte[] apdu)
setOnResponseApduAvailableListener()
method.apdu
- the APDU to be sent.true
if the reader is connected, otherwise
false
.public abstract boolean transmitEscapeCommand(byte[] escapeCommand)
setOnEscapeResponseAvailableListener()
method.escapeCommand
- the escape command to be sent.true
if the reader is connected, otherwise
false
.Copyright © 2014-2015 Advanced Card Systems Ltd. All Rights Reserved.