Find a best way to import weigths to the Keras

[zaleslaw]

We have the ability to load the model configuration from Keras JSON format and pre-trained weights stored in h5 format.
But how to export the model pre-trained in KotlinDL to the Keras or pure TensorFlow?

Currently, we support the weights export to the txt files. It's a baseline solution.
We need research here to find the best way to export weights.

There are a few open questions:

1. What part of weights loading should be implemented on the KotlinDL side or maybe we need a special loader to the Keras in Python (published as a separate pip package)?
2. Should we export to txt or another popular format or maybe to NumPy arrays to easily parse it on the Python side?
3. Is it easy to write h5 writer to store them in Keras weight format?
4. Will it be enough of a universal approach which could be reused for weights export to ONNX or PyTorch? Or we will eat the elephant in parts and develop an individual approach to exporting weights to different systems.

Let's discuss here, in this issue the possible approaches, their advantages, and disadvantages?

P.S Read the Contributing Guidelines.

[dosier]

Maybe we can abstract out the serialisation part, then provide a default serialiser for the Keras weight format (this seems most fitting for KotlinDL). If we abstract the serialisation part, people can implement their own serialisers and provide it as a dependency for the niche use-cases. Maybe inspiration can be taken from KTor's features system.

[zaleslaw]

Yeah, it's a great idea to separate the serialization API (now it's built on Keras format for model saving).
What parts of KTor do you mean? I'm not familiar with this functionality

[dosier]

Nevermind the KTor part, it came to mind because it has a nice syntax for handling serialisation (e.g. https://ktor.io/docs/kotlin-serialization.html#register_arbitrary_converter).
But now come to think of it, we probably don't want to define the serialiser when we define the model but rather let the user provide it when saving the model. That way they can easily save the same model using multiple serialisers.

Though a case could be made for both, it definitely would be nice to have an option to easily define the serialiser when defining the model. I'd guess most users will only use one anyways.

They don't have to mutually exclusive either, maybe the save function could have an optional parameter if you want to use a different serialiser than the one provided during model creation.

[dosier]

What are your thoughts on using https://github.com/Kotlin/kotlinx.serialization for implementing a serialisation strategy for the H5 format. I could probably make a PR for this. However, one drawback from kotlinx.serialization is that it depends upon a compiler Gradle plugin, this will make it incompatible with the new K2 compiler (at least for the next few months). But if this is not a problem, we can use it to implement a custom serializer for the H5 format.
However, tbh I am not entirely sure what the direct benefits would be of using this rather than write a custom parser from scratch. I guess integration, and ease of converting between formats.