dataesr/scientific-paragraphs-categorization huggingface dataset:
for N ∈ IpixNeighbour(t. ipix) do 4: S + = S + ∪ { t ⊕ ipix = n | ∀n ∈ N } 5: end for 6: end for 7: c = Join(R, S + , R. ipix= S +. ipix) 8: return Filter(c, sphericalDistance(c. R, c. S + ) ≤ ) The pseudo-code of cross-matching (HX-MATCH)  [23]  is explained in Algorithm 1. It takes as input two partitioned files and a search radius and returns all matching points that satisfy a distance criteria. The algorithm runs as follows: 1. We chose the smallest dataset as a reference, let say S. We augment S (into S + ), by creating for each object as many replicates as the number of neighboring cells (Line 4), where we substitute the HEALPix value (here ipix) by the current cell and the one of each neighbor cell (Line 4). Here, IpixNeighbour is a user defined function which returns the current cell and all the neighboring cells.
2. We apply an equi-join query between R and this augmented dataset S + to get the candidate pairs (Line 7). At last, the refinement step checks the exact objects' harvesine distance and returns the cross-match results (Line 8). To execute the cross-matching query, ASTROIDE integrates strategies to limit pairwise computations. It starts by scanning the two input files. Then, it applies the GENERATE logical operator which is internally defined in catalyst to calculate the list N of neighboring cells for each row in S and generate a new row for each element in N. This operator duplicates all objects of the reference catalog in the neighboring cells, runs a sort merge join algorithm on HEALPix indices, and finally, filters the output result according to the spherical distance predicate. (see physical plan in figure  5 )  Efficient process of a kNN join query is challenging since it involves both the join and the kNN query.
Experiments This section provides an evaluation study of ASTROIDE performance. We compare the effectiveness and the efficiency with the closest prototype in the state-of-the-art, i. e. SIMBA  [3]  and Spark SQL. Experiments were performed over a distributed system composed of 6 nodes having 80 cores with one Gigabit network. The main memory reserved for Spark is 156 GB in total. We used three datasets in our experiments: each record contains a sourceId, a two-dimensional coordinate (ra and dec) representing the star position on the sky and many other non spatial attributes including magnitude, metalicity, and so on. • GAIA. The public GAIA DR1 dataset  [1] , which describes more than one billion sources and represents the most detailed all-sky map in the optical to date. • IGSL. Short of the Initial Gaia Source List  [24].
Cone Search Query Figure  7  relates how the data size affects the performance of cone search queries on GAIA DR1 datasets. Predictably, the query execution time increases when the data size increases, due to the access cost to the partitions and the communication costs when the query result spread over several partitions. We observe that ASTROIDE is much more efficient than SIMBA, which in turn, outperforms SPARK SQL. Indeed, ASTROIDE requires less access to partitions than SIMBA but Spark SQL has to scan all objects in the dataset. Figure  8  studies the impact of query radius on execution time. We increased the radius from 2 arc-seconds to 50 arc-seconds. The performance of ASTROIDE, SIMBA and Spark SQL remains constant. ASTROIDE is two orders of magnitude faster than SIMBA and five orders of magnitude faster than Spark SQL.
Cross-Matching Query We evaluated the performance of ASTROIDE, SIMBA and Spark SQL regarding cross-matching queriy performance. As shown in Figure  9 , ASTORIDE is scalable and efficient. The performance shows a linear trend. Our approach shows the best performance compared to SIMBA because it requires less access to partitions and fewer objects along the borders. Since ASTROIDE is using the HEALPix library for its indexing module, a sky partitioning technique adapted to astronomical data, experiments show that ASTROIDE outperforms SIMBA. Furthermore, SIMBA only implements the Euclidean distance, which leads to erroneous result when cross-matching. For instance, the difference in terms of number of outputs for a catalog of 50 million stars is about 3000 objects. This is due to the difference between the spherical distance and the euclidean distance, i.
kNN Query Figure  11  shows the performance of the KNN query on GAIA datasets in ASTROIDE, Spark SQL and SIMBA. We select a random point from the input dataset, fix k to 10 and measure the execution time of the query. In Figure  11 , we study the effect of increasing the data size from 50 millions to 1. 2 billions. ASTROIDE outperforms Spark SQL since Spark SQL requires scanning the whole dataset to execute a kNN query. ASTROIDE achieves two orders of magnitude better performance than SIMBA, because it scans less partitions. In general, one or two partitions are sufficient to cover the kNN result. In addition, we study the effect of k parameter, by varying k from 10 to 100 (we fixed the data size to about 50 millions objects). Figure  12  shows that the performance of ASTROIDE, SIMBA and Spark SQL are not affected by k.
kNN Join The kNN join query is impossible to execute with Spark SQL. That is why we choose to compare the performance of kNN join in ASTROIDE with SIMBA. We tested the performance of this operator when increasing the number of objects of IGSL catalog while having the number of object fixed to 1 million for GAIA dataset. The result are presented in figure  13. We can observe that ASTROIDE outperforms SIMBA for k = 5. ASTROIDE shows a very scale up feature: it achieves a linear speed-up with the increase of the data size. The result of varying k on kNN join are illustrated in figure  14. As we can see, when k increases, the performance of SIMBA remains nearly the same. This is because SIMBA partitions the dataset applies a sampling technique to compute a distance bound for each partition. For ASTROIDE, the execution time increases linearly, which indicates that data replication is sensitive to k.
Conclusion In this paper, we presented a query processing module that improves the execution of astronomical queries using ASTROIDE, an astronomical in-memory processing framework. ASTROIDE achieves scalability through astronomical indexing and partitioning, dynamic query rewriting and efficient optimizer based on customized rules and strategies. Experiments have shown that our querying system is comparable to an existing spatial in-memory distributed framework. ASTROIDE is a workable solution intended for use by astronomers or as a backed for other services as virtual observatories or graphical tools. In future work, we will complement our approach with a deep cost analysis, and we will investigate the integration of a cost model into the optimizer. Another interesting perspective is to couple our system with a test and query profiling tool, which would facilitate the experiments, but also give insight into the optimization process.
ACKNOWLEDGMENT The present paper has been partially supported by CNES (Centre National d'Etudes Spatiales) and by the MASTER project that has received funding from the European Union's Horizon 2020 research and innovation programme under the Marie-Slodowska Curie grant agreement N. 777695. We would like to thank Veronique Valette from the CNES for her cooperation. We are also thankful to François-Xavier Pineau and colleagues from the CDS (Centre de Données astronomiques de Strasbourg) for their help regarding the ADQL Parser. This work has made use of data from the ESA mission Gaia.
kNN-Join(R,S,k) Input: R, S datasets, and k Output: R + ← ∅; L={} 2: for each t ∈ R do Res = {}; nb = 0 IpixN eighbour(P revN eighbours) -Res 7:nb = nb + count(S, ipix), ∀ipix ∈ V + = R + ∪ { t ⊕ ipix = n | ∀n ∈ Res} 12:end for 13: c = Join(R + , S, R +. ipix= S. ipix ) 14: XM=OrderBy(c, c. R. id,c. sphericalDistance (c. R, c. S)) 15: return = L ∪ {g1,. , g k |∀g 1 ,. , g n ∈ Group(XM, XM. R. id)}.
Algorithm 2 : 1 : 3 :V=R 213 kNN-Join(R,S,k) Input: R, S datasets, and k Output: R + ← ∅; L={} 2: for each t ∈ R do Res = {}; nb = 0 IpixN eighbour(P revN eighbours) -Res 7:nb = nb + count(S, ipix), ∀ipix ∈ V + = R + ∪ { t ⊕ ipix = n | ∀n ∈ Res} 12:end for 13: c = Join(R + , S, R +. ipix= S. ipix ) 14: XM=OrderBy(c, c. R. id,c. sphericalDistance (c. R, c. S)) 15: return = L ∪ {g1,. , g k |∀g 1 ,. , g n ∈ Group(XM, XM. R. id)}.
INTRODUCTION Cloud computing is a technology that uses the internet and central remote servers to provide services for its customers on demand  (Kaur et al. , 2011; Mell et al. , 2011). Google App Engine, Amazon EC2, Aneka and Microsoft Azure are some of the prominent cloud computing platforms  (Masdari et al. , 2016). Generally, the services provided by the cloud can be classified as SaaS (Software as a Service), PaaS (Platform as a Service) and IaaS (Infrastructure as a Service)  (Wu et al. , 2013). SaaS is a software delivery paradigm, where the software is developed by service providers and delivered via internet  (Espadas et al. , 2013). PaaS provides platforms to develop and deploy applications in cloud infrastructure using programming languages, libraries and so on  (Fakhfakh et al.
, 2014). IaaS providers deliver processing, storage, network and other fundamental computing resources to deploy and run customers' software  (Dillon et al. , 2010; Mell et al. , 2011). In fact, customers can provision resources (e. g. processors, storage space, network, etc. ) whenever they want and release them when they are no longer needed  (Dillon et al. , 2010). However, based on the "pay-as-you-go" model, customers are usually charged following the resource usage. Consequently, it is important to have the ability to adjust this usage, i. e. , allocate resources only when needed and release them when they are no longer used, in order to reduce costs. This can be done by dynamically allocating and releasing resources based on their usage  (Fakhfakh et al. , 2014; Xu et al. , 2009). Nevertheless, the dynamic allocation and release requires determining, for each application, which resources are used, as well as when and where they are utilized.
TASK IDENTIFICATION Our OO-to-Workflow mapping model establishes a unique mapping for a workflow tasks, a task corresponds to a method in the OO source code (see Figure  2 ). Thus, we transform all statements that do not represent method invocations in the OO code into method invocations based on code refactoring. Once this refactoring is done, we determine among all the code methods those to transform into primitive tasks from those to transform into composite ones. Finally, we determine the input and output data for each task.
Identifying Tasks Inputs and Outputs Each of the identified tasks, primitive or composite, have input and output data. As explained in section 2. 2, the inputs correspond to the parameters and the receiving object of the corresponding method, whereas the outputs are the inputs that have been modified and the returned value by the corresponding method. Note that the modified inputs of a task are considered as its outputs because their new values are produced by this task. To identify which inputs can be modified by a method, we compute for each method M both its DEF and USE sets. The DEF (resp. , USE) set contains parameters and attributes defined (resp. , used) by M, i. e. parameters and attributes that their values are modified (resp. , read) by M. An input INDATA of a task is considered as modified if either 1) INDATA is the receiving object of M and at least one of its attributes ∈ DEF(M) or 2) INDATA ∈ DEF(M).
Computing DEF and USE sets We consider that assignment on a variable of a primitive type (type which is not a class) is a DEF operation. All others operations on primitive variables are considered as USE ones  (Martena et al. , 2002). However, we consider that operations on an object are DEF ones in the following cases: 1) this operation defines some of the attributes of the object 2) it is a constructor invocation 3) it is a call of a method that modifies this object  (Chen and Kao, 1999). Otherwise, these operations are of USE category. Determining whether an input INDATA of a method M (i. e. a parameter or the receiving object) belongs to DEF or to USE sets depends on the DEF and USE sets of the methods called by M. An input INDATA of M is considered as defined (resp. , used) if it is defined (resp.
, used) by either 1) a statement of M which is not a method invocation (e. g. assignment, etc) or 2) at least one of the methods invoked by M. More precisely, an input INDATA is considered as defined (resp. , used) in a called method CalledM by M in two cases: • Case 1: INDATA is the receiving object of the invocation of CalledM and the DEF(resp. , USE) set of CalledM contains at least one of the attribute of INDATA. For example, the receiving object of the invocation of the method initilizeX in Line 21 (see Listing 1) is considered as defined because the the method initializeX defines the attribute x of the receiving object in Line 17. • Case 2: INDATA is passed as a parameter in the invocation of CalledM and its corresponding formal parameter is in the DEF(resp. , USE) set of CalledM. For example, the input y passed as parameter in the invocation of the method initializeX in Line 21 (see Listing 1) is considered as used because its corresponding formal parameter (i.
Note that, by replacing the DEF set with USE set in the former formula, it specifies when an input INDATA is considered as used. To compute DEF and USE sets, an analysis order of methods is required. For example, to compute DEF and USE sets of the method m (see Listing 1), DEF and USE sets of the called methods on the attribute foo (initializeX, getX and incX ) are required to check whether foo is defined and/or used. The built call graph allows the definition of a topological total order of its nodes. Analyzing methods according to this order guarantees that a called method is always analyzed before its caller. The first methods in the total order are the ones that do not invoke others. These methods correspond to the leaves of the graph. In the presence of direct or indirect recursion, the call graph contains cycles, and hence it is not possible to determine an order.
EXPERIMENTATION AND VALIDATION 6. 1 Data Collection As a proof of concept of the proposed refactoring process, we performed a case study on two applications. Table  3  provides insight into the nature of the used applications in our case study. eLib application is a Java program that supports the main functions operated in a library: 1) insert and remove of users/documents, search for users/documents and loan management. Its code is provided in  (Tonella and Potrich, 2005). PostOffice application is also a Java program that computes for each postal item its postage fee and its reimbursement rate. In addition, it prints item information. There are three types of postal items: letters, parcels and express parcels.
Refactoring Results We applied the workflow refactoring process on the source code of each application in order to generate the corresponding workflow. As explained previously, the first step in our refactoring process is task identification which requires applying extract method refactoring. Table  4  shows the applications characteristics after applying extract method refactoring using the built in functionality Extract method within eclipse IDE. As we can notice, the number of methods after applying extract method refactoring increased by an average of 27,15% with a standard deviation of 16,61. This can be explained by the fact that new methods were created depending on the number of fragments to be extracted, i. e. fragments consisting of statements delimited by user method invocations that belong to the same block, in the application'source code.
In addition to previous works that are related to workflow extraction, other works suggested to reverse engineer others abstract models by analyzing source code. In fact, reverse engineering of OO source code have been widely studied in literature. The aim is to generate models which allow the understanding of the structure, such as class diagrams  (Budhkar and Gopal, 2011) , and behavior, like activity diagrams, interaction diagrams and workflows. Several tools have been developed to recover an activity diagram from source code. Kosower and Lopez-Villarejo  (Kosower and Lopez-Villarejo, 2015)  proposed a tool, named Flowfen, to generate a set of interconnected activity diagrams from annotated C++ code. Each diagram represents a method in the source code. In order to recover these diagrams, the authors proposed that developers annotate the C++ code.
The task of Question Answering is at the very core of machine comprehension. In this paper, we propose a Convolutional Neural Network (CNN) model for textbased multiple choice question answering where questions are based on a particular article. Given an article and a multiple choice question, our model assigns a score to each question-option tuple and chooses the final option accordingly. We test our model on Textbook Question Answering (TQA) and SciQ dataset. Our model outperforms several LSTM-based baseline models on the two datasets.
Introduction Answering questions based on a particular text requires a diverse skill set. It requires look-up ability, ability to deduce, ability to perform simple mathematical operations (e. g. to answer questions like how many times did the following word occur?), ability to merge information contained in multiple sentences. This diverse skill set makes question answering a challenging task. Question Answering (QA) has seen a great surge of more challenging datasets and novel architectures in recent times. Question Answering task may require the system to reason over few sentences  (Weston et al. , 2015) , table  (Pasupat and Liang, 2015) , Wikipedia passage  (Rajpurkar et al. , 2016; Yang et al. , 2015) , lesson  (Kembhavi et al. , 2017). Increase in the size of the datasets has allowed researchers to explore different neural network architectures  (Chen et al.
The main contributions of this paper are (i) The proposed CNN model performs comparatively or better than LSTM-based baselines on two different datasets. (Kembhavi et al. , 2017; Welbl et al. , 2017)  (ii) Our model takes question-option tuple to generate a score for the concerned option. We argue that this is a better strategy than considering questions and options separately for multiple choice question answering. For example, consider the question "The color of the ball is" with three options: red, green and yellow. If the model generates a vector which is to be compared with the three option embeddings, then this might lead to error since the three option embeddings are close to each other. (iii) We have devised a simple but effective strategy to deal with questions having options like none of the above, two of the above, all of the above, both (a) and (b) etc.
Training Details We tried two different CNN models, one having f j 's equal to 3,4,5 and other having f j 's equal to 2,3,4. We refer to two models as CN N 3,4,5 and CN N 2,3,4 respectively. The values of hyperparameters used are: d = 300, k = 100. The other hyperparamters vary from dataset to dataset. Since the number of options vary from question to question, our model generates the probability distribution over the set of available options. Similarly, the number of sentences in the most relevant paragraph can vary from question to question, so we set a ij = -∞ whenever d j was a zero vector. Cross entropy loss function was minimized during training.
Results and Discussion The accuracy of our proposed model on validation set of TQA and SciQ dataset  (Kembhavi et al. , 2017; Welbl et al. , 2017)  is given in Table  1  and Table 2. GRU bl refers to the model where CNN is replaced by Gated Recurrent Unit (GRU)  (Cho et al. , 2014)  to embed question-option tuples and the sentences. The size of GRU cell was 100. For SciQ dataset, we used the associated passage provided with the question. AS Reader  (Kadlec et al. , 2016)  which models the question and the paragraph using GRU followed by attention mechanism got 74. 1% accuracy on the SciQ test set. However, for a question, they used a different corpus to extract the text passage. Hence it is not judicious to compare the two models. 1 : Accuracy for true-false and multiple choice questions on validation set of TQA dataset.
can be seen from the Tables  1  and 2, CN N 2,3,4  gives the best performance on the validation set of both the datasets so we evaluate it on the test sets. Note that GRU bl highly overfits on the SciQ dataset which shows that CNN-based models work better for those datasets where long-term dependency is not a major concern. This rationale is also supported by the fact that CN N 2,3,4 performed better than CN N 3,4,5 on the two datasets.
Model Accuracy GRU bl 68. 2% CN N 3,4,5 87. 1% CN N 2,3,4 87. 8% CN N 2,3,4 84. 7% (test-set) Table  2 : Accuracy of the models on SciQ dataset. The first three accuarcies are on validation set. The last accuracy is of CN N 2,3,4 model on the test set. Baselines for TQA dataset: Three baselines models are mentioned in  Kembhavi (2017). These baseline models rely on word-level attention and encoding question and options separately. The baseline models are random model,  Text-Only model and BIDAF Model (Seo et al. , 2016). Text-Only model is a variant of Memory network  (Weston et al. , 2014)  where the paragraph, question and options are embedded separately using LSTM followed by attention mechanism. In BIDAF Model, character and word level embedding is used to encode the question and the text followed by bidirectional attention mechanism.
Sentence level attention leads to better attention weights, especially in cases where a single sentence suffices to answer the question. If question is given as input to the model, then the model has to extract the embedding of the answer whereas giving question-option tuple as input simplifies the task to comparison between the two embeddings. SciQ dataset didn't have any questions with forbidden options. However, in the validation set of TQA, 433 out of 1530 multiple choice questions had forbidden options. Using the proposed threshold strategy for tackling forbidden options, CN N 2,3,4 gets 188 out of 433 questions correct. Without using this strategy and giving every question-option tuple as input, CN N 2,3,4 gets 109 out of 433 questions correct.
A number of groups exist on Facebook and LinkedIn, and increasingly also in the online platforms of learned societies like the Institute of Electrical and Electronic Engineers (IEEE) in which discussions on subjects similar to the CCL's take place. They may oppose less friction to membership, provide richer interactions, and supply software, datasets, literature, and other resources, in formats with which especially younger researchers and students are familiar. However, they have not "caught" enough to displace the CCL, in part because some of the most valued members of the CCL have not migrated to those platforms, either for professional purposes only, or at all. The most valuable resource that keeps the CCL together, in this view, is its own community. It is a general trend in scholarly communities to give up on mailing lists (as a tool created, designed and maintained by scholars for scholars), like the CCL or the other chemistry related CHMINF-L list  [12] , and surrender to social media (as services to extract marketing value where scholars are dispossessed of their tools): the CCL is a place of resistance in this respect.