dataesr/scientific-paragraphs-categorization huggingface dataset:
Not all carbohydrate structures are susceptible to automated description by PDB-care. In a number of cases, we have manually curated and provided IUPAC descriptions for structures that are unsuitable to PDB-care: (i) nonreducing glycans (cyclodextrins, sucrose and sucrose derivatives, trehalose, kestose, raffinose, nystose, etc. ), (ii) ligands that contain both carbohydrate and noncarbohydrate moieties such as acarbose and acarbose derivatives, (iii) sulfur-containing oligosaccharides, (iv) fluorine-containing carbohydrates and (v) oligosaccharides containing 3,6-anhydro bridges. Table  2  displays examples of the manually handled cases. In addition, automated scripts have been devised to handle 180 carbohydrate analogues that we denote <carb_like_ligandref> where ligandref corresponds to the three-letter ligand name given by the PDB.
For instance, the carbohydrate-like inhibitor 1-deoxynojirimycin appears as <carb_like_NOJ>. The structural biology community is invited to contact us to report the possible errors that might have slipped through our curation process. As of September 2013, >1400 CAZymes and modules thereof have a known 3D structure, corresponding to almost 6000 PDB entries out of which 1500 carbohydrate (or carbohydrate analogue) ligands are now identified and presented in the structure tab of each CAZy family.
ACKNOWLEDGMENTS We thank  Thomas Lu¨tteke  ( Justus-Liebig University Gießen, Institute of Veterinary Physiology and Biochemistry, Germany ) for providing us the  PDB-care program , and  Kirk M. Schnorr  ( Novozymes, Bagsvaerd, Denmark ) for his help with proof reading this manuscript. Bernard Henrissat  is a Honorary Professor of Glycomics at the  Faculty of Health and Medical Sciences, University of Copenhagen, Denmark.
B. Simulation results Computer simulations with Matlab/Simulink are carried out to validate the performance of the new approach under industrial operating condition. We use the system parameters given in table 2. The system is supplied from a balanced three-phase voltage sources feeding a threephase diode bridge rectifier with inductive load. The reference current extracted by the neural method called the diphase current as shown in the Figure  7. It is similar to that identified by the conventional p-q theory, method based on the instantaneous powers with a time response of 10 ms (Fig. 6 ). The harmonic currents considered on the inputs of the two ADALINE for Diphase Current Method are the 5 th , 7 th , 11 th , 13th, 17 th , and 19 th.
C. Experimental results In order to validate the simulated results, experimental tests in real time with a dSPACE Board were carried out. The system is supplied from a balanced three-phase voltage sources feeding a controlled three-phase bridge rectifier (α=0°) with inductive load. The system parameters are illustrated in table 2; the two methods have been implemented on a dSPACE Board (DS1104) as shown in Figure  10. For fast response and in order to obtain the convergence of the LMS algorithm, the learning rate has been tested and chosen equal to 0. 01. This value is motivated by several tests and the input types of the ADALINE witch are the cosine and sine (they vary between -1 to +1). In this application, the program of the neural networks is written in C ++ code. The Current and voltage sensors have a reduction factor equal to 10.
CONCLUSION The results obtained by the two harmonic extraction methods prove that accurate harmonic current extraction is obtained when the diphase current neural method is used. It can be also noted that the approach is different and the following conclusions can be drawn: • If the system is unbalanced it is necessary to calculate the direct voltage components for the p-q theory. • The neural method can estimate the harmonic terms individually, and realize a selective compensation. • In real time implementations, the neural method is the most suitable technique because its algorithm can be converted easily to another programming language, such as C ++ or JAVA. The convergence can be obtained by testing the learning rate algorithm. • The architecture of the ADALINE enables the studied method to be easily implemented in real-time applications.
Due to many factors such as, high transistor density, high frequency, and low voltage, today's processors are more than ever subject to hardware failures. These errors have various impacts depending on the location of the error and the type of processor. Because of the hierarchical structure of the compute units and work scheduling, the hardware failure on GPUs affect only part of the application. In this paper we present a new methodology to characterize the hardware failures of Nvidia GPUs based on a software micro-benchmarking platform implemented in OpenCL. We also present which hardware part of TESLA architecture is more sensitive to intermittent errors, which usually appears when the processor is aging. We obtained these results by accelerating the aging process by running the processors at high temperature.
To study the intermittent and permanent hardware failures on different GPUs, we design and implement a microbenchmark platform in OpenCL  [11] , a portable high-level language. Our benchmarks platform helps the user to detect and localize the intermittent and permanent hardware errors on GPUs. Using the error location, it is possible to modify the hardware, the driver, or the user code to schedule useful work exclusively on trusted parts and avoid the defective ones. To validate the hypothesis of the error self-containement to a particular tile in the GPU hardware hierarchy, we design a hardware apparatus to accelerate aging of the GPU chip  [2]  while executing our benchmarks. We modify the cooling system of the target architecture and enclose the GPU card in a thermal chamber. The result is an accurate control of temperature increase to accelerate the GPU aging.
A. GPU programing model There are currently two main alternatives to program Nvidia GPU devices: CUDA and OpenCL. In order to ease the description of TESLA architecture, we use CUDA terminology. However, Table  I  shows the correspondence between the terminology of both languages. From the programmer's point of view, the thread hierarchy is divided in three levels: threads, blocks and grid. The same device code is executed by many thread operating in parallel on different data. Threads are packed in sets of block_size threads to form a so called blocks. Threads can be synchronized if they belong to the same block. Threads of a block and blocks of a grid are virtually launched in parallel. This means that no assumption can be done on their execution order. The grid is defined by its dimension in a number of blocks.
A block is identified by its unique coordinate in the grid, and a thread by its coordinate in the block. Therefore, the programmer can use these identification numbers to specify the work done by each thread in each block. The host controls the execution steps: create an execution context associated to the target device, allocate memory on the device, initiate the transfer of the input dataset, call the kernel on the device, and transfer the result to the host. When calling the kernel, the host fixes the grid and block dimensions. They have to be chosen carefully by the user to be valid and efficient on the target.
A. Host System It is essential in our protocol to minimize the interference between the device program and the control of the experiment. To do so, we use the OpenCL philosophy and delegate the control to the host code. The C++ code running on the host is generic and can be reused in experiments on various platforms. The host is in charge of: • Selecting the target device in case of multiple possible OpenCL target devices in the system. • Allocating memory on the device and transfer the initial input datasets. • Defining each kernel scheduling parameters, such as local work size and global work size. • Selecting the pattern of micro-benchmark kernels to execute in sequence. • Iterating over kernels sequence and repeat. • Controling the test duration. • Controling the number of iterations. • Performing some additional software controls of the working temperature by modulating the charge of the GPU.
B. GPU Device The benchmark is built from multiple micro-benchmarks. Micro-benchmarks are compiled without any optimization, and the generated assembly validity is checked with a disassembler. Among the specific targeted architectural elements, we focus on register banks (REGkernel), shared memory (SHMKernel) and fused add-multiply (MADKernel). Each of these kernels is built from a particular sequence of instructions in a loop. The instructions and the input data are built such as single error propagate up to the final result. This way, errors will be detected be comparing results with the reference results computed kernel launch. We provide a generic OpenCL template to build new micro-benchmarks. Each new kernel must provide an input dataset, a reference result, and an OpenCL kernel conforming to the signature template.
The output produced by kernel executions has to be deterministic. Algorithm 1 presents the SHMKernel. The kernel loads and stores in sequence different patterns from the shared memory. If an error occurred, it appears in vecA with its position. This code is not using the vecB reference result since the result is the input vector itself. Even though the framework is written in OpenCL with portability in mind, each device micro-benchmark has to be architecture dependent to take into account their internal specificities. In this work, each proposed OpenCL micro-kernel targets a very specific part of Nvidia architecture. We demonstrate our protocol for TESLA architecture. #define  NBPATTERN.
A. TESLA Scheduling Algorithm To ease the understanding of the link between the hardware and the software, we use the CUDA terminology for the execution parameter set in software. Without loss of generality we only consider execution parameter in one dimension, even though it is possible to set some of these parameters in higher dimension where, • GridDim is the number of block within the grid • BlockDim is the number of thread per block • BlockID. x is the block id x within the grid • T hreadID. x is the thread id x within the block In a similar manner, we define the following hardware identifier for a given GPU: • N umSM is the number of multiprocessor • SM. x is the multiprocessor number x • SP. x is the Streaming Processor number x In this definition, we omit the Thread Processor Cluster level, present in the TESLA architecture.
C. Solutions to Quarantine Defective Hardware To avoid faulty units, we propose to exploit a characteristic of the data parallel programming of GPUs such as CUDA or OpenCL. In this programming model, threads are independent and no communication is allowed between two threads of two different blocks. In addition, it is not possible to make any assumption about the scheduling of software threads of a given block as threads can be executed in any order. However, it is possible to define synchronization barrier between threads of a given block. We propose to avoid corrupted units using this important property. There are two solutions, either making correct SP do the job of corrupted SP and increasing ILP or by launching extra threads and/or extra blocks. We propose to detail the second solution which implies modifications of the execution parameters of the kernel as well as the kernel itself.
However, one can observe that divergence is contained. When a block is executed on a normal SM, only the code from line 2 to 6 is executed. In this case the overhead is limited to the test (line 2) and the management of the extra warps that are not doing any work (line 4). When a block is executed on a SM having a corrupted SP of index Corr SP (line 7 to 18), only correct SP are doing work (line 9), and the extra launched threads are used to make the others SP do the work that should have been done by the corrupted one. The described mechanism works as long as no assumptions are done on the thread scheduling as mentioned in CUDA or OpenCL specifications. However, we noticed during our tests, that this assumption is not always respected. Some developers are using the fact that all the threads of the same warp execute in one single step.
For example, this is the case for the last few steps of the reduction program provided with the OpenCL/CUDA Nvidia sdk. A solution would be to force developer to respect the philosophy of the data parallel programing model and do not make such assumptions about the hardware. In a similar manner it is possible to alleviate the impact of vector error. In this case, the entire multiprocessor were those errors arise are unreliable and should be avoided. It is possible to do so by launching extra M/N umSM blocks and using the same test as described in listing 3, line 2 to avoid the faulty multiprocessor.
In this article, we have seen three major contributions improving the reliability of GPUs. The first one, is GPUBurn, a framework implemented in OpenCL made of several micro-benchmarks. This framework addresses three different hardware units of the TESLA architecture. GPUBurn can be easily extended to other units and architectures. The second contribution of this paper is to investigate which units of TESLA architecture are the most sensitive to IC aging. This is possible with a thermal chamber where GPUs are running at high temperature. We observe that most of the errors were concentrated on streaming processor or multiprocessor level. The third contribution is a set of software modifications of the execution kernel to quarantine faulty units at either streaming processor or multiprocessor level when detected.
Motivation: The cell nucleus is a highly organized cellular organelle that contains the genetic material. The study of nuclear architecture has become an important field of cellular biology. Extracting quantitative data from 3D fluorescence imaging helps understand the functions of different nuclear compartments. However, such approaches are limited by the requirement for processing and analyzing large sets of images. Results: Here, we describe Tools for Analysis of Nuclear Genome Organization (TANGO), an image analysis tool dedicated to the study of nuclear architecture. TANGO is a coherent framework allowing biologists to perform the complete analysis process of 3D fluorescence images by combining two environments: ImageJ (http://imagej. nih. gov/ij/) for image processing and quantitative analysis and R (http://cran.
Data organization and general workflow The input data of TANGO consists of multichannel Z-stack images of microscopy fields, containing one or several nuclei. Each channel corresponds to a fluorescent marker and can be associated with a biological compartment of interest (further termed structure). All image files compatible with Bio-formats (http://loci. wisc. edu/software/bio-formats) (4100 formats) can be imported to TANGO. The processing workflow is composed of two successive steps (Supplementary Fig. S1 ): segmentation of nuclei, followed by segmentation of structures within each nucleus (when needed). This results in an hierarchical organization of data: fields contain nuclei, which contain structures, which can contain segmented objects. This pre-defined workflow simplifies the workload: TANGO only requires specification of the number of channels, then the definition of associated structures.
Quantitative image analysis Quantitative image analysis is the process of computing numerical information describing each structure and the relationships between them. Voxel-based measurements quantify the staining pattern of a fluorescence signal within a segmented structure (e. g. mean intensity inside or outside objects, radial autocorrelation, layer measurements) or the co-localization of two signals. Segmentation-based measurements provide morphological descriptors of objects (e. g. volume, elongation) or descriptors of spatial relations between several objects, including overlap, border-to-border distance between pairs of objects or radial localization within the nucleus. TANGO includes a large collection of 3D measurements, some of which are rarely encountered in image analysis software (listed in Supplementary Table  S2 ), and programmers can easily add their own plug-ins.
Statistical processing with R A part of TANGO is implemented as an R-package. Measurement results can be directly imported from the TANGO database to R as indexed dataframe objects and thus can be processed using the wide panel of functions provided by R. When analyzing data, it can be useful to visualize the images associated to a subset of the studied population. To do so, subpopulations of nuclei and objects can be defined in R and will be highlighted in TANGO. This can be accomplished through the use of interactive plots (Supplementary Fig. S4 ). Finally, rtango is compatible with a flow-cytometry r-package (flowcore) that implements specific data visualization and analysis tools, thereby providing a complete solution for image cytometry.
CONCLUSION TANGO is a versatile software, which, owing to a large collection of 3D processing operations and measurements as well as a convenient data visualization and analysis system, allows biologists to obtain quantitative information regarding the organization of the nucleus. We have successfully detected and analyzed various types of FISH (e. g. BAC probes or chromosome territories) and immunocytochemistry (e. g. centromeres or nucleoli) signals. TANGO is integrated into ImageJ and R, both of which are modular open-source software widely used in the scientific community, allowing one to benefit from the rich potential of the two environments when using TANGO (Supplementary Fig. S5 ).
SYSTEM ARCHITECTURE Basis of the REVERIE architecture, depicted in Fig. 1 , is a model where various REVERIE clients communicate, using an Application Server. The server, that shows up in the figure on the left side, hosts application related modules such as a game engine utilized for scene navigation and modules for avatar reasoning, and networking related modules like session manager, network monitoring and media stream synchronization. At the top of the figure, the social network is highlighted, which will be used for extracting static information of the participants (e. g. public information of their profiles) and dynamic information (e. g. participants availability). User generated content (e. g. virtual environments) could be stored and downloaded or shared on demand from the social network.
At the bottom of the figure, the Future (public) Internet is highlighted, which will provide the means for efficient delivery of content. The REVERIE project exploits and enhances technologies and tools integrated into one common framework to enable end-to-end processing and efficient distribution of 3D, immersive and interactive media over the Internet. This framework takes care of 3D data acquisition and processing (capturing of the human user's gestures and emotional expressions), 3D sound processing, networking, and real-time ren-dering. An avatar reasoning module deals with autonomous behavior, physical interaction and emotional engagement regarding the virtual humanoid characters.
Reconstruction is performed for each captured frame, resulting in a time-varying mesh sequence. The methods were implemented based on the CUDA parallel computing architecture and are running in near real-time (approx. 10fps). Data preprocessing is similar for both reconstruction meth- ods and can be summarized as follows: (a) A weak 2D bilateral filter is applied to the depth maps to reduce Kinect measurements noise; (b) A binary "human silhouette" map is generated for each depth map, by background subtraction; (c) For each depth map, a surface-normal map is calculated; (d) Additionally, a "distance-to-background" confidence map is computed, which accounts for the fact that Kinect measurements near object boundaries are noisy. (e) Finally, using the normal-map and "distance-to-background" map, a "confidence" map is calculated.
MODEL BASED CAPTURING AND REN-DERING A major limitation of directly streaming the captured data to allow for free viewpoint rendering, e. g. images-plus-depth or pure multi-view, is the very high bandwidth consumption, which drastically limits the achieved level of quality. To overcome this limitation, we exploit an underlying articulated template model and a pose-dependent database of appearance to render arbitrary viewpoints solely based on pose parameters, see Fig. 3. Such, only parameters describing a person's pose (typically, a very limited number of skeleton joint angles) need to be sent over the network. A pose-dependent, multi-view database of high-resolution appearance examples of a participant is created in an offline fashion, see Fig. 5. This database contains intensively preprocessed data, like alpha masks, depth maps, skeleton information as well as image warp functions between the database images to transform one pose into another one.
Following the approach presented in  [13] , we synthesize highly realistic animations from this database solely based on the joint angles of the underlying template model for the desired pose by warping and merging the pre-captured database images. The main idea is that small pose-dependent details are modeled by appearance/images, enabling highly realistic visualization while coarse 3D information allows animation and free-viewpoint rendering. In order to use this animation scheme for TI purposes, the required parameters of all joint angles and global similarity have to be extracted on-the-fly from a live capture. For this purpose we capture the user with multiple calibrated HD cameras in a green-screen environment and subtract the background using chroma-keying techniques. Then, using the ICP-based Kinematic Template Fitting algorithm  [8] , the rigged human template model mentioned above is fitted in a globally consistent manner against the 3D reconstructed depth maps of the segmentation results in a shape aware manner.
The REVERIE framework proposes the integration of an audio subsystem that receives the information regarding the position of the sound source with respect to the listener, chooses an appropriate head related impulse response (HRIR) from a database and then performs the necessary operations: FIR (Finite Impulse Response) filtering or frequency-domain convolution. This choice depends mostly on the "size" of the filter kernels. For short filters FIR filtering performs very well while, given the complexity, moving to longer impulse responses (such as the ones of reverberant environments) could lead to performance degradation. For this reason convoluting in frequency domain via FFT is a convenient strategy. A schematic overview is depicted in Fig. 6. The REVERIE audio subsystem is also extending the system by adding room acoustic simulation (reverb).
Tests on a large dataset show an encoding and decoding speed-up of over 10 to 20 times at similar compression and quality rates, when compared to the high-end MPEG-4 SC3DMC mesh encoder  [21]. Generally, mesh geometry transmission over lossy networks has been challenging, as triangle mesh compression have not been designed with resilience to losses in mind. In the presented system, a rateless code to achieve minimal end-to-end delay and protection against packet losses has been implemented. This implemented rateless code, similar to fountain codes  [19] , ensures complete packet loss protection of the triangle mesh object and avoids delay introduced by retransmissions. This approach is compared to a streaming mechanism over TCP and outperforms it at packet loss rates over 2% and/or latencies over 9ms in terms of end-to-end transmission delay  [21].