dataesr/scientific-paragraphs-categorization huggingface dataset:
Additional baseline covariates collected at the start of the study are also included, including performance status (0/1/2), lung metastatic site (Y/N), previous adjuvant radiotherapy (Y/N), previous surgery (no surgery/curative/palliative), and metastases (metachronous/synchronous). The first analysis of this dataset  (Tournigand et al. , 2004)  did not find any significant difference between the two treatment strategies using classic survival analysis methods (i. e. , log-rank tests). A trivariate joint model has been applied to this study for the simultaneous analysis of the longitudinal SLD, recurrent events (progres- sion of lesions not included in the SLD or new lesions), and the terminal event  (Król et al. , 2018). A flexible mechanistic model using an ordinary differential equation was proposed to fit the biomarker dynamics.
85, SD = 0. 39). This effect of treatment indicates that treatment arm B may be associated with a stronger reduction of the log SLD in early follow-up followed by a higher increase of the log SLD in the late follow-up compared to treatment arm A. This difference among positive values does not translate into a significant difference in the marginal evolution of the log SLD (i. e. , including both zeros and positives), suggesting that models mixing zeros and positive (e. g. , Tobit model) may miss this effect. Figure  S2  in the Supporting Information displays observed vs. fitted longitudinal trajectory of the log SLD for five patients representative of the dataset, illustrating the good fit of the model. These fitted trajectories are only displayed with INLA since the linear predictors for each observation are directly available as part of the model's output, while frailtypack does not provide such information.
Description The Panitumumab Randomized Trial in Combination with Chemotherapy for Metastatic Colorectal Cancer to Determine Efficacy (PRIME) study is a more challenging application for fitting the TPJM because it includes information about the KRAS mutation status (exon 2 codons 12/13), which has been shown to impact the clinical response to treatment in metastatic colorectal cancer patients  (Van Cutsem et al. , 2008; Normanno et al. , 2009; Bokemeyer et al. , 2008). It is, therefore, an important risk modifier, and clinicians are interested to assess treatment by mutation interaction in order to tailor treatment to patients' genetic risk  (Marabelle et al. , 2020). This dataset is freely available on ProjectDataSphere. org (PDS UID: Colorec_Amgen_2006_309). The PRIME study is a randomized clinical trial that compares the efficacy and safety of panitumumab (anti-EGFR) in combination with FOLFOX4 (chemotherapy) with those of FOLFOX4 alone in the first-line treatment of patients, according to KRAS exon 2 status (wild type or mutant type).
Between August 2006 and February 2008, 1183 patients were randomly assigned to receive treatment arm A (FOLFOX4 alone) or treatment arm B (panitumumab + FOLFOX4). The data for analysis include a subset of 442 patients (i. e. , 741 excluded from the publicly available dataset). There are 2372 repeated measurements of the SLD, 99 of which are zero values (4%). The small rate of zero measurements in the SLD distribution leads to large variability in the binary part; however, zeros correspond to patients with a complete shrinkage of their target lesions, which is a very relevant information for clinicians about treatment effect. The number of individual repeated measurements for this biomarker varies between 1 and 24 with a median of 5. The death rate is 74%, corresponding to 328 deaths. Summary statistics of the dataset are given in Table  1.
Similarly to the GERCOR study, we can compare the top 15% patients with the smallest SLD at baseline to the average patient, their risk of death is reduced by 39% (HR = 0. 61, CI = 0. 51-0. 75). In conclusion, we did not find a direct effect of treatment B versus A on the risk of death while the initial study  (Douillard et al. , 2013)  finds a slightly significant improvement in overall survival for patients with wild-type KRAS status (HR = 0. 78, CI = 0. 62-0. 99), likely because of the reduced sample size available for our analysis (publicly available dataset only includes 37% of the original set of patients). Interestingly, the analysis of the continuous part of the TPJM suggests that the reduction of the SLD over time conditional on a positive value is attenuated with treatment B compared to treatment A for patients with wild-type KRAS status.
DISCUSSION In this article, we developed a Bayesian estimation approach based on the INLA algorithm for TPJMs for a longitudinal semicontinuous biomarker and a terminal event. We also provided a comparison with a frequentist alternative approach implemented into the frailtypack package, using small sample sizes as seen in cancer clinical trial evaluation. The frequentist estimation faced some limitations when fitting complex joint models with a high number of random effects and much increased computation time compared to INLA. The Bayesian estimation proposed in the R package INLA has been recently introduced to fit complex joint models (Van Niekerk, Bakka, Rue, & Schenk, 2021) but, to our knowledge, has never been proposed for TPJMs. Accounting for the semicontinuous nature of the biomarker, that is, the SLD, and being able to fit joint models with more complex association structures between the biomarker and the terminal event, can be quite relevant in clinical applications by providing critical insights into the direct and indirect effect of a treatment on the event of interest.
Description of the GERCOR and PRIME study datasets. Study GERCOR PRIME treatment Arm A Arm B Arm A Arm B FOLFIRI/FOLFOX6 FOLFOX6/FOLFIRI FOLFOX4 Panitumumab/FOLFOX4 Number of patients enrolled 109 111 593 590 Number of patients for the analysis 101 104 223 219 number of repeated measurements of the SLD 748 727 1192 1081 Number of zero values (%) 118 (16. 2%) 56 (7. 5%) 47 (3. 8%) 52 (4. 6%) Number of death (%) 83 (82. 2%) 82 (78. 8%) 164 (73. 5%) 164 (74. 9%) Median OS (years) 1. 8 (1. 4-2. 3) 1. 8 (1. 5-2. 2) 1. 7 (1. 5-1. 9) 1. 4 (1. 3-1. 7) KRAS exon 2 at codons 12 and 13 Nonmutated 132 (59. 2%) 128 (58. 4%) Mutated 91 (40. 8%) 91 (41. 6%) Not available 101 (100%) 104 (100%) TA B L E 1in frailtypack. R codes including data simulation and model estimation with frailtypack and INLA assuming a conditional TPJM are available at github.
INTRODUCTION Hardware/Software co-simulation is a technology that is very useful during the design, implementation and even actual use of processor centric systems. It can be implemented in many different ways  [14, 22] , as does the simulator responsible for the execution of the software parts of the system. For this latter task, Dynamic Binary Translation (DBT) has proven to be very efficient and scalable. Its simulation strategy is based on the following consideration: a sequence of non-branch instructions ended by a branch can be executed atomically. Therefore, by translating a sequence once and reusing it for its many executions, the translation time is amortized, and the speed of simulation dictated mainly by the speed of execution of the translated code. When it comes to evaluating performances, DBT is challenging.
RELATED WORKS A recent survey on cache simulators is available in  [6]. As explained in this necessarily non-exhaustive survey, about 30 years ago cache simulators were mainly studied for research purposes and were the alternative for when the corresponding hardware was not available. The tool representative of this period is Dinero, whose version IV  [10]  is the latest. Nowadays, these simulators are also used to help optimize software stacks, including parallel ones. Instrumentation is in important mechanism to analyse software but it can be challenging to implement. This topic has been addressed by  [17, 18]  that achieve good performance. The Dynamic Binary Instrumentation framework Valgrind  [21]  proposes a more complete instrumentation for heavyweight Dynamic Binary Analysis. With the module Cachegrind, the analysis tool Valgrind is able to simulate classical cache hierarchies  [25].
Error in Counting Instructions and How to Mitigate it Unfortunately, the occurrence of exceptions is like a grain of sand seizing up this well oiled mechanism. When we enter a Tb, we make the assumption that all instructions it contains will be executed atomically, and therefore run our model on all addresses that might miss it contains. Alas, when an exception occurs, what is left of the Tb beyond the faulty instruction is not executed, and control is handed over to the simulation environment to fetch the instructions of the exception handler. Then on return from the handler, since the pc of the instruction that was following the access was not known, what was left of the Tb is retranslated into a new smaller Tb, and accounted for by our model. Figure  3  illustrates this with actual page-faults taking place during Linux boot, once the kernel page table has been set-up.
Dependency on Simulator Runtime Another, deeply annoying, unexpected behavior is the dependencies of the flow of executed target instructions on the time it takes to perform cache simulation for programs running on top of Linux 2. We discovered this seemingly odd behavior while testing several cache implementations: to our amazement, the faster the simulator, the lower the number of executed instructions for a given program. To the best of our knowledge, that effect has not yet been reported in the literature. This makes the evaluations obtained in previous works (we specifically refer here to the ones using QEMU, but we see no reason why similar tools would behave differently), e. g. [12, 16, 24] , questionable, although no wrong per se, since the executed instructions produce a valid behavior.
We investigated to understand the reasons behind this behavior, and we discovered they are due to repeated occurrences of timer interrupts because the simulator uses the host real-time clock (obtained, e. g. using rdtsc on x86 hosts) to trigger alarms. In this situation, the timer interruption is raised when a given wallclock Δ has elapsed, which finally ends up calling the target Linux update_cfs_group scheduling function over and over. To exemplify the behavior, we have added in the cache model a delay using a for loop iterating  times, which leads to the results given Figure  4. This can be mitigated by forcing QEMU to use a clock of its own 3 in which case only 1830 irqs are raised, for any added delay. However, in that case it cannot run vCPUs in parallel, which greatly hinders performance.
IMPLEMENTATION 5. 1 QEMU TCG Plugins The Tiny Code Generator (TCG) plugin is a feature introduced in QEMU version 4. 2  [9]. It provides an API to write plugins in order to facilitate code instrumentation. Information is given through the plugin API at translation and execution times. It can be retrieved each time a block is translated or/and executed, or for every instruction and memory access that is executed. By instrumenting all instructions and memory accesses executed by the target through the TCG plugins, we have access to all the information we need to simulate a cache. Figure  5  shows the simplified plugin mechanism of QEMU's TCG. First, we have to indicate to which events proposed by the TCG plugin API we want to subscribe. It can be an instruction or a memory access execution or a translation block translation/execution.
Then, during QEMU execution, each time the event occurs the main loop will send information to the plugin thanks to callback functions. Finally, inside the plugin, we can add our own code to do what we want. For this work, we do not consider the data-cache and solely focus on the instruction cache. TCG plugins are independent from the simulated architecture and thus can be used with all the different targets QEMU supports. In our case, we decided to work only with RISC-V but the approach we propose can be applied to all the other architectures as well.
EXPERIMENTS To evaluate our solution, we use two benchmarking suites: Poly-Bench/C for uniprocessor, and PARSEC for multiprocessors. The PolyBench/C suite is run with the MEDIUM inputs and the PARSEC suite with the LARGE inputs. We decided to work with the RISC-V target. We used QEMU in two different modes: user-mode, in which system calls and signals are handled by the host OS, and full-system, which is a Linux-capable target. QEMU, Linux and the machine we run on are not time deterministic. We therefore run our experiments 20 times to measure performances, which, by the virtue of the central limit theorem and given the standard deviation we obtain, gives a high confidence in the computed execution time mean. In the following figures, cache refers to QEMU existing cache plugin, cacheTB refers to QEMU with a plugin that implements our solution and vanilla refers to QEMU without any plugin.
Error due to exceptions in Tbs Because early internal Tbs exits can occur, we need to make sure the error it incurs is negligible. To that aim, we choose 2 programs that we run on a single vCPU: a boot of Linux that finishes just before printing the login prompt, and the LU decomposition of a 2048 × 2048 matrix from the parsec. We measure the total number of executed Tbs, the number of internal Tbs exits, the total number of instructions and the number of instructions that have been accounted for while they shouldn't. This is reported in Table  1. The average number of target instructions per Tb is 5. 51 for Linux boot, and 16. 61 for LU, which outlines the differences between both workloads. Although the error in number of instructions is negligible, we made a change in QEMU in which each memory access ends a Tb.
For Linux boot, the number of executed Tbs almost quadruples, to 124,097,849, while the total simulation time increases by 50%. This is not a surprise, as in that workload, 44% of the instructions are memory accesses. In conclusion, our approach to consider all instructions that belong to a Tb as executed makes sense. It is not useful to mitigate it, since it costs a lot in simulation time while having zero impact on the cache statistics.
Statistics validation using QEMU existing cache plugin We report in this section how we validated the statistics produced by our plugin. Although we thoroughly tested the behavior of our cache model against QEMU's current one, all the experiments were done with the following arbitrary instruction cache configuration: 8-way, 32-set, 64 bytes per line and LRU. the existing cache plugin. We obtained the exact same number of instructions and instruction misses with both plugins for the whole benchmark. Thus we have been able to confirm the good behavior of our model in monoprocessor. 6. 2. 2 Multicore: PARSEC Suite. In order to validate our cache model without the issues raised in Section 4 when using Linux, we run the PARSEC suite in QEMU user-mode. Figure  6  shows the number of instruction misses for the number of virtual CPUs from 1 to 128 by integer power of 2 steps for the lu_cb PARSEC benchmark.
Simulation time: vanilla vs cache vs cacheTB In this section, we compare the simulation time of QEMU cache plugin and our own cacheTB plugin. Figure  7  compares the simulation time of the benchmarks of the PolyBench/C suite in bare metal. Figure  8  compares the simulation time of the PARSEC program lu_cb run in user-mode with 1 to 128 virtual CPUs. Instead of showing the simulation time histograms for all PARSEC programs that we used and because they have all the same shape, we represent Figure  9  the simulation time using 128 virtual CPUs only for all programs (on a 2 GHz 64-core AMD EPYC 7702P PowerEdge R6515 server), outlining the scalability of our approach, QEMU in itself being fairly scalable  [2]. Table  2  summarizes all the different mean speedup/overhead ratios. According to the different types of experiments, our plugin is 7 to 10 times faster than the cache plugin.
Visual saliency prediction remains an academic challenge due to the diversity and complexity of natural scenes as well as the scarcity of eye movement data on where people look in images. In many practical applications, digital images are inevitably subject to distortions, such as those caused by acquisition, editing, compression or transmission. A great deal of attention has been paid to predicting the saliency of distortionfree pristine images, but little attention has been given to understanding the impact of visual distortions on saliency prediction. In this paper, we first present the CUDAS database -a new distortion-aware saliency benchmark, where eye-tracking data was collected for 60 pristine images and their corresponding 540 distorted formats. We then conduct a statistical evaluation to reveal the behaviour of state-of-the-art saliency prediction models on distorted images and provide insights on building an effective model for distortion-aware saliency prediction.
The past few decades have witnessed significant progress in visual saliency modelling. The advances in this field are largely attributed to the creation of benchmark databases for human eye movements, which provide insights on functional mechanism of attention. Popular databases include MIT300  [9] , CAT2000  [10] , and SALICON  [11]. The MIT300 dataset is widely used to benchmark the performance of visual saliency models and contains 300 indoor and outdoor images. The CAT2000 dataset offers a diverse range of image content, featuring 4,000 images across 20 scene categories, such as action, art, and cartoon, with 200 images per category. SALICON dataset uses mouse clicks rather than eye trackers to collect human visual attention. SALICON is one of the largest saliency datasets available in the literature, comprising 10,000 training images, 5,000 validation images, and 5,000 test images.
VOLUME 11, 2023  This work is licensed under a Creative Commons Attribution-NonCommercial-NoDerivatives 4. 0 License. For more information, see https://creativecommons. org/licenses/by-nc-nd/4. 0/ Using these benchmark databases, many computational models have been proposed to automatically predict visual saliency  [12] ,  [13] ,  [14] ,  [15] ,  [16] ,  [17] ,  [18] ,  [19] ,  [20] ,  [21] ,  [22] ,  [23] ,  [24] ,  [25] ,  [26] ,  [27] ,  [28] ,  [29] ,  [30] ,  [31] ,  [32] ,  [33] ,  [34]. These models take various approaches to model saliency and generate a saliency map that indicates conspicuousness of different scene locations. The so-called traditional method relies on extracting low-level visual features, such as colour, intensity and orientation and combining these features to form a saliency map.
Unfortunately, there is still a lack of benchmark databases in the literature to comprehensively address the problem of saliency modelling for distorted images. Pioneering work was conducted in  [39] , where the SIQ288 database was created using eye-tracking to understand the impact of distortions on human gaze. This work focused on developing an experimental methodology for reliably collecting eye movement data for images of varying degrees and types of distortion. However, the database remains limited in terms of diversity in image content, for example. In order to drive this line of research forward, we create a new distortion-aware saliency benchmark, namely Cardiff University Distortion-Aware Saliency (CUDAS) database. Based on the new benchmark, we analyse the behaviour of state-of-the-art saliency models in predicting saliency of distorted images.
The contributions of this work are detailed below. • We apply a reliable experimental methodology in  [39]  to conduct a large-scale eye-tracking study on distorted images, resulting in the largest-of-its-kind distortionaware saliency database, namely CUDAS. It consists of 60 pristine (undistorted) high-quality and highresolution source images from 10 different categories of visual content. These source images were degraded using three types of distortion and each at three levels of distortion. This gives a set of 600 stimuli including originals. A total of 96 subjects were recruited to participate in the eye-tracking study in a fully controlled lab environment, which ensures the reliability of the ground truth saliency maps of the CUDAS database. • We conduct an exhaustive analysis on the behaviour of 20 state-of-the-art saliency models, including both traditional and deep learning-based models, on the CUDAS database.
C. SALIENCY MAP GENERATION We follow the standard approach  [39]  to generate saliency maps from the eye-tracking data. In this study, a ground truth fixation was rigorously defined by the SMI BeGaze Analysis Software using an established dispersal and duration based algorithm  [43]. For each image, fixations extracted from the raw eye-tracking data collected over all 16 subjects are converted to a saliency map: SM(x, y) = N i=1 exp - (x i -x) 2 + (y i -y) 2 σ 2 , (1) where SM (x, y) represents the saliency map; (x i , y i ) represents the coordinates of i-th fixation; N is the number of total fixations; and σ is the standard deviation of the Gaussian (σ = 45 pixels determined as per  [44]  in our study). In creating a saliency map (also known as fixation density map), a Gaussian patch is added to each fixation location to simulate the foveal vision (i.
e. , 2 • of visual angle) of the human visual system (HVS). The intensity of the resulting saliency map is linearly normalised to the range [0, 1]. Now, the Cardiff University Distortion-Aware Saliency (CUDAS) database is generated. Fig. 2  shows the fixation map and saliency map (visualised as a heat map) for one of the pristine images in the CUDAS database. Fig. 3  illustrates the saliency maps generated for 9 different distorted formats of the pristine image.
III. CUDAS: PERFORMANCE BENCHMARKING AND EVALUATION OF STATE-OF-THE-ART SALIENCY MODELS A. EVALUATION FRAMEWORK 1) SALIENCY MODELS In this study, we aim to benchmark the performance of state-of-the-art saliency models and reveal their behaviour on distorted images contained in the CUDAS database. We selected 10 traditional models  [12] ,  [13] ,  [14] ,  [15] ,  [16] ,  [17] ,  [18] ,  [19] ,  [20] ,  [21]  and 10 deep learning-based models  [22] ,  [23] ,  [24] ,  [25] ,  [26] ,  [27] ,  [28] ,  [29] ,  [30]. These models have been proven rather effective in predicting saliency of pristine images  [45] ; however, their performance on distorted images remains largely unexplored. To this end, we evaluate (1) the overall performance of state-of-the-art saliency models on the CUDAS database; (2) the impact of distortion (both level and type) on the performance of these saliency models.
It is suggested in  [46]  that in those applications where it is important to evaluate the relative importance of different image regions, metrics like Correlation Coefficient (CC) and Similarity (SIM) are the best fit. The studies conducted by Yang et al. [47]  and Li et al. [48]  suggest that CC and SIM are the only two metrics which are in close agreement with human subjective assessments of saliency maps; and that other metrics are not ''perceptionbased'' and therefore cannot measure the perceptual relevance of the computational saliency maps. Therefore, CC and SIM metrics are used in our study to benchmark and evaluate saliency models on the CUDAS database. Hereby we give brief descriptions of CC and SIM metrics below, letting PM and SM be the predicted saliency map and ground truth saliency map, respectively.