dataesr/scientific-paragraphs-categorization huggingface dataset:
Information retrieval systems first retrieve a broad set of candidate answers by querying the search API of KBs with a transformation of the question into a valid query and then use fine-grained detection heuristics to identify the exact answer  [8, 12, 14]. On the other hand, semantic parsing methods focus on the correct interpretation of the meaning of a question by a semantic parsing system. A correct interpretation converts a question into the exact database query that returns the correct answer. Interestingly, recent works  [1, 9, 2, 7]  have shown that such systems can be efficiently trained under indirect and imperfect supervision and hence scale to large-scale regimes, while bypassing most of the annotation costs. Yet, even if both kinds of system have shown the ability to handle largescale KBs, they still require experts to hand-craft lexicons, grammars, and KB schema to be effective.
This non-negligible human intervention might not be generic enough to conveniently scale up to new databases with other schema, broader vocabularies or languages other than English. In contrast,  [6]  proposed a framework for open QA requiring almost no human annotation. Despite being an interesting approach, this method is outperformed by other competing methods. [5]  introduced an embedding model, which learns low-dimensional vector representations of words and symbols (such as KBs constituents) and can be trained with even less supervision than the system of  [6]  while being able to achieve better prediction performance. However, this approach is only compared with  [6]  which operates in a simplified setting and has not been applied in more realistic conditions nor evaluated against the best performing methods.
Task Definition Our main motivation is to provide a system for open QA able to be trained as long as it has access to: (1) a training set of questions paired with answers and (2) a KB providing a structure among answers. We suppose that all potential answers are entities in the KB and that questions are sequences of words that include one identified KB entity. When this entity is not given, plain string matching is used to perform entity resolution. Smarter methods could be used but this is not our focus. We use WebQuestions  [1]  as our evaluation bemchmark. Since it contains few training samples, it is impossible to learn on it alone, and this section describes the various data sources that were used for training. These are similar to those used in  [2]. WebQuestions This dataset is built using Freebase as the KB and contains 5,810 question-answer pairs.
It was created by crawling questions through the Google Suggest API, and then obtaining answers using Amazon Mechanical Turk. We used the original split  (3, 778  examples for training and 2,032 for testing), and isolated 1k questions from the training set for validation. We-bQuestions is built on Freebase since all answers are defined as Freebase entities. In each question, we identified one Freebase entity using string matching between words of the question and entity names in Freebase. When the same string matches multiple entities, only the entity appearing in most triples, i. e. the most popular in Freebase, was kept. Example questions (answers) in the dataset include "Where did Edgar Allan Poe died?" (baltimore) or "What degrees did Barack Obama get?" (bachelor of arts, juris doctor).
Freebase Freebase  [3]  is a huge and freely available database of general facts; data is organized as triplets (subject, type1. type2. predicate, object), where two entities subject and object (identified by mids) are connected by the relation type type1. type2. predicate. We used a subset, created by only keeping triples where one of the entities was appearing in either the WebQuestions training/validation set or in ClueWeb extractions. We also removed all entities appearing less than 5 times and finally obtained a Freebase set containing 14M triples made of 2. 2M entities and 7k relation types. 1  Since the format of triples does not correspond to any structure one could find in language, we decided to transform them into automatically generated questions. Hence, all triples were converted into questions "What is the predicate of the type2 subject?" (using the mid of the subject) with the answer being object.
WebQuestions ClueWeb Extractions Freebase data allows to train our model on 14M questions but these have a fixed lexicon and vocabulary, which is not realistic. Following  [1] , we also created questions using ClueWeb extractions provided by  [10]. Using string matching, we ended up with 2M extractions structured as (subject, "text string", object) with both subject and object linked to Freebase. We also converted these triples into questions by using simple patterns and Freebase types. An example of generated question is "Where barack obama was allegedly bear in?" (hawaii). Paraphrases The automatically generated questions that are useful to connect Freebase triples and natural language, do not provide a satisfactory modeling of natural language because of their semi-automatic wording and rigid syntax.
Multitask Training of Embeddings Since a large number of questions in our training datasets are synthetically generated, they do not adequately cover the range of syntax used in natural language. Hence, we also multi-task the training of our model with the task of paraphrase prediction. We do so by alternating the training of S with that of a scoring function S prp (q 1 , q 2 ) = f (q 1 ) f (q 2 ), which uses the same embedding matrix W and makes the embeddings of a pair of questions (q 1 , q 2 ) similar to each other if they are paraphrases (i. e. if they belong to the same paraphrase cluster), and make them different otherwise. Training S prp is similar to that of S except that negative samples are obtained by sampling a question from another paraphrase cluster. We also multitask the training of the embeddings with the mapping of the mids of Freebase entities to the actual words of their names, so that the model learns that the embedding of the mid of an entity should be similar to the embedding of the word(s) that compose its name(s).
Several software efforts have been produced over the past few years in various programming languages to help developers handle pseudorandom streams partitioning. Parallel and Distributed Stochastic Simulations (PDSS) can obviously benefit from this kind of high-level tools. The latest release of the Java Development Kit (JDK 7) tries to tackle this problem by providing facilities to partition a pseudorandom stream across various threads thanks to the new class ThreadLocalRandom. Meanwhile, Java 7 offers a framework to split a problem in a divide and conquer way through the new class called ForkJoinPool. As any other Java Thread Pool, ForkJoin exploits threads as workers and manipulates the tasks that will be run on the workers. In Thread-LocalRandom, pseudorandom number generation is handled at a thread level.
This change is confusing in two ways. Not only does it break encapsulation, one of the elementary concepts of the object-oriented paradigm, but it also appears as a lack of good software engineering. It is indeed not recommended to adapt an implementation according to an already existing source code. Instead, it is safer to rely on the specification only. In our case, the Random class documentation issued by Oracle makes no mention of a potential call to the setSeed method by the Random constructor. As a consequence, we cannot blame Oracle for this bug, but rather advise developers to focus on the official documentation only, especially when they are working on such sensitive aspects of the implementation. Another weakness in the implementation of ThreadLocalRandom lies in the impossibility to reproduce the same pseudorandom sequences throughout several runs of the application by default.
Scientific applications such as stochastic simulations need to ensure reproducibility between executions for their results to be checked or for debug purposes. When ThreadLocalRandom is used by default, it does not satisfy this need because it relies on the Random constructor to set its internal seed, which behaviour is to use the current system time as seed. This could be interesting for games but not for a scientific software. This problem can be fixed by basing the initial seed on a unique identifier for each thread, so that for a given identifier, a thread will always be assigned the same stochastic stream. Still, although Java provides a thread identifier at runtime through the Thread. currentThread(). getId() call, this identifier is not reliable since it is global for the whole JVM and thus depends on how many threads were created before the one considered.
TestU01 currently offers the most complete collection of utilities for the empirical statistical testing of uniform random number generators. Please note that this enumeration does not take into account testing suites focusing on cryptographic applications. In this category the leading tool is instead the NIST STS proposal  [Rukhin et al. , 2001] , although TestU01 also owns tests targeting cryptographic generators. In addition to the classical statistical tests for PRNGs, and the other tests previously cited and proposed in the literature, TestU01 proposes new original tests as well as predefined tests suites (SmallCrush, Crush and BigCrush with more than a hundred tests). Many of the most spread PRNGs fail significantly when faced with this software. The underlying PRNG of ThreadLocalRandom, is a well-known and widely studied LCG from Knuth  [Knuth, 1969]  (it also rules the output of the POSIX drand48 C function for example), is among the algorithms at fault.
Furthermore, JAPARA allows the user to save and restore the current state of a PRNG, thus permitting to checkpoint a simulation. After having first proposed a random number package with splitting facilities [L'  Ecuyer and Côté, 1991] , L'Ecuyer's team proposed an object-oriented pseudorandom generation package in 2002 with [L'  Ecuyer et al. , 2002b]. This was achieved in [L'  Ecuyer et al. , 2002b ] that proposes a C++ implementation of the MRG32k3a PRNG, which independent streams are partitioned from an original stream thanks to the Sequence Splitting technique  [Hill et al. , 2013]. A Java declination comes with the SSJ (Stochastic Simulation in Java) [L'  Ecuyer et al. , 2002a]  framework and its RandomStream interface, the pseudorandom streams parallelization utility of the library. It provides a greater set of PRNGs (including the famous Mersenne Twister  [Matsumoto and Nishimura, 1998 ] for instance), and a compliant set of distribution techniques.
The latest Java random number generation framework that has retained our attention is DistRNG  [Reuillon et al. , 2011 , Reuillon, 2008]. While its API does not diverge from the two other proposals described in this section, DistRNG focuses on correct partition of random streams. To do so, this framework handles XML generic statuses that model any PRNG state. Every computational element is initialized with a different XML status that needs to be built upstream. DistRNG displays a fine choice of statistically sound PRNGs according to the TestU01 reference testing library. Now considering other languages, SPRNG  [Mascagni and Srinivasan, 2000 ] is one of the most widely used libraries in C++ to automatically distribute pseudorandom streams across MPI  [MPI Forum, 1993]  processes. While this framework achieves the same result than ThreadLocalRandom for MPI processes, it takes advantage of the MPI rank (MPI term for process identifier) assigned to processes by MPI, whereas we cannot rely on such a mechanism in Java.
The Challenge of Uniquely Identifying Tasks The main struggle at the heart of TaskLocalRandom is to provide a unique task identifier, which the Java language does not support at the time of writing. As explained previously, ThreadLocalRandom benefits of the ThreadLocal mechanism from the Java SDK. ThreadLocal relies on JNI (Java Native Interface) calls, which means its implementation is directly tied to the underlying Operating System (OS) that supports the JVM. Each OS deals with threads on its own way, using native APIs. However, these native APIs do not provide a common concept of threads. It seems consequently difficult to implement a mechanism equivalent to ThreadLocal at a task level. Two approaches can be considered to avoid this lack: either each task can autonomously distinguish itself from the others using a particular algorithm, or a central element in the system needs to uniquely identify each task.
Implementation Details We have designed TaskLocalRandom for it to be used as an alternative to ThreadLocalRandom. It displays the very same interface as its counterpart. The methods contained in our class can produce two kinds of random outputs: double precision floating point values and integers. These are the two kinds of data types that are handled by the original MRG32k3a implementation described in [L'  Ecuyer et al. , 2002b]. Double precision numbers are natively produced by the algorithm, which manipulates 64-bit floating point values at its heart in order to take advantage of hardware-implemented operations on modern CPUs. In contrast with ThreadLocalRandom, TaskLocalRandom does not inherit from java. util. Random, which contains superfluous methods directly bound to the underlying LCG of this class.
TinyMT TinyMT is the latest offspring from the Mersenne Twister family. TinyMT is not described in any scientific article yet, but information about it can be found on its dedicated webpage  [Saito, 2011]. This PRNG matches the requirements we have formulated for a PRNG to be integrated in TaskLocalRandom: it is stated as producing a good quality output, according to TestU01 statistical tests, and displays a long-enough period of 2 127 numbers. As explained in the introduction of this section, this PRNG champions parameterization to provide highly independent streams. It is shipped with an adapted version of the Dynamic Creator (DC) software tool  [Matsumoto and Nishimura, 2000 ] that can create more than 2 32 × 2 16 highly independent statuses. As always with Mersenne-Twister-like PRNGs, this algorithm is based upon linear recurrences.
of MCQTl parameters and thus boost the QTl discovery. We developed clusthaplo, an r package (http://cran. rproject. org/web/packages/clusthaplo/index. html), which aims to cluster haplotypes using a genomic similarity that reflects the probability of sharing the same ancestral allele. Computed in a sliding window along the genome and followed by a clustering method, the genomic similarity allows the local clustering of the parent haplotypes. Our assumption is that the haplotypes belonging to the same class transmit the same ancestral allele. So their putative QTl allelic effects can be modeled with the same parameter, leading to a parsimonious model, that is plugged in MCQTl. Intensive simulations using three maize data sets showed the significant gain in power and in accuracy of the QTl mapping with the ancestral allele model compared to the classical MCQTl model.
To achieve this goal, we developed clusthaplo, an r package (r Development Core Team 2008), that permits to group the parent lines of multi-cross designs using a genomic similarity that reflects the probability of sharing the same ancestral allele. Computed using a sliding window along the genome and followed by a classical method of clustering, the genomic similarity allows the local clustering of the parents. Our assumption is that the parents belonging to the same class transmit the same ancestral allele. So their putative QTl allelic effects can be modeled with the same parameter, leading to a parsimonious model that should be powerful and accurate. We also extended MCQTl  (Jourjon et al. 2005) , a stand-alone Java and C++ software application that runs on linux operating system, to allow it to be fed by clusthaplo outputs.
The model is presented as a purely additive QTl model but a more complex model involving dominance is implemented in MCQTl. Clusthaplo is an r package (r Development Core Team 2008). It is designed to perform clustering of haplotypes that ought to share a ancestor. It is based on a pairwise similarity measure computed for every pair of haplotypes using a sliding window along the genome. For the markers inside a window, we build a weighted graph having the haplotypes as nodes and the pairwise haplotype similarities as edge weights. Then, the haplotype clustering for the position at the center of the window is obtained by building the transitive closure of the filtered graph. We propose two different methods for the graph filtering step. One is based on Hidden Markov model (HMM) and the second on computing a threshold by simulations.
This was confirmed by 91. 2 clustering changes in average over the parameter cases studied in Table  1  (limited to a window length of 20 cM and for the extended score) compared to 143. 4 for the equilibrium clustering method. Adding that the HMM method is much faster to compute, it should be the chosen clustering method for its stability. However, we do not chose it as the default method to limit the dependency of our package to another r package since we used the rHmm package (http://www. r-project. org, http://r-forge. rproject. org/projects/rhmm/) to estimate the HMM models and to cluster the haplotypes. The second reason is that rHmm has huge difficulty to estimate the HMM models when the window length is small since the similarity score fluctuates too much and thus is far from a HMM signal in that cases.
(2013). MCQTl_lD offers a QTl model featuring a versatility that is not found in other application softwares. The marker regression model, implemented in MCQTl_lD, has the general properties of linear model, which include the robustness to non linear residuals and it was proved to be asymptotically equivalent to the QTl mixture model  (rebai et al. 1995). This model benefits of the robust method of permutation tests (Doerge and Churchill 1996). Finally, dominance parameters and epistasis QTls can be included in the model. These interactions QTl effects are already implemented in MCQTl and can be analyzed more precisely in MCQTl_lD thanks to the clusthaplo plug-in.
Conclusion MCQTl_lD and clusthaplo are unique software tools that permits to analyze multiple related families to detect and localize QTl. They implement a QTl mapping method that makes use of both linkage and linkage disequilibrium. The linkage disequilibrium is taking into account by clusthaplo that clusters the family parents and assigns to each of them at each position along the genome a probable ancestral allele. MCQTl_lD uses these probable ancestral alleles to lessen the number of its model parameters. Clusthaplo uses a pairwise similarity measure computed in a sliding window along the genome to cluster the parent haplotypes. This measure reflects the alike-in-state status of alleles and the length of the longest common segment. We have implemented different options to compute this similarity measure.
Non-thermal ionization and excitation are also critical since they affect the color evolution and the ∆M 15 decline rate of our model. While impacting little the bolometric luminosity, a more complete treatment of decay routes leads to enhanced line blanketing, e. g. , associated with 48 Ti in the U and B bands. Overall, we find that SN Ia radiation properties are influenced in a complicated way by the atomic data we employ, so that obtaining converged results is a real challenge. Nonetheless, with our fully-fledged CMFGEN model, we obtain good agreement with the golden standard type Ia SN 2005cf in the optical and near-IR, from 5 to 60 d after explosion, suggesting that assuming spherical symmetry is not detrimental to SN Ia radiativetransfer modeling at these times. Multi-D effects no doubt matter, but they are perhaps less important than accurately treating the non-LTE processes that are crucial to obtain reliable temperature and ionization structures.
There are a number of approaches for doing the radiative transfer of SNe Ia more accurately. One approach is to treat the photospheric layers exclusively and assume steady state. Radiation transport is undertaken using the Monte Carlo technique (e. g. ,  Mazzali & Lucy 1993)  or by solving the transfer equation (e. g. Nugent et al. 1995; Pauldrach et al. 1996; Baron et al. 1996; Blondin et al. 2006; Branch et al. 2006; Pauldrach et al. 2013). The advantages of this approach are computational speed, and the ease with which model parameters and abundances can be altered to fit models to observations. The drawback is that model adjustments may be used erroneously to overcome missing physics (either in the atomic data or in the model). One major disadvantage of the method is that the infrared spectral range is optically thin even before the B-band maximum, and the concept of a well defined photosphere becomes meaningless.
This suggests that while multi-dimensionality may play a role, it is not paramount for the radiative transfer solution. Far more important is to treat explicitly non-LTE, line blanketing, non-thermal processes, and to include all relevant radiative and collisional processes. Although generally neglected, forbidden line transitions are found to play an essential role in controlling the ejecta ionization and temperature as early as the peak of the light curve. Following these fruitful benchmarking and educational explorations, we are now in a position to investigate the physics of SN Ia explosions and search for clues about the progenitor systems. comments regarding the two emission features near 1. 7µm. LD and SB acknowledge financial support from the European Community through an International Re-integration Grant, under grant number PIRG04-GA-2008-239184, and from "Agence Nationale de la Recherche" grant ANR-2011-Blanc-SIMI-5-6-007-01.
DJH acknowledges support from STScI theory grant HST-AR-12640. 01, and NASA theory grant NNX10AC80G. This work was also supported in part by the National Science Foundation under Grant No. PHYS-1066293 and benefited from the hospitality of the Aspen Center for Physics. AK acknowledges the NSF support through the NSF grants AST-0709181 and TG-AST090074. This work was granted access to the HPC resources of CINES under the allocation c2013046608 made by GENCI (Grand Equipement National de Calcul Intensif).
(1988) , and for the carbon isoelectronic sequence from  Luo & Pradhan (1989). Collision strengths for Ar II are from  Tayal & Henry (1996). The LS Ne I photoionization cross-sections were modified according to  Seaton (1998). The same procedure was applied to using Ar I mixing coefficients computed at http://aphysics2. lanl. gov/tempweb/lanl. Additional data for Ne I was obtained from the MCHF/MCDHF web site: http://nlte. nist. gov/MCHF. For the modelling of SNe Ia, the main issues concern the Cobalt atomic data, and in particular Co II and Co III. For these, accurate photo-ionization cross sections and collisional rates are needed to improve the accuracy of the radiation transfer modelling. Table  A1. Summary of the model atom A0, refered to as "Small" in Table  1. The source of the atomic datasets is given in  Dessart & Hillier (2010)  and in Section A.
First simulation results with a classical AO system (D = 16 m) In order to validate some of the items discussed in sections 3 and 4, we have implemented the three previous control laws (based on the KF, the ETKF and the Local ETKF) under the OOMAO Matlab environment  [39]  and we have also developed our OpenMP parallelized version. For this Single Conjugate AO (SCAO) system simulation, we consider a 16 m diameter telescope (without central obscuration) with a 32×32 microlenses S-H WFS. Only the subapertures with a surface enlightened more than 50 % are considered and the number of valid subapertures is 812 that means p = 1624. The linear response of the S-H WFS is emulated by a matrix which calculates differences of the phase in two directions at the edges of each subaperture  [18, 28]. The AO system works in a closed-loop at 500 Hz.