meta-model | 元数据驱动引擎之 数据服务 ; 如果需要独立的服务化server , 请建立WebServer工程

No. The MappingConverter is not only used and needed for converting an entity to and from JSON, but also for converting and mapping fieldnames, dateformats and other stuff for example when CriteriaQuerys are created or when search resukts like highlights are processed. There are man places in Spring Data Elasticsearch where the mapping information for an entity is needed and Jackson cannot be used there.

So in versions before 4.0 it was necessary to customize Jackson with jackson-annotations on the entity and the other stuff with different annotations, this has been consolidated.

What functionality do you need that the MappingConverter (implementation of the meta model mapper) does not offer in combination with custom converters?

Edit 05.12.2020:

valid point from the comments: It should be possible to define a FieldNamingStrategy for an entity. I created an issue for that.

The problem here is not the missing _class entry. Spring Data Elasticsearch can read entities without this (it is really needed when dealing with inherited classes and collections).

Normally an entity like this would be all you'd need (I leave out the getter and setter for brevity):

The solution is to use:

Currently this is not possible. You can create an issue in Jira to have this implemented as a new feature, but beware that if type hints are not written, you wont be able to properly read collection-like values of generics.

For example if you have two classes Foo and Bar and in an entity you have a property of type List which contains Foos and Bars you won't be able to read back such an entity from Elasticsearch, because the type information of the objects would be lost.

I am not sure I understand your question correctly, but I will try to answer parts of it.

However, problems were encountered in formalizing the modeling language.

Could you clarify which problems you encountered or give a concrete example of the modelling language you want to formalize?

Should I self-code a theory file with .thy suffix in programming mode, and then run it in proof mode to get a proof of correctness?

Isabelle does not have separate modes for programming and for verification. You can mix function definitions and lemmas in the same .thy file.

Most aspects of correctness are done in lemmas/theorems, but even if you just define a recursive function in Isabelle you will already get some correctness guarantees: you need to prove that your definition is well-defined.

Isabelle has many coding fields, such as data types, constants, functions, definitions, lemmas and theorems. Should I code these separately to prove the correctness of the model transformations?

As I said above you don't need to separate them into different files. However, everything must be defined in order in Isabelle. For example if you want to prove something about a function, then the function must be defined before the lemma in the source code. If the function works on some data structure, the corresponding type definitions have to come before the function.

The ElasticsearchOperations interface has a method putMapping(class). This method can be used to write the index mappings to an index. The default non-reactive repository implementations do this when an index is created.

The default method implementation checks if there is a @Mapping annotation on the class. If yes, this mapping definitions are used. If this annotation is not present, then the class is inspected and checked for the @Field annotation on the properties.

So in your case, the annotations on the properties are not used for writing the index mappings.

I would recommend to use the properties on the class, because it's more likely that you change some mapping property in the class and forget it in the json file.

For example in your code in the class sampleObject is defined as keyword but int the mappings it's a String. Somebody looking just at the code might miss the different definition.

Rule Ending has zero or more empty string match ''* that is essentially an infinite loop building a parse tree node with an infinite number of empty match terminals. Eventually, the parse tree eats up all the memory and you get MemoryError.

In general, repetitions ('*', '+') over a parsing expression that could potentially be an empty match could lead to an infinite loop.

I suggest that you register an issue in the issue tracker for this as it should be fairly easy to at least detect it at runtime without to much overhead.

Here's a solution using dummy().

• First we actually have to replace the NA values with non-NA values; it doesn't matter what they are since they will be multiplied by zero and/or ignored ... (there may be a tidyverse and/or simpler version of this)

AzureML HyperDrive is a black box optimizer, meaning that it will just run your code with different parameter combinations based on the configuration you chose. At the same time, it supports Random and Bayesian sampling and has different policies for early stopping (see here for relevant docs and here for an example -- HyperDrive is towards the end of the notebook).

The only thing that your model/script/training needs to adhere to is to be launched from a script that takes --param style parameters. As long as that holds you could optimize the parameters for each of your models individually and then tune the meta-model, or you could tune them all in one run. It will mainly depend on the size of the parameter space and the amount of compute you want to use (or pay for).