dataesr/scientific-paragraphs-categorization huggingface dataset:
A. Implementation principle The implementation of the CASCADE protocols consists in both a device-side and server-side implementation. We assume that the server has high computational capabilities, whereas the implementation should be as lightweight as possible on the device. Table  IV  summarises how computations are distributed between the device and the server. 1) Device side: For the device side implementation of CASCADE, we chose cost-optimised FPGA devices from the Xilinx Spartan and Intel Cyclone families, since those are typically the ones used in applications requiring a lightweight root of trust like a PUF. We selected two FPGAs per family, namely Spartan 3, Spartan 6, Cyclone III and Cyclone V. We integrated the module computing the parity in a simple controller with three states: idle, compute parity and send parity.
Since the RAM is used to store the PUF response, the number of RAM bits required grows linearly with the response length. With implementation figures between 3 and 6 LUTs and 1 D flip-flop, this FPGA implementation of the CASCADE protocol using RAM is by far the most lightweight error-correction module to date. 2) Execution Time: Another criterion used to evaluate the different error-correcting codes is their execution time. We give the execution times in number of clock cycles to be device-independent. Implementation options 1 and 3 have an identical way of selecting the PUF bits, therefore they have the same execution time. Implementation option 2 on the other hand has a longer execution time since it requires to shift the circular shift register to select the appropriate response bit. The execution time of the protocol can be split into a fixed and a variable portion.
Therefore, we propose to add an extra countermeasure. b) Counter-measure 2: At the beginning of each execution of the CASCADE protocol, a new PUF response must be requested. By doing so, the attacker can obtain more parity relations between the PUF response bits. However, since a new response has been generated, some bits might have flipped to an erroneous value or flipped back to a correct value with respect to the reference response r 0. Therefore, the parity relations do not correspond to the same PUF response, and cannot be used to forge a response by Gaussian elimination. This problem is similar to the Learning parities with noise problem, which is considered a hard problem and has been used as the hardness assumption in constructing cryptographic schemes  [38]. Learning parities with noise is equivalent in complexity to decoding from a random linear code  [39] , which is known to be an NP-hard problem.
ACKNOWLEDGEMENTS The work presented in this paper was realised in the frame of the  SALWARE  project number  ANR-13-JS03-0003  supported by the  French "Agence Nationale de la Recherche " and by the  French "Fondation de Recherche pour l'Aéronautique et l'Espace" , funding for this project was also provided by a grant from  "La Région Rhône-Alpes ". This work has also received funding from the  European Union 's  Horizon 2020 research and innovation programme  in the framework of the project  HECTOR (Hardware Enabled Crypto and Randomness)  under grant agreement No  644052.
, 2012; Gurney et al. , 2017). These three sources of insight into urban GHG emissions, airborne-and tower-based GHG measurements and inventory data products, are complementary, and largely independent. We plan to explore means of merging them into a single approach that meets the INFLUX research objectives. This strategy is similar to that employed by the North American Carbon Program (NACP) Midcontinent Intensive (MCI) regional study  (Ogle et al. , 2006) , which resulted in a successful demonstration of independent quantification of CO 2 fluxes from an agricultural region of the upper Midwest using both atmospheric  (Miles et al. , 2012; Lauvaux et al, 2012a)  and inventory  (Ogle et al, 2010; West et al, 2011)  methods. Good agreement between these approaches  (Schuh et al. , 2013)  was obtained.
2. 2. 4 Temporal trends-High fidelity, long-term monitoring of atmospheric GHG mole fractions and the state of the urban ABL are intended to provide the accuracy and precision in inverse GHG flux estimates needed to identify changes in GHG emissions over time. Atmospheric data have been demonstrated to be uniquely capable of identifying changes in urban emissions over time  (Lauvaux et al. , 2013). INFLUX has quantified uncertainties in urban emissions estimates, but has not yet explicitly examined trend detection. Multi-year flux estimates are a high priority for future research using the INFLUX observational array.
Robust estimation of the Essential matrix Even if the underlying dataset is contaminated with outliers, RANSAC estimator can be used to robustly estimate the model parameters. RANSAC uses a randomly chosen subset of the entire dataset to compute a hypothesis. The remaining datapoints are used for validation. Repeating the hypothesis computation and validation with different subsets, the probability of finding a hypothesis that fits the data well increases. For a data set with a given proportion ε of outliers, the number of trials N required to give sufficiently high probability p to pick an outlier-free subset consisting of k point correspondences is N = log(1 -p) log(1 -(1 -ε) k ) (5) Since the confidence p is generally chosen to be p ≥ 0. 99, the number of required RANSAC iterations N only depends on the number of parameters k and the assumed ratio of outliers ε.
GPU IMPLEMENTATION OF RELATIVE POSE FROM FIVE 2D-2D CORRESPONDENCES In this section, we present the implementation details of the essential matrix estimation from five correspondences within RANSAC using the CUDA programming model. As stated before, the eigenvalues of the action matrix contain the essential matrices solutions according to Stewenius's method  (Stewenius et al. , 2006). However, a device based eigenvalue computation on CUDA doesn't exist yet. Hence, we have relied on the Matlab code provided by Chris Engels, based on the reduction to a single polynomial  (Stewenius and Engels, 2008). This is done through the computation of the action matrix characteristic polynomial roots, equivalent to the action matrix eigenvalues. Our parallelization approach is based on performing the required RANSAC iterations in parallel on CUDA to achieve a certain amount of speedup.
It is worth noting that this configuration is possible because the matrix sizes in our problem are small (5 refrectors, each of size 9 × 9) and consequently, all reflectors fit at once in shared memory. The computation consists in loading, first, the A[blockIdx. x], and the array of scalars Tauarray[blockIdx. x] exited by cublasDqr f Batched into shared memory where the matrix Q is also allocated. The vector v i relative to each reflector q i is then putted in the required form, where v i (1 : i -1) = 0 and v i (i) = 1 with v i (i + 1 : m) on exit in A[blockIdx. x][i + 1 : m, i]. Each reflector q i has the form q i = I -Tau[i]. v. transpose(v), computed for all reflectors by the pseudocode explicited in Figure  1  and finally, the product of all reflectors is computed to retrieve Q. Once the null space determined, the second step is to compute a 10 × 20 matrix M that is accelerated in the provided openSource code, through a symbolic computation of the expanded constraints.
RANSAC models computation kernel At this level, the kernel is launched with one CUDA block and iterations number of threads. We only use global memory where the computations of the previous kernel are stored and small per thread arrays using registers and local memory. Each thread computes a 10 th degree polynomial using local variables. This is done by extracting from the RREF in global memory the coefficients of two 3 rd degree polynomials and a 4 th degree polynomial represented by private local arrays for each thread. These polynomials are afterwards convoluted then substracted and added to generate a single 10 th degree polynomial for each thread as explicited in the original Matlab code and which refers to the computation of the determinant of the characteristic polynomial. The covolution is performed in our implementation through a special device function presented as a symbolic computation of three polynomials of 3 rd , 3 rd and 4 th degrees respectively.
RANSAC rating kernel In order to validate each estimated model, we compute a loss value for each datapoint of the dataset. The loss value is used to verify the model by computing the reprojection error of all triangulated bearing vectors of the dataset. Outliers are subsequently found by thresholding the reprojection errors, and the best model refers to the one with the maximum number of inliers. As the entire operation is in 3D, we use the thresholding scheme adopted in the Opengv librairy  (Kneip and Furgale, 2014). This latter uses a threshold angle θ threshold to constrain f repr to lie within a cone of axis f meas and of opening angle θ threshold as depicted in Figure  3. The threshold error is given by ε threshold = 1 -cos θ threshold = 1 -cos(arctan ψ l ), (9) where ψ refers to the classical reprojection error threshold expressed in pixels and l to the focal length.
The model validation process considers multiple accesses to global memory to evaluate whether each correspondance of the dataset is an inlier or an outlier which is a very execution-time consuming. The shared memory is, hence, used as a cache to accelerate computations. The RANSAC rating kernel employs a block level parallelism and is lauched with iterations blocks to make each block handles a RANSAC model and 8 × warpsize threads. Since warpsize = 32, a total of 256 threads is launched per block and each thread in the block evaluates a point. To load datapoints in shared memory, a buffer is allocated of size 256 × s where s refers to the size of each datapoint. In case of bearing vectors, s = 6. Each thread triangulates bearing vector correspondances into a 3D point and computes its reprojection error according to Equation 8.
This latter is, thereafter, compared to the precalculated threshold according to Equation 9 to decide whether the correspondance refers to an inlier or to an outlier. In our implementation, the number of inliers for 256 values is automatically returned via: inlier_count=__syncthreads_count( reproj_error[threadIdx. x]<threshold); The process of loading data into buffer and evaluating 256 reprojection errors is repeated ceil(datasetCount/256) times.
Random Problem Generation To make synthetic data for our tests, we used the automatic benchmark for relative pose included in the Matlab interface of the OpenGV librairy. We used the provided experiment to create a random relative pose problem, that is, correspondences of bearing vectors in two viewpoints using two cameras at the number of 1000 correspondences. In fact, the number of 1000 correspondences has been chosen based on an averaged number obtained from real images. The experiment returns the observations in both viewpoints (assumed to be a stereo camera system), plus the ground truth values for the relative transformation parameters.
Timing We have measured the mean time while running on the GPU and CPU (using OpenGV librairy). To compute the mean time, each estimation is repeated 20 times. The repetition rate is required since a single estimation can be much slower or much faster than the mean due to the randomization. We will present results of computations for both single-precision and double-precision datatypes. The system on which the code has been evaluated is equipped with an i7 CPU running at up to 3. 5 GHz, the intel i7 CORE. The CUDA device is an NVIDIA GeForce GTX 850M running at 876 MHz with 4096 MB of GDDR5 device memory. The evaluation has been performed with CUDA version 7. 5 integrated with VisualStudio 2012. At the first execution of the estimation, memory allocations have to be performed. This is required only once and takes about 6ms.
These initial mappings are the input of the structural level matcher in order to deduce a new set of mappings. Ontology Matching Systems. We review some of the top relevant and mature matching systems, which had a significant success during the last years of the OAEI campaign. Our results will be compared with these matching systems on section 4. Agreement Maker Light (AML)  (Faria et al. , 2013)  is an automated large-scale ontology matching system focusing on the biomedical ontologies matching. AML translates the entities of the input ontologies into the same language. Then, AML employs several matchers such as a lexical matcher, an external background knowledge matcher, a structural matcher and an instance matcher. AML follows a sequential composition. The first matcher implemented by AML is the Lexicon Matcher, which searches for exact matching between the entities names of the two input ontologies.
We argue that comparing all the names of the two input ontologies is more efficient than comparing only the labels. For instance, our element level matcher achieved an F-Measure of 0. 830 using only the labels on the anatomy OAEI dataset. However, using all the names associated with the Anatomy entities, we succeeded to accomplish an F-Measure of 0. 862. Therefore, we are able to better capture the syntactic mappings between two ontologies and achieve better results. We employed similarity measures in order to compare pairwise names. The efficiency of a syntactic matcher is determined by the trade-off between its resulted F-measure value and its runtime. For example, a non-efficient syntactic matcher can produce a high F-measure in a very long time. The variety of syntactic similarity measures arises the difficulty of choosing the optimal one associated with its threshold.
Experimental Results Anatomy. The anatomy track is a matching task between the Adult Mouse Anatomy (2744 classes) and the NCI Thesaurus (3304 classes) describing the human anatomy. In terms of F-Measure, POMap is ranked in the fourth position among 14 matching systems while producing a competitive runtime of 43 seconds. We achieved an F-Measure of 0. 893 without using any external knowledge source unlike the other top performing matching systems (AML, LogMap and XMap). Table  1  illustrates the positioning of POMap (grey color) compared to the participated matching systems of OAEI 2016. Conference. This track consists of matching seven ontologies describing the conference organisation domain. Dealing with the conference dataset, we succeeded to achieve an F-Measure of 64%, which is an average score compared to the other matching systems.
Since this dataset includes the matching of   2  represents the obtained results for the FMA-NCI small fragment. We succeed to achieve an F-measure of 90%. Table  3  illustrates the results of POMap for the FMA-SNOMED small fragment in which we obtained an F-measure of 84% better than two matures matching systems. We draws in the table 4 the results of POMap in the SNOMED-NCI small fragment task in which we achieved an F-measure of 73%. All the resulted alignments by our system can be downloaded at https://goo. gl/gRYtQj. After performing the experimental process, we can notice that some matching systems (AML, LogMap, XMAP and Cromatcher) are performing better than POMap. We argue that these systems are outperforming POMap because of their implementation of a variety of matchers. However, POMap implements only three matchers: one syntactic matcher and two structural matchers.
CONCLUSION In this paper, we described POMap a novel matching system dedicated for the ontologies matching process. POMap is employing syntactic techniques in order to accomplish the element and structural level matching. After performing a series of experiments, we provided the top performing similarity measures and thresholds that can be employed by an element level matcher in the case of pre-processed ontologies. We have proposed two structural matchers, which perform the syntactic treatment over the siblings as well as the sub classes. These two structural matchers explore the initial mappings resulted by the element level matcher in order to improve the matching system results. As a future work, we plan to adapt our matching system in order to achieve a better run time over the larger datasets of the OAEI campaign.
Storing, sharing, managing taxonomic data is crucial for research and systematic outreach. In this context, Xper2 (Ung et al. 2010) and Xper3 (Vignes Lebbe et al. 2015)  are two platforms dedicated to taxonomic descriptions and computer-aided identification. These freeware provide a sleek and easy to use interface, and do not require computer skills. Xper2 is available on Windows, MacOS or Linux. Download the software on the website. Xper3 gives users the ability to work simultaneously and remotely on the same knowledge base. Create your own account on the online platform.
Program sensitivity, also known as Lipschitz continuity, describes how small changes in a program's input lead to bounded changes in the output. We propose an average notion of program sensitivity for probabilistic programs-expected sensitivity-that averages a distance function over a probabilistic coupling of two output distributions from two similar inputs. By varying the distance, expected sensitivity recovers useful notions of probabilistic function sensitivity, including stability of machine learning algorithms and convergence of Markov chains. Furthermore, expected sensitivity satisfies clean compositional properties and is amenable to formal verification. We develop a relational program logic called EpRHL for proving expected sensitivity properties. Our logic features two key ideas.
EpRHL: A Program Logic for Expected Sensitivity Bounds By leveraging these principles, we can bound expected sensitivity by compositionally building an expectation coupling between output distributions from pairs of nearby inputs. Concretely, we develop a relational program logic EpRHL to construct expectation couplings between pairs of programs. EpRHL judgments have the form {Φ; d} s 1 ∼ f s 2 {Ψ; d ′ }, where s 1 and s 2 are probabilistic imperative programs-often, the same program-the pre-and postconditions Φ, Ψ : M×M → B are relational assertions over pairs of memories, d, d ′ : M×M → R + are non-negative distances on memories, and f (z) = α • z + β is a non-negative affine function with α, β ≥ 0. EpRHL judgments state that for any pair of related input memories (m 1 , m 2 ) satisfying the pre-condition Φ, there exists an expectation coupling µ of the output distributions such that all pairs of output memories (m ′ 1 , m ′ 2 ) in the support of µ (i.
e. , with positive probability) satisfy the post-condition Ψ, and the expected distance is bounded: E (m ′ 1 ,m ′ 2 )∼µ [d ′ (m ′ 1 , m ′ 2 )] ≤ f (d(m 1 , m 2 )) = α • d(m 1 , m 2 ) + β. We call f a distance transformer, as it bounds the (average) post-distance d ′ in terms of the predistance d. When s 1 and s 2 are the same program s, for instance, a EpRHL judgment establishes an expected sensitivity bound for s. We give a rich Hoare-style proof system for EpRHL, internalizing various composition properties of expectation couplings. For instance, given two judgments {Φ; d} s 1 ∼ f s 2 {Ξ; d ′ } and {Ξ; d ′ } s ′ 1 ∼ f ′ s ′ 2 {Ψ; d ′′ }, the sequential composition rule in EpRHL yields {Φ; d} s 1 ; s ′ 1 ∼ f ′ •f s 2 ; s ′ 2 {Ψ; d ′′ }. Note that the pre-and post-conditions and the distances compose naturally, while the distance transformers combine smoothly by function composition.
Outline and Core Contributions After illustrating our approach on a simple example ( § 2) and reviewing mathematical preliminaries, we present the following contributions. • A novel abstraction called expectation couplings for reasoning about probabilistic sensitivity, supporting natural composition properties ( § 3). • A probabilistic relational program logic EpRHL for constructing expectation couplings, along with a proof of soundness ( § 4). Proving Expected Sensitivity of Probabilistic Programs 57:5 • A formal proof of uniform stability for two versions of the Stochastic Gradient Method, relying on proof rules to perform probabilistic case analysis ( § 5). • A formal proof of rapid mixing for a Markov chain simulating population evolution, relying on a proof rule internalizing the maximal coupling of two multinomial distributions ( § 6).
Programming Language We base our development on pWhile, a core language with deterministic assignments, probabilistic assignments, conditionals, and loops. The syntax of statements is defined by the grammar: s ::= x ← e | x $ ← д | s; s | skip | if e then s else s | while e do s where x, e, and д range over variables V, expressions E and distribution expressions D respectively. E is defined inductively from V and operators, while D consists of parametrized distributions-for instance, the uniform distribution [n] over the set {0,. , n -1} or the Bernoulli distribution Bern(p), where the numeric parameter p ∈ [0, 1] is the probability of returning true. We will write if e then s as shorthand for if e then s else skip. We implicitly assume that programs are well-typed skip m = δ m x $ ← д m = E v∼ д m [δ m[x v] ] x ← e m = δ m[x e m ] if e then s 1 else s 2 m = if e m then s 1 m else s 2 m s 1 ; s 2 m = E ξ ∼ s 1 m [ s 2 ξ ] while b do s m = lim n→∞ (if b then s) n |¬b m (Note that E is the monadic bind.
Proof System EpRHL is a Hoare-style logic augmented to consider two programs instead of one (a so-called relational program logic). EpRHL judgments are of the form {Φ; d} s 1 ∼ f s 2 {Ψ; d ′ } for programs s 1 , s 2 , assertions Φ, Ψ : M × M → B, distances d, d ′ : M × M → R + , and a non-negative affine function f ∈ A. We will refer to f as a distance transformer. Definition 4. 1. A judgment {Φ; d} s 1 ∼ f s 2 {Ψ; d ′ } is valid if for every memories m 1 , m 2 s. t. (m 1 , m 2 ) |= Φ, there exists µ such that s 1 m 1 ⟨µ⟩ Ψ d ′ ≤f (d(m 1 ,m 2 )) s 2 m 2 The notion of validity is closely tied to expected f -sensitivity. For instance, if the judgment {⊤; d} s ∼ f s {⊤; d ′ } is valid, then the program s interpreted as a function s : M → D(M) is expected f -sensitive with respect to distances d and d ′.
Given a memory m, variable x and expression e such that the types of x and e agree, we let m[x e] denote the unique memory m ′ such that m(y) = m ′ (y) if y x and m ′ (x) = e m. Then, given a variable x (resp. x ′ ), an expression e (resp. e ′ ), and an assertion Φ, we define the assertion Φ[x ◁ , x ′ ▷ e ◁ , e ′ ▷ ] by the clause Φ[x ◁ , x ′ ▷ e ◁ , e ′ ▷ ](m 1 , m 2 ) ≜ Φ(m 1 [x e], m 2 [x ′ e ′ ] ). Substitution of distances is defined similarly. One can also define one-sided substitutions, for instance Φ[x ◁ e ◁ ]. We now turn to the rules of the proof system in Fig. 2. The rules can be divided into two groups: two-sided rules relate programs with the same structure, while structural rules apply to two programs of any shape. The full logic EpRHL also features one-sided rules for relating a program with a fixed shape to a program of unknown shape; later we will show that many of these rules are derivable.
SGM with Non-Convex Loss When the loss function is non-convex, the previous proof no longer goes through. However, we can still verify the uniform stability bound by  Hardt et al. [2016]. Technically, they prove uniform stability by dividing the proof into two pieces. First they show that with sufficiently high probability, the algorithm does not select the differing example before a carefully chosen time t 0. In particular, with high probability the parameters w ◁ and w ▷ are equal up to iteration t 0. Then, they prove a uniform stability bound for SGM started at iteration t 0 , assuming w ◁ = w ▷ ; if the step size α t is taken to be rapidly decreasing, SGM will be already be contracting by iteration t 0. This proof can also be carried out in EpRHL, with some extensions. First, we split the SGM program into two loops: iterations before t 0 , and iterations after t 0.