dataesr/scientific-paragraphs-categorization huggingface dataset:
However, we found search precision underestimates the quality of online and progressive algorithms; for example, if only 10% of the data is indexed and the exact neighbors are uniformly distributed in data, the search precision of a progressive algorithm cannot surpass 10%, since 90% of the exact neighbors are not in the index. Therefore, we measured a relative error, mean distance error (MDE); for each query point, we first compute the ratio between the distances to its exact k-th nearest neighbor and to its approximate k-th nearest neighbor and then calculate the mean of the ratios for all query points. An MDE of one means that the exact neighbors were found, and an MDE of two means on average the algorithm found neighbors that are two times farther than the exact ones. Figure  1  shows the changes in measures per iterations according to datasets and ordering conditions.
Since the online trees used all 5,000 operations to insert new points, the corresponding red line ends at the 200th iteration (1,000,000 / 5,000 = 200). The online algorithm builds new trees each time the number of inserted points doubles. This behavior yields spikes in the insertion time (the red lines on the leftmost charts in Figure  1 ). The spikes clearly revealed the limitation of the online trees: At the 126th iteration, the online trees produced a peak latency in insertion time that was longer than 10 seconds. In contrast, regardless of datasets and ordering conditions, the progressive trees kept the insertion time under one second: in progressive k-d trees, abrupt changes in insertion time were removed. Since we controlled the number of operations in one iteration to achieve progressiveness, not execution time, insertion time varied depending on the numbers of insertion and reconstruction tasks.
Regarding QPS, the online trees had a performance gain after tree reconstruction, since the trees became well balanced (i. e. , at the 62nd and 126th iterations in the middle column of Figure  1 ). The progressive trees showed lower performance, but the gap could be narrowed by adjusting the value of α (i. e. , the reconstruction weight). Progressive trees with a smaller value of τ yield better QPS, but the differences were small. As more points were inserted to k-d trees, the mean distance error (MDE) of answers decreased, finally converging to an MDE of 7% for the GloVe dataset and 3% for the Blob dataset. We measured the time from the beginning to the moment when the MDE converges and marked it in the rightmost charts in Figure  1. The online tree took the smallest number of iterations to reach the final MDE.
The reason may be that it used all its operations to insert new points, so exact neighbors were more likely to be in the trees and searched. Indeed, progressive k-d trees with a larger value of τ assigned more operations to index new points, producing faster convergence. However, due to the longer insertion time, the online trees took the longest time to reach the final MDE, which suggests the effectiveness of our progressive k-d trees. In the Blob dataset under the shuffled condition, the progressive trees generally took the fewest iterations to index the whole dataset and the shortest time to reach to the final MDE. The reason may be that the dataset had randomly sampled points in a random order, so the trees spent the fewest operations in rebalancing and the approximation in k-d trees was effective.
k -Nearest Neighbor Lookup Tables The second benchmark evaluates the performance of KNN lookup tables. As in the first benchmark, we used the GloVe and Blob datasets and the two ordering conditions (i. e. , original and shuffled). For progressive k-d trees, we used the same settings as those used in the first benchmark except ops = 4, 000 for shorter insertion time. Since KNN lookup tables were designed for the all approximate knearest neighbor problem, we sampled 1,000 points from the training data as test data instead of using an extra set of 1,000 points. We set the value of τ for internal progressive k-d trees to 0. 5. To see the effect of dirtiness tests, we used three different values for λ (i. e. , the queue update fraction): 0. 3, 0. 4, and 0. 5. Other constants were identical to those of the first benchmark, such as k = 20 and α = 100.
KNN density estimation is similar to KNN regression except that it predicts the density of training data on a specific point instead of a target value. The goal of KNN density estimation is to provide density information on 2D input points to help users understand the distribution of the input points. Again, suppose that training data X consists of N instances, x 1 , x 2 , • • • , x N. Using a Gaussian kernel with a bandwidth h, the density of X on a specific point p is given by ρ(p): Fig. 2 : Benchmark results of k-nearest neighbor lookup tables according to datasets (GloVe  [41]  and Blob) and ordering conditions (original and shuffled). Designed for repeated KNN queries for points in training data, KNN lookup tables can answer a KNN query in constant time (i. e. , one table lookup operation).
e. , the projection includes more points) and quality (i. e. , the projection minimizes the error between the original points and the embedded points). To compare our responsive t-SNE algorithm with the BH-SNE algorithm, we ran both algorithms on the MNIST dataset  [45]  as an exploratory benchmark. The MNIST dataset consists of 60,000 vectors, each vector representing 784 (28 × 28) pixels of a handwritten digit scanned. We used an open-source implementation of BH-SNE  [46]  as a baseline. In contrast to the BH-SNE algorithm, where the projection (i. e. , y i ) is randomly initialized for all points, we used random initialization only for the points in the first batch. For each point in later batches, we set its initial position to the centroid of its k neighbors, which is a better starting point.
96 for BH-SNE and 4. 59 for responsive t-SNE. Since responsive t-SNE computes an embedding incrementally, the quality of the resulting embedding can be affected by the order of input points. For example, we can create an extremely skewed dataset by sorting the MNIST data by the digit each instance represents (e. g. , from 0 to 9). To alleviate the bias resulting from the skewed data, we introduce a technique called periodic exaggeration, which is inspired by a technique from a previous study  [3]. Periodic exaggeration regularly multiplies a constant factor to the conditional probabilities between points, which allows the clusters in the data to form separated clusters in the embedding. For instance, the responsive t-SNE algorithm increases the conditional probabilities by a factor at the beginning of the 100 first iterations, and restores them to 1 after 30 iterations.
One common task in exploratory visual analytics is to understand the overall distribution of multidimensional data. To support this task, we can construct a visualization pipeline by combining responsive t-SNE and progressive density estimation. The multidimensional data is first projected on a 2D plane progressively through responsive t-SNE. Then, we measure the density of the embedding for each sample point on a grid using the progressive density estimation algorithm. Finally, we can draw a contour plot to show the density, giving an overview of the multidimensional data within a controlled latency.
IMPLEMENTATION We implemented the core of PANENE in C++ as well as a Python binding of PANENE called PyNENE, for a wider range of applications, such as its integration in the Progres-siVis toolkit  [1]. PANENE relies on the OpenMP library  [47]  to process multiple queries in parallel, and on the Roaring Bitmaps library  [37]  to support efficient filtering. PANENE, the parameters for benchmarks, and applications presented in this paper are available at github. com/e-/PANENE under the BSD 2-clause "Simplified" License.
For now, in our benchmark settings, it took approximately 0. 15 seconds on average to split a node with 10 millions of 100-dimensional points. Finally, in this work, we assumed that our algorithms run on a single thread. However, the only constraint we Fig. 3 : Embedding of the MNIST dataset using Barnes-Hut t-SNE and Responsive t-SNE The Barnes-Hut t-SNE algorithm took about 45 minutes to precompute the nearest neighbors of data points, restricting interactive analysis. In contrast, our responsive t-SNE produced the initial result in a few seconds by computing the nearest neighbors progressively and running the optimization loop of the t-SNE algorithm in an alternate manner. The Barnes-Hut t-SNE took 54. 4 minutes to run 1,000 iterations, giving a loss of 3. 96, while the responsive t-SNE took 11.
| ddRAD sequencing and genotyping Genomic DNA from silica-dried leaf tissue was extracted using Qiagen's DNeasy Plant Mini Kit (Qiagen, Germany) and quantified using a Qubit dsDNA HS Fluorometer (Life Technologies, Sweden). We prepared libraries for double-digest RAD sequencing (ddRADseq) with the restriction enzymes EcoRI and Taq α I as described in  Liu and Karrenberg (2018). Briefly, enzymatically digested DNA was ligated with barcoded adaptors and size-selected to ~550 bp  (Peterson et al. , 2012). In total, nine 48-plex libraries were sequenced on Illumina HiSeq 2500 systems at the SNP&SEQ Technology Platform of SciLifeLab, Uppsala, Sweden, using 125-bp paired-end chemistry and two libraries per lane. ddRAD-seq data were processed following the dDocent pipeline v2. 2  (Puritz, Hollenbeck, & Gold, 2014).
| Population structure We analysed population structure using admixture  (Alexander, Novembre, & Lange, 2009). To avoid inclusion of linked loci, we randomly selected one SNP per contig. The input file was prepared using plink  (Purcell et al. , 2007). We examined the clustering of individuals in admixture with the number of groups (K) set to two (the number of species) and to 20 (the number of populations). In addition to the admixture analysis, we also assessed the relationships between populations using a neighbour-joining tree based on genetic distance in the r package hierfstat  (Goudet, 2004 ) and a principal component analysis (PCA) using the glPca command in the r package adegenet  (Jombart, 2008).
| Demographic modelling To investigate the evolutionary history of the lineage split between S. dioica and S. latifolia, we performed demographical modelling based on the folded joint site frequency spectrum (SFS) using the software ∂a∂i, which implements a diffusion approximation-based approach  (Gutenkunst et al. , 2009). We randomly selected one SNP per reference contig (average length 251 bp), a total of 10,415 SNP, for sub- We first considered a standard set of demographic scenarios: strict isolation without gene flow (SI), isolation with gene flow (IM), secondary contact (SC) and ancient migration (AM) (Figure  S1 ). As a second step, we added population expansion to each of these models ("exp" models). Further models allowed for heterogeneity in migration rate, | 5 LIU et aL. m ("hm" models), effective population size, N e , ("hn" models) or both m and N e ("hmhn" models).
Nested model comparisons were performed using likelihood ratio tests; comparisons of non-nested models were based on the Akaike information criterion (AIC). In addition, we used simulations to assess goodness of fit of the best-supported model as suggested by R. Gutekunst (https://github. com/dport ik/dadi_pipel ine/tree/maste r/Goodn ess_of_Fit). This approach is similar to parametric bootstrap for a chi-square goodness-of-fit test between the observed SFS and model SFS for the best-fitting model. We simulated 100 SFSs using model parameter genotype call rate: >70% of the individuals, excluding individuals genotyped at < 6% of the sites). We used a generation time of one year and a mutation rate μ of 7. 92 × 10 -9 for estimating population size and divergence time  (Krasovec et al. , 2018).
| Calculation of differentiation, sequence divergence and diversity statistics We calculated differentiation between the two species as hierarchical F-statistics ("hierarchical F ST ") to account for population structure within species using AMOVA models in the R package hierfstat  (Goudet, 2004)  for both SNPs and contigs. We also calculated Nei's estimate of F ST  (Nei, 1987 ) between all population pairs (between species and within species). We calculated sequence divergence, d XY, between the two species using a custom Perl script. Within each species, we computed genetic diversity (π) using vcftools  (Danecek et al. , 2011)  and estimated Tajima's D  (Takahata & Nei, 1985)  using a custom Perl script. For contig-based calculations dependent on sequence length (d XY , π and Tajima's D), we determined sequence length as number of bases meeting SNP filtering criteria in each contig as described above.
| Genomic landscapes and signatures of selection As a first step, we analysed correlations between contig-based F ST and d XY using a permutation test in the R package coin  (Hothorn, Hornik, Wiel, & Zeileis, 2006). We further identified genomic islands of elevated differentiation as contig sequences with hierarchical F ST exceeding the 95% quantile of the F ST value distribution for all contigs. To assess signatures of selection in these highly differentiated regions, we compared d XY , π and Tajima's D between the differentiation islands and background regions using Mood's median test in the R package coin  (Hothorn et al. , 2006). The above analyses were performed both for mapped contigs (data from both linkage maps combined, N = 1,327) and for all contigs in our data set (N = 10,415).
| Within-versus between-species differentiation Genetic differentiation landscapes within and between species are expected to correlate if they are mainly governed by variation in conserved genomic features, such as recombination rate variation and gene density  (Berner & Roesti, 2017; Burri, 2017; Haenel, Laurentino, Roesti, & Berner, 2018; Stankowski et al. , 2019). We compared the betweenspecies differentiation landscape (hierarchical F ST ) to within-species differentiation landscapes using the population pairs with the highest overall F ST within each species. We further evaluated correlations of hierarchical F ST and within-species F ST for both mapped and all contigs using a permutation test in the r package coin  (Hothorn et al. , 2006).
The observed joint site frequency spectrum (SFS) of the data was similar to the one generated by the best-supported IMhmhn model, except for a more pronounced pattern along the diagonal in the observed SFS: loci with high frequencies in one species but low frequencies in the other were underrepresented in the model as compared to the data (Figure3b). Normalized model residuals were mainly in the range of -2 to 2, with a bias towards positive residuals (FigureS4a,b). Goodness-of-fit tests between observed SFS and model SFS for the IMhmhn model yielded chi-square and likelihood ratio values close to modes of the distributions of these statistics for tests between simulated SFS and model SFS, indicating that this model fits the data well (Figure S4c,d, https://github. com/dport ik/ dadi_pipel ine/tree/maste r/Goodn ess_of_Fit).
DATA ACCE SS I B I LIT Y Double-digest RAD (ddRAD) sequencing data will be available on NCBI's Short Read Archive (SRA, SUB7812013 https://www. ncbi. nlm. nih. gov/sra/PRJNA 649094). The data in variant call format (VCF) file, Perl codes for genetic analysis, R codes for plotting and Python codes for demographical modelling are available on Dryad (https://doi. org/10. 5061/dryad. 6djh9 w0zd).
In core computer vision tasks, we have witnessed significant advances in object detection, localisation and tracking. However, there are currently no methods to detect, localize and track objects in road environments, and taking into account real-time constraints. In this paper, our objective is to develop a deep learning multi object detection and tracking technique applied to road smart mobility. Firstly, we propose an effective detector-based on YOLOv3 which we adapt to our context. Subsequently, to localize successfully the detected objects, we put forward an adaptive method aiming to extract 3D information, i. e. , depth maps. To do so, a comparative study is carried out taking into account two approaches: Monodepth2 for monocular vision and MADNEt for stereoscopic vision. These approaches are then evaluated over datasets containing depth information in order to discern the best solution that performs better in real-time conditions.
Object tracking is necessary in order to mitigate the risks of collisions. Unlike traditional tracking approaches which require target initialization beforehand, our approach consists of using information from object detection and distance estimation to initialize targets and to track them later. Expressly, we propose here to improve SORT approach for 3D object tracking. We introduce an extended Kalman filter to better estimate the position of objects. Extensive experiments carried out on KITTI dataset prove that our proposal outperforms state-of-the-art approches.
g. , laser-ultrasonic  [12]  and time of flight sensors  [13]. These kinds of sensors are widely used in such contexts, yet the use of multiple types of sensors, distance sensors with cameras makes the system more complex and expensive. Unlike most of the closely related work and in order to relax the computational complexity, we investigate here in this work a monocular camera to infer the distance information of the scene used in the detection step. For learning purposes, if the datasets used for object detection had the distance from object as ground-truth information, information of distance could be learned by adding for example a regression output to the CNN. The literature still lacks such a dataset that contains the distance map for each instance. Another problem is the fully connected layer of the neural networks, i.
Overview In order to design an efficient object detection technique, achieving the right speed/accuracy trade-off for a given system is required. As hinted earlier, deep learning based approaches are reporting state-of-the-art results for most challenging contexts; however, the main constraints related to the use of Deep Learning algorithms is the computation cost required for training on large scale dataset. Although some deep architecture applied to different different domains can run on CPUs, for our task here, a fairly powerful Nvidia R GPU with at least 4 GB of VRAM is crucial. To perform the training of different deep learning architectures, the supercomputer MYRIA (https://www. criann. fr/renouvellement-2016/) is utilized, which is used by numerous research institutions and companies for applications ranging from fluid mechanics to Deep Learning calculations.
Datasets The second most important constraint in Deep Learning is the acquisition of large scale datasets needed for training and testing the performance of the proposed algorithms against the state-of-the-art ones. Owing to the importance of autonomous driving, there are numerous datasets devoted to the road domain such as KITTI  [18]  which provides images from a stereoscopic camera, the depth of the scene measured by a Lidar Velodyne as well as annotations of the vehicles and pedestrians for the detected objects. Along with KITTI, many other datasets are available such as CityScapes  [19] , Pascal VOC  [20] , MS-COCO  [21] , ImageNet  [22]  and OpenImages [23].
Deep Learning Libraries We employ several libraries available in the field of deep learning. Among the most important libraries, we can cite TensorFlow, which is the most famous open-source library. It was developed in Python and C ++ by Google. Similarly, Keras is an open-source deep learning library available also on Python. This library offers the possibility to create high-level neural networks. It is one of the easiest to understand and use, and it allows fast creation of network prototypes. However, it is less efficient than other recent libraries, for e. g. , Pytorch, which is a high-level open-source library that has been developed to integrate seamlessly with other Python modules like Numpy, SciPy and Cython. This better integration makes this library simple to use while offering very good performance.
Object Detection Based SSD SSD  [6]  is based on a single network to perform the region proposal and classification, thus allowing to reduce the computational time. The feature extraction is performed by VGG-16  [25]. To allow a multi-scale detection, the size of the layers is gradually smaller, and each of them produces a separate prediction. Several implementations of SSD have been tested on Python. All tests were performed using a COCO-based pre-trained model consisting of 80 classes ranging from a person to a flower pot. The results of these different implementations in terms of computation time can be found in Table  1. An example of an image returned by the algorithm can also be found in Section 4. 4. It is important to note that the detection performance is identical while the computation time and accessibility to code changes are affected in the different implementations.
Detectron Object Detection Detectron is a C ++ and Python library specialized in object detection based on Deep Learning developed by Facebook and implemented in Caffe2. Among the present methods, we can find Faster RCNN  [10]  and Mask RCNN  [8]. Both of these methods rely on two separate neural networks to perform the detection. The first one is the Region Proposal Network (RPN)  [26]  in charge of finding the region of interest where an object is located. The second network is for object classification in the bounding boxes returned by the RPN. Mask RCNN  [8]  is able to to extract a mask from the detected objects, which therefore represents a better localisation of the object in the image compared to the bounding boxes returned by most other object detection algorithms. However, this performance in terms of detection has heavy computing time and thus Mask RCNN  [8]  rotating at 3 frames per second.
Performance of Detection Evaluating detection performance is a complex task that requires a lot of time. It is for this reason that we have relied on the results published in the article by YOLOv3 to choose the optimal algorithm. It indicates that YOLOv3 works better than SSD, which is confirmed by the inference tests we have done. Comparative results with state of the art can be found in Table  1. An example of detection of YOLOv3 with respect to the SSD is given in Figure  4. In view of the above results, we therefore select YOLOv3 on PyTorch because it offers detection performance superior to that of SSD while offering an acceptable computational time. Finally, the advantage of YOLOv3 on PyTorch compared to SSD on Caffe is that the whole code is in Python, whereas Caffe is mainly in C ++, which makes YOLOv3 more simple to modify to match the constraints of the project.
Choice of the Method In order to select which method to use, we first determine which method performs best in each category: Monocular and Stereoscopic. The evaluation of the algorithms is problematic because each method returns the disparity map in a different format, so it is impossible to use it to find the depth map. To overcome this problem, each method has been tested on a sequence of the KITTI dataset because it has a ground truth of distance thanks to the lidar data. Owing to this, we can transform the disparity map returned by each method and transform it into a depth map using the median scaling between the inverse of the disparity predicted and the ground truth. The accuracy of the method is then estimated by computing the mean squared difference between the distance predicted by the algorithm and the ground truth.