dataesr/scientific-paragraphs-categorization huggingface dataset:
Among the five top-rated brain extraction methods on SVE, pincram is the only one that enables users to segment their own images with a publicly available atlas set. When carried out in sequence, the calculations involved in applying pincram to a given target are fairly time-consuming. This can be mitigated by parallelization. The current version makes a provision for shell-level parallelization of the registration subtasks via the '-par' option. The most computationally intensive parts of the calculation can thus be distributed to multiple CPU cores. In practice, we found that this reduces calculation times from 195 to circa 15 minutes. Further optimization of the code will lead to quicker turnaround times for single subjects. However, optimal throughput for larger target ensembles is achieved using the sequential task configuration (option '-par 1') and processing as many targets in parallel as the given architecture allows.
Collaboration patterns are an efficient way to define, reuse and enact collaborative software development processes. We propose an approach to define and apply collaboration patterns at modelling, instantiation or execution time. Our patterns, inspired from workflow patterns, are described in CMSPEM, a Process Modelling Language developed in our team. In this paper, we briefly describe the CMSPEM metamodel and focus our presentation on two collaboration patterns: Duplicate in Sequence with Multiple Actors, Duplicate in Parallel with Multiple Actors and Merge. The approach is illustrated by a case study concerning the collaborative process "Review a deliverable".
In this paper, we describe a set of generic collaboration software patterns and propose a way to apply them automatically. This work is a continuation of our previous works on process patterns  (Tran et al. , 2011)  and on collaborative software processes  (Kedji et al. , 2011 (Kedji et al. , , 2013)). In the first work we proposed a language to represent process patterns and a mechanism to apply patterns at modeling time. In the second work, we defined the meta-model CMSPEM as an extension of the OMG standard SPEM for describing collaborative software processes. The work described in this paper uses CMSPEM to represent collaboration patterns which are inspired from workflow patterns (Van der Aalst, website), and proposes mechanisms to apply collaborative patterns not only at modeling but also at instantiation or enactment time.
Solution: The same activity (cloned) is done by different actors playing a given role. They work in sequence on a product elaborated by another actor. The resulting product becomes the input for the next actor. Figure  7  shows this pattern as an activity diagram in CMSPEM for two abstract actors called Actor1 and Actor2. It contains abstract cloned activities having one input product and one output product. Each activity is enacted in sequence by different actors playing the same role. For example, this pattern could be used for enacting activities such as Design a software, Review a document, Test a program, etc. is in charge of merging the output products into a unique one. Solution: Cloned activities are enacted in parallel with the same product (cloned) as input. Their termination is synchronized and then followed by a merging activity performed by one of the actors.
CONCLUSION Our work mainly addresses collaborative software process modeling and enactment. For that sake, we decided to define and apply collaboration patterns inspired from workflow patterns whose efficiency has been largely proven. In this paper, we have proposed an approach to firstly (1) model collaboration patterns in CMSPEM, and secondly (2) apply them during software development. Our proposition has been validated (as a proof of concept) on a simple but realistic case study. A prototype supporting the approach has been also developed. The tool is operational, but other collaboration patterns should be implemented in the prototype. As main perspectives of this research work, we are considering several topics at short and longer terms. First we intend to enrich the base of collaboration patterns, and to manage them thanks to.
Acknowledgements This work was supported by in part by the  ERC  advanced grant Higgs@LHC, by the  French Agence Nationale de la Recherche , under grant  ANR-10-CEXC-009-01 , by the  EU ITN  grant LHCPhenoNet, PITN-GA-2010-264564 and by the  ILP LABEX  ( ANR-10-LABX-63 ) supported by  French  state funds managed by the  ANR  within the  Investissements d'Avenir programme  under reference  ANR-11-IDEX-0004-02.
To our knowledge, GCM is one of the only established component models that provides specific features for managing complex software systems, and that offers architectural artifacts and methodological approaches to organise the control part of such applications. GCM-based systems can be designed and modeled using the Ver-Cors tool  1  ; An XML-based Architecture Description Language (ADL) file, describing the architecture of the application, can then be generated by VerCors and used to build and deploy the GCM application, using the GCM/ProActive execution environment  [5]. We started from the formal representation of GCM architecture given in  [2]  and introduced a number of important concepts. This article has the following new contributions: • First, we provide a formal representation of component architectures including a flexible set of constructs for the definition of non-functional part of an application which has never been formalized before.
VerCors VerCors is a platform for the specification, analysis, verification, and validation of the GCM-based applications. The principle of the tool is illustrated in Figure  3. First, a user specifies the architecture of a GCM-based application, the signature of its interfaces, and the behavior of the primitive components using VerCors Component Editor (VCE). Then, from these descriptions the behavioral model of an application is generated (ADL2N) in a form of a dedicated behavioral semantic model: a parameterized networks of synchronized automata (pNets). This semantic model is transformed by abstraction functions (ABS*), until reaching a finite model suitable for model-checking. Finally, the resulting behavioral model is translated (N2F) into a set of languages used by a Model Checker (CADP tool  [10] ).
Related Approaches In a slightly different application domain, BIP  [6, 3]  is a formal framework that allows building and analyzing complex component-based systems, both synchronous (reactive) or asynchronous (distributed) by coordinating the behaviour of a set of primitive and heterogeneous components. BIP is supported by a tool set including translators from various programming languages as Lustre and C into BIP, a compiler for generating code executable by a dedicated engine, and the verification tool dFinder. Concerning the formalization of component structure, the two closest previous works are the formalization of Fractal in Alloy  [14] , and the formalization of GCM in Isabelle/HOL  [12]. The first framework focuses on structural aspects in order to prove the realisability of component systems, while the second aims at providing lemmas and theorems to reason on component models at a meta-level, and prove generic properties of the component model.
3 in order to validate component assemblies. The Acceleo language  4  is used for the definition of such rules. An example of a rule defining the naming constraint for the components is given below: [not self. siblings(Component)->collect(name)->includes(self. name)/] This rule will be applied to each component. Here, self is the component on which the constraint is validated; let us denote it C. The function siblings(Component) returns the set of all the components in the same container as C. The function collect(name) extracts the names of all such components. Finally, includes(self. name) checks if there is any component with the same name as C and returns true if it finds one. VCE v. 3 editor reports about the constraint violations. The elements of the architecture which are not correct are marked with red signs.
The description of an error is given in a standard Eclipse Problem panel. Figure  4  illustrates an example of the architecture validation result; the architecture contains only one error: there is a binding between two interfaces with incompatible types (C1 and S1). To conclude, based on the formal definitions given in this paper, we implemented an environment for the specification of the component-based applications involving group communications and with strong separation of functional and non-functional concerns. The validation of designed models ensures the correctness of the components assemblies. From this specification VerCors environment allows the verification of the behavioural properties of the system, and the generation of executable code that is safe by construction and can be run using the GCM/ProActive library.
Acknowledgments We thank  Jukka Pekola  for discussions on the physical implementations. We acknowledge financial support from the  Swiss National Science Foundation  (grant  PP00P2_138917  and Starting Grant DIAQ), SEFRI ( COST action   MP1006 ), and the  EU SIQS. GH also acknowledges support from the  ERC  grant MesoQMC. MH acknowledges funding from the  Juan de la Cierva fellowship  ( JCI 2012-14155 ), the  European Commission (STREP "RAQUEL")  and the  Spanish MINECO  Project No. FIS2013-40627-P , the  Generalitat de Catalunya CIRIT  Project No. 2014 SGR 966. Appendix A. Implementation with flux qubits.
Related Work Privacy preserving data sharing has been a well studied problem, particularly in the context of sharing information from databases controlled by multiple parties. The participating parties in a privacy preserving database querying system are: the data owner, variously called the data source or publisher of the data, who provides access to its data to others, the data querier who generates query against the publisher's data and receives the results, and the host who (potentially) stores the publisher's data, and executes the query by performing relevant computations. In our setting, we respectively denote by publisher, subscriber and broker the data owner, data querier and the host. The challenging scenario addressed in this work considers many competitor publishers that do not want to reveal any information about their data to each other but would like to anonymously and securely share some information with the subscriber.
In addition, the subscriber is not only interested in querying their data separately, but jointly in order to find connected records across the databases. Furthermore, the subscriber wants to be able to retrieve updates about some previously queried entities. If the querier is the owner of the data itself, and the host is an untrusted outsourced third party, searchable encryption schemes or Oblivious RAM (ORAM) are used to protect the data and maintain the owner privacy. Considerable amount of research has been done towards this problem that resulted in very efficient and expressive schemes  [1] [2] [3] [4] [5] [6]. However, in searchable encryption schemes, the data to be joined must be encrypted under the same key that has been shared among the owners. So searchable encryption schemes cannot directly be applied for our scenario.
In some settings, there are at least two parties each hosting their own data and either one or both of them wants to query other's data against his data. Each of them is considered the adversary to the other and ideally should not learn any thing beyond the query result. For such cases, private set intersection  [7, 8]  and multi-party computation are potential solutions  [9]. For instance, Agrawal et al. [10]  propose a set of operations on private databases between two parties where nothing is learned by the parties rather than the results of the operations. De Cristofaro et al. [11]  make also use of set intersection techniques, yet using a certification authority (CA) to authorize queries and leverage client and server privacy. However, these solutions although appealing from a security perspective are not very efficient for large settings.
Yin and Yau  [16]  propose a privacy preserving repository for data integration across data sharing services that allows owners to specify integration requirements and data sharing services to safeguard their privacy. The owners determine who and how their data can be used. The authors presented what they call context aware data sharing to help data services to share data with the repository. However, the matching process between records is done using the hash value of their identification information, which is not secure and does not preserve privacy. This scheme suffers from the same underlying problems of the previous construction, namely, a mandatory secret sharing between competing parties. Carbunar and Sion  [17]  introduce a mechanism for executing a general binary join operation on an outsourced relational database with low overhead using predefined binary finite match predicates for computed match set.
However they assume that the keys of both columns used in the join are known to the data owner. If the data belongs to two different owners, this key must be shared beforehand -essentially the same problem as earlier. Chow et al. [18]  propose a model for performing privacy preserving operations in a distributed database environment. The model, called Two-Party Query computation, comprises a randomizer and computing engine that do not reveal any information between themselves. The model in essence emulates a central party with the functions split into two entities. In order to guarantee that the randomizer and the computing engine do not collude, the authors proposes to use key agreement protocol among the participating entities. This protocol has limited applicability to our scenario since it doesn't not support the retrospective queries.
Finally, a solution presented by Tassa et al. [19]  targets gathering data between horizontally or vertically divided dataset while preserving sensitive information. The computation is over sanitized data set using k-anonymity or l-diversity sanitizing techniques. Their main focus is on anonymization of distributed databases in such a way that each party locally anonymizes its data without revealing its original content to others. While the ideas and techniques of this work are suitable for distributed data mining problems, since our requirements are quite different Tassa et al. ś work cannot be easily used to serve our needs.
Encryption of query results phase This phase is triggered by a query sent by a subscriber requesting information from publishers. This represents a data pull model; however, our scheme can be also used in a data push mode where publishers send data directly to the broker which redirects it to the corresponding subscribers. After executing the received query, each publisher encrypts the identifying parts of the query results using any cryptosystem that relies on DDH (Decisional Diffie-Hellman ) or DL (Discrete Logarithm) hardness assumptions, such as ElGamal cryptosystem. For performance reasons, our construction uses Elliptic Curves (EC) instead of Finite Groups of large primes as the underlying group for the used cryptosystem. Each publisher has the publicly known ElGamal EC parameters, i.
The search complexity depends on the query sent by the subscriber through the broker. Also the complexity of this phase greatly depends on the size of the database of the publishers and the sanitizing protocols used as well. For this reason, we consider only the communication overhead for this phase. For the last phase performed by the broker, given all identifiers that match the query, the goal consists of retrieving all subscribers identifiers as well as the randomized identifiers. Using SSE, the search is optimal and similar to plaintext data. Given an identifier, the search complexity will be in the number of matching results. To sum up, the construction does not induce any overhead during the matching phase more than the one expected on plaintext data. The linear construction of the key converters is done once during the instantiation of the protocol.
e. , the number of correctly located targets. The number of search errors was determined for the task "search red" with an error categorization as follows: type I errors (false positive), i. e. , a reported target was of correct shape but of wrong color, and type II errors (false negative), i. e. , a correct target was fixated, but not reported. Both types of errors are made on an already fixated item, and thus relate to the final "verification" stage of search  (Malcolm and Henderson, 2009) , rather than to search per-se. Statistical analysis was performed with MATLAB 2010a, Mathworks Inc. and R version 3. 0. 2. (R Core Team and R Foundation for Statistical Computing, 2013). Confidence intervals presented in figures were computed in MATLAB by applying the bias-corrected percentile bootstrap method.
ACKNOWLEDGMENTS The study was supported in part by the  German Federal Ministry of Education and Research  (Grant  01 EO0901 ) and by  DFG cluster of excellence CoTeSys  (www. cotesys. org). FS was partially supported by  ERC Advanced  Grant  323674  "FEEL. "The funders had no role in study design, data collection and analysis, decision to publish, or preparation of the manuscript. The authors thank  Peter König  for his contributions to the experimental design and the manuscript, and  Christoph Witzel  for feedback on the manuscript. We are grateful to  Solveig Schneider  for her suggestion to use candies as targets.
Acknowledgments The authors are grateful to  John Goold ,  Roberto Merlin ,  Keith Nelson ,  Mauro Paternostro  and  Charles Shank  for the insightful discussions and critical reading of the manuscript. We thank the  CAEN company  for the project and the realization of the differential detector used in the experiments. We acknowledge  Giovanni Franchi  for the design of the detector and  Riccardo Tommasini  for support during its development. The experimental activities have been carried out at the  TRex labs  within the  Fermi project at Trieste 's synchrotron facility. This work has been supported by a grant from the  University of Trieste  ( FRA 2013 ) and a grant from  Italian Ministry of Education Universities and Research MIUR  (SIR 2015, Controlling quantum Coherent Phases of matter by THz light pulses).
This paper presents an entity recognition approach on documents recognized by OCR (Optical Character Recognition). The recognition is formulated as a task of matching entities in a database with their representations in a document. A pre-processing step of entity resolution is performed on the database to provide a better representation of the entities. For this, a statistical model based on record linkage and record merge phases is used. Furthermore, documents recognized by OCR can contain noisy data and altered structure. An adapted method is proposed to retrieve the entities from their structures by tolerating possible OCR errors. A modified version of EROCS is applied to this problem by adapting the notion of segments to blocks provided by the OCR. It handles document segments to match the document to its corresponding entities.
INTRODUCTION With the growth of industrial data and the multitude of inflow sources in the companies, the processed documents can be of different types  (electronic, scanned, etc. )  and different classes (purchase orders, invoices, etc. ). These documents often contain unstructured textual data. For a better management, it is necessary to automate the task of data processing in documents by identifying and extracting contained information and then structuring it. The data contained in administrative documents are often predefined in structured catalogs: databases prepared by experts. An entity contained in a catalog is represented by a series of fields: text values whose semantics and types are informed by the headers of the database. Entity Recognition is the process of identifying and locating a term or phrase in an unstructured textual document referring a particular entity such as a person, a place, an organization, etc.
In this context, the problem can be reformulated as a task of matching a mentioned entity in the document with its representation in the database. This task is far from being solved by a simple intersection between words in document and those in database records and it is a more complex one since: • Documents do not explicitly mention unique identity of entities as defined in the database. • Terms defining the entity in the document differ from terms defining the entity in the database. This is caused by non-standardized representations like abbreviations, incorrect or missing punctuation and fused or split words. • The extraction of content from documents recognized by Optical Character Recognition (called OCRed documents in this paper) is a challenging task since we have to deal with OCR errors.
• OCR poorly reproduces the physical and the logical structures of the document. • Industrial databases are often voluminous, contain poor quality of data such as missing fields, typing errors and non-standardized representation. Also, they contain redundant records which could be represented differently but refer to the same real world entity. Such database is called redundant database in this paper. Entities defined in databases can be duplicated since database can be either dynamic, managed by different users, or a result of merging multiple databases. These problems related to the database make the comparison task with document complex. The task of resolving such problems is called entity resolution. An approach that benefits from entity resolution to enhance entity recognition in documents is proposed.
In this paper, we address the idiosyncrasies of entity recognition in an OCRed document that contains noisy data and has a specific structure. We propose a solution that retrieves entities from OCR blocks and identifies their structured representation in the database in spite of the altered content of OCR. Furthermore, we combine the two problems of entity resolution in industrial databases and entity recognition in documents and we show how the entity resolution task can enhance the entity matching task by improving the quality of the database. The remainder of this paper is organized as follows: Section 2 presents some related research about entity resolution and entity recognition, Section 3 details the proposed approach and Section 4 presents the experiments on real world data.
The authors in  (Cohen et al. , 2003)  studied the comparison between these different measures on record linkage results. In large databases, record pairs comparison is expensive since it consists of a cartesian product of records. (Bilenko, 2006)  proposed a step of blocking which consists of separating the database into blocks that contain approximately similar records. This separation could be based on a selection of keys such as regrouping records that share the same zip-code or the same first three characters of the name. Entity Recognition. In the literature, several studies have addressed the problem of entity recognition in unstructured documents. These studies could be classified into three categories: context-oriented approaches, data-intensive approaches and mixed approaches. • Context-oriented approaches are based on contextual rules and require an explicit linguistic and grammatical recognition of text using syntactic and eventual semantic labeling.