dataesr/scientific-paragraphs-categorization huggingface dataset:
Non-human primate studies (e. g. , 20) have shown that subfields such as the DG, CA2/3, and the subiculum (but not the prenor para-subiculum) are growing asynchronously until adulthood. However, this question has only been recently addressed in human children and adolescents with inconsistent results. According to  Ellis et al. (2021) , the DG exhibits a very rapid growth in infants, doubling in size, associated with an increase in CA1 and CA3 volumes during development (8-14 years old). This contrasts with a stable or a slight linear decrease in subicular volumes  (Ziegler et al. , 2012; Lee et al. , 2014). Concerning normal aging, data suggest a volumetric decrease of all subfields which predominates in the DG (  de Flores et al. , 2015; Foster et al. , 2019). While the literature suggests a differential maturation and aging of hippocampal subfields, there is currently a lack of accurate automated segmentation tools which hinders the use of large datasets to study trajectories across the lifespan.
Here, we offer the first end-to-end deep learning pipeline to segment the hippocampal subfields. Hippocampal segmentation factory (HSF) is an open-source tool that leverages new computer vision segmentation methods. It was trained on a heterogeneous database comprising all public datasets with manually segmented hippocampal subfields and new manually segmented observations to ensure generalization. We hypothesized (i) that HSF provides a better overlap (dice coefficient), fewer outliers (Hausdorff distance), and a better volumetric similarity than currently available tools abiding Barron's protocol  (Berron et al. , 2017) ; (ii) that subfields such as DG and CA1 exhibit differential lifespan dynamics which can be divided into three periods (a. growth, b. stability, and c. decay); (iii) a fast decay for all subfields starting from 60 to 65 years old; (iv) finally that there are sex differences in the volumetric trajectories, with volumetric variations being more intense in men than in women.
Method This section aims at describing (i) the technical details of HSF development in terms of computational architecture, training regime, and inference peculiarities, (ii) how it differs from other state-of-the-art tools addressing the same segmentation problem, and (iii) how we leveraged the potential of HSF to study hippocampal subfields volumetric trajectories in large healthy individuals datasets which covers the lifespan (5-100+ years old). Please note that we conducted a speed test comparing the tools included in our benchmark. While FreeSurfer, one of the most used neuroimaging tools, possesses modules for hippocampal subfields segmentation, we chose not to compare it. Although FreeSurfer  (Iglesias et al. , 2015)  is still considered a classic neuroimaging tool, it has recently incorporated deep learning-based approaches.
HSF: description of the hippocampal segmentation factory HSF is designed to be a fully customizable end-to-end pipeline, handling tasks from the preprocessing of raw anatomical images, to the segmentation of the hippocampal subfields through specialized and highly efficient deep learning models comprised in a "Model Hub" on any hardware acceleration platform such as CUDA, TensorRT, or OpenVINO. HSF also supports the DeepSparse compute engine to benefit from the AVX512 (VNNI) vector instruction set. HSF is distributed under the MIT license at https:// github. com/clementpoiret/HSF.
Internal information processing The HSF pipeline consists of three main steps: 1/a preprocessing step handled by ROILoc (a standalone byproduct of HSF available at https://github. com/clementpoiret/ ROILoc) to extract the hippocampi from a given MRI (Figure  1 ), 2/an augmentation pipeline, and 3/a segmentation by multiple expert models in order to produce both the segmentation and an uncertainty map (Figure  2 ). In order to limit the computational impact of HSF, we used a preprocessing step to extract the hippocampi from the MRI. To do so, ROILoc registers the MNI152 09c Sym template  (Fonov et al. , 2009)  to the T1w or T2w input MRI. Utilizing the CerebrA atlas  (Manera et al. , 2020) , the registration process facilitated the inference of approximate coordinates of the hippocampus in native space.
, 2017), and HippUnfold (DeKraker et al. , 2021). To compare it with manual segmentations, CP, AB, SP, and MF randomly segmented 25 subjects who were excluded from our training set from 5 different datasets: HiPlay7, MemoDev  (Bouyeure et al. , 2021)  (Table  1 ), as well as HCP-Development (HCP-D), HCP-Young Adults (HCP-YA), and HCP-Aging (HCP-A). This segmentation process took approximately 5 h per hippocampus. In relation to an earlier study on MemoDev, an assessment was conducted by  Bouyeure et al. (2021)  to determine the reliability of the manual segmentations. This evaluation involved the computation of an inter-rater reliability index, specifically the dice coefficient, between two individual tracers, who followed the same segmentation protocol. Furthermore, it is worth noting that both raters had no prior knowledge of the participants' age, sex, or memory performance.
The obtained interrater reliability indices were notably high at 0. 77 and 0. 79 for the right and left hippocampi, respectively. Segmentations are compared on three metrics: • the dice coefficient (DC), an overlap metric ranging from 0 (no overlap) to 1 (full overlap) defined as DC = As both T1w and T2w images can be segmented by HSF, we conducted an additional analysis to evaluate any discrepancies in quality across these contrasts using the same metrics. Given the strong correlation between contrast and resolution (e. g. , an isometric millimetric MPRAGE 3D T1w and anisotropic 2D Coro-T2w), we limited our study to only 15 subjects from our test set sourced from the HCP databases, where T1w and T2w MRIs are in the same space and at the same resolution. Owing to the presence of either heteroscedasticity or non-normal distributions of scores, we compared segmentations utilizing nonparametric Kruskal-Wallis or pairwise Wilcoxon-Mann-Whitney tests, with p-values corrected using the Benjamini-Hochberg false discovery rate.
MRI segmentation Prior to HCP's datasets' segmentation and after the HSF validation, we retrained HSF's models with the manually segmented observations coming from the previous section (see Section 2. 2. ) including observations from the HCP's datasets. We thereby improved the reliability of segmentations by including new and HCP-specific observations to ensure there was no mismatch between our training set's distribution and HCP's distribution of observations. All segmentations are performed on T2w images, with ROILoc's location algorithm using the ' Affine' registration and a margin of 16 voxels in all directions to ensure that whole hippocampi are included in their boxes.
Using HSF, we created an overall normalized anteroposterior distribution of subfields across all three HCP datasets (Figure  6 ). We found no anatomical differences between lifespan periods and sexes. According to HSF, the hippocampal head starts mostly with CA1, quickly followed by the subiculum and then the DG before the hippocampal body. After the body, CA2 and CA3 start to disappear and then followed by the DG. The tail comprises mostly subiculum, CA1, and a small portion of DG which disappears near the middle of the tail.
Discussion This study had two main goals: 1/to introduce a new segmentation tool for the hippocampal subfield based on machine learning named hippocampal segmentation factor (HSF), which leverages the latest advances in computer vision, and 2/to study lifespan volumetric trajectories of hippocampal subfields in healthy individuals using the proposed tool. We developed and validated HSF, and demonstrated that it is faster than all previous tools while offering a better segmentation quality closer to manual segmentation. Then, applying our tool to data from 3,750 individuals (HCP-development, HCP-young adults, and HCP-aging), we show that hippocampal subfields have different volumetric trajectories across the lifespan. These trajectories are non-linear, and inflection points differ between males and females in accordance with prior literature (16).
First of all, we validated HSF in comparison to ASHS, HIPS, and HippUnfold. When looking at the DC, it has to be noted that, even in the absence of histological ground truth, HSF matches the inter-rater agreement (Figure  4 ). Moreover, its scalability benefits out-of-the-box from the latest advances in computing due to the open neural network exchange (ONNX) ecosystem and NeuralMagic's DeepSparse inference engine. HSF shows an unprecedented segmentation speed which makes it particularly suited to the processing of big datasets such as the HCP. The bootstrap aggregation strategy, coupled with the testtime augmentation, makes HSF more robust than ASHS and HippUnfold as suggested by our results, with a lower variance with respect to the DC, HD, and VS (Figure  4 ). One feature of interest is the ability of HSF to segment both T1w and T2w images.
Our investigation yielded superior quality segmentations through the utilization of T2w images-a result that aligns with the existing literature. It is important to note, however, that our dataset contained a larger quantity of T2w images compared to T1w images. Therefore, we are unable to definitively conclude whether the observed disparities in quality are a direct result of superior T2w contrast or a potential bias within our dataset. However, because each tool was trained using data segmented with different protocols, it is difficult to compare their accuracy, especially regarding the boundary between CA1 and the Subiculum  (Yushkevich et al. , 2015a). As HSF learned from multiple datasets, we interpret its segmentation as following a consensus between multiple segmentation guidelines, even if our results show it is very close to Barron's protocol  (Berron et al.
Ever since the most recent launch of FreeSurfer 7, the original authors  (Iglesias et al. , 2015)  have been endeavoring to enhance their segmentation pipeline of the hippocampal subfields. Due to the fact that this updated version is still untested and limited, it has not been integrated into our benchmark because of the current limitation to low-resolution T1 images. Thus, we highly suggest that future studies thoroughly examine this novel update as soon as it exits the beta stage. After validating HSF, we segmented and analyzed hippocampal ROIs obtained from the HCP-development, HCP-young adults, and HCP-aging datasets. This allowed us to study the developmental trajectories of hippocampal subfields during the lifespan with a bigger age range than previous studies [e. g. , (Yang   et al.
Although we found no anteroposterior differences between subjects, we believe it is critical to go beyond volumetric analysis and assess additional information, such as shape as suggested by  Yang et al. (2013) ,  Voineskos et al. (2015) , and  Lynch et al. (2019)  or other complementary measures gathered through diffusion imaging, or even quantitative T1 relaxation maps, a proxy for intracortical myelin (Vos de  Wael et al. , 2018). Therefore, while the hippocampal subfields are critical in the physiology of episodic memory, the lack of efficient segmentation tools hinders the use of large datasets to study their role in health and disease. Here, we introduced a new segmentation tool, HSF, robust to changes in populations, and acquisition parameters such as contrast, resolution, or magnetic field intensity.
After its validation against other existing tools (ASHS, HIPS, and HippUnfold), we used it to segment large datasets (HCPdevelopment, HCP-young adults, and HCP-aging) in order to model volumetric trajectories of the hippocampal subfields from 5 to 100 years old. Our volumetric analysis has shown that most subfields except the subiculum are positively correlated with age until the early 20s, and that the most correlated subfield is the dentate gyrus. This study also found a major inflection point at approximately 70 years old (even earlier in the subiculum) where a fast and significant volumetric decrease occurs. Our study has yet to be correlated with evaluations of mnesic performances, which could help to validate subicular volumes as a relevant biomarker for the early diagnosis of age-related cognitive decline.
Haeger et al. (2020) * * T2 DG/CA1/CA2/CA3/Sub 7T 50-70 -Shaw et al. (2020) * * T1 and T2 DG/CA1/CA2/CA3/Sub 7T 23-29 -Lagarde et al. (2021) * * T2 DG/CA1/CA2/CA3/Sub 7T 50-84 SC/MCI/AD Description of the training database, alongside their manually segmented hippocampal subfields, namely the dentate gyrus (DG), the cornu ammonis (CA)1, CA2, and CA3. Included participants are either healthy, exhibiting mild cognitive impairments (MCI), Alzheimer's disease (AD), hippocampal sclerosis (SC), or temporal lobe epilepsy (TLE).
All databases are acquired on a 3T Siemens Prisma (Skyra for HCP-YA) scanner:-HCP-D: HCP-D contains 1350 healthy children, adolescents, and young adults aged from 5 to 21 years. T1w and T2w MRIs are acquired at an isotropic resolution of 0. 8 mm across four sites (Somerville et al. , 2018) , -HCP-YA: HCP-YA includes 1,200 subjects with ages ranging from 22 to 35 years. T1w and T2w MRIs have been acquired on a single site at an isotropic resolution of 0. 7 mm, -HCP-A: HCP-A comprises 1,200 subjects from 36 to 100+ years old. T1w and T2w MRIs are acquired at an isotropic resolution of 0. 8 mm across four different sites (Bookheimer et al. , 2019). The HCP datasets were provided in part by the : David Van Essen and Kamil Ugurbil; 1U54MH091657) funded by the 16 NIH Institutes and Centers that support the NIH Blueprint for Neuroscience Research and by the McDonnell Center for Systems Neuroscience at Washington University.
INTRODUCTION Analyzing Android applications is a crucial task for security experts to ensure security for mobile phone users. These experts must quickly understand the main purpose of the applications and even their hidden features. They have to assess whether the applications violate a given security policy or whether they are indeed malware. Meanwhile, both legitimate developers of proprietary code and malware authors try their best to avoid such 30:2 • P. Graux et al. analyses. Developers use various obfuscation techniques whose sole purpose is to prevent, limit, and slow down reverse analyses. These obfuscation techniques usually target the code, which is the primary source of information about what a software can perform. In Android applications, the code can be composed of both Dalvik bytecode  [3] , potentially compiled into an OAT file, and native code.
BACKGROUND This section depicts the necessary background on what composes the code of an Android application and how runtime-based obfuscation operates to hide their codes. Even if we present some historical elements on the evolution of Android internals, all the technical details are strictly relative to version 7. 0 (Nougat, 2016) of Android and we focus on the ARMv8  [4]  architecture as it is the most recent version of the most used architecture  [29]. This version has been chosen because we run our experiments on a real smartphone: the Sony Xperia X. This smartphone is one of the first devices to be part of the Open Devices program, which simplifies the recompilation of the AOSP tree. 2  The version 7. 0 uses Kernel 3. 10 but can be easily adapted to version 7. 1 that runs kernel 4. 4.
Android Application Execution Application and DEX format. An Android application is an archive composed of a Manifest file (metadata), resource files (texts, pictures, and layouts), and a file that contains the application bytecode in the DEX format  [2]. Dalvik is the virtual machine that interprets and performs just-in-time (JIT) compilation of the application bytecode written for Android. The DEX bytecode is independent of the device architecture. Since Android 4. 4 (KitKat), Dalvik bytecode can be compiled into assembly code but can still be interpreted by the ART. Hence, analysis tools cannot avoid handling Dalvik bytecode. Ahead-of-Time Compilation. Since Android 5. 0 (Lollipop, 2014), the bytecode of an application can be compiled into native assembly code. Forcing the compilation of the bytecode of every application may cause a huge overhead, especially when the operating system is updated.
Packing consists in storing the Dalvik bytecode ciphered, which will be dynamically deciphered and loaded at runtime. This relies on native code that directly modifies Android's internal structures for deploying new bytecode. These modifications can occur at any time of the bytecode loading process or before the execution. Packing has been extensively studied  [20, 34, 36, 39, 40] , and packing DEX bytecode using native code is a popular technique: Duan et al. [13]  reported that an average of 13. 89% of malware in the wild between 2010 and 2015 used packing techniques to hide malicious behavior. AOTC-based bytecode hiding. The AOTC-based bytecode hiding scheme is a recently described obfuscation technique  [8]  that aims at hiding the bytecode of sensitive methods from both static and dynamic analyses.
Unpacking Hidden Bytecode DexHunter  [40]  and AppSpear  [39]  are unpackers that try to discover how native code is used to modify the code loading process. They overload the runtime methods that load the bytecode. When the packed application is launched, the unpacker calls these overloaded methods, which log the loaded bytecode. When the execution is over, the unpackers reconstruct the application by merging the different parts of the bytecode that they obtained. However, packers can avoid using the functions hooked by the unpackers or even change the bytecode after it is loaded. For this reason, PackerGrind  [36]  and TIRO  [34]  do not set up any hooks. Instead, they watch the structures managed by the runtime involved in the bytecode loading process. When these structures are modified, they choose, manually for PackerGrind, to retrieve the newly loaded code.
Many works  [19, 24, 32, 37]  have aimed at tracking the information flow during the execution of an Android application. NDroid  [24]  propagates TaintDroid  [14]  taints by hooking the Android framework methods that call native code and all JNI entry points (QEMU hooking and VM introspection). AppLance  [19]  hooks source methods and changes their return values. With several executions, it can detect if the sink methods' parameters changed owing to a modification of the source methods' return values. JN-SAF  [32]  uses angr  [28]  to statically track information flows. The key idea is to initialize the JNI entry point table with symbolic addresses representing the different JNI methods. Then, JN-SAF can represent their effects symbolically. All these approaches provide all the sensitive information flow between methods, but retrieve only the behaviors involved in the information flow.
It is reported as medium in Table  1. Xue et al. provided a comprehensive view of the Android malware behaviors using Malton  [37]. Malton is a dynamic analysis platform that aims to compute information flows. It relies on Valgrind  [22]  to hook method calls, ART, and framework libraries. It stores the address of every Java and native method and then checks, for every jump, if the destination address is the address of a method. Then Malton reconstructs the Java objects corresponding to the arguments by parsing the memory. It also hooks framework methods responsible for loading code and the JNI entry points and intercepts all system calls. Finally, it propagates taints through every assembly instruction. Moreover, Malton leverages concolic execution to trigger or force the execution of specific, manually tagged, code areas.
The Runner module lifts these limitations by using monitor methods inside the ART library when possible and low-level debug methods otherwise. Table  2  summarizes how each action is monitored, depending on the binary code type. If the action goes through the ART (all actions in the Dalvik bytecode, and object allocation, monitoring of the entry or exit, and exception handling in all code types), then a direct event is generated by adding a call to the logger inside the runtime. Otherwise, the action is retrieved by generating a low-level event based on debugging or memory protection capabilities. In particular, an OAT code that accesses (read or write) an object field is captured by disabling the heap memory: All heap accesses will generate a segv event. The same applies to native code when bypassing the JNI interface.
Thus, patching the runtime allows us to bridge the semantic gap between the assembly and the bytecode world. The patch is divided into two entities: the ProbeManager and the SignalManager. The ProbeManager handles high-level events. It is the interface between the runtime and the output file when actions are logged. It logs object-level actions when they occur. The SignalManager handles low-level events. It sets breakpoints, handles kernel signals, and notifies the ProbeManager to log associated actions. The ProbeManager logs each event with its associated instruction address. This allows linking of the bytecode events to the assembly code and will be used by the Concolic analyzer module (cf. Section 4. 4). The thread identifier from which the event originates is also logged to avoid concurrent execution issues.
CFG Creator Module The CFG creator module is in charge of creating the CFG. In fact, this graph is the union of the interprocedural call graph (iCFG) and the methods' olCFGs. These CFGs are built sequentially, using the events outputted by the Runner module: First, actions are split by method and the iCFG is created, and then the olCFG of each method is computed. iCFG computation. The logs are split by method. The boundary of a method is defined by two properties of the Dalvik bytecode  [3]. First, each method begins with an invoke and ends with a return. Then, each return is preceded by its corresponding invoke action. An invoke action is not necessarily followed by a return: Methods may never return (e. g. , the main loops of graphical engines are infinite loops). Second, there is no jump across method bodies ("goto"-like statement).
Thus, if a method m b is invoked after a method m a , then the return of m a cannot occur before the return of m b. Invocations cannot be interleaved. Thanks to this last remark, we can split actions by method by reconstructing the call stack. During the call stack computation, the iCFG is made: When an invoke event occurs, an edge is added between it and the last method. Note that actions are mixed between different threads. The inclusion of the thread identifier in logs allows each thread CFG to be built independently. olCFG computation. We define the olCFG of a method the graph whose nodes contain Java-level actions (as listed later in Table  2 ), and whose edges represent the execution traces. Each node contains, for each execution: Listing 2. Runner module output on SimpleTestPIN. • the address of the instruction that operated on the Java object: the address of the instruction in the case of native code; the index of the instruction in the bytecode, otherwise; • the execution number, to distinguish between several executions of the application; • the nature of the operation (INVOKE, READ, etc.
Memory Dumper Module The Memory dumper module is responsible for making snapshots of the memory. This module is called just before the execution of a method and dumps the whole memory or the process. These snapshots give the method's code and data to the Concolic analyzer module in charge of the symbolic execution. In this way, if a method is used as a place holder for several unpacked assembly codes, then each snapshot will provide the current version of the code. This module can be either activated by the Runner at each method execution (but it considerably slows down the analysis) or activated on demand by the human analyst.