dataesr/scientific-paragraphs-categorization huggingface dataset:
Other faint unresolved sources are scattered in the remaining parts of the structure. It is unclear whether some diffused emission is present (on the eastern edge notably), or if this is an artifact resulting from the mix of several other faint unresolved components. Considering the description above, the structure could be a stellar cluster. Object No. 2: The JWST dataset consists of relatively few data points, sampling quite uniformly the uv-plane. A basic analysis of the data (through visual inspection, model fitting, standard image reconstruction or directly with the method described here) leads to the conclusion that the source consists of a bright point source surrounded by faint extended structures. Taking advantage of this information, the model was trained with images that systemically contained a central point source contributing to at least 50% of the flux, reducing greatly the parameter space in which it has to perform.
Metric 2: The second metric corresponds to the linear cross-correlation between the model images and the different contributions. Since each one of the participants performed reconstructions with different image parameters, before getting the cross-correlation coefficient, the following linear transformations were applied (the transformed images were also used for computing metrics 3 and 4): First, all the images were interpolated to have the same pixel scale. In the case of the first object, all the image contributions were interpolated to a pixel scale of 0. 1 mas/pixel, for the second object, all the image contributions were interpolated to a pixel scale of 10 mas/pixel. To perform the scaling, we used the Python function zoom from the package scipy. ndimage. This routine uses a spline interpolation of the requested order.
ACKNOWLEDGMENTS J. S. -B. acknowledges the support received from the  Mexican Council of Science (CONACyT) "Ciencia de Frontera " project  CF-263975. P. Vermot thanks his institute for its support through the international collaboration in astronomy  CZ. 02. 2. 690. 00. 018 0530016972  as well as the institutional project RVO: 67985815. J. K. acknowledges support from  FWO  under the senior  postdoctoral fellowship  ( 1281121N ).
Classification of detection schemes. [3]. Intrusion detection systems (IDS) are another widely used approach to protect the network. They are generally based on two main detection techniques: signature-based and anomaly-based or eventually a hybridization of these two techniques  [4]. Signature-based techniques exploit a database corresponding to the behavior of some known attacks. Then, they compare the collected data with this database in order to detect a behavior that corresponds to a suspicious behavior  [5]. Anomaly-based techniques observe the system to catch the deviations (anomalies) and classify them as misbehavior. For anomaly-based IDS on which this paper focuses, several methods have been already proposed  [6] -  [10] , namely watchdog mechanism, machine learning, hashing pseudonym to common values, RSSI-based analysis, honeypot based approach, fuzzy clustering, etc.
In this work with an ensemble learning based detection system, training phase will be executed centrally. Then, any vehicle will be able to use this trained model to detect rapidly an attack through the new arriving messages/vehicles. This work proposes a new feature combination related to C-ITS and exploits them to develop a distributed IDS that benefit from machine learning (ML) techniques. The performance of the proposed misbehavior detection approach is evaluated by comparing it with other approaches using a specifically built large dataset. The contributions of the work are the following: • Some new features are introduced to better detect position falsification misbehavior. These position-related features are the estimated angle of arrival, estimated distance between sender and receiver, and the difference between the declared and estimated distance between sender and receiver.
Van der Heijden et al. [24]  generated a public dataset to detect position falsification misbehavior and published it to allow researchers to compare and evaluate different misbehavior detection techniques. The dataset, called Vehicular Reference Misbehavior Dataset (VeReMi), is used as a basis to assess the performances of new detection approaches. Our proposal will be evaluated in this paper using this dataset (i. e. VeReMi) in order to compare its performances with related works that already implemented this dataset.
Their proposal on vehicle trust model requires a central Trust Authority (TA) as well as a local vehicle trust module to combine different assessments. Some other studies were inspired by the public dataset VeReMi and simulated their own scenarios to create new attack types for their approaches  [28] -  [30]. They also generated several other features (e. g. plausibility, consistency, etc. ) as well as kinematic data (e. g. position, speed, acceleration). In these works, a centralized misbehavior authority takes the final decision even if the detection is done by vehicles and RSUs. Decentralized IDS using ML techniques are also well studied in the literature. Sharma and Kaul  [31]  proposed a multi cluster head based detection system, where the head is chosen by hybrid fuzzy multi-criteria decision making approaches.
Ad hoc On-demand Distance Vector (AODV) protocol is used as routing protocol and trust aware SVM is implemented for detection. Each vehicle in the packet forwarding route examines the behavior of the next hop to detect any signs of a misbehaving node that could influence the system performance. Kim et al. [38]  created a public intrusion detection dataset, called KDD CUP 1999, for four attack types: DoS, probing, user to root (U2R), and remote to local (R2L) attacks. They considered these attacks as multiclass in the classification process of SVM and feed-forward neural network. Some features are determined through a trace file, the significant ones are extracted and fuzzified to be used in the distributed detection mechanism. Ghaleb et al. [39]  developed a distributed misbehavior-aware on-demand IDS and implemented it on the previously mentioned KDD dataset.
The important features are selected using chi-square test. They tested their proposed detection model using RF, XGBoost, and SVM. Several works, using the public VeRemi dataset provided by  [24] , implemented well-known ML techniques, e. g. k-Nearest Neighbor, Random Forest, Support Vector Machines, and Logistic Regression (LR), while proposing different features for position falsification attack detection  [40] -  [44]. So et al. [40]  observed the relation between RSSI and distance of sender-receiver. Different attacks are also detected by their proposal on three plausibility checks: First-Basic Safety Message (F-BSM), Majority-BSM (M-BSM), and Weighted-BSM (W-BSM). They compared the results with the ones obtained from SVM and kNN. Different feature combinations are proposed in  [41]  to detect misbehavior over a single class by considering all attack types in one overall class.
kNN is one of the most known ML techniques for classification problems (k is a pre-defined number of neighbors that should be selected carefully). Fig. 5  gives an example of kNN with different k values. Larger values of k cause less distinct boundaries for classes while decreasing the noise effect on the classification. Therefore, smaller k values are generally preferred. If the problem is binary classification, then an odd number of k is recommended to avoid equality of votes. Since this classification is based on neighbors' votes, the computations rely on distance. The most popular distance calculation methods are Euclidean, Manhattan, Hamming, and Minkowski distance  [48]. On the other hand, RF is based on DTs that are trained on independent sub-datasets as shown in Fig. 6. Hence, it prevents overfitting issues and classifies the data based on the  Stacking is an ensemble learning method that allows the combination of heterogeneous learning techniques in order to enhance the performance of the classification.
In such a method, various learning techniques are used in a first classification step on the same dataset. Then, a generalization model, i. e. meta-classifier, combines the predictions of the primary techniques  [50]. Generalized Boosted Model (GBM) and Generalized Linear Model (GLM) are two examples of the methods used to combine the results in Stacking method. Thus, this paper proposes to exploit the potential of Stacking method by using kNN and RF for the first step and GLM for the generalization step as shown in Fig. 7. To the best of our knowledge, such an approach has not been yet studied in the literature to detect position falsification attacks in VANETs.
IV. SIMULATION RESULTS To show the efficiency of our proposed IDS mechanism and to facilitate the comparison with the existing works, the simulation results of this paper are based on a public dataset, denoted VeReMi, which has been built specifically for testing misbehavior detection  [24]. The main workflow of the simulation is shown in Fig. 8. The first step of this workflow consists of obtaining a real or a simulated dataset and reorganizing it by matching senders and receivers. Then, new features are calculated to be used for the classification of the vehicles as attackers or normal vehicles by using different ML and ensemble learning techniques. Finally, the obtained results are compared with those using features already proposed by other researchers.
A. DATASET DESCRIPTION AND EVALUATION INDICATORS VeReMi dataset, which allows evaluating misbehavior detection approaches, is used in this work as a basis for the implementation of the proposed mechanism. Reference  [24]  performed the simulations with the Luxembourg traffic scenario (LuST) for realistic mobility patterns in a city and used Veins, based on OMNET++ (an event-based network simulator) and Simulation of Urban MObility (SUMO) (a road traffic simulator), for the vehicular network simulations to obtain this dataset. The published VeReMi dataset consists of 5 different attacks and considers 3 different attacker rates (10%, 20%, and 30%) for different traffic densities (low, medium, and high). The attacks, defined here, are related to position falsification, i. e. Constant, Constant Offset, Random, Random Offset, and Eventual Stop.
B. DISCUSSION FOR RESULTS OF FEATURES COMPARISON In order to show the interest in the new proposed features and the efficiency of the used approach, this section compares our results with those obtained by other works that are implemented using VeReMi dataset  [40] -  [44]. A summary of these works is given in Table  4. To achieve this task, the new features proposed in this work (AoA, d, ∆d R→S ) are fixed in all possible feature combinations. Besides, previously defined features in the literature are added in pairs to these combinations. After several simulations, the combinations which yield commonly better performances were selected and are listed in Table  5.
2% and 92. 5% for different scenarios. One can also infer that the computation time increases as the traffic density increases for each Attack ID. Furthermore, the percentages of the average improvements comparing with the work  [44]  are given in Table  8  in parentheses. According to this table, it can be easily seen that the computation time is reduced in each case for our proposal. Computation time mainly depends on the number of used features for classification and the learning method as well as the size of the data. When comparing our mechanism with the one in  [44] , while using the same learning methods and the same datasets with different feature combinations, one can notice that our proposal provides better or similar accuracy and F1-score by considering fewer number of features, which requires considerably less computation time.
There is no generally accepted 8-bit quarter precision format, though suggestions have been made by  Moler (2017)  (and implemented in MATLAB by Moler2),  Tagliavini et al. (2018), and Wang et al. (2018). Double-double arithmetic is a form of quadruple precision arithmetic in which a quadruple precision number is represented as the unevaluated sum of two double precision numbers, one representing the higher-order bits of the significand and the other the lower-order bits  (Muller et al. 2018, Section 14. 1). Double-double 2 http://mathworks. com/matlabcentral/fileexchange/59085-cleve-laboratory arithmetic has a long history going back to the 1960s  (Li et al. 2002). It is a "poor man's quadruple precision" in that it is slightly less accurate than quadruple precision, has roughly the same range as double precision, and does not inherit all the desirable properties of the underlying double precision arithmetic  (Joldes, Muller and Popescu 2017).
Availability in hardware and software IEEE single and double precision arithmetic began to be widely supported in hardware in the late 1980s and early 1990s. In fact, the Intel 8087 coprocessor, produced before the standard was published, partly supported it. In principle, single precision arithmetic operations should run twice as fast as their double precision counterparts, and single precision variables have the benefit of requiring half the storage of double precision ones, resulting in less data movement, but on Intel chips single precision had no speed advantage over double precision until the late 1990s, when Streaming SIMD Extensions (SSE) instructions were introduced  (Langou et al. 2006). IEEE fp16 arithmetic began to be supported on NVIDIA GPUs in the Maxwell architectures  (Jetson TX1, 2014)  and was included in the subsequent Pascal (P100, 2016), Volta (V100, 2017), Turing (T4, 2018), and Ampere (A100, 2020) architectures.
Fp16 is also supported on AMD GPUs in the GCN and CDNA architectures. Bfloat16 is supported on Google's TPUs  (Norrie et al. 2021) , the NVIDIA A100 GPU  (Choquette et al. 2021 , NVIDIA Corporation 2020) , the ARM NEON architecture (ARM 2018) and Armv8-A architecture (ARM 2019), the Fujitsu A64FX ARM processor  (Dongarra 2020 , Sato et al. 2020) , and the Intel Xeon Cooper Lake processors. It is not only high-end devices that support half precision: the Raspberry Pi, which uses the Armv8-A architecture, supports Bfloat16  (Groote, Morel, Schmaltz and Watkins 2021, Sec. 7. 2. 1). The future Chinese Sunway exascale computer is scheduled to have double precision arithmetic running at 1 ExaFlop/s and half precision arithmetic running at 4 ExaFlop/s  (Gao et al. 2021, Sec. 4). Quadruple precision arithmetic is available almost exclusively in software.
It is supported by some compilers, such as the GNU Compiler Collection (GCC)3, and in MATLAB through the Symbolic Math Toolbox4 and the Multiprecision Computing Toolbox. 5 Quadruple precision arithmetic is supported in hardware on N. J. H T. M the IBM Power9 processor  (Trader 2016 ) and the IBM z13 processor  (Lichtenau, Carlough and Mueller 2016). A set of extended and mixed precision Basic Linear Algebra Subprograms (BLAS) known as the XBLAS6 provides extended and mixed precision counterparts of selected level 1, 2, and 3 BLAS  (Li et al. 2002). They use extended precision internally, defined to mean a precision at least 1. 5 times as accurate as double precision and wider than 80 bits. The input and output arguments remain single or double precision variables, but some arguments can be of mixed type (real or complex) as well as mixed precision (single or double), and the main visible difference is an extra input argument that specifies the precision at which internal computations are to be performed.
Multiprecision arithmetic Multiprecison floating-point arithmetic is a built-in feature of Maple7 and Mathem-atica8 as well as the open-source PARI/GP9 and Sage10 computer algebra systems. T. M It is available in MATLAB through the Symbolic Math Toolbox and the Multiprecision Computing Toolbox. The programming language Julia11  (Bezanson, Edelman, Karpinski and Shah 2017)  supports multiprecison floating-point numbers by means of the built-in data type BigFloat. For other languages third-party libraries are available: Python: mpmath12  (Johansson et al. 2013 ) and SymPy13  (Meurer et al. 2017). C: the GNU Multiple Precision Arithmetic Library14 and the GNU MPFR Lib-rary15  (Fousse et al. 2007). C++: the BOOST libraries. 16 C++ and Fortran: the ARPREC library  (Bailey, Hida, Li and Thompson 2002).
C++: the MPFUN2020 library  (Bailey 2021 ). 17 The GNU MPFR Library is used in some of the software mentioned above, and interfaces to it are available for several programming languages. It was originally intended for high precisions, though recent work has improved its efficiency for fp64 and fp128  (Lefèvre and Zimmermann 2017). As the documentation notes,18 the default exponent range is wide and "subnormal numbers are not implemented (but can be emulated)". Nakata (2021)  has produced a multiprecision version of the LAPACK library called MPLAPACK by translating the LAPACK source code from Fortran to C++. MPLAPACK has several options for the underlying arithmetic, including quadruple precision provided by GCC, double-double arithmetic, quad-double arithmetic (which represents a number as the unevaluated sum of four double precision numbers, so has about twice the precision of quadruple precision), the GNU Multiple Precision Arithmetic Library, and the GNU MPFR Library.
The MATLAB function chop19 of  Higham and Pranesh (2019)  rounds the elements of a matrix stored in single precision or double precision to a lower precision using one of several forms of rounding, with the result stored in the original precision. The target format for the rounding is specified by the number of bits in the significand and the maximum value of the exponent. The bfloat16, fp16, and fp32 formats are built-in. Subnormal numbers can be included or not. Six rounding modes are supported: round to nearest using round to even last bit to break ties (the default), round towards plus infinity, round towards minus infinity, round towards zero, and two forms of stochastic rounding. The chop function makes it easy to adapt existing codes to mixed precision by wrapping statements in calls to chop, and since the chop function is vectorized few calls to it are typically needed for linear algebra codes.
The library CPFloat20 by  Fasi and Mikaitis (2020)  offers similar functionality to chop for C. It comes with a MEX interface to MATLAB, and calling CPFloat can be faster than calling chop for large matrices. Fasi and Mikaitis (2020)  offer a comparison with some other available packages for simulating low precision floating-point arithmetics. Another approach to simulation is to provide a new storage class and overload operators to do arithmetic on the class. The fp16 half precision MATLAB class of  Moler (2017) 21 introduces a new data type fp16 that implements the fp16 storage format and overloads some basic functions for fp16 arguments. Arithmetic in this class is slow because of both the overhead of object orientation in MATLAB and the cost of converting to and from the fp16 storage format.
2) needs to be stored in fp32. Lopez and Mary (2020)  propose a modification of the above approaches of Haidar et al. , based on a left-looking Crout factorization that allows them to store the matrix in fp16 while accumulating computations in fp32 buffers of controlled size. As a result, memory consumption is halved and data movement costs are greatly reduced, making the factorization faster by up to a factor two on NVIDIA V100 GPUs.
They apply this strategy to the Cholesky factorization of data sparse covariance matrices arising in geostatistical modeling, obtaining an average 1. 6× speedup. The approach is extended to also include half precision in  Abdulah et al. (2022) , leading to an improved 2. 6× speedup. Doucet, Ltaief, Gratadour and Keyes (2019)  use the same approach in a different application in computational astronomy (tomographic reconstructors) using only single and half precisions on NVIDIA V100 GPUs. To go even further, in addition to storing different blocks in different precisions, each block can also use a mixed precision representation. Since most of the blocks of data sparse matrices exhibit rapidly decaying singular values, they are amenable to the mixed precision low-rank representation proposed by  Amestoy et al.
An example of such work is the tool Precimonious, by  Rubio-González et al. (2013) , which uses execution time as the performance metric. It takes a C program as input and outputs a description of the precisions to be assigned to the variables. The experiments in  Rubio-González et al. (2013)  demonstrate a speedup of up to a factor 1. 4 by replacing certain double precision variables with single precision ones in the benchmark codes tested. A more recent example, focused on GPUs, is GRAM, which chooses the precisions at run time  (Ho, De Silva and Wong 2021). Each block of threads is kept at the same precision and a proportion α of the blocks is assigned a lower precision, with a binary search used to select α. Speedups on an NVIDIA GPU of up to 1. 8 over single precision are reported, by exploiting half precision arithmetic.
GRAM does not support the use of tensor cores. Brun et al. (2021)  develop a tool that uses a heuristic search strategy to select the precisions at which elementary functions are evaluated in a code, aiming to minimize the precisions subject to achieving output of a given accuracy. They use the Intel Vector Mathematics functions (VM) in the Intel oneAPI Math Kernel Library, which have an input argument that allows the user to select "high accuracy", "low accuracy", or "enhanced performance accuracy" modes for the functions. They are able to obtain up to an approximate halving of the execution time on a Monte Carlo code that spends 70 percent of its time in mathematical library functions. Precision tuning has also been used in climate and weather models. Tintó Prims et al. (2019) use the rpe Fortran library that emulates reduced precision, which we mentioned in Section 2.
Acknowledgements The work of the first author was supported by  Engineering and Physical Sciences Research Council  grant  EP/P020720/1 , the  Royal Society , and the  Exascale Computing Project  ( 17-SC-20-SC ), a collaborative effort of the  U. S. Department of Energy Office of Science  and the  National Nuclear Security Administration. The work of the second author was supported by the  InterFLOP  project ( ANR-20-CE46-0009 ) of the  French National Agency for Research. We thank  Massimiliano Fasi ,  Sven Hammarling ,  Claude-Pierre Jeannerod ,  Mantas Mikaitis , and  Françoise Tisseur  for their comments on a draft manuscript.
Introduction Recent advances in memory technology have resulted in byte-addressable Non-Volatile Main Memory (NVMM), which attempts to combine the performance benefits of conventional main memory with the strong persistence characteristics of secondary storage. A program running in a traditional memory hierarchy system stores its operational data in volatile data structures maintained in DRAM, whereas its recovery data (such as transactional logs) are usually stored in non-volatile secondary storage. In the event of a failure, all in-memory data structures are lost and must be re-constructed from recovery data to make the system functional again. This poses major performance overheads. The availability of NVMM enables the design of concurrent algorithms, whose execution will be recoverable at no significant cost.