InferCode: Self-Supervised Learning of Code Representations by Predicting Subtrees

Learning code representations has found many uses in software engineering, such as code classification, code search, comment generation, and bug prediction, etc. Although representations of code in tokens, syntax trees, dependency graphs, paths in trees, or the combinations of their variants have been proposed, existing learning techniques have a major limitation that these models are often trained on datasets labeled for specific downstream tasks, and as such the code representations may not be suitable for other tasks. Even though some techniques generate representations from unlabeled code, they are far from being satisfactory when applied to the downstream tasks. To overcome the limitation, this paper proposes InferCode, which adapts the self-supervised learning idea from natural language processing to the abstract syntax trees (ASTs) of code. The novelty lies in the training of code representations by predicting subtrees automatically identified from the contexts of ASTs. With InferCode, subtrees in ASTs are treated as the labels for training the code representations without any human labelling effort or the overhead of expensive graph construction, and the trained representations are no longer tied to any specific downstream tasks or code units. We have trained an instance of InferCode model using Tree-Based Convolutional Neural Network (TBCNN) as the encoder of a large set of Java code. This pre-trained model can then be applied to downstream unsupervised tasks such as code clustering, code clone detection, cross-language code search, or be reused under a transfer learning scheme to continue training the model weights for supervised tasks such as code classification and method name prediction. Compared to prior techniques applied to the same downstream tasks, such as code2vec, code2seq, ASTNN, using our pre-trained InferCode model higher performance is achieved with a significant margin for most of the tasks, including those involving different programming languages. The implementation of InferCode and the trained embeddings are available at the link: https://github.com/bdqnghi/infercode

TreeCaps: Tree-Based Capsule Networks for Source Code Processing

Recently program learning techniques have been proposed to process source code based on syntactical structures (e.g., Abstract Syntax Trees) and/or semantic information (e.g., Dependency Graphs). While graphs may be better at capturing various viewpoints of code semantics than trees, constructing graph inputs from code needs static code semantic analysis that may not be accurate and introduces noise during learning. Although syntax trees are precisely defined according to the language grammar and easier to construct and process than graphs, previous tree-based learning techniques have not been able to learn semantic information from trees to achieve better accuracy than graph-based techniques. We propose a new learning technique, named TreeCaps, by fusing together capsule networks with tree-based convolutional neural networks, to achieve learning accuracy higher than existing graph-based techniques while it is based only on trees. TreeCaps introduces novel variable-to-static routing algorithms into the capsule networks to compensate for the loss of previous routing algorithms. Aside from accuracy, we also find that TreeCaps is the most robust to withstand those semantic-preserving program transformations that change code syntax without modifying the semantics. Evaluated on a large number of Java and C/C++ programs, TreeCaps models outperform prior deep learning models of program source code, in terms of both accuracy and robustness for program comprehension tasks such as code functionality classification and function name prediction. Our implementation are publicly available at: https://github.com/bdqnghi/treecaps

CUORE: The first bolometric experiment at the ton scale for the search for neutrino-less double beta decay

The Cryogenic Underground Observatory for Rare Events (CUORE) is the most massive bolometric experiment searching for neutrino-less double beta (0νββ) decay. The detector consists of an array of 988 TeO crystals (742 kg) arranged in a compact cylindrical structure of 19 towers. This paper will describe the CUORE experiment, including the cryostat, and present the detector performance during the first year of running. Additional detail will describe the effort made in improving the energy resolution in the Te 0νββ decay region of interest (ROI) and the suppression of backgrounds. A description of work to lower the energy threshold in order to give CUORE the sensitivity to search for other rare events, such as dark matter, will also be provided. 2 13

Search for 14.4 keV Solar Axions from M1 Transition of 57Fe with CUORE Crystals

We report the results of a search for axions from the 14.4 keV M1 transition from 57Fe in the core of the sun using the axio-electric effect in TeO2bolometers. The detectors are 5 × 5 × 5 cm3 crystals operated at about 10 mK in a facility used to test bolometers for the CUORE experiment at the Laboratori Nazionali del Gran Sasso in Italy. An analysis of 43.65 kg⋅d of data was made using a newly developed low energy trigger which was optimized to reduce the energy threshold of the detector. An upper limit of 0.58 c⋅kg−1⋅d−1 is established at 95% C.L., which translates into lower bounds fA ≥ 3.12 × 105 GeV 95% C.L. (DFSZ model) and fA ≥ 2.41 × 104 GeV 95% C.L. (KSVZ model) on the Peccei-Quinn symmetry-breaking scale, for a value of S = 0.5 of the flavor-singlet axial vector matrix element. These bounds can be expressed in terms of axion masses as mA ≤ 19.2 eV and mA ≤ 250 eV at 95% C.L. in the DFSZ and KSVZ models respectively. Bounds are given also for the interval 0.35 ≤ S ≤ 0.55

Safe and Secure Networked Control Systems under Denial-of-Service Attacks

Abstract. We consider the problem of security constrained optimal con-trol for discrete-time, linear dynamical systems in which control and mea-surement packets are transmitted over a communication network. The packets may be jammed or compromised by a malicious adversary. For a class of denial-of-service (DoS) attack models, the goal is to find an (op-timal) causal feedback controller that minimizes a given objective func-tion subject to safety and power constraints. We present a semi-definite programming based solution for solving this problem. Our analysis also presents insights on the effect of attack models on solution of the optimal control problem.