dataesr/scientific-paragraphs-categorization huggingface dataset:
Among all the aforementioned multidimensional visualization techniques (scatterplots, table lenses, PCP's, and projections), the latter are the most visually scalable and clutter free, as they map an n-D point to a 2D point. However, projections are fundamentally weak in accurately showing similarities between n-D points for the entire input dataset D  [24]. As such, given such a dataset D, there is typically no single projection V(D) that can faithfully show all patterns D. We shall show in Section 4 how we effectively address this problem by interactively combining insights obtained from different projections of a given dataset D. Graph drawings (GDs) are a second important type of element-based plots. In detail, a graph is a dataset D = (N, E) with nodes n ∈ N and edges e ∈ E. Both nodes and edges can have data attributes, thereby making D a multidimensional dataset.
Navigating Multidimensional Data Visualizations Exploring the space of visualizations that one can create for a given multidimensional dataset is a wide topic. Several technique classes exist to this end, as follows. Animation is a prominent technique that supports exploring the parameter space P and the related view space V. Animation has a long history in data exploration  [34, 35]. In this context, animation corresponds to a (smooth) change of the visual variables used to encode the input data V(D)  [1, 36]. Animation has proven to help users transition between visual configurations  [37]  while maintaining the mental map of the data exploration  [38]. The simplest form of animation, used by virtually all visualization tools, lets an user vary the value of p i interactively by a classical user interface (GUI) while watching how the V(P) changes.
While simple, this type of animation does not 'guide' the user in the exploration of the parameter space P and the related view space V in any way. Within the scope of multidimensional visualization, parameter-space animations include rolling-the-dice  [39] , where the user controls the plane on which the multidimensional data is projected; the grand tour  [40] , where a large sequence of 2D projections are displayed from a multidimensional dataset in a flip-book manner (the parameters P controlling projection-plane orientation in nD being varied randomly); the class tour  [41] , which refines the grand tour so as to generate projections which preserve class separation of the data points; combinations of the grand tour with projection pursuit  [42]  (the parameters P controlling the projection-plane orientation being varied along the derivatives of the so-called projection pursuit index, so as to drive the tour through interesting projections); and drawing faded trails that connect two consecutive views in a tour to give a feeling of how the projection plane changed in between  [43].
Examples of such manipulations are deformation, focus-and-context, and semantic lens techniques, all of which typically linearly interpolate between two parameter-set values P 1 and P 2 and show the corresponding animation of V(P 1 ) to V(P 2 ). Such animations have been applied to large element-based plots such as bundled graphs and scatterplots  [6, 58]. Smooth real-time animations of large datasets have been made possible by using GPU-based techniques  [59]. For multidimensional projections, we have the following direct manipulation techniques. Control-point-based projections, such as LSP  [60] , PLMP  [61] , generalized Sammon mapping  [62] , hybrid MDS  [63] , and LAMP  [15] , allow users to interactively (dis)place a small subset of V(D), called control points, on the 2D view plane, after which they arrange the remaining points around these controls so as to best preserve the nD data structure.
We will use all these techniques in the design of our exploratory visualization in Section 2. 2. Other approaches: Visualization presets have also been investigated for graph datasets  [69]. Separately, exploratory visualization approaches have used the view space in a foresighted manner to sketch possible next steps along the visual exploration path. Several such approaches exist, which can be subsumed by the term 'visualization by example'  [70]. All such approaches allow one to select a desired view V(P i ) from a range of candidates, the main distinction being how these candidates are picked from the view space calV and how V is presented to the user. Our proposal: We combine several of the advantages, and reduce some of the limitations, of the above-mentioned techniques for navigating a view space V constructed from a high-dimensional dataset D by means of a parameter space P, as follows: • Genericity: We handle all types of element-based plots (Section 2.
• Guided: The set of preset views between which the user can choose V(P i ) is limited by construction, and depends on the dimensionality of the input dataset D. • Free: The set of preset views is fully configurable by the user, who can choose any number and type of views in V to animate between. The second axis (horizontal in Figure  1  characterizes how the user can control the animation during the transition between two views V 1 ∈ V and V 2 ∈ V, and has tho values: • Implicit: Once the transition (animation) between V 1 and V 2 is triggered by the user, the generation of intermediate views between V 1 and V 2 happens automatically (usually via some type of linear interpolation). The user can specify V 1 and V 2 , but not the path in the view-space V along which the animation evolves nor can he slow/accelerate/pause the animation.
Our proposal FromDaDy Figure  1. Animation design space between two data views V 1 and V 2. The user can control or not the transition (controlled vs. automatic), and the transition is defined by the user or predefined by the tool (explicit vs. implicit). The presented tools are Histomages  [71] , Rolling-the-Dice  [39] , FromDaDy  [58] , and our proposal. To clarify the above, some examples of existing animations follow. Implicit and guided transition: Rolling-the-dice  [39]  is a metaphor of a 3D rolling die which allows smooth transitions between 2D scatterplots obtained from an nD dataset. The preset views V i are implicitly defined by the pair-wise combinations of data dimensions in the input dataset D (n 2 /2 in total). The transitions are automatic linear interpolations between two such scatterplots.
Implicit and free transition: In FromDady  [58] , the user can interactively define views to animate between, based on desired combinations of the dataset's attribute-pairs. In contrast to ScatterDice, the user can control the transition speed and direction (V 1 to V 2 or conversely) with a mouse drag gesture. However, the set of preset views V i is given by the pair-wise combinations of dimensions in the input data. Moreover,the transition is not entirely free, although one can control its direction and speed, its path is still a linear interpolation between V 1 and V 2. Explicit and guided transition: The user can define an open set of preset views V i that can be interpolated. For example, in the preset controller, these views are arbitrary parameter-sets P i that generate corresponding views V(P i )  [57].
• Allow one to freely sketch the interpolation path between two such view presets V(P i ), in an interactive and visual way (as in  [57] ), rather than automatically controlling the interpolation via a linear formula. We proceed as follows. Figure  2  illustrates the process for a multidimensional dataset D that we visualize using multidimensional projections, which are introduced in Section 2. 1. We proceed by allowing users to specify any (small) set of views V i for the given dataset D. These can be created either by the same visualization method, but using different parameter values P i , or by completely different methods. The only restriction is that these should be element-based plots, i. e. , consist each of N visual elements V i (d j ), 1 ≤ j ≤ N, one for each data element d j ∈ D.
We organize these view presets in a simple square grid, much like  [55] , to minimize the used screen space to display them (see Figure  2b ). As explained in Section 2. 2, manually generating a rich set of view presets V i can be delicate. Typically, one starts with a small set of just a few salient view presets, for instance, one for each type of visualization method considered for a given dataset. In our running example in Figure  2 , we have five such presets, corresponding to five multidimensional projection methods (PCA  [13] , Isomap  [14] , LAMP  [15] , MDS  [11] , and t-SNE  [12] ). In general, these views can be very different. In other words, they are a very sparse sampling of the rich view space V. We do not know what lies in between, so, navigating between them can be unintuitive.
As noted, the original views can be freely arranged over the thumbnails grid. This, and changing the power p in Equation (  1 ), offers a flexible way of specifying how the original views are mixed to yield the view V(x) at some position x. To better understand this, Figure  3  shows the effects of these two changes. Here, we have five views V 1. V 5 , arranged on a five by five thumbnails grid. Each entire view (and thus thumbnail) is simply a colored pixel in RGB space, for illustration purposes: V 1 = red, V 2 = green, V 3 = yellow, V 4 = purple, V 5 = blue, and V 6 = purple. As such, we can render the interpolated views V(x) at all the positions x over the thumbnails grid. In other words, the color images in Figure  3  show the entire view space V that can be generated from the five presets, something we cannot do, of course, for actual views of complex datasets.
However, the implementation becomes quite complex, as one has to code all the interaction and interpolation in a fragment shader whose code becomes hard to manage. We therefore explored another solution based on coding Equation (  1 ) in NVIDIA's CUDA parallel programming language. This solution proved to be even faster than the transform feedback one, while allowing for a simple implementation too. As a result, our tool can generate fluent animations of datasets having up to one million visual elements (points) on a modern GPU.
Software Dataset In this dataset, observations correspond to N = 6733 software repositories from SourceForge. net. The n = 12 dimensions are different quality metrics of the software repositories, such as the number of lines per method, coupling between objects, and the cyclomatic complexity of methods. For each repository (observation), metric values are averaged over all its units of computation (classes, methods, files). Details on these metrics and the data are available  [76]. Additionally, every observation is labeled by its type (e. g. , small library, large library, monolithic application). One interesting question for this dataset is whether projections can help us separate repositories of one kind (say, small class libraries) from those of other kinds (say, large monolithic systems).
We conclude that the 11 recorded metrics are not a good predictor of the type of software system in a repository-in other words, systems of different kinds can have similar qualities, and conversely. Interestingly, the same result was noted by the original paper that analyzed this dataset  [76] , which did not use multidimensional visualization. Separately, a different work also showed that using 2D projections cannot achieve the desired separation but that such a separation is better possible using a 3D projection  [77].
Segmentation Dataset In this use-case, the dataset D is a set of seven images. Every dataset element d i ∈ D corresponds to a three by three block of pixels from one of the images, that is manually labeled into six classes (e. g. , brickface, sky, grass, etc). Each of the N = 2300 elements has 17 dimensions which describe image features computed on the block of pixels. This dataset is well known in the machine learning literature , in the context of designing classifiers able to predict the six classes from the 17 measured dimensions  [78]. To do this, one way is to engineer discriminating features using the raw 17 ones present in the data. Projections can help us in determining how good the engineered features are: if we find a projection where same-class points are well separated into clusters then the features that the projection has used as input are a good start for building a good classifier  [79].
Bundled Graph Drawings Graphs are used to encode large relational datasets, such as the dependencies between components in a software system. As outlined in Section 2, a graph drawing can also be seen as an element-based plot, where the drawn edges are the elements. As also explained there, edge bundling (EB) is an established effective instrument for reducing clutter in large graph drawings, allowing one to follow easier the coarse structure of a graph. However, we have outlined that no single bundling method is ideal. The situation here is very similar to the visual exploration of multidimensional projections: we can generate a right set of bundled drawings; each drawing may be good for conveying partial insights in the input graph; but no drawing is optimal in this respect. Hence, having a way to merge the insights obtained from multiple EB drawings is useful.
We can use our method to mix several drawings created by different EB methods, as follows. For this, we consider a dataset having 1024 nodes, which are functions of a software system, and N = 4021 edges, which model function calls. The nodes are laid out in a radial way (for details, see the radial dataset in  [28, 29] ). Figure  8  (b) shows the unbundled graph, where one clearly cannot see any structure. The thumbnail grid is based on five presets, containing the bundling of the graph by the KDEEB method  [29]  (images (c) and (d); we used here two parameter sets for KDEEB, the first by pre-clustering graph edges based on their spatial similarity, and the second by using no clustering), the SBEB method  [28]  (image (e)), and the ADEB method  [30]  (image (f)). We start our navigation from the unbundled view to view 2, where we see three bundles which are well separated from the others.
Knowing this helps users in, for example, assessing which techniques behave similarly and thus can be substituted for each other in an application. Figure  9  shows how we can answer this question. We use here the same thumbnails grid and dataset as in Figure  8. However, we only perform four simple navigations, by going several times to-and-fro between the four preset views in the grid corners. The right image in Figure  9  shows intermediate frames during these animations. We see here that going from SBEB to ADEB or from SBEB to KDEEB-NoCluster creates relatively structured in-between frames. Hence, the methods SBEB, ADEB, and KDEEB-NoCluster provide similar layouts in terms of their visual signatures. In contrast, going from KDEEB-Cluster to KDEEB-NoCluster or to ADEB creates intermediate views that look completely messy.
In particular, the projections of high-dimensional data of Lehmann and Theisel  [47]  is interesting, as it captures (much of) the structure of an nD dataset with only n/2 projections. As above, the only constraint here is that all these presets are element-based plots of the same dataset. Scalability and simplicity: Our technique is simple to implement, requiring only the application of Equtaion (1) on the sets of 2D primitives corresponding to the preset views. Our current CUDA-based implementation can handle interpolation of datasets of roughly 10 preset views, each having about one million points, in real time on a modern GPU. Ease of use: The technique is fully automatic, requiring no user parameter setting, apart from organizing the available preset views in the thumbnails matrix-which can be done by a simple click-to-place process.
The difference is very important. It allows us to arrange our presets in any way so as to flexibly define regions over the thumbnail grid where only certain presets have a large influence. The importance of this flexibility was demonstrated earlier by Van Wijk et al. [57]. In contrast, ProjInspector only allows permuting presets along what is essentially a sampled circle. (b) ProjInspector does not use animation for data exploration. In contrast, we allow users to define multiple exploration paths, which are explicitly drawn and visualized in the thumbnail grid, and then (re)run the exploration along them. (c) ProjInspector only handles control-point-based projections  [15, [60] [61] [62] [63]. As outlined several times, we handle any projection, and actually any element-based plot. (d) ProjInspector is designed to work interactively for datasets of moderate size; the largest dataset at which the authors report interactive exploration has 19029 points.
2). Limitations and open points: Our technique has, however, several limitations, as follows. First, different placements of the preset views in specific places in the thumbnails grid can result in significantly different view-space explorations, due to the fact that the interpolation in Equation (1) considers the distances form the current focus point to these preset views. As such, certain intermediate views can or cannot be possible to realize, depending on where the presets are placed. Finding the optimal placement of presets for a given exploration of the view space is a challenging, and not yet solved, problem. However, we note that the same issue exists for all comparable techniques, most notably the original preset controller  [57]  and ProjInspector  [44]. Secondly, we note that some intermediate views created by interpolation typically may not correspond to an actual view of the input dataset realized by any given visualization method.
Conclusions In this paper, we presented a new technique to support the interactive visual exploration of multidimensional datasets. For this, we leverage the user's cognitive ability in terms of discovering stable and/or changing patterns in an animated view that is created under direct control of the user, by interpolation from a number of so-called preset views. Our technique combines and generalizes earlier animation and interaction techniques for exploring multidimensional data from a variety of viewpoints. Our proposal is generic (it works for any element-based plot consisting of a set of 2D point or line primitives), simple to implement and use, and scalable up to roughly one million data elements. We demonstrate our technique by applying it on multidimensional projections and bundled graph layouts and on several real-world datasets.
Acknowledgments: The authors acknowledge the support of the  French National Agency for Research (Agence Nationale de la Recherche -ANR)  under the grant  ANR-14-CE24-0006-01  project " TERANOVA ", the  SESAR Research and Innovation Action Horizon 2020  under project " MOTO " (The embodied reMOte TOwer) and the " Remote Tower " project from the  "Universite Federale Toulouse Midi-Pyrenees"  under the grant " Initiatives d'Excellence IDEX UNITI Actions Thèmatiques Strategiques (ATS) 2014 ".
The Cherenkov Telescope Array (CTA) observatory will probe the non-thermal universe above 20 GeV up to several hundreds of TeV with a significant improvement in sensitivity and angular resolution compared to current experiments. Its outstanding capabilities will allow to increase the number of extragalactic cosmic accelerators detected at very high energy (VHE) and therefore to better constrain the population of VHE accelerators and the gamma-ray absorption processes in the intergalactic medium. For the first time in the history of imaging atmospheric Cherenkov telescopes (IACTs), CTA will be an open observatory and high-level data will be made available to the astronomical community. Gammapy is an open-source Python package developed by the Cherenkov telescope community that provides tools to simulate the gamma-ray sky and analyse IACT data.
Gammapy 1  is a community-developed, open-source Python package for γ-ray astronomy  [2]. It is built on widely-used scientific packages (Astropy, Numpy, Scipy) and provides tools to simulate and analyse IACT data. It was thought to produce high level data, such as spectra, maps, light curves and even catalogues, taking as inputs lower level data such as event lists and instrument response functions. Classical methods to analyse data in very high energy astronomy, such as background substraction or full-forward folding spectral reconstruction are implemented and were highly tested with real data, especially in the H. E. S. S. experiment. Cube-style analysis, in which a spectral and a spatial model are jointly adjusted, is also implemented  [3]. In this contribution, we show how Gammapy can easily be used to tackle some extragalactic science cases of CTA.
We first present in Section 2 how point-like source simulations are made within Gammapy. Section 3 describes how it can contribute to the ongoing efforts to estimate the number of expected blazars that could be detected with CTA. Section 4 is a technical discussion on how Gammapy can be used to constrain the EBL scale factor. Section 5 briefly presents an application about GRB detectability. The Python scripts used to produce all results and figures presented here are available at https://github. com/gammapy/icrc2017-gammapy-cta-egal.
Application example: the EBL scale factor One of the main cosmological topics with the Cherenkov Telescope Array is to improve the constraints obtained with blazars on the diffuse extragalactic background light. A general and complete discussion can be found in  [11]. In this section we will focus on the technical aspects to constrain an EBL scale factor for a given absorption model with Gammapy and the Python library Sherpa  3. Gammapy has been designed to provide flexibility in data-analysis to the end users. Simulations can be fed to widely-used tools that have been developed for X-ray astronomy, such as the Sherpa library, to produce higher data level. Sherpa gives access to the full-forward folding method to handle spectral reconstruction and provides a convenient way to do arithmetic with spectral models.
Furthermore, each model can be adjusted on its own dataset and each parameter can be linked between different models, which makes the fit of the EBL scale factor straightforward. To obtain strong constraints on the EBL scale factor it is necessary to adjust multiple sources for different redshift ranges  [11]. The choice of the modelling of the source will have an impact on our ability to reconstruct the EBL scale factor. As an illustration, we studied the impact of an exponential cut-off, fixed at energy 1 TeV/(1 + z), on the determination of the EBL scale factor, called α, for different redshifts. To proceed, we used the same sample of blazars described in  [11]  and adjusted for each source the intrinsic spectra φ int and α resulting in an observed spectrum : φ (E) = φ int (E) × e (-ατ m (E,z)) where τ m is the γ-ray opacity of the intergalactic medium given by the model m.
Conclusion We have shown how Gammapy capabilities can be used to handle extragalactic science cases with the Cherenkov Telescopes Array. As mentioned in the introduction, we note that the Python scripts used to produce all results and figures presented in this contribution are available at https://github. com/gammapy/icrc2017-gammapy-cta-egal. This means anyone can reproduce and check the results, and use the scripts as examples to start their own studies.