dataesr/scientific-paragraphs-categorization huggingface dataset:
Most of them have several categories and will be used for the multiclass learning experiments. One-class learning and multi-class novelty detection will be conducted by selecting only one or several target categories among others. Online learning will be simulated as follows: the majority of the data set is stored in hard drive and a data chunk of size l will be extracted and stored in the random access memory at each learning step. Table  2  lists the competitors used in the experimental evaluation. Most of these methods work incrementally or recursively (see column Incr. in Table  2  ) but few of them have a compression mechanism (see column Comp. in Table  2  ). More precisely, the proposed algorithm, named "ICNKDA" (acronym of incremental and compressible null KDA), is compared with the batch KNDA  [5]  that serves as baseline and recent incremental extensions of KDA (see Table  2  ) such as spectral regression kernel discriminant analysis (SRKDA,  [6]  ), factorization-free kernel discriminant analysis (IFKDA,  [8]  ), null kernel discriminant analysis (INKDA,  [9]  ), sketch online discriminant analysis (SoDA,  [27]  ) and streaming kernel discriminant analysis (SKDA,  [28]  ).
In  [34]  , Deep TL has been used for a novelty detection task. Based on this work, we propose here to apply transfert learning for novelty detection by using the following strategy: first, we select Resnet-101 as pretrained neural network, this network has been trained on 1. 2 million training images, with 10 0 0 classes of objects. Secondly, the last learnable layer 'fc10 0 0' of resnet-101 is replaced by a new convolutional layer with the number of filters equal to the number of known classes. Lastly, the modified neural network is trained with the studied data sets only composed of the target classes. Novelty detection is performed by using our finetuned network on a test data set composed of known and novel classes as defined previously. Lastly, a one-class classifier based on the principle of Generative Adversarial Network (GAN), named "ALOCC" is proposed in  [32]  for novelty detection.
Comparative study with the Liu's scheme In this first experiment, we compare specifically our scheme with that of Liu on three points: a) the accuracy in approximating the batch KNDA solution, b) the empirical time complexity and c) the dimension of the null space obtained. The area under the ROC curve (AUC) is used to measure the performance of the classifiers. The MNIST data set is used to conduct the evaluation and composed of 10 0 0 image samples which are delivered in packets of size l = 100. We analyse the performance of the competitors by increasing the number of classes to learn from one to ten (closedworld classification). At each experiment, each target class will be represented equally in the training dataset, i. e: 10 0 0 for the oneclass scenario, 500 for the two-class problem,.
and 100 for the ten-class problem. The test data set will be composed of 50 0 0 images including the known classes and unseen classes. Each test class will be represented equally by 500 image samples. A cross validation step is beforehand used to select the values the kernel width σ corresponding to the best AUC. Moreover, we analyse the impact of the proposed compression mechanism on the performance of our algorithm by varying the compression parameter ν in [0,0. 25,0. 35,0. 45] where ν = 0 means "no compression". Fig. 1  summarizes the results of this experiment. First, Fig. 1 a  shows the classification performances measured by the average AUC values obtained from 10 simulations for each scenario. In each scenario we compare the AUC values recorded by the batch KNDA (red bar), our algorithm with different levels of compression (grey bars) and the Liu's scheme (blue bar).
In all scenarios, we observe that the Liu's scheme is less efficient than both our incremental scheme and the batch KNDA. Precisely, the performance of INKDA tends to grow as the number of target classes to learn increases. As illustrated on Fig. 1 a , the AUC values recorded by the proposed method coincide with the batch KNDA which validate the effectiveness of our algorithm. When the compression is enabled we notice that the performances of our algorithm decrease very slightly but remains better that the Liu'scheme in all the scenario. These results also mean that the MNIST data set shows a high level of redundancy in the data. Fig. 1 b  shows the evolution of the dimension of the null space of each method. As demonstrated previously (see Section 4. 2 ), the dimension of the null space of the Liu's scheme is not bounded and linearly increases with respect to the number of data packets and the number of classes to learn.
Multi-class learning and comparative study In this part, we consider closed-world classification experiment, i. e all the known classes are represented in the training data set. Table  3  shows the methods used in these experiments and the values of the hyperparameters involved in this evaluation. We tuned them to achieve the best performances of each studied methods. Moreover, the behavior of ICNKDA will be analysed without compression (ν = 0) and with compression (ν = 0. 25). Since most of the competitors are not equipped with a compression mechanism, we will limit the size of the training sample to 10 0 0. The classification performance is evaluated with the accuracy measure (ACC) which records the percentage of well-classified instances. Training times (in sec. ) of the studied competitors are also reported in Table  4.
However, this step needs to known in advance the size of the training data set which is a brake to process continuous streaming data sets. d) The factorization mechanism used by IFKDA provides the best training times among the competitors. We observe that FKDA-C (row 7) is very fast but using only the class centers as discriminative information seem to be not enough to perform as well as the other competitors. By using O micro-clusters by class, FKDA improves its generalization ability and performs better, but to the detriment of the training time. e) We can also notice that SKDA records better classification performances than SoDA on each experiment. These results show the contribution of the kernel trick. However, SKDA is performing lower than our approach in all the experiments. Moreover, SoDA and SKDA fail to classify a high-dimensional data set such as RCV1.
Now, we complete our evaluation by considering a multi-class problem with very large training data sets. In this experiment, three large data sets will be considered: MNIST, CIFAR-10 and AWA2. 50,0 0 0 gray level images of MNIST (50 0 0 images by category), 50,0 0 0 color images of CIFAR (50 0 0 images by category) and 9600 color images of AWA2 ( ∼200 images by category) will    3  shows the evolution of the accuracy measure over the learning process. In these figures, each method is associated a color and two styles of curves (dashed or solid) are used to distinguish the value of parameters. The performances of IC-NKDA, IFKDA, SoDA and SKDA are represented by a blue, red, green and black curve, respectively. On these three data sets, we observe that the proposed algorithm outperforms the other competitors.
SKDA, which is the nearest competitor in this evaluation, is clearly outperformed by our approach on the MNIST and CIFAR-10 data sets. The two approaches show similar results on AWA2 with IC-NKDA having the edge (acc = 90. 70 instead of 89. 40). We can note also that in a first time if the compression factor influences the classification performance of ICNKDA its impact is decreasing when enough training data have been processed. Fig. 3  clearly illustrates this result when the blue solid curve and the blue dashed curve correspond at the end of the learning process. Of course, higher the value of the compression factor is, smaller the training time will be. In conclusion, the choice of the value of ν will be the result of a trade-off between the classification performance, the training time and the size of the training data set.
Multi-class novelty detection in large data sets In this part, we study the performance of ICNKDA on multiclass novelty detection. Multi-class novelty detection tries to identify new categories from known categories in a newly arrived data chunk. In this perspective, we study the performance of ICNKDA to detect novelty by considering an evaluation data set composed of samples that belong to k known or target classes and samples that belong to m new classes. Thus, its capacity to separate known from unknow classes is evaluated at each learning step. In order to address the problem of novelty detection in large-scale data sets, we have to limit the scope of our comparison with methods using a compression mechanism. Hence, we selected IFKDA, SoDA, SKDA and ISVDD as comparative baseline. Deep transfert learning   3.
The learning rate of deep transfert learning is set to 1e-3. Two large-scale data sets will be used in this experiment: CIFAR-10 and AWA2. For each data sets, we define the following protocol for multi-class novelty detection: first we consider that class names are initially sorted alphabetically. Secondly, we study three scenarios where the number of known classes increases. In CIFAR-10 we pick the first 3, 5 and 8 classes as target classes and the remaining classes as novel classes. The training data set will be composed of 50 0 0 images by class while the test set will be composed of 500 unseen images of each class, representing a total of 50 0 0 test images. Since AWA2 has 50 categories, we define three scenarios with 10, 25 and 45 classes as target classes and the remaining classes as novel classes.
The training data set will be composed of 80 0,50 0 and 300 images by class for the first, second and third scenario, respectively. Since novelty detection methods typically define a novelty score to be compared against a threshold, the performance of the different methods will depend on the value of the threshold. For fair comparison, the ROC curve is a commonly adopted measure for characterizing the average performance of a novelty detector across all possible thresholds. The Area Under Curve (AUC) will be used as a single performance measure. The bar-graphs of Fig. 4  summarize the classification performance of each novelty detectors. The first observation is that ISVDD (yellow bar) is the worst-performing method in each experiment suggesting that the strategy to learn one class separately is not relevant for multi-class novelty detection.
AER measures the percentage of samples misclassified in a data chunk. Three kinds of errors can be found: a) the samples belonging to the target classes but misclassified into novel classes, b) the samples belonging to the target classes but misclassified into another target classes and c) the samples belonging to the novel classes but misclassified into the target classes. AER can be computed when a novelty threshold is clearly defined. In the case of FKDA, each center of the k known classes is represented in the projective space by an unit vector of the canonical basis of the k -dimensional space. Then, a decision boundary around each class center can be defined by an hypersphere of a fixed radius equals to 0. 7. For ICNKDA, as explained in Section 6 , thresholds are obtained by computing the radius of hyperspheres computed around each class center.
We set the number of epochs to 15. The comparison will be based on two large data sets: MNIST and CIFAR-10. In each data set, one of the categories will be taken as target class and the other categories as novelties. This experiment will be repeated for all the ten categories. The learning protocol is organized as follows: the training set is conducted with 50 0 0 images of the target class and the test set is composed with 500 images of each class (known and novel classes) defining a test set of size 50 0 0. Table  5  shows the results obtained by the different detectors on the MNIST data set. First, we clearly note that ICNKDA records very goods results outperforming the other competitors in most of the scenarios. Moreover, its performance is slightly affected with a change of the compression factor.
This result was expected since the MNIST data set shows a high degree of redundancy in data. Given the number of epochs set, ALOCC records contrasting results, clearly outperforming the other competitors in the case of the digit 1 for instance but far below in the cases of the digits 5 and 8. ISVDD records results at levels very close to those reached by ICNKDA. The most remarkable feature is the training times reached by our method when the compression mechanism is activated. These times recorded by IC-NKDA show that redundancy is high in the MNIST data set and most of the time data are not processed during training. This ability to detect redundancy in data is the cornerstone of the proposed method. Now, Table  6  shows the results on CIFAR10 data set. The competitor ALOCC has been removed from the experiment because the convergence of ALOCC on this data set is not reached despite an increase of the number of epochs.
We used the code proposed by the authors in  [32]  and we observed that the architecture of the network is only suitable for processing the MNIST data set. The analysis of Table  6  confirms the previous results obtained with the MNIST data set. ICNKDA outperforms ISVDD and K-NN on each scenario. The proposed compression mechanism offers the ability to maintain very good classification performances and process large training data sets within a very short period of time. As previously, ISVDD records similar results than ICNKDA but at the detriment of an increase of the training time. Indeed, ISVDD is sensitive to the dimensionality of the data. The repeated access to the expanding, shrinking and bookkeeping steps in ISVDD for maintaining the KKT conditions can be time-consuming for high dimensional data sets.
We observe this drawback for the CIFAR10 data set. Lastly, the curves on Fig. 6  illustrate the evolution of the average AUC computed from the 10 scenarios presented in Tables  5  and 6  over the learning period. NKDA continues to "learn" and update its model. Conversely, we note that the "learning" performance of ISVDD decreases in average in the case of CIFAR10.
Such simulation gives the most quantitative and intuitive feed-back to designers, and is very helpful for innovation and optimization of pMUTs. Optimization Work: Based on the above modeling method, a more significant and robust performance indicator has been proposed: i. e. , the product of round-trip sensitivity and fractional bandwidth (SBW), taking into account not only the influence of the complex geometry on sensitivity and bandwidth of the pMUT, but also the whole wave process from source excitation to charged reception including coupling medium. Based on the SBW criterion, a MATLAB-controlled FEM batch analysis on COMSOL has been carried out to optimize pMUT's multi-parameter geometry. Study of Acoustic Matching Layers: Different from bulk piezoelectric transducers, MUT vibrates on the bending resonance mode of the thin diaphragm.
X{r p , r t , t p , t si In general, the program opens the transmitting model and receiving model in sequence, edits the models' parameters and executes the calculation in COMSOL's kernel, then extracts the required data to calculate F pmut (ω, X) and SBW. As f c is the center frequency of -6 dB bandwidth of F pmut , it can be changed when the geometrical parameters are swept in the optimization process. So in the program, a switch loop is used to adjust the cavity radius r c in a way that f c always meets the target frequency f t. According to clamped plate's vibrating theory  [32] , the pMUT resonance frequency f r can be estimated by the following relation: f r ∝ t/r 2 ( 4 ) where t is the plate's effective thickness, r c is the plate's effective radius. The program adjusts the current cavity radius r c by multiplying it with a factor f c / f t while keeping t constant, it continues to calculate until the f c reaches f t within an error of 1%.
Since the center frequency of the pMUTs can shift due to the geometry optimization, the pMUTs cavity radius is adjusted to compensate the frequency shift, keeping the working frequency at the design target one. We have set-up an efficient program based on LiveLink TM for MATLAB to accelerate the modeling process during such optimization. The result of geometry optimization shows a 52% enhancement of SBW when the top electrode and piezoelectric layer are both etched to 75% radius of the cavity beneath. It also reminds designers to make a compromise between performance, process yield and operating voltage range required for the target application, and then choose the thinnest available device layer thickness to achieve maximum performance. In the last part, we studied the effect of the acoustic matching layer on the pMUT performance with several possible matching materials.
In this paper, we detail each algorithm phase, show that each is in  (2 poly (N ) ), and focus on preparation and generation of objects, the phases completely original to this work. The practical applicability of our algorithm is proved by our experimentation, which is another contribution of this work. Our experiments are based on four real-world datasets, on a synthetic dataset, and on a handwritten dataset. Real-world datasets comprise 6,427 unique schemas extracted, through an extensive data cleaning process, from a large corpus of schemas crawled from GitHub  [13]  and curated by us for errors and redundancies; the other datasets, already used in  [22] , are related to specific application domains and originated from Snowplow  [4] , The Washington Post  [27] , and Kubernetes  [23]. The synthetic dataset is synthesized from the standard schemas provided by JSON Schema Org  [25] , from which we derive schemas that are known to be satisfiable or unsatisfiable by design  [6].
The handwritten dataset is specifically engineered to test the most complex aspects of the JSON Schema language. The experiments show that our algorithm is complete, and that, despite its exponential complexity, it behaves quite well even on schemas with tens of thousands of nodes. Paper outline. In Section 2 we review related work. In Section 3 we describe our algebraic representation of JSON Schema. In Sections 4-6, we describe the algorithm. In Section 7 we present our experimental evaluation. We conclude in Section 8.
[22]. While it has been designed for schema containment checking, e. g. ,  1 ⊆  2 , it can also be exploited for schema satisfiability since  is satisfiable if and only if  ⊈  ′ , where  ′ is an empty schema. The approach of  Habib et al. bears some resemblances to ours, e. g. , schema canonicalization has been first presented there, but its ability to cope with negation is very limited as well as its support for recursion. Several tools (see  [16]  and  [1] ) for example generation exist. They generate JSON data starting from a schema. These tools, however, are based on a trial-and-error approach and cannot detect unsatisfiable schemas. We compare our tool with  [16]  in our experiments. Own prior work. In our technical report  [14] , we discuss negation-completeness for JSON Schema, that is, we show how pairs of schema operators such as "patternProperties"-"required" and "items"-"contains" are almost dual under negation, as ∧-∨ or ∀-∃ are, but not exactly.
JSON SCHEMA AND THE ALGEBRA 3. 1 JSON data model Each JSON value belongs to one of the six JSON Schema types: nulls, Booleans, decimal numbers Num, strings Str, objects, arrays. 𝐽 ::= 𝐵 | 𝑂 | 𝐴 JSON expr 𝐵 ::= null | true | false | 𝑞 | 𝑠 𝑞 ∈ Num, 𝑠 ∈ Str Basic values 𝑂 ::= {𝑙 1 : 𝐽 1 ,. , 𝑙 𝑛 : 𝐽 𝑛 } 𝑛 ≥ 0, 𝑖 ≠ 𝑗 ⇒ 𝑙 𝑖 ≠ 𝑙 𝑗 Objects 𝐴 ::= [𝐽 1 ,. , 𝐽 𝑛 ] 𝑛 ≥ 0 Arrays Definition 1 (JSON objects). We interpret a JSON object { 1 :  1 ,. ,   :   } as a set of pairs (members) {( 1 ,  1 ),. , (  ,   )}, where  ≠  ⇒   ≠   , and an array [ 1 ,. ,   ] as an ordered list; JSON value equality is defined accordingly, that is, by ignoring member order when comparing objects.
But, crucially, and-completion is lazy: we do not pre-compute every possible conjunction, but only those that are really needed by some specific non-cp-empty choice. This laziness is crucial for the practical feasibility of the algorithm: when different constraints, or requirements, are associated to disjoint patterns, we have very few non-cp-empty choices, and in most cases they do not need any fresh variable, as in the example. Despite laziness, this preparegenerate-normalize-prepare loop can still generate a huge number of variables. We keep their number under control using the ROBD-DTab data structure that we introduced in Section 5. 1, which allows us to create a new variable only when none of the existing variables is boolean-equivalent to its body; this crucial optimization also ensures that this phase can never generate an infinite loop.
EXPERIMENTAL ANALYSIS 7. 1 Implementation and experimental setup We implemented our algorithm in Java 11, employing the Brics library  [24]  to generate witnesses from patterns, and the jdd library  [29]  for ROBDDs. Our experiments were run on a virtualized machine deployed on a server with a 12-core Intel Xeon Silver 2. 40GhZ CPU, 64 GB of RAM, running Debian GNU/Linux 11. Witnesses were validated by an external tool  [2] , and additionally by hand, since the external tool reported false negatives in a few cases. Each schema is processed by a single thread, and all reported times are measured for a single run. Our reproduction package  [3]  can be used to confirm our results.
Schema collections We conduct experiments with different schema collections. Table  1  states the respective numbers of satisfiable/unsatisfiable schemas. Real-world schemas. For the GitHub collection, we retrieved virtually all files from GitHub that present the features of JSON Schema, based on a BigQuery search on the GitHub public dataset. We downloaded the 80K identified schemas (shared online  [13] ). We performed duplicate-elimination and data cleaning (see  [9] ), arriving at 6,427 schemas, 40 of which are unsatisfiable (according to our tool and confirmed by direct inspection). We renamed all occurrences of uniqueItems, treating it as a user-defined keyword. The three remaining real-world collections correspond to specifications of standards for deploying applications (Kubernetes  [23] ), ruling interactions within a specific system (Snowplow  [4] ), and describing data produced by content management systems (Washington Post [27]).
36% of schemas  (23 schemas). No failures arise in the other schema collections, supporting hypothesis H1. The DG tool successfully handles 94. 20% of the GitHub schemas, and has similar correctness ratio for the other real-world schemas but it performs poorly regarding correctness on handwritten schemas, and cannot be really used for inclusion checking, since it does not detect unsatisfiability. It is difficult to compare run-times between tools. Essentially, on most schemas the two tools have comparable times, evident when looking at the median times, but there is a small percentage of files where our tool takes a very long time, and this is reflected on our disproportionately high average time. The synthesized schemas show that our tool supports a much wider range of language features (hypothesis H2), which is natural since the CC tool targets a language subset, while completeness is core to our work.