dataesr/scientific-paragraphs-categorization huggingface dataset:
Dataset Search 9  from Google is another free search engine tool for searching 25 million publicly available datasets. Google does not curate or provide direct access to datasets directly, so the dataset publishers must use the open standards of schema. org to describe their dataset's metadata. Google then indexes and makes that metadata searchable across publishers. The report from  Schmidt (2018)  outlined several experiments showing the terrifying scope of the collection of user data by Google, which then targets the users with paid advertising. Google collects data whenever the user interacts with Google by using their platforms (e. g. , Chrome, Android etc. ), applications (e. g. , Google Maps, YouTube etc. ), publisher tools (e. g. , AdSense, G analytics) and other tools (e. g. , AdWords, AdMob).
This information is particularly useful to other tourism enterprises, the shopping mall, and travel and tour operators because they can provide attractive offers to the customers during their stay. The collected useful data from the user profile can be shared among the enterprise consortium as per the predefined agreed terms in the smart contract. The collected data at Node 1 from the off-chain database is converted into JSON format before being published as items into the stream. There can be any number of streams and the data published in every stream is stored in full or referenced by a hash inside the transactions. Only the nodes with permission can view the contents of the streams. All other nodes in the network easily can convert and store the received items into their own repositories.
Every node in the MultiChain can have access to any stored raw data. To ensure data confidentiality, streams from the Multichain are used with a combination of symmetric and asymmetric cryptography for encrypting the data before being put into the chain. This method utilizes three blockchain streams (more details about this can be found in Greenspan, 2013): 1. Pubkeys stream: To distribute the participants' public keys under the RSA public-key cryptography.
Items stream: To publish the large pieces of data, each of which is encrypted using a symmetric AES cryptography scheme. 3. Access stream: To create stream-entry containing a secret password for data, encrypted with the participant's public key to provide data access. Therefore, only a subset of blockchain participants with the password can read the encrypted data. All the participants in the system with their Ethereum account addresses are in the MultiChain network. The data provider node puts customer data in the local storage. The MultiChain enables to encrypt it using the data consumer node's public key and slice the large dataset into smaller segments. The encryption process starts with the generation of the RSA private-public key pair on the node (server with running bash shell and xxd installed on) The data provider node uses the openssl with AES cryptography scheme to encrypt the data and produces the corresponding hexadecimal file as: $ openssl enc -aes-256-cbc -in [datafile] pass:$(openssl rand -base64 48) | xxd -p -c 9999 It then publishes the encrypted file into the items stream by creating a transaction with their hashes and commits it into the blockchain.
In addition to that, it also retrieves the public key of the data consumer node from the pubkeys stream to encrypt the secret password for data as: $ [passwordshellvariable] | openssl rsautl -encrypt -inkey [publickeyshellvariable]. pem -pubin | xxd -p -c 9999 It then publishes the secret password for data into the access stream by creating a transaction with their hashes using the data consumer node's address, item's label and commits it into the blockchain. The enterprise data consumer node subscribes to the stream searching for the data and finds the off-chain item with the help of their metadata and hashes. It then places the hash portion in its retrieval queue that queries the data in the P2P network. The node which possesses the data signature responds to the query. At this point, the smart contracts get triggered and with their successful execution, the tokens are transferred from the data consumer's Ethereum address to the customer's account while delivering the requested data (with verified hashes) to the local storage of the consumer node using the same path.
User Incentives for Sharing We deploy smart contracts on Ethereum that guarantee the user receives the incentive when the user data is consumed by the participating enterprise nodes. All the users (data providers), participating enterprise nodes (data consumers) have Ethereum addresses which interact with the smart contracts. The users can decide which consumers (applications or companies) can access their data. Here, the application sets the terms and conditions that the users agree to allow the enterprise a license to collect and use the contents before using their services and specifies that the user who shared their data retain ultimate ownership to their content, but the enterprise node also receives the limited perpetual license  (and right   the beginning, only the selected enterprises access the user data by subscribing to the published streams in the MultiChain.
The incentive is given in the form of a digital token by transferring ethers to users' ether addresses. We use Ropsten blockchain to implement the contracts on an online Remix IDE 12  because the Ropsten is a test network with the same proof of work (PoW) consensus mechanism for the block's validation as in the mainnet of the Ethereum and the Remix is a free IDE to deploy any untrusted codes before going live. In addition to that, anyone can use Etherscan 13  to explore the Ropsten blockchain for searching for any transactions taking place on the blockchain. Also, we use metamask 14  to deploy the Injected web3 environment to connect the contracts with the ether account addresses. Figure  7  illustrates a flowchart for the workflow logic with the full process cycle, including the creation of contracts to handling the successful payment for data sharing.
We confine the functions (methods) into our smart contract as per the roles of the participating entities to successively execute different tasks between the data provider and the consumer. The steps to generate the codes are described in Algorithm B and Algorithm C. The variables hold the Ethereum addresses, data prices, and contract states. We create a setter function to make its parent or child change the state of the contract if needed, and the compiler automatically generated getter functions for all public variables. We added modifiers in the contracts to support inheritance by restricting the functions with some conditions and created events to keep arguments in the transaction logs that notify clients about what is happening with the contracts. This model doesn't include the attestation of the smart contracts which might be required to ensure the reliability of the contracts.
PERFORMANCE EVALUATION The system performance evaluation was carried out by analyzing the performance metrics that mostly affect user experience (UX). We did successive experiments on the freshly created node to evaluate the performance of the system by setting four goals to find out: 1. How long it takes an enterprise Multichain node to get connected to the network. 2. How long it takes the enterprise Multichain node to respond to the actions (like starting stream, viewing a stream item, loading or publishing the items into the stream). 3. How much memory the node consumes when blockchain daemon gets started, and 4. How much gas the transactions use (validation cost) to complete the execution. Since there are two blockchain platforms in our system, we considered measuring latency and memory consumption parameters among the private blockchain nodes because the data sharing is performed in the private network which requires very low latency for optimal performance and the storage delay can also play a role in the increased latency and poor performance.
Node parameters were set up as stated before to store the key-value pairs of all the block and state hashes. The theoretical peak bandwidth of a network connection is fixed as per the technology used. However, the actual number of packets to be sent over the network is affected by higher and lower latencies. Excessive latency prevents data  from filling the network pipe, thus decreasing throughput and limiting the maximum effective bandwidth of a connection. Therefore, we set our goal of the evaluation to retrieve the latency alongside memory consumption in each case. To observe the effect of the multichain core daemon being stopped and reconnected into the network, we made the scripts that run with the gap of 1 min for every new observation with the following Multichain commands: multichain-cli model stop multichaind model daemon We observed the latency from the first node Node 1, when it got connected to another single-node N2 for scenario S1, next when it got connected to the other two nodes N2 and N3 for scenario S2 and similarly with other seven nodes N2-N7 for scenario S3 in a total of 20 observations.
We carried out 20 successive observations this time to see the memory consumption, which changed from the initial memory usage of 938 to 970 MB after the multichain daemon began. So, it can be concluded that the memory usage was around 28 MB and is not so huge to operate the model with the Multichain blockchain. Moreover, it is also based on the number of unspent transactions. There are also around 300 bytes of memory already kept for each block in the chain. Therefore, if the node is subscribed to millions of streams, then that would increase memory usage. However, our model has focused on storing the user profile data, and even 1 million of those data will have a size of just around 100 MB. So, this model is very effective in terms of a quick start, quick response and fewer memory consumptions.
CONCLUSION In summary, we did an experimental study of our new blockchain-based platform for sharing user profile data that allows users to retain control of the sharing and earn rewards. It is based on user-controlled privacy and data-sharing policies encoded in smart contracts. It also naturally supports building up incentives for users to share their profile data, in terms of rewards (micro-payments or credits). In this way, users become owners of their data and can decide how their data is collected and used, as well as shared. To share user profile data in a distributed fashion, the concept of streams from the MultiChain has been successfully interpreted by taking the case of the travel booking domain. We presented a hotel reservation system as one of the enterprise nodes of Multichain which collects users' profile data and allows users to receive rewards while sharing their profile data with other travel industries according to their privacy preferences expressed in smart contracts.
to sublicense) to distribute such contents (see Appendix A and Appendix B for associated smart contracts). The smart contracts give the users full transparency over who accesses their data, when and for what purpose. So, in 11 https://github. com/MultiChain/multichain/blob/master/COPYINGALGORITHMB| Signed Terms And ConditionsInput: A cu , A co , A cc, deposit, dataPrice, contractState 1. A cu , A co , A cc are the set of all ether addresses of customers, data consumers and contracts, respectively. 2. Grant access to only a cu ε A cu , a co ε A co who got registered into the system. Transfer deposit e p from a cc back to a co. 9. Remaining Contract balance of a cc becomes r b = e d + e p. 10. Transfer r b to a cu.
to sublicense) to distribute such contents (see Appendix A and Appendix B for associated smart contracts). The smart contracts give the users full transparency over who accesses their data, when and for what purpose. So, in 11 https://github. com/MultiChain/multichain/blob/master/COPYINGALGORITHMB| Signed Terms And ConditionsInput: A cu , A co , A cc, deposit, dataPrice, contractState 1. A cu , A co , A cc are the set of all ether addresses of customers, data consumers and contracts, respectively. 2. Grant access to only a cu ε A cu , a co ε A co who got registered into the system. Transfer deposit e p from a cc back to a co. 9. Remaining Contract balance of a cc becomes r b = e d + e p. 10. Transfer r b to a cu. 3. Change the contract state to Created. 4. a cu deposits e d. 5. Set data price to ep such that e p = ½ e d.
et al. , 2011) ; it is used to smooth the high-frequency impulse response arising from fault-induced impacts in order to detect the moments (or frequency) at which impacts occur  (McFadden & Smith, 1984). In this study, we present a method for automatically identifying behavioural microevents that combines considerations of the physics of animal body-and-sensor systems, the technique of signal enveloping, feature engineering and robust machine learning. In our method, we: (a) automatically detect microevents using a novel algorithm based on signal enveloping, (b) engineer meaningful features to characterise microevents and (c) use robust machine learning algorithms to classify microevents. We showcase the application of our method on data collected on 10 wild-living meerkats Suricata suricatta, where fine-scale foraging behaviour such as searching, one-armed and two-armed digging, and prey ingestion were groundtruthed against annotated videos.
| Detecting microevents in recorded acceleration Our microevent (μE) detection method involves: (a) selecting the accelerometer axis on which μE's will be detected, (b) computing signal amplitude and (c) segmenting the amplitude to find locations and spans of μE's. Custom MATLAB code (microevent) to detect microevents, along with a vignette with pseudocode explaining its usage (vignette_microevent), are supplied as Supplementary Information.
| Characterising detected microevents using features Both local and contextual data from each axis are used in this step to characterise each microevent μE i (Figure  1c ) through feature is segmented into individual microevents (solid red triangles) with spans given by each microevent's onset and end (solid cyan discs) after selecting from the pool of microevent candidates (locations: unfilled red triangles; spans: unfilled cyan circles) and removing non-event zones (grey), and (c) two neighbourhoods were considered for characterising microevents through feature computation: local, given by microevent μE i 's span (solid cyan discs), and contextual, given by a window (dark red box) of length w seconds centred at μE i 's location (solid red triangle). sub-category (e. g. using rankfeatures, © MATLAB R2019a).
Axis selection and signal amplitude computation We chose the surge axis for microevent detection. We filtered surge acceleration with a Butterworth low-pass filter of order 4 and cutoff frequency 25 Hz to remove noise. In line with the considerations in Section 2. 1. 2, and given that meerkat running frequency was observed to be ~4-5 Hz  (Chakravarty, Cozzi, et al. , 2019) , we computed envelopes with M env = 11 samples, and smoothed them using an M env th-order FIR low-pass filter (implemented using fir1 in MATLAB R2019b) with cut-off frequency f c = 5 Hz (see purple/yellow curves in Figure  1a  for smoothed envelopes).
Feature development and selection We chose a window of size w = 1. 5 s for feature computation to ensure that the window would be long enough to include sufficient context before and after the microevent, but short enough to capture enough data since meerkat behaviours are typically short-lived. We computed 200 features from tri-axial acceleration across nine sub-categories (cf. Section 2. 1. 3): posture, intensity, periodicity, dominant frequency, band-specific frequency content, microevent amplitude-peak characteristics, coordination between surge and heave, tortuosity and statistical summaries. We selected the best features from each sub-category and node (Figure  2 ) using five filter feature-ranking methods (Appendix S3).
Classical machine learning has previously been used with small window sizes (0. 3 s) to differentiate fine-scale behaviour such as prey handling from swimming in little penguins Eudyptula minor  (Carroll et al. , 2014). We included this possibility by computing benchmarking results with two window sizes: 1. 5 s with 1 s overlap, and 0. 3 s with 50% overlap between successive windows. We performed feature selection separately for the two window sizes (Appendix S6). Finally, we computed LOIO classification results with balanced as well as imbalanced datasets.
| Collected data and detected microevents Data for all four behaviours were collected for eight of ten individuals (Table  1 ). The dataset was imbalanced both across individuals and behaviours: (a) 55% of the total duration of recorded behaviours came from three individuals (individuals #3, #6 and #10) and (b) 50% of the duration of chewing data came from one individual (#3), and 39% of all 2AD came from one individual (#6). Recorded acceleration patterns for the microevents (μE's; Figure  3 , left column) showed, as expected, multiple peaks with varying amplitudes and inter-peak     S6  and S8 ) and those from the feature family developed in this study (Tables  S7  and S9 ) were selected. For LOIO, three individuals had to be left out because of insufficient data for at least one of the four behaviours (Table  1 ): individuals #2 and #7 did not have data from 1AD and 2AD, respectively, and individual #1 did not have enough chewing samples (SMOTE requires at least six samples from each class).
This was primarily due to misclassification of Search as 1AD for a single individual (#4, Table  S10 ). Re-examination of video footage revealed that most of this individual's (#4, Table  1 ) annotated searching behaviour (68%) actually came from brisk walking/trotting -though #4 looked briefly at the ground while doing so, it seemed unclear whether it was actually searching for food or simply catching up with its group. Thus, the errors obtained for this individual are more a consequence of imperfect annotation rather than limitations of the model. 1AD precision improved to 86. 7 ± 7. 4% and searching sensitivity to 87. 6 ± 7% when this individual's metrics were excluded. With balanced datasets, μEvId's overall accuracy exceeded that of the best CML model by 8. 6% (Table  2 ). For each CML model, there was at least one behaviour-specific performance metric that was <70%.
| Potential for other studies, and future work The fact that a majority of μEvId's selected features (Table  S3 ) were based on contextual acceleration (Figure  1c ) suggests that including data from a time window longer than the signal pattern of interest gives more accurate and robust results than characterising the signal pattern alone. This finding could be leveraged to define robust guidelines for manual waveform characterisation in semiautomated approaches  (Wilson, Neate, et al. , 2018). In our study, accurate identification of fine-scale behaviour was achieved with a single sensor. This shows that algorithmic advances could possibly be helpful in simplifying tag attachment issues in other studies, for example, by reducing the number of sensors needed to identify rapid head movements during prey capture in Adélie penguins Pygoscelis adeliae (W atanabe & T akahashi, 2013) from two (on head and back) to one.
lected per individual did not bias model training, we balanced the dataset so that each behavioural class had an equal amount of data from each individual (Appendix S4). For this, we resampled the dataset through a combination of oversampling rare classes using the Synthetic Majority Oversampling Technique (SMOTE) and randomly undersampling over-represented classes (Chawla et al. , 2002;  Appendix S4). Thereafter, we performed leave-oneindividual-out cross-validation (LOIO) on the balanced dataset. Models were trained using data pooled over all individuals except one, and tested on data from the individual left out. This process was repeated until each individual had been the 'test' individual once. To prevent specific outputs of random number generation in SMOTE from potentially biasing results, we averaged results over an ensemble of 10 balanced datasets for each cross-validation run.
ACKNOWLEDGEMENTS We thank the  Northern Cape Conservation Authority  for permission to conduct this research, and the  Kalahari Research Trust  and  Tim Clutton-Brock  as director of the Kalahari Meerkat Project for access to facilities and habituated animals in the Kuruman River Reserve,  South Africa. This project was supported by the  Swiss National Science Foundation  (research grant no. CR32I3_159743 ). During the period of our project, the long-term research on meerkats was supported by a  European Research Council Advanced Grant  (No. 294494 ) to  Tim Clutton-Brock , by grants from the  University of Zurich  to  Marta Manser , and the MAVA foundation. We thank the field managers, collaborators and assistants for facilitating field work and helping with data collection, and in particular  David Gaynor ,  Tim Vink ,  Ana Morales González  and  Héctor Ruiz Villar.
We consider in this work that choosing a battery discharge and charge limiting power provides an extension of the battery life. On the other hand, we simulated the dynamic behavior of the architecture's various components according to their mathematical modeling. Following this, an energy management algorithm was proposed, and simulated using MATLAB/SIMULINK to serve the load. The results have shown that the load was served in all cases, taking into account the electrical behavior of the inhabitants as well as the weather changes on a typical day. Indeed, the load was served either by instant solar production between sunrise and sunset, or the recovery from sunset to 10pm, which could be a stored or injected energy without exceeding the 1000W per hour.
The latter, using our energy management algorithm, is able to manage its energy sources, and estimate its consumption from each source, in a time step of one hour. Our hybrid grid-connected PV-battery architecture was developed respecting technical constraints and components health state. Also the system can work in both isolated and connected mode. To do so, a modeling of the different sources and constraints of the system was developed and simulated. The same constraints were taken into consideration when designing the flowchart of the energy management procedure, as well as the algorithm implemented on MATLAB. Furthermore, the proposed system overcomes other limitations such as AC sources synchronization issues, deterioration of the battery's health status, inadequate energy management during surpluses and energy shortages.
Uncertain variables: temperature, irradiation and power demand The uncertain variables of our system are: Energy demand and weather conditions, namely: temperature and irradiance. The determination of a site's renewable potential can be done by interpolating reliable measurement point data from nearby regions, which has been achieved by using neural networks in  [26] , in order to determine the solar potential in Morocco. Otherwise, the energy demand is estimated by studying the electrical behavior of the inhabitants. However, this parameter does not influence the results of our algorithm. Indeed, our program is managed in real time and does not require a prior processing. To simulate our program and validate it in all cases, an interval of random consumption [0, 1500 W] was considered, see Fig.
6. This value (1500 W) was estimated as the dispersion of the total energy consumed daily over an average consumption time of 9 h. For temperature and irradiations, we simulate our study for a house in Marrakech, Morocco with an average daily irradiations of 5. 4959 kWh/m 2  [27] , the distribution of this irradiations over one day, was carried out via TRNSYS, combined to METEONORM as a reliable database of metrological conditions, which is presented by Fig. 5.