dataesr/scientific-paragraphs-categorization huggingface dataset:
Acknowledgements We would particularly like to thank all the patients and control men who took part in all the studies involved in this work, as well as all the researchers, clinicians, technicians and administrative staff who have enabled this work to be carried out, and the collaborators in the PRACTICAL consortium. We wish to thank all GWAS study groups contributing to the meta-analysis data set from which these fine-mapping analyses were conducted:  BPC3  (Breast and  Prostate Cancer Cohort Consortium) ;  CAPS (Cancer of the Prostate in Sweden) ;  PEGASUS (Prostate Cancer Genome-wide Association Study of Uncommon Susceptibility Loci ); The  PRACTICAL (Prostate Cancer Association Group  to  Investigate Cancer-Associated Alterations  in the Genome) Consortium; and The  GAME-ON/ ELLIPSE Consortium.
Data availability. The meta-analysis summary data used in this fine-mapping project are available from the PRACTICAL Consortium (http://practical. icr. ac. uk/ blog/?page_id=8164) or GitHub (https://github. com/oncogenetics/LocusExplorer/ tree/master/Data/ProstateData). Results from the fine-mapping analyses may be explored interactively through Locus Explorer 71 (http://www. oncogenetics. icr. ac. uk/LocusExplorer/).
Second, using genotypes assayed with the Metabochip DNA arrays (Illumina) from about 4,500 individuals recruited in the French cohort D. E. S. I. R. (Data from an Epidemiological Study on the Insulin Resistance syndrome), we assess the feasibility of implementing the joint modelling approach in a real high-throughput genomic dataset. An alternative model approximating the joint model, called the Two-Step approach (TS), is also presented. Although the joint model shows more precise and less biased estimators than its alternative counterpart, the TS approach results in much reduced computational times, and could thus be used for testing millions of SNPs at the genome-wide scale.
INTRODUCTION With the increased availability of longitudinal and survival data in large cohorts, joint models have emerged as an appropriate approach to account for both types of data, especially when dealing with informative/non-informative dropouts which commonly occur in such cohorts. Joint models have been studied and overviewed in the literature  (Wulfsohn and Tsiatis, 1997; Tsiatis and Davidian, 2004; Chen et al. , 2011; Elashoff et al. , 2016) , and their implementation has been proposed in different softwares and platforms  (Diggle and Kenward, 1994; Sun et al. , 2007; Elashoff et al. , 2008; Proust-Lima et al. , 2009; Rizopoulos, 2010; Rizopoulos and Ghosh, 2011). Main applications of the joint model approach are: (i) to efficiently model the survival process with a time-varying covariate, accounting for missing data and measurement error; and (ii) to account for informative dropouts in the longitudinal data.
We also showed that, while highly demanding computation and convergence issues might arise during JM computation, TS offers a good alternative to JM in greatly reducing computational time, especially when applied at the genome-scale level. We also investigated and decomposed the computational time required by R package "JM"  (Rizopoulos, 2010 (Rizopoulos, , 2017)) , and by the TS approach which combines R packages "survival"  (Therneau, 2017)  and "nlme"  (Pinheiro et al. , 2017). Finally, we applied both approaches to a real dataset, the D. E. S. I. R. cohort (Data from the Epidemiological Study on the Insulin Resistance syndrome), which included 5,212 individuals with extensive phenotypic measurements recorded at four 3-yearly intervals, spanning a 9-year follow up. Individuals were genotyped using the Illumina Metabochip DNA array of nearly 200,000 SNPs  (Voight et al.
Simulations Simulations were carried out to further examine the sensitivity of the JM estimations under several scenarios. Parameters were set based on values estimated (Table  1 ) from the strongest SNPs associated with T2D from the literature, i. e. , rs17747324 in gene TCF7L2 (T2D risk allele: C; α = 0. 358; p = 8. 5 × 10 -55  (Morris et al. , 2012) ; FPG increasing allele: C; γ = 0. 025; p = 6. 5 × 10 -08  Dupuis et al. , 2010). Longitudinal data were simulated according to Equation (3), while event times were generated from an exponential distribution for the CoxPH model  (Austin, 2012) , with X i (t) as a linear function. λ 0 (t) = λ (5) H i (T i ) = T i 0 λ exp(βX i (t) + αZ i )dt (6) F i (T i ) = 1 -exp(-H i (T i )) = u (7) u ∼ U(0, 1) (8) T i = 1 βθ 1i log 1 - βθ 1i × log(1 -u) λ exp(βθ 0i + (βγ + α)Z i ) (9) where λ was set to achieve the targeted incidence rate in the simulated dataset.
Datasets were simulated by varying the number of longitudinal measurements m ∈ {2; 3; 4; 5}, the number of individuals n ∈ {500; 1, 000; 2, 500; 5, 000; 10, 000}, the allele frequency f ∈ {0. 05; 0. 1; 0. 25; 0. 5} and the incidence rate d ∈ {0. 025; 0. 05; 0. 1}, thereby leading to 240 different scenarios. Each scenario was simulated 500 times. The Root-Mean Square Error (RMSE) RMSE( φ) = E(( φ -φ) 2 ) ( 10 ) was used to assess precision of estimators φ = (β, γ , α), when testing the association between Y ij , and T i , the effect of Z i on Y ij and the effect of Z i on T i , respectively. In addition, statistical power and type I error were also estimated. The computational burden of each approach (JM and TS) was also investigated as our goal is to implement these approaches at a genome-wide scale.
Computational Times Based on our simulations, we calculated approximate computational times for four sample sizes with parameters as listed in Table  1 , using a UNIX system with Intel R Xeon R CPU E7-4870 @ 2. 40 GHz (80 such CPUs available computing in parallel). Table  2  shows computational times for one SNP, and for extrapolating the total computational time for 100,000 SNPs, which is the approximate number of SNPs on the Metabochip, after data cleaning and quality-control for common SNPs (minor allele frequency > 0. 05). To investigate further computational time issues, we profiled the execution of the main function "jointmodel" from the R package "JM, " which implements the joint likelihood modelling approach as described in this paper. In the "JM" package, the linear mixed effect sub-model is handled by the function "lme" from the "nlme" package.
Real Data SNP genotyping was performed with Metabochip DNA arrays  (Voight et al. , 2012)  using Illumina HiScan technology and GenomeStudio software (Illumina, San Diego, USA) in 5,212 individuals from the French cohort D. E. S. I. R. (Balkau, 1996). These participants have been followed for 9 years, and extensive phenotypic data has been recorded at four different 3-yearly time interval during that follow-up. All participants signed informed consent, and the protocol was approved by the ethics committee of Kremlin Bicetre Hospital, Paris. Quality control was performed using PLINK 1. 90 beta version  (Chang et al. , 2015; Purcell and Chang, 2015). SNPs with call rate of at least 95%, with no significant deviation from Hardy-Weinberg equilibrium at p > 1 × 10 -5 , and with minor allele frequency (MAF) over System time was computed ten times per sample size (number of individuals).
Extrapolation is displayed for 100,000 SNPs. 5% were kept for analysis, resulting in 101,305 SNPs. Due to missing phenotypes which did not allow to confirm T2D status, 232 individuals were removed. An additional 554 individuals were excluded due to individual call rate lower than 95%, leaving 4,426 individuals for analysis after these quality control steps (Figure  1 ). Principal component analysis was performed using a combined dataset comprised of the 4,426 D. E. S. I. R. participants, along with participants from the publicly available 1,000 Genomes database (The 1000 Genomes Project Consortium, 2015). SNPs retained for analysis were restricted to those common to both sample sets. The first two components were sufficient to discriminate ethnic origin, which led to exclusion of 62 non Caucasians.
A further 12 prevalent cases of T2D at baseline were also removed. As a result, the final dataset included 4,352 individuals, of whom 167 were diagnosed as T2D incident cases. Type 2 diabetes was defined using one of the following criteria: use of glucose lowering medication, and/or fasting plasma glucose [FPG] ≥ 7 mmol/L, and/or glycaeted haemoglobin A1c [HbA1c] ≥ 6. 5% (48 mmol/mol). Using the joint modelling approach implemented in the package "JM"  (Rizopoulos, 2010 (Rizopoulos, , 2017) )  within the R software version 3. 4. 2 (R Core Team, 2017), all 101,305 SNPs were tested for joint association with FPG and T2D. Following the above joint modelling formulation, Y ij denotes the observed values of FPG, Z i represents the genotype of individual i at each SNP, with W i being covariates such as age, sex and BMI (Figure  2 ).
Application in Real Data Applying the R package "JM" to our D. E. S. I. R. cleaned dataset, 265 SNPs (Figure  6 ) were associated (with p < 0. 05) with FPG and T2D events through their respective parameters γ and α. Amongst these 265 SNPs (163 unique genes), we identified 17 genes (Table  3 ) which had already been reported to be associated with FPG and/or T2D risk. Parameter β was highly significant (below the genome-wide threshold of 5×10 -8 ) for all these SNPs,   FIGURE 6 | Results from statistical analysis using "JM"  (Rizopoulos, 2010 (Rizopoulos, , 2017)) , using fasting plasma glucose increasing allele as effect allele. Estimated effects of γ are displayed on the x-axis, with corresponding estimated hazard ratio exp(α) on the y-axis. Statistical power reported is the theoretical (retrospective) power to detect a genetic joint effect βγ + α based on estimated model parameters  (Chen et al.
047 mmol/L (data not shown). Zooming in on simultaneous associations with the longitudinal and survival processes revealed well known genes, such as TCF7L2, which has been shown in many meta-analyses to be associated with elevated FPG and an increased risk of T2D (Table  4 ). MTNR1B was also found to be associated (34 SNPs within 30 kb) with estimated α = -0. 44 (p = 9. 37 × 10 -04 ) and γ = 0. 099 (p = 1. 33 × 10 -23 ) for SNP rs10830963, the SNP usually reported in the literature. To better compare JM and TS, we repeated the analysis on the whole dataset using TS. As shown in Figure  8 , p-values differ, especially when testing parameter α; however for tests on parameter γ , approximations were quite close to the p-values provided via the joint likelihood framework. Comparison is shown with effect sizes as reported by consortia meta-analyses in genes MTNR1B and TCF7L2.
However, depending on the parameters of the dataset (sample size, incidence rate, number of measures), a joint likelihood method always has to be preferred over TS when one wants to obtain accurate estimation of parameters γ and α, which describe the SNP effect on the trajectory of FPG and on the timeto-onset of T2D, resp. Although we computed the theoretical statistical power to detect a joint genetic effect βγ +α  (Chen et al. , 2011) , we did not test this effect at the genome-wide scale due to its computational burden. In this paper, we used the closed-form expression from  Chen et al. (2011)  to evaluate retrospectively the probability to obtain the same significant results in a similarly designed study to D. E. S. I. R. This closed-form expression could be use to design a new study (e.
Fuzzy Sets for Representing Imprecise Spatio-Temporal Beliefs Spatio-temporal data are often affected by imprecision and uncertainty  (Galton, 2009)  due to several reasons. Spatial uncertainty refers to positional accuracy (e. g. , location of an individual or a car). Temporal uncertainty states whether temporal information describes well a spatial phenomena. A fuzzy set, because of its ability to represent degrees of membership, is more suitable for modeling geographical entities. In a GIS database, real world objects can be represented by the degrees of membership to multiple classes or objects. Representing only the spatial or the temporal dimension is not sufficient to model and analyze such phenomena. Modeling change involves incorporating both dimensions simultaneously. In this work, we adopt a dual representation of dynamic spatial information proposed by Bordogna et al.
Implementation In agent-based systems with spatial reasoning and social behavior, a visual output is needed to display the agents' movements and interactions in two-or threedimensional spaces. NetLogo 1  is a multi-agent programming language and modeling environment for simulating natural and social phenomena particularly suited for modeling complex systems evolving over time. To implement our scenario, we decided to use NetLogo, as it also provides support for the BDI architecture and the FIPA Agent Communication Language. The spatial module is implemented using the Geographic Information Systems (GIS) extension for Netlogo 2. We used data about the road network and Electric Vehicle (EV) charging points from the Nice city open geographical database 3  in shapefile format (i. e. , the format supported by the GIS Netlogo extension).
Modeling turbulent transport is a major goal in order to predict confinement performance in a tokamak plasma. The gyrokinetic framework considers a computational domain in five dimensions to look at kinetic issues in a plasma; this leads to huge computational needs. Therefore, optimization of the code is an especially important aspect, especially since coprocessors and complex manycore architectures are foreseen as building blocks for Exascale systems. This project aims to evaluate the applicability of two auto-tuning approaches with the BOAST and StarPU tools on the gysela code in order to circumvent performance portability issues. A specific computation intensive kernel is considered in order to evaluate the benefit of these methods. StarPU enables to match the performance and even sometimes outperform the hand-optimized version of the code while leaving scheduling choices to an automated process.
The gysela code The gysela code is a non-linear 5D global gyrokinetic full-f code which performs flux-driven simulations of ion temperature gradient driven turbulence (ITG) in the electrostatic limit with adiabatic electrons. The five dimensions correspond to three dimensions in toroidal geometry (r, θ, ϕ) and 2D in velocity space (parallel velocity v and perpendicular velocity v ⊥ to the magnetic field). It solves the standard gyrokinetic equation for the full-f distribution function, i. e. no assumption on scale separation between equilibrium and perturbations is done. This 5D equation is self-consistently coupled to a 3D quasineutrality equation. The code also includes other features not described here (ion-ion collisions, several kind of heat sources). The code has the originality to be based on a semi-Lagrangian scheme  [16]  and it is parallelized using an hybrid OpenMP/MPI paradigm  [10, 13].
The StarPU task runtime StarPU  [1, 2]  is one of the runtime systems that supports the execution of task graphs. Its tasks are typed by "codelets" that can have multiple implementations with different performance characteristics or hardware targets (CPU, GPU, etc. ). This enables StarPU schedulers to use a performance model to select the best implementation of each task depending on the available execution resources. StarPU also features a data management layer that handles the memory buffers manipulated by tasks. It offers a software virtual shared memory which ensures data consistency when using accelerator with distinct address space and supports data-prefetch. This layer enables application developers to explicitly define data partitioning and which data pieces may be accessed by tasks during submission.
Implementation choices and evaluation In this section, we first present a straightforward StarPU implementation of the previously described splinebased advection DAG. This naive implementation leads to a rather inefficient execution and we therefore propose and implement several incremental optimizations. We evaluate each of these on two datasets and analyze their impact. We also implement and evaluate a task version of the Lagrange-based advection using the same set of optimizations. Performance evaluations are done on a node of the Poincare cluster (IDRIS, France). Each node contains 2 Intel Xeon E5-2670 (2. 60GHz) sockets with 8 cores each. Experiments have been done 20 times and the median is displayed with the minimum and maximum as error bar. The compiler used is Intel ICC 15. 0. 0 (the latest version available on the machine) with its native OpenMP runtime.
Figures  2  and 3  present the completion time of each version of the spline-based advection on a small (N r × N θ × N ϕ × N v = 64 × 129 × 32 × 16) and more realistic (N r × N θ × N ϕ × N v = 512 × 513 × 32 × 16) dataset respectively. The reference version has been directly extracted from gysela and rewritten as a standalone C++ code. Similar to the original code, the parallelization relies on the OpenMP fork-join paradigm and uses a single parallel for to iterate over (r, θ) plans of the buffers using 16 threads. The code is close to a C code and does not use C++ specific features except for arrays that are stored in a dedicated class implementing the parenthesis operator to make multidimensional array access close to the Fortran syntax. The performance of this version is comparable to the original gysela Fortran code.
The intermediate version uses the same OpenMP parallelization but changes the code structure compared to gysela to make introducing tasks easier. The code of this version has been "flattened". I. e. the original code had a deep call structure where each subroutine could contain loops, call other subroutines and provide multiple alternative implementations through conditionals. Instead, in this new version, the loops and conditionals have been moved to the outermost subroutine that thus mostly contains a single loop nest. At the heart of each loop, the computation is implemented by a call to another dedicated subroutine that does not make further function call (assuming that compilers are able to inline such functions). Transfer of information through global variables has also been removed and replaced by function parameters.
All in all, these changes make understanding the flow of information easier just by looking at the outermost function. Each function it calls corresponds to one task of Figure  1 , the parameters of these functions correspond to the inputs and outputs of the tasks and the loop nest exhibits the available parallelism. The performance of this version is similar to the reference on the small dataset but 22% faster on the realistic one because the simpler code flow is easier to optimize for the compiler. The task-base version builds on the intermediate version and replaces the OpenMP parallelization by calls to the StarPU API using 17 threads (1 "main" thread + 16 worker threads). This implementation is 80% slower than the intermediate version on the small dataset and 45% on the realistic one.
It is also 15% slower than the reference on the realistic dataset even if it includes the optimization contained in the intermediate version. This performance degradation is caused by many combined factors that we will handle step by step to understand their impact with each of the following versions. A first potential source of overhead is the large number of tasks submitted compared to their duration. Indeed each task submission and its scheduling has a cost and if this is not hidden by the task execution cost, the overhead can become important. In addition, having distinct tasks that work on the same data but can be executed on distinct cores can lead to bad cache behavior. The task-merged version thus merges all the tasks computing the velocity that read same constant data. This works well on the small dataset where it improves performance by 15% over the task-base version but not on the realistic dataset where it is 3% slower.
Indeed, for this dataset, the duration of each task is higher and reducing the number of task limits the choice available to the scheduler with only a limited impact on submission overhead. Another potential source of overhead comes from the management of StarPU "temporary" buffers that are allocated and freed before and after each use. The scratch version thus replaces temporary buffers by "scratch" buffers that are allocated only once by thread for the whole duration of the DAG execution when possible (i. e. when the buffer is not transmitted between tasks). This significantly improves the performance with a 10% gain on the small dataset and 24% on the realistic one compared to the task-merged version. As a result, this version is still 42% slower than the reference on the small dataset, but already 10% faster on the realistic one.
The intermediate version does however remain faster even on the later case. The merge of tasks in the task-merge optimization makes it possible to go further with the reduction of temporary buffers; not in term of size, but in term on number. Indeed, since each group of four tasks are merged into one task, the four output buffers required by the four tasks can be merged together to a unique output buffer per merged task. The data-merge version thus aggregates the four buffers produced by the fields tasks into a single one and reduces by four the amount of allocated temporary data. This improves performance by 21% on the small dataset and by 12% on the realistic one over the scratch version. On the small dataset, this is still 12% slower than the reference and intermediate versions, but on the realistic one, this is comparable to the intermediate version, i.
e. 28% faster than the reference. A last potential source of overhead we have studied is the contention between application threads and workers for the access to the DAG representation. The paused version tries to solve this by stopping the workers during task submission. This optimization works well on the small dataset where many small tasks that imply lots of access to the DAG are submitted. The performance is improved by 10% over the data-merge version to reach the same performance as the reference. On the realistic dataset however, it has no noticeable impact. As one can see on Figures  2  and 3 , reducing the amount of StarPU temporary buffers (change from task-merge to data-merge) has a large impact on performance. On the realistic dataset, this is even the only optimization required to go from the worst case to the best one.
When this thread is overloaded, it becomes appropriate to use 15 workers threads rather than 16. However, the impact of the submission thread is negligible in this kernel. Finally, in order to validate this optimization approach, we have applied the exact same process for the Lagrange variant of the 2D advection: tasks and temporary buffers have been merged, scratch data are used and the workers are stopped during task submission. The granularity used on this variant is still (r, θ) 2D planes. Even though the submitted task graph differs (only the left part remains: the fields tasks), it is still compliant with Algorithm 1. Figure  5  presents the execution time for the OpenMP reference and the fully optimized task version on a realistic dataset (N r × N θ × N ϕ × N v = 512 × 513 × 32 × 16) using 16+1 threads.
This has been done using scratch data and by adapting the temporary data granularity. Moreover, task granularity should also be carefully chosen since it is closely related with the number of temporary data. Indeed, splitting a task in two or more involves the use of temporary data to assure information sharing between the tasks. Finally, it can sometimes be relevant to stop the workers during the task submission. One must however notice that the best optimizations strongly depend on the dataset size. This is because tasks operate on a too small granularity for small datasets, which make some overheads noticeable that would not be apparent otherwise. It is really important to adapt the optimizations process and task granularity to realistic data sizes to reach good performance in production.