handle 4 dims tensors and eof

ggml/examples/unity/model_loader.cpp

@@ -1,6 +1,8 @@
 #include <string>
 #include "model_loader.h"
 
+#define DEBUG 1
+
 std::ifstream open_ggml_file(const char* fname) {
     printf("%s: loading model from '%s'\n", __func__, fname);
 
@@ -24,78 +26,47 @@ model_loader::load_model_weights(fairseq2_model &model, std::ifstream &fin)
 {
     size_t total_size = 0;
     while (!fin.eof()) {
-        auto tensor = next_tensor(fin, model);
-        load_tensor_value(fin, tensor);
+        std::string name = get_name(fin);
+        if (name.length() == 0)
+            break;
+        auto tensor = load_tensor_value(fin, model.ctx);
+        model.tensors[name] = tensor;
+        if (DEBUG) {
+            printf("%s [%5ld, %5ld], type = %6s, %6.2f MB, %9zu bytes\n", name.c_str(), tensor->ne[0], tensor->ne[1], ggml_type_name(tensor->type), ggml_nbytes(tensor)/1024.0/1024.0, ggml_nbytes(tensor));
+        }
         total_size += ggml_nbytes(tensor);
     }
 
     printf("%s: model size  = %8.2f MB\n", __func__, total_size/1024.0/1024.0);
 };
 
-ggml_tensor *
-model_loader::next_tensor(std::ifstream &fin, fairseq2_model &model)
-{
-    auto name = get_name(fin);
-    std::cout << "loading tensor: " << name << std::endl;
-
-    if (model.tensors.find(name) == model.tensors.end()) {
-        fprintf(stderr, "%s: unknown tensor '%s' in model file\n", __func__, name.c_str());
-        throw std::invalid_argument("failed to open file."); // TODO Merge error message.
-    }
-
-    return model.tensors[name];
-};
-
-void
-model_loader::load_tensor_value(std::ifstream &fin, ggml_tensor *tensor)
+ggml_tensor* load_tensor_value(std::ifstream &fin, ggml_context* ctx)
 {
     int32_t n_dims;
-    int32_t ttype;
+    int32_t raw_type;
 
     fin.read(reinterpret_cast<char *>(&n_dims), sizeof(n_dims));
-    fin.read(reinterpret_cast<char *>(&ttype),  sizeof(ttype));
+    fin.read(reinterpret_cast<char *>(&raw_type),  sizeof(raw_type));
+    ggml_type type = ggml_type(raw_type);
 
-    int32_t nelements = 1;
-    int32_t ne[3] = {1, 1, 1};
+    int64_t ne[4] = {1, 1, 1, 1};
     for (int i = 0; i < n_dims; ++i) {
         fin.read(reinterpret_cast<char *>(&ne[i]), sizeof(ne[i]));
-        nelements *= ne[i];
     }
-
-    if (ggml_nelements(tensor) != nelements) {
-        std::cout << ggml_nelements(tensor) << std::endl;
-        std::cout << nelements << std::endl;
-        throw std::runtime_error("tensor has wrong size in model file.");
-    }
-
-    if (tensor->ne[0] != ne[0] || tensor->ne[1] != ne[1]) {
-        fprintf(stderr, "%s: tensor '%s' has wrong shape in model file: got [%d, %d], expected [%d, %d]\n",
-                __func__, (int) tensor->ne[0], (int) tensor->ne[1], ne[0], ne[1]);
-        throw std::runtime_error("tensor has wrong shape in file."); // TODO Merge error message.
-    }
-
-    // for debugging
-    if (0) {
-        printf("%[%5d, %5d], type = %6s, %6.2f MB, %9zu bytes\n", ne[0], ne[1], ggml_type_name(ggml_type(ttype)), ggml_nbytes(tensor)/1024.0/1024.0, ggml_nbytes(tensor));
-    }
-
-    const size_t bpe = ggml_type_size(ggml_type(ttype));
-
-    if ((nelements * bpe)/ggml_blck_size(tensor->type) != ggml_nbytes(tensor)) {
-        fprintf(stderr, "%s: tensor has wrong size in model file: got %zu, expected %zu\n",
-                __func__, ggml_nbytes(tensor), nelements * bpe);
-        throw std::runtime_error("tensor has wrong size in file."); // TODO Merge error message.
-    }
-
+    ggml_tensor* tensor = ggml_new_tensor(ctx, type, n_dims, ne);
     fin.read(reinterpret_cast<char *>(tensor->data), ggml_nbytes(tensor));
+    return tensor;
 };
 
 std::string
 model_loader::get_name(std::ifstream& fin)
 {
-    std::uint32_t length;
+    std::uint32_t length = 0;
     fin.read(reinterpret_cast<char *>(&length), sizeof(length));
     std::string name(length, 0);
+    if (length == 0) {
+        return name;
+    };
     fin.read(&name[0], length);
 
     return name;

ggml/examples/unity/model_loader.h

@@ -32,11 +32,11 @@ public:
 private:
     ggml_tensor * next_tensor(std::ifstream &fin, fairseq2_model &model);
 
-    // TODO Move these two to helpers
-    void load_tensor_value(std::ifstream &fin, ggml_tensor *tensor);
     std::string get_name(std::ifstream &fin);
 };
 
+ggml_tensor* load_tensor_value(std::ifstream &fin, ggml_context* ctx);
+
 std::ifstream open_ggml_file(const char* fname);
 
 template<typename T>
@@ -53,8 +53,6 @@ void load_fairseq2_ggml_file(fairseq2_model& model, const char* fname) {
     };
     model.ctx = ggml_init(params);
 
-    // TODO: should we delay weights loading/allocating ?
-    loader.tensors_alloc(model);
     loader.load_model_weights(model, fin);;
 }
 

ggml/examples/unity/unity_model_loader.cpp

@@ -14,68 +14,18 @@
 
 void unity_model_loader::load_hparams(fairseq2_model& model, std::ifstream &fin)
 {
-    auto& hparams = (unity_hparams&)model.hparams;
-
-    fin.read((char*) &hparams.model_dim, sizeof(hparams.model_dim));
-    fin.read((char*) &hparams.w2v2_encoder_config__model_dim, sizeof(hparams.w2v2_encoder_config__model_dim));
-    fin.read((char*) &hparams.w2v2_encoder_config__max_seq_len, sizeof(hparams.w2v2_encoder_config__max_seq_len));
-    fin.read((char*) &hparams.w2v2_encoder_config__feature_dim, sizeof(hparams.w2v2_encoder_config__feature_dim));
-    fin.read((char*) &hparams.w2v2_encoder_config__use_fbank, sizeof(hparams.w2v2_encoder_config__use_fbank));
-    fin.read((char*) &hparams.w2v2_encoder_config__first_pass_dropout_p, sizeof(hparams.w2v2_encoder_config__first_pass_dropout_p));
-    fin.read((char*) &hparams.w2v2_encoder_config__layer_norm_features, sizeof(hparams.w2v2_encoder_config__layer_norm_features));
-    fin.read((char*) &hparams.w2v2_encoder_config__feature_extractor_bias, sizeof(hparams.w2v2_encoder_config__feature_extractor_bias));
-    fin.read((char*) &hparams.w2v2_encoder_config__feature_extractor_layer_norm_convs, sizeof(hparams.w2v2_encoder_config__feature_extractor_layer_norm_convs));
-    fin.read((char*) &hparams.w2v2_encoder_config__feature_grad_scale, sizeof(hparams.w2v2_encoder_config__feature_grad_scale));
-    fin.read((char*) &hparams.w2v2_encoder_config__num_fbank_channels, sizeof(hparams.w2v2_encoder_config__num_fbank_channels));
-    fin.read((char*) &hparams.w2v2_encoder_config__fbank_stride, sizeof(hparams.w2v2_encoder_config__fbank_stride));
-    fin.read((char*) &hparams.w2v2_encoder_config__sample_fbank_every_k, sizeof(hparams.w2v2_encoder_config__sample_fbank_every_k));
-    fin.read((char*) &hparams.w2v2_encoder_config__pos_encoder_depth, sizeof(hparams.w2v2_encoder_config__pos_encoder_depth));
-    fin.read((char*) &hparams.w2v2_encoder_config__pos_conv_kernel_size, sizeof(hparams.w2v2_encoder_config__pos_conv_kernel_size));
-    fin.read((char*) &hparams.w2v2_encoder_config__num_pos_conv_groups, sizeof(hparams.w2v2_encoder_config__num_pos_conv_groups));
-    fin.read((char*) &hparams.w2v2_encoder_config__use_conformer, sizeof(hparams.w2v2_encoder_config__use_conformer));
-    fin.read((char*) &hparams.w2v2_encoder_config__num_encoder_layers, sizeof(hparams.w2v2_encoder_config__num_encoder_layers));
-    fin.read((char*) &hparams.w2v2_encoder_config__num_encoder_attn_heads, sizeof(hparams.w2v2_encoder_config__num_encoder_attn_heads));
-    fin.read((char*) &hparams.w2v2_encoder_config__ffn_inner_dim, sizeof(hparams.w2v2_encoder_config__ffn_inner_dim));
-    fin.read((char*) &hparams.w2v2_encoder_config__dropout_p, sizeof(hparams.w2v2_encoder_config__dropout_p));
-    fin.read((char*) &hparams.w2v2_encoder_config__attn_dropout_p, sizeof(hparams.w2v2_encoder_config__attn_dropout_p));
-    fin.read((char*) &hparams.w2v2_encoder_config__layer_drop_p, sizeof(hparams.w2v2_encoder_config__layer_drop_p));
-    fin.read((char*) &hparams.w2v2_encoder_config__norm_order, sizeof(hparams.w2v2_encoder_config__norm_order));
-    fin.read((char*) &hparams.w2v2_encoder_config__depthwise_conv_kernel_size, sizeof(hparams.w2v2_encoder_config__depthwise_conv_kernel_size));
-    fin.read((char*) &hparams.nllb_config__model_dim, sizeof(hparams.nllb_config__model_dim));
-    fin.read((char*) &hparams.nllb_config__max_seq_len, sizeof(hparams.nllb_config__max_seq_len));
-    fin.read((char*) &hparams.nllb_config__vocabulary_size, sizeof(hparams.nllb_config__vocabulary_size));
-    fin.read((char*) &hparams.nllb_config__pad_idx, sizeof(hparams.nllb_config__pad_idx));
-    fin.read((char*) &hparams.nllb_config__num_encoder_layers, sizeof(hparams.nllb_config__num_encoder_layers));
-    fin.read((char*) &hparams.nllb_config__num_decoder_layers, sizeof(hparams.nllb_config__num_decoder_layers));
-    fin.read((char*) &hparams.nllb_config__num_encoder_attn_heads, sizeof(hparams.nllb_config__num_encoder_attn_heads));
-    fin.read((char*) &hparams.nllb_config__num_decoder_attn_heads, sizeof(hparams.nllb_config__num_decoder_attn_heads));
-    fin.read((char*) &hparams.nllb_config__ffn_inner_dim, sizeof(hparams.nllb_config__ffn_inner_dim));
-    fin.read((char*) &hparams.nllb_config__dropout_p, sizeof(hparams.nllb_config__dropout_p));
-    fin.read((char*) &hparams.t2u_config__model_dim, sizeof(hparams.t2u_config__model_dim));
-    fin.read((char*) &hparams.t2u_config__unit_max_seq_len, sizeof(hparams.t2u_config__unit_max_seq_len));
-    fin.read((char*) &hparams.t2u_config__unit_vocabulary_size, sizeof(hparams.t2u_config__unit_vocabulary_size));
-    fin.read((char*) &hparams.t2u_config__unit_pad_idx, sizeof(hparams.t2u_config__unit_pad_idx));
-    fin.read((char*) &hparams.t2u_config__num_encoder_layers, sizeof(hparams.t2u_config__num_encoder_layers));
-    fin.read((char*) &hparams.t2u_config__num_decoder_layers, sizeof(hparams.t2u_config__num_decoder_layers));
-    fin.read((char*) &hparams.t2u_config__num_encoder_attn_heads, sizeof(hparams.t2u_config__num_encoder_attn_heads));
-    fin.read((char*) &hparams.t2u_config__num_decoder_attn_heads, sizeof(hparams.t2u_config__num_decoder_attn_heads));
-    fin.read((char*) &hparams.t2u_config__ffn_inner_dim, sizeof(hparams.t2u_config__ffn_inner_dim));
-    fin.read((char*) &hparams.t2u_config__dropout_p, sizeof(hparams.t2u_config__dropout_p));
-    fin.read((char*) &hparams.use_text_encoder, sizeof(hparams.use_text_encoder));
-    fin.read((char*) &hparams.use_conformer_adaptor, sizeof(hparams.use_conformer_adaptor));
-    fin.read((char*) &hparams.num_adaptor_layers, sizeof(hparams.num_adaptor_layers));
-    fin.read((char*) &hparams.adaptor_kernel_size, sizeof(hparams.adaptor_kernel_size));
-    fin.read((char*) &hparams.adaptor_stride, sizeof(hparams.adaptor_stride));
-    fin.read((char*) &hparams.adaptor_layer_norm, sizeof(hparams.adaptor_layer_norm));
-    fin.read((char*) &hparams.adaptor_dropout_p, sizeof(hparams.adaptor_dropout_p));
-};
+    unity_hparams* hparams = (unity_hparams*)model.hparams;
+    read_unity_hparams(hparams, fin);
+    if (hparams->__end_of_hparams__ != 6877961321223123048) {
+        throw std::invalid_argument("");
+    }
+}
 
 std::size_t
 unity_model_loader::compute_context_size(void* raw_hparams)
 {
-    // TODO
-    auto hparams = (unity_hparams&)raw_hparams;
-    return hparams.model_dim * 1024 * 100;
+    auto* hparams = (unity_hparams*)raw_hparams;
+    return hparams->model_byte_size;
 };
 
 struct UnityArch {

ggml/examples/unity/unity_model_loader.h

@@ -12,62 +12,127 @@
 
 // TODO Merge with Ning implementation
 struct unity_hparams {
-    int32_t model_dim;
-    int32_t w2v2_encoder_config__model_dim;
-    int32_t w2v2_encoder_config__max_seq_len;
-    int32_t w2v2_encoder_config__feature_dim;
-    int32_t w2v2_encoder_config__use_fbank;
+    std::int64_t model_dim;
+    std::int64_t w2v2_encoder_config__model_dim;
+    std::int64_t w2v2_encoder_config__max_seq_len;
+    std::int64_t w2v2_encoder_config__feature_dim;
+    std::int64_t w2v2_encoder_config__use_fbank;
     float w2v2_encoder_config__first_pass_dropout_p;
-    int32_t w2v2_encoder_config__layer_norm_features;
-    int32_t w2v2_encoder_config__feature_extractor_bias;
-    int32_t w2v2_encoder_config__feature_extractor_layer_norm_convs;
-    int32_t w2v2_encoder_config__feature_grad_scale;
-    int32_t w2v2_encoder_config__num_fbank_channels;
-    int32_t w2v2_encoder_config__fbank_stride;
-    int32_t w2v2_encoder_config__sample_fbank_every_k;
-    int32_t w2v2_encoder_config__pos_encoder_depth;
-    int32_t w2v2_encoder_config__pos_conv_kernel_size;
-    int32_t w2v2_encoder_config__num_pos_conv_groups;
-    int32_t w2v2_encoder_config__use_conformer;
-    int32_t w2v2_encoder_config__num_encoder_layers;
-    int32_t w2v2_encoder_config__num_encoder_attn_heads;
-    int32_t w2v2_encoder_config__ffn_inner_dim;
+    std::int64_t w2v2_encoder_config__layer_norm_features;
+    // Error: Unsupported type <class 'list'> w2v2_encoder_config__feature_extractor_layer_descs;
+    std::int64_t w2v2_encoder_config__feature_extractor_bias;
+    std::int64_t w2v2_encoder_config__feature_extractor_layer_norm_convs;
+    std::int64_t w2v2_encoder_config__feature_grad_scale;
+    std::int64_t w2v2_encoder_config__num_fbank_channels;
+    std::int64_t w2v2_encoder_config__fbank_stride;
+    std::int64_t w2v2_encoder_config__sample_fbank_every_k;
+    // Error: Unsupported type <class 'str'> w2v2_encoder_config__pos_encoder_type;
+    std::int64_t w2v2_encoder_config__pos_encoder_depth;
+    std::int64_t w2v2_encoder_config__pos_conv_kernel_size;
+    std::int64_t w2v2_encoder_config__num_pos_conv_groups;
+    std::int64_t w2v2_encoder_config__use_conformer;
+    std::int64_t w2v2_encoder_config__num_encoder_layers;
+    std::int64_t w2v2_encoder_config__num_encoder_attn_heads;
+    std::int64_t w2v2_encoder_config__ffn_inner_dim;
     float w2v2_encoder_config__dropout_p;
     float w2v2_encoder_config__attn_dropout_p;
     float w2v2_encoder_config__layer_drop_p;
-    int32_t w2v2_encoder_config__norm_order;
-    int32_t w2v2_encoder_config__depthwise_conv_kernel_size;
-    int32_t nllb_config__model_dim;
-    int32_t nllb_config__max_seq_len;
-    int32_t nllb_config__vocabulary_size;
-    int32_t nllb_config__pad_idx;
-    int32_t nllb_config__num_encoder_layers;
-    int32_t nllb_config__num_decoder_layers;
-    int32_t nllb_config__num_encoder_attn_heads;
-    int32_t nllb_config__num_decoder_attn_heads;
-    int32_t nllb_config__ffn_inner_dim;
+    std::int32_t w2v2_encoder_config__norm_order;
+    std::int64_t w2v2_encoder_config__depthwise_conv_kernel_size;
+    std::int64_t nllb_config__model_dim;
+    std::int64_t nllb_config__max_seq_len;
+    std::int64_t nllb_config__vocabulary_size;
+    std::int64_t nllb_config__pad_idx;
+    std::int64_t nllb_config__num_encoder_layers;
+    std::int64_t nllb_config__num_decoder_layers;
+    std::int64_t nllb_config__num_encoder_attn_heads;
+    std::int64_t nllb_config__num_decoder_attn_heads;
+    std::int64_t nllb_config__ffn_inner_dim;
     float nllb_config__dropout_p;
-    int32_t t2u_config__model_dim;
-    int32_t t2u_config__unit_max_seq_len;
-    int32_t t2u_config__unit_vocabulary_size;
-    int32_t t2u_config__unit_pad_idx;
-    int32_t t2u_config__num_encoder_layers;
-    int32_t t2u_config__num_decoder_layers;
-    int32_t t2u_config__num_encoder_attn_heads;
-    int32_t t2u_config__num_decoder_attn_heads;
-    int32_t t2u_config__ffn_inner_dim;
+    std::int64_t t2u_config__model_dim;
+    std::int64_t t2u_config__unit_max_seq_len;
+    std::int64_t t2u_config__unit_vocabulary_size;
+    std::int64_t t2u_config__unit_pad_idx;
+    std::int64_t t2u_config__num_encoder_layers;
+    std::int64_t t2u_config__num_decoder_layers;
+    std::int64_t t2u_config__num_encoder_attn_heads;
+    std::int64_t t2u_config__num_decoder_attn_heads;
+    std::int64_t t2u_config__ffn_inner_dim;
     float t2u_config__dropout_p;
-    int32_t use_text_encoder;
-    int32_t use_conformer_adaptor;
-    int32_t num_adaptor_layers;
-    int32_t adaptor_kernel_size;
-    int32_t adaptor_stride;
-    int32_t adaptor_layer_norm;
+    std::int64_t use_text_encoder;
+    std::int64_t use_conformer_adaptor;
+    std::int64_t num_adaptor_layers;
+    std::int64_t adaptor_kernel_size;
+    std::int64_t adaptor_stride;
+    std::int64_t adaptor_layer_norm;
     float adaptor_dropout_p;
+    std::int64_t model_byte_size;
+    std::int64_t __end_of_hparams__;
+
+};
+
+void read_unity_hparams(unity_hparams* out, std::ifstream &fin) {
+    fin.read((char*) &out->model_dim, sizeof(out->model_dim));
+    fin.read((char*) &out->w2v2_encoder_config__model_dim, sizeof(out->w2v2_encoder_config__model_dim));
+    fin.read((char*) &out->w2v2_encoder_config__max_seq_len, sizeof(out->w2v2_encoder_config__max_seq_len));
+    fin.read((char*) &out->w2v2_encoder_config__feature_dim, sizeof(out->w2v2_encoder_config__feature_dim));
+    fin.read((char*) &out->w2v2_encoder_config__use_fbank, sizeof(out->w2v2_encoder_config__use_fbank));
+    fin.read((char*) &out->w2v2_encoder_config__first_pass_dropout_p, sizeof(out->w2v2_encoder_config__first_pass_dropout_p));
+    fin.read((char*) &out->w2v2_encoder_config__layer_norm_features, sizeof(out->w2v2_encoder_config__layer_norm_features));
+    fin.read((char*) &out->w2v2_encoder_config__feature_extractor_bias, sizeof(out->w2v2_encoder_config__feature_extractor_bias));
+    fin.read((char*) &out->w2v2_encoder_config__feature_extractor_layer_norm_convs, sizeof(out->w2v2_encoder_config__feature_extractor_layer_norm_convs));
+    fin.read((char*) &out->w2v2_encoder_config__feature_grad_scale, sizeof(out->w2v2_encoder_config__feature_grad_scale));
+    fin.read((char*) &out->w2v2_encoder_config__num_fbank_channels, sizeof(out->w2v2_encoder_config__num_fbank_channels));
+    fin.read((char*) &out->w2v2_encoder_config__fbank_stride, sizeof(out->w2v2_encoder_config__fbank_stride));
+    fin.read((char*) &out->w2v2_encoder_config__sample_fbank_every_k, sizeof(out->w2v2_encoder_config__sample_fbank_every_k));
+    fin.read((char*) &out->w2v2_encoder_config__pos_encoder_depth, sizeof(out->w2v2_encoder_config__pos_encoder_depth));
+    fin.read((char*) &out->w2v2_encoder_config__pos_conv_kernel_size, sizeof(out->w2v2_encoder_config__pos_conv_kernel_size));
+    fin.read((char*) &out->w2v2_encoder_config__num_pos_conv_groups, sizeof(out->w2v2_encoder_config__num_pos_conv_groups));
+    fin.read((char*) &out->w2v2_encoder_config__use_conformer, sizeof(out->w2v2_encoder_config__use_conformer));
+    fin.read((char*) &out->w2v2_encoder_config__num_encoder_layers, sizeof(out->w2v2_encoder_config__num_encoder_layers));
+    fin.read((char*) &out->w2v2_encoder_config__num_encoder_attn_heads, sizeof(out->w2v2_encoder_config__num_encoder_attn_heads));
+    fin.read((char*) &out->w2v2_encoder_config__ffn_inner_dim, sizeof(out->w2v2_encoder_config__ffn_inner_dim));
+    fin.read((char*) &out->w2v2_encoder_config__dropout_p, sizeof(out->w2v2_encoder_config__dropout_p));
+    fin.read((char*) &out->w2v2_encoder_config__attn_dropout_p, sizeof(out->w2v2_encoder_config__attn_dropout_p));
+    fin.read((char*) &out->w2v2_encoder_config__layer_drop_p, sizeof(out->w2v2_encoder_config__layer_drop_p));
+    fin.read((char*) &out->w2v2_encoder_config__norm_order, sizeof(out->w2v2_encoder_config__norm_order));
+    fin.read((char*) &out->w2v2_encoder_config__depthwise_conv_kernel_size, sizeof(out->w2v2_encoder_config__depthwise_conv_kernel_size));
+    fin.read((char*) &out->nllb_config__model_dim, sizeof(out->nllb_config__model_dim));
+    fin.read((char*) &out->nllb_config__max_seq_len, sizeof(out->nllb_config__max_seq_len));
+    fin.read((char*) &out->nllb_config__vocabulary_size, sizeof(out->nllb_config__vocabulary_size));
+    fin.read((char*) &out->nllb_config__pad_idx, sizeof(out->nllb_config__pad_idx));
+    fin.read((char*) &out->nllb_config__num_encoder_layers, sizeof(out->nllb_config__num_encoder_layers));
+    fin.read((char*) &out->nllb_config__num_decoder_layers, sizeof(out->nllb_config__num_decoder_layers));
+    fin.read((char*) &out->nllb_config__num_encoder_attn_heads, sizeof(out->nllb_config__num_encoder_attn_heads));
+    fin.read((char*) &out->nllb_config__num_decoder_attn_heads, sizeof(out->nllb_config__num_decoder_attn_heads));
+    fin.read((char*) &out->nllb_config__ffn_inner_dim, sizeof(out->nllb_config__ffn_inner_dim));
+    fin.read((char*) &out->nllb_config__dropout_p, sizeof(out->nllb_config__dropout_p));
+    fin.read((char*) &out->t2u_config__model_dim, sizeof(out->t2u_config__model_dim));
+    fin.read((char*) &out->t2u_config__unit_max_seq_len, sizeof(out->t2u_config__unit_max_seq_len));
+    fin.read((char*) &out->t2u_config__unit_vocabulary_size, sizeof(out->t2u_config__unit_vocabulary_size));
+    fin.read((char*) &out->t2u_config__unit_pad_idx, sizeof(out->t2u_config__unit_pad_idx));
+    fin.read((char*) &out->t2u_config__num_encoder_layers, sizeof(out->t2u_config__num_encoder_layers));
+    fin.read((char*) &out->t2u_config__num_decoder_layers, sizeof(out->t2u_config__num_decoder_layers));
+    fin.read((char*) &out->t2u_config__num_encoder_attn_heads, sizeof(out->t2u_config__num_encoder_attn_heads));
+    fin.read((char*) &out->t2u_config__num_decoder_attn_heads, sizeof(out->t2u_config__num_decoder_attn_heads));
+    fin.read((char*) &out->t2u_config__ffn_inner_dim, sizeof(out->t2u_config__ffn_inner_dim));
+    fin.read((char*) &out->t2u_config__dropout_p, sizeof(out->t2u_config__dropout_p));
+    fin.read((char*) &out->use_text_encoder, sizeof(out->use_text_encoder));
+    fin.read((char*) &out->use_conformer_adaptor, sizeof(out->use_conformer_adaptor));
+    fin.read((char*) &out->num_adaptor_layers, sizeof(out->num_adaptor_layers));
+    fin.read((char*) &out->adaptor_kernel_size, sizeof(out->adaptor_kernel_size));
+    fin.read((char*) &out->adaptor_stride, sizeof(out->adaptor_stride));
+    fin.read((char*) &out->adaptor_layer_norm, sizeof(out->adaptor_layer_norm));
+    fin.read((char*) &out->adaptor_dropout_p, sizeof(out->adaptor_dropout_p));
+    fin.read((char*) &out->model_byte_size, sizeof(out->model_byte_size));
+    fin.read((char*) &out->__end_of_hparams__, sizeof(out->__end_of_hparams__));
+
 };
 
 
 
+
+
 // Embedding
 std::size_t compute_embed_size(int32_t vocab_size, int32_t dim)
 {