@scrypted/libav 1.0.169 → 1.0.171

package/opus/dnn/training_tf2/dataloader.py

@@ -1,49 +0,0 @@
-import numpy as np
-from tensorflow.keras.utils import Sequence
-from ulaw import lin2ulaw
-
-def lpc2rc(lpc):
-    #print("shape is = ", lpc.shape)
-    order = lpc.shape[-1]
-    rc = 0*lpc
-    for i in range(order, 0, -1):
-        rc[:,:,i-1] = lpc[:,:,-1]
-        ki = rc[:,:,i-1:i].repeat(i-1, axis=2)
-        lpc = (lpc[:,:,:-1] - ki*lpc[:,:,-2::-1])/(1-ki*ki)
-    return rc
-
-class LPCNetLoader(Sequence):
-    def __init__(self, data, features, periods, batch_size, e2e=False, lookahead=2):
-        self.batch_size = batch_size
-        self.nb_batches = np.minimum(np.minimum(data.shape[0], features.shape[0]), periods.shape[0])//self.batch_size
-        self.data = data[:self.nb_batches*self.batch_size, :]
-        self.features = features[:self.nb_batches*self.batch_size, :]
-        self.periods = periods[:self.nb_batches*self.batch_size, :]
-        self.e2e = e2e
-        self.lookahead = lookahead
-        self.on_epoch_end()
-
-    def on_epoch_end(self):
-        self.indices = np.arange(self.nb_batches*self.batch_size)
-        np.random.shuffle(self.indices)
-
-    def __getitem__(self, index):
-        data = self.data[self.indices[index*self.batch_size:(index+1)*self.batch_size], :, :]
-        in_data = data[: , :, :1]
-        out_data = data[: , :, 1:]
-        features = self.features[self.indices[index*self.batch_size:(index+1)*self.batch_size], :, :-16]
-        periods = self.periods[self.indices[index*self.batch_size:(index+1)*self.batch_size], :, :]
-        outputs = [out_data]
-        inputs = [in_data, features, periods]
-        if self.lookahead > 0:
-            lpc = self.features[self.indices[index*self.batch_size:(index+1)*self.batch_size], 4-self.lookahead:-self.lookahead, -16:]
-        else:
-            lpc = self.features[self.indices[index*self.batch_size:(index+1)*self.batch_size], 4:, -16:]
-        if self.e2e:
-            outputs.append(lpc2rc(lpc))
-        else:
-            inputs.append(lpc)
-        return (inputs, outputs)
-
-    def __len__(self):
-        return self.nb_batches

package/opus/dnn/training_tf2/decode_rdovae.py

@@ -1,111 +0,0 @@
-#!/usr/bin/python3
-'''Copyright (c) 2021-2022 Amazon
-   Copyright (c) 2018-2019 Mozilla
-
-   Redistribution and use in source and binary forms, with or without
-   modification, are permitted provided that the following conditions
-   are met:
-
-   - Redistributions of source code must retain the above copyright
-   notice, this list of conditions and the following disclaimer.
-
-   - Redistributions in binary form must reproduce the above copyright
-   notice, this list of conditions and the following disclaimer in the
-   documentation and/or other materials provided with the distribution.
-
-   THIS SOFTWARE IS PROVIDED BY THE COPYRIGHT HOLDERS AND CONTRIBUTORS
-   ``AS IS'' AND ANY EXPRESS OR IMPLIED WARRANTIES, INCLUDING, BUT NOT
-   LIMITED TO, THE IMPLIED WARRANTIES OF MERCHANTABILITY AND FITNESS FOR
-   A PARTICULAR PURPOSE ARE DISCLAIMED.  IN NO EVENT SHALL THE FOUNDATION OR
-   CONTRIBUTORS BE LIABLE FOR ANY DIRECT, INDIRECT, INCIDENTAL, SPECIAL,
-   EXEMPLARY, OR CONSEQUENTIAL DAMAGES (INCLUDING, BUT NOT LIMITED TO,
-   PROCUREMENT OF SUBSTITUTE GOODS OR SERVICES; LOSS OF USE, DATA, OR
-   PROFITS; OR BUSINESS INTERRUPTION) HOWEVER CAUSED AND ON ANY THEORY OF
-   LIABILITY, WHETHER IN CONTRACT, STRICT LIABILITY, OR TORT (INCLUDING
-   NEGLIGENCE OR OTHERWISE) ARISING IN ANY WAY OUT OF THE USE OF THIS
-   SOFTWARE, EVEN IF ADVISED OF THE POSSIBILITY OF SUCH DAMAGE.
-'''
-
-# Train an LPCNet model
-
-import argparse
-#from plc_loader import PLCLoader
-
-parser = argparse.ArgumentParser(description='Train a PLC model')
-
-parser.add_argument('bits', metavar='<bits file>', help='binary features file (int16)')
-parser.add_argument('output', metavar='<output>', help='output features')
-parser.add_argument('--model', metavar='<model>', default='rdovae', help='PLC model python definition (without .py)')
-group1 = parser.add_mutually_exclusive_group()
-group1.add_argument('--weights', metavar='<input weights>', help='model weights')
-parser.add_argument('--cond-size', metavar='<units>', default=1024, type=int, help='number of units in conditioning network (default 1024)')
-parser.add_argument('--batch-size', metavar='<batch size>', default=1, type=int, help='batch size to use (default 128)')
-parser.add_argument('--seq-length', metavar='<sequence length>', default=1000, type=int, help='sequence length to use (default 1000)')
-
-
-args = parser.parse_args()
-
-import importlib
-rdovae = importlib.import_module(args.model)
-
-import sys
-import numpy as np
-from tensorflow.keras.optimizers import Adam
-from tensorflow.keras.callbacks import ModelCheckpoint, CSVLogger
-import tensorflow.keras.backend as K
-import h5py
-
-import tensorflow as tf
-from rdovae import pvq_quantize
-from rdovae import apply_dead_zone
-
-# Try reducing batch_size if you run out of memory on your GPU
-batch_size = args.batch_size
-
-model, encoder, decoder, qembedding = rdovae.new_rdovae_model(nb_used_features=20, nb_bits=80, batch_size=batch_size, cond_size=args.cond_size)
-model.load_weights(args.weights)
-
-lpc_order = 16
-nbits=80
-
-
-bits_file = args.bits
-sequence_size = args.seq_length
-
-# u for unquantised, load 16 bit PCM samples and convert to mu-law
-
-
-bits = np.memmap(bits_file + "-syms.f32", dtype='float32', mode='r')
-nb_sequences = len(bits)//(40*sequence_size)//batch_size*batch_size
-bits = bits[:nb_sequences*sequence_size*40]
-
-bits = np.reshape(bits, (nb_sequences, sequence_size//2, 20*4))
-print(bits.shape)
-
-lambda_val = 0.001 * np.ones((nb_sequences, sequence_size//2, 1))
-quant_id = np.round(3.8*np.log(lambda_val/.0002)).astype('int16')
-quant_id = quant_id[:,:,0]
-quant_embed = qembedding(quant_id)
-quant_scale = tf.math.softplus(quant_embed[:,:,:nbits])
-dead_zone = tf.math.softplus(quant_embed[:, :, nbits : 2 * nbits])
-
-bits = bits*quant_scale
-bits = np.round(apply_dead_zone([bits, dead_zone]).numpy())
-bits = bits/quant_scale
-
-
-state = np.memmap(bits_file + "-state.f32", dtype='float32', mode='r')
-
-state = np.reshape(state, (nb_sequences, sequence_size//2, 24))
-state = state[:,-1,:]
-state = pvq_quantize(state, 82)
-#state = state/(1e-15+tf.norm(state, axis=-1,keepdims=True))
-
-print("shapes are:")
-print(bits.shape)
-print(state.shape)
-
-bits = bits[:,1::2,:]
-features = decoder.predict([bits, state], batch_size=batch_size)
-
-features.astype('float32').tofile(args.output)

package/opus/dnn/training_tf2/diffembed.py

@@ -1,49 +0,0 @@
-"""
-Modification of Tensorflow's Embedding Layer:
-    1. Not restricted to be the first layer of a model
-    2. Differentiable (allows non-integer lookups)
-        - For non integer lookup, this layer linearly interpolates between the adjacent embeddings in the following way to preserver gradient flow
-            - E = (1 - frac(x))*embed(floor(x)) + frac(x)*embed(ceil(x))
-"""
-
-import tensorflow as tf
-from tensorflow.keras.layers import Layer
-
-class diff_Embed(Layer):
-    """
-    Parameters:
-        - units: int
-            Dimension of the Embedding
-        - dict_size: int
-            Number of Embeddings to lookup
-        - pcm_init: boolean
-            Initialized for the embedding matrix
-    """
-    def __init__(self, units=128, dict_size = 256, pcm_init = True, initializer = None, **kwargs):
-        super(diff_Embed, self).__init__(**kwargs)
-        self.units = units
-        self.dict_size = dict_size
-        self.pcm_init = pcm_init
-        self.initializer = initializer
-
-    def build(self, input_shape):
-        w_init = tf.random_normal_initializer()
-        if self.pcm_init:
-            w_init = self.initializer
-        self.w = tf.Variable(initial_value=w_init(shape=(self.dict_size, self.units),dtype='float32'),trainable=True)
-
-    def call(self, inputs):
-        alpha = inputs - tf.math.floor(inputs)
-        alpha = tf.expand_dims(alpha,axis = -1)
-        alpha = tf.tile(alpha,[1,1,1,self.units])
-        inputs = tf.cast(inputs,'int32')
-        M = (1 - alpha)*tf.gather(self.w,inputs) + alpha*tf.gather(self.w,tf.clip_by_value(inputs + 1, 0, 255))
-        return M
-
-    def get_config(self):
-        config = super(diff_Embed, self).get_config()
-        config.update({"units": self.units})
-        config.update({"dict_size" : self.dict_size})
-        config.update({"pcm_init" : self.pcm_init})
-        config.update({"initializer" : self.initializer})
-        return config

package/opus/dnn/training_tf2/dump_lpcnet.py

@@ -1,388 +0,0 @@
-#!/usr/bin/python3
-'''Copyright (c) 2017-2018 Mozilla
-
-   Redistribution and use in source and binary forms, with or without
-   modification, are permitted provided that the following conditions
-   are met:
-
-   - Redistributions of source code must retain the above copyright
-   notice, this list of conditions and the following disclaimer.
-
-   - Redistributions in binary form must reproduce the above copyright
-   notice, this list of conditions and the following disclaimer in the
-   documentation and/or other materials provided with the distribution.
-
-   THIS SOFTWARE IS PROVIDED BY THE COPYRIGHT HOLDERS AND CONTRIBUTORS
-   ``AS IS'' AND ANY EXPRESS OR IMPLIED WARRANTIES, INCLUDING, BUT NOT
-   LIMITED TO, THE IMPLIED WARRANTIES OF MERCHANTABILITY AND FITNESS FOR
-   A PARTICULAR PURPOSE ARE DISCLAIMED.  IN NO EVENT SHALL THE FOUNDATION OR
-   CONTRIBUTORS BE LIABLE FOR ANY DIRECT, INDIRECT, INCIDENTAL, SPECIAL,
-   EXEMPLARY, OR CONSEQUENTIAL DAMAGES (INCLUDING, BUT NOT LIMITED TO,
-   PROCUREMENT OF SUBSTITUTE GOODS OR SERVICES; LOSS OF USE, DATA, OR
-   PROFITS; OR BUSINESS INTERRUPTION) HOWEVER CAUSED AND ON ANY THEORY OF
-   LIABILITY, WHETHER IN CONTRACT, STRICT LIABILITY, OR TORT (INCLUDING
-   NEGLIGENCE OR OTHERWISE) ARISING IN ANY WAY OUT OF THE USE OF THIS
-   SOFTWARE, EVEN IF ADVISED OF THE POSSIBILITY OF SUCH DAMAGE.
-'''
-
-import os
-import io
-import lpcnet
-import sys
-import numpy as np
-from tensorflow.keras.optimizers import Adam
-from tensorflow.keras.layers import Layer, GRU, Dense, Conv1D, Embedding
-from ulaw import ulaw2lin, lin2ulaw
-from mdense import MDense
-from diffembed import diff_Embed
-from parameters import get_parameter
-import h5py
-import re
-import argparse
-
-
-# no cuda devices needed
-os.environ['CUDA_VISIBLE_DEVICES'] = ""
-
-# Flag for dumping e2e (differentiable lpc) network weights
-flag_e2e = False
-
-
-max_rnn_neurons = 1
-max_conv_inputs = 1
-max_mdense_tmp = 1
-
-def printVector(f, vector, name, dtype='float', dotp=False):
-    global array_list
-    if dotp:
-        vector = vector.reshape((vector.shape[0]//4, 4, vector.shape[1]//8, 8))
-        vector = vector.transpose((2, 0, 3, 1))
-    v = np.reshape(vector, (-1));
-    #print('static const float ', name, '[', len(v), '] = \n', file=f)
-    if name not in array_list:
-        array_list.append(name)
-    f.write('#ifndef USE_WEIGHTS_FILE\n')
-    f.write('#define WEIGHTS_{}_DEFINED\n'.format(name))
-    f.write('#define WEIGHTS_{}_TYPE WEIGHT_TYPE_{}\n'.format(name, dtype))
-    f.write('static const {} {}[{}] = {{\n   '.format(dtype, name, len(v)))
-    for i in range(0, len(v)):
-        f.write('{}'.format(v[i]))
-        if (i!=len(v)-1):
-            f.write(',')
-        else:
-            break;
-        if (i%8==7):
-            f.write("\n   ")
-        else:
-            f.write(" ")
-    #print(v, file=f)
-    f.write('\n};\n')
-    f.write('#endif\n\n')
-    return;
-
-def printSparseVector(f, A, name, have_diag=True):
-    N = A.shape[0]
-    M = A.shape[1]
-    W = np.zeros((0,), dtype='int')
-    W0 = np.zeros((0,))
-    if have_diag:
-        diag = np.concatenate([np.diag(A[:,:N]), np.diag(A[:,N:2*N]), np.diag(A[:,2*N:])])
-        A[:,:N] = A[:,:N] - np.diag(np.diag(A[:,:N]))
-        A[:,N:2*N] = A[:,N:2*N] - np.diag(np.diag(A[:,N:2*N]))
-        A[:,2*N:] = A[:,2*N:] - np.diag(np.diag(A[:,2*N:]))
-        printVector(f, diag, name + '_diag')
-    AQ = np.minimum(127, np.maximum(-128, np.round(A*128))).astype('int')
-    idx = np.zeros((0,), dtype='int')
-    for i in range(M//8):
-        pos = idx.shape[0]
-        idx = np.append(idx, -1)
-        nb_nonzero = 0
-        for j in range(N//4):
-            block = A[j*4:(j+1)*4, i*8:(i+1)*8]
-            qblock = AQ[j*4:(j+1)*4, i*8:(i+1)*8]
-            if np.sum(np.abs(block)) > 1e-10:
-                nb_nonzero = nb_nonzero + 1
-                idx = np.append(idx, j*4)
-                vblock = qblock.transpose((1,0)).reshape((-1,))
-                W0 = np.concatenate([W0, block.reshape((-1,))])
-                W = np.concatenate([W, vblock])
-        idx[pos] = nb_nonzero
-    f.write('#ifdef DOT_PROD\n')
-    printVector(f, W, name, dtype='qweight')
-    f.write('#else /*DOT_PROD*/\n')
-    printVector(f, W0, name, dtype='qweight')
-    f.write('#endif /*DOT_PROD*/\n')
-    #idx = np.tile(np.concatenate([np.array([N]), np.arange(N)]), 3*N//16)
-    printVector(f, idx, name + '_idx', dtype='int')
-    return AQ
-
-def dump_layer_ignore(self, f, hf):
-    print("ignoring layer " + self.name + " of type " + self.__class__.__name__)
-    return False
-Layer.dump_layer = dump_layer_ignore
-
-def dump_sparse_gru(self, f, hf):
-    global max_rnn_neurons
-    name = 'sparse_' + self.name
-    print("printing layer " + name + " of type sparse " + self.__class__.__name__)
-    weights = self.get_weights()
-    qweights = printSparseVector(f, weights[1], name + '_recurrent_weights')
-    printVector(f, weights[-1], name + '_bias')
-    subias = weights[-1].copy()
-    subias[1,:] = subias[1,:] - np.sum(qweights*(1./128),axis=0)
-    printVector(f, subias, name + '_subias')
-    if hasattr(self, 'activation'):
-        activation = self.activation.__name__.upper()
-    else:
-        activation = 'TANH'
-    if hasattr(self, 'reset_after') and not self.reset_after:
-        reset_after = 0
-    else:
-        reset_after = 1
-    neurons = weights[0].shape[1]//3
-    max_rnn_neurons = max(max_rnn_neurons, neurons)
-    hf.write('#define {}_OUT_SIZE {}\n'.format(name.upper(), weights[0].shape[1]//3))
-    hf.write('#define {}_STATE_SIZE {}\n'.format(name.upper(), weights[0].shape[1]//3))
-    model_struct.write('  SparseGRULayer {};\n'.format(name));
-    model_init.write('  if (sparse_gru_init(&model->{}, arrays, "{}_bias", "{}_subias", "{}_recurrent_weights_diag", "{}_recurrent_weights", "{}_recurrent_weights_idx",  {}, ACTIVATION_{}, {})) return 1;\n'
-            .format(name, name, name, name, name, name, weights[0].shape[1]//3, activation, reset_after))
-    return True
-
-def dump_grub(self, f, hf, gru_a_size):
-    global max_rnn_neurons
-    name = self.name
-    print("printing layer " + name + " of type " + self.__class__.__name__)
-    weights = self.get_weights()
-    qweight = printSparseVector(f, weights[0][:gru_a_size, :], name + '_weights', have_diag=False)
-
-    f.write('#ifdef DOT_PROD\n')
-    qweight2 = np.clip(np.round(128.*weights[1]).astype('int'), -128, 127)
-    printVector(f, qweight2, name + '_recurrent_weights', dotp=True, dtype='qweight')
-    f.write('#else /*DOT_PROD*/\n')
-    printVector(f, weights[1], name + '_recurrent_weights')
-    f.write('#endif /*DOT_PROD*/\n')
-
-    printVector(f, weights[-1], name + '_bias')
-    subias = weights[-1].copy()
-    subias[0,:] = subias[0,:] - np.sum(qweight*(1./128.),axis=0)
-    subias[1,:] = subias[1,:] - np.sum(qweight2*(1./128.),axis=0)
-    printVector(f, subias, name + '_subias')
-    if hasattr(self, 'activation'):
-        activation = self.activation.__name__.upper()
-    else:
-        activation = 'TANH'
-    if hasattr(self, 'reset_after') and not self.reset_after:
-        reset_after = 0
-    else:
-        reset_after = 1
-    neurons = weights[0].shape[1]//3
-    max_rnn_neurons = max(max_rnn_neurons, neurons)
-    model_struct.write('  GRULayer {};\n'.format(name));
-    model_init.write('  if (gru_init(&model->{}, arrays, "{}_bias", "{}_subias", "{}_weights", "{}_weights_idx", "{}_recurrent_weights", {}, {}, ACTIVATION_{}, {})) return 1;\n'
-            .format(name, name, name, name, name, name, gru_a_size, weights[0].shape[1]//3, activation, reset_after))
-    return True
-
-def dump_gru_layer_dummy(self, f, hf):
-    name = self.name
-    weights = self.get_weights()
-    hf.write('#define {}_OUT_SIZE {}\n'.format(name.upper(), weights[0].shape[1]//3))
-    hf.write('#define {}_STATE_SIZE {}\n'.format(name.upper(), weights[0].shape[1]//3))
-    return True;
-
-GRU.dump_layer = dump_gru_layer_dummy
-
-def dump_dense_layer_impl(name, weights, bias, activation, f, hf):
-    printVector(f, weights, name + '_weights')
-    printVector(f, bias, name + '_bias')
-    hf.write('#define {}_OUT_SIZE {}\n'.format(name.upper(), weights.shape[1]))
-    model_struct.write('  DenseLayer {};\n'.format(name));
-    model_init.write('  if (dense_init(&model->{}, arrays, "{}_bias", "{}_weights", {}, {}, ACTIVATION_{})) return 1;\n'
-            .format(name, name, name, weights.shape[0], weights.shape[1], activation))
-
-def dump_dense_layer(self, f, hf):
-    name = self.name
-    print("printing layer " + name + " of type " + self.__class__.__name__)
-    weights = self.get_weights()
-    activation = self.activation.__name__.upper()
-    dump_dense_layer_impl(name, weights[0], weights[1], activation, f, hf)
-    return False
-
-Dense.dump_layer = dump_dense_layer
-
-def dump_mdense_layer(self, f, hf):
-    global max_mdense_tmp
-    name = self.name
-    print("printing layer " + name + " of type " + self.__class__.__name__)
-    weights = self.get_weights()
-    printVector(f, np.transpose(weights[0], (0, 2, 1)), name + '_weights')
-    printVector(f, np.transpose(weights[1], (1, 0)), name + '_bias')
-    printVector(f, np.transpose(weights[2], (1, 0)), name + '_factor')
-    activation = self.activation.__name__.upper()
-    max_mdense_tmp = max(max_mdense_tmp, weights[0].shape[0]*weights[0].shape[2])
-    hf.write('#define {}_OUT_SIZE {}\n'.format(name.upper(), weights[0].shape[0]))
-    model_struct.write('  MDenseLayer {};\n'.format(name));
-    model_init.write('  if (mdense_init(&model->{}, arrays, "{}_bias",  "{}_weights",  "{}_factor",  {}, {}, {}, ACTIVATION_{})) return 1;\n'
-            .format(name, name, name, name, weights[0].shape[1], weights[0].shape[0], weights[0].shape[2], activation))
-    return False
-MDense.dump_layer = dump_mdense_layer
-
-def dump_conv1d_layer(self, f, hf):
-    global max_conv_inputs
-    name = self.name
-    print("printing layer " + name + " of type " + self.__class__.__name__)
-    weights = self.get_weights()
-    printVector(f, weights[0], name + '_weights')
-    printVector(f, weights[-1], name + '_bias')
-    activation = self.activation.__name__.upper()
-    max_conv_inputs = max(max_conv_inputs, weights[0].shape[1]*weights[0].shape[0])
-    hf.write('#define {}_OUT_SIZE {}\n'.format(name.upper(), weights[0].shape[2]))
-    hf.write('#define {}_STATE_SIZE ({}*{})\n'.format(name.upper(), weights[0].shape[1], (weights[0].shape[0]-1)))
-    hf.write('#define {}_DELAY {}\n'.format(name.upper(), (weights[0].shape[0]-1)//2))
-    model_struct.write('  Conv1DLayer {};\n'.format(name));
-    model_init.write('  if (conv1d_init(&model->{}, arrays, "{}_bias", "{}_weights", {}, {}, {}, ACTIVATION_{})) return 1;\n'
-            .format(name, name, name, weights[0].shape[1], weights[0].shape[0], weights[0].shape[2], activation))
-    return True
-Conv1D.dump_layer = dump_conv1d_layer
-
-
-def dump_embedding_layer_impl(name, weights, f, hf):
-    printVector(f, weights, name + '_weights')
-    hf.write('#define {}_OUT_SIZE {}\n'.format(name.upper(), weights.shape[1]))
-    model_struct.write('  EmbeddingLayer {};\n'.format(name));
-    model_init.write('  if (embedding_init(&model->{}, arrays, "{}_weights", {}, {})) return 1;\n'
-            .format(name, name, weights.shape[0], weights.shape[1]))
-
-def dump_embedding_layer(self, f, hf):
-    name = self.name
-    print("printing layer " + name + " of type " + self.__class__.__name__)
-    weights = self.get_weights()[0]
-    dump_embedding_layer_impl(name, weights, f, hf)
-    return False
-Embedding.dump_layer = dump_embedding_layer
-diff_Embed.dump_layer = dump_embedding_layer
-
-if __name__ == "__main__":
-    parser = argparse.ArgumentParser()
-    parser.add_argument('model_file', type=str, help='model weight h5 file')
-    parser.add_argument('--nnet-header', type=str, help='name of c header file for dumped model', default='nnet_data.h')
-    parser.add_argument('--nnet-source', type=str, help='name of c source file for dumped model', default='nnet_data.c')
-    parser.add_argument('--lpc-gamma', type=float, help='LPC weighting factor. If not specified I will attempt to read it from the model file with 1 as default', default=None)
-    parser.add_argument('--lookahead', type=float, help='Features lookahead. If not specified I will attempt to read it from the model file with 2 as default', default=None)
-
-    args = parser.parse_args()
-
-    filename = args.model_file
-    with h5py.File(filename, "r") as f:
-        units = min(f['model_weights']['gru_a']['gru_a']['recurrent_kernel:0'].shape)
-        units2 = min(f['model_weights']['gru_b']['gru_b']['recurrent_kernel:0'].shape)
-        cond_size = min(f['model_weights']['feature_dense1']['feature_dense1']['kernel:0'].shape)
-        e2e = 'rc2lpc' in f['model_weights']
-
-    model, _, _ = lpcnet.new_lpcnet_model(rnn_units1=units, rnn_units2=units2, flag_e2e = e2e, cond_size=cond_size)
-    model.compile(optimizer='adam', loss='sparse_categorical_crossentropy', metrics=['sparse_categorical_accuracy'])
-    #model.summary()
-
-    model.load_weights(filename, by_name=True)
-
-    cfile = args.nnet_source
-    hfile = args.nnet_header
-
-    f = open(cfile, 'w')
-    hf = open(hfile, 'w')
-    model_struct = io.StringIO()
-    model_init = io.StringIO()
-    model_struct.write('typedef struct {\n')
-    model_init.write('#ifndef DUMP_BINARY_WEIGHTS\n')
-    model_init.write('int init_lpcnet_model(LPCNetModel *model, const WeightArray *arrays) {\n')
-    array_list = []
-
-    f.write('/*This file is automatically generated from a Keras model*/\n')
-    f.write('/*based on model {}*/\n\n'.format(sys.argv[1]))
-    f.write('#ifdef HAVE_CONFIG_H\n#include "config.h"\n#endif\n\n#include "nnet.h"\n#include "{}"\n\n'.format(hfile))
-
-    hf.write('/*This file is automatically generated from a Keras model*/\n\n')
-    hf.write('#ifndef RNN_DATA_H\n#define RNN_DATA_H\n\n#include "nnet.h"\n\n')
-
-    if e2e:
-        hf.write('/* This is an end-to-end model */\n')
-        hf.write('#define END2END\n\n')
-    else:
-        hf.write('/* This is *not* an end-to-end model */\n')
-        hf.write('/* #define END2END */\n\n')
-
-    # LPC weighting factor
-    if type(args.lpc_gamma) == type(None):
-        lpc_gamma = get_parameter(model, 'lpc_gamma', 1)
-    else:
-        lpc_gamma = args.lpc_gamma
-
-    hf.write('/* LPC weighting factor */\n')
-    hf.write('#define LPC_GAMMA ' + str(lpc_gamma) +'f\n\n')
-
-    # look-ahead
-    if type(args.lookahead) == type(None):
-        lookahead = get_parameter(model, 'lookahead', 2)
-    else:
-        lookahead = args.lookahead
-
-    hf.write('/* Features look-ahead */\n')
-    hf.write('#define FEATURES_DELAY ' + str(lookahead) +'\n\n')
-
-    embed_size = lpcnet.embed_size
-
-    E = model.get_layer('embed_sig').get_weights()[0]
-    W = model.get_layer('gru_a').get_weights()[0][:embed_size,:]
-    dump_embedding_layer_impl('gru_a_embed_sig', np.dot(E, W), f, hf)
-    W = model.get_layer('gru_a').get_weights()[0][embed_size:2*embed_size,:]
-    dump_embedding_layer_impl('gru_a_embed_pred', np.dot(E, W), f, hf)
-    W = model.get_layer('gru_a').get_weights()[0][2*embed_size:3*embed_size,:]
-    dump_embedding_layer_impl('gru_a_embed_exc', np.dot(E, W), f, hf)
-    W = model.get_layer('gru_a').get_weights()[0][3*embed_size:,:]
-    #FIXME: dump only half the biases
-    b = model.get_layer('gru_a').get_weights()[2]
-    dump_dense_layer_impl('gru_a_dense_feature', W, b[:len(b)//2], 'LINEAR', f, hf)
-
-    W = model.get_layer('gru_b').get_weights()[0][model.rnn_units1:,:]
-    b = model.get_layer('gru_b').get_weights()[2]
-    # Set biases to zero because they'll be included in the GRU input part
-    # (we need regular and SU biases)
-    dump_dense_layer_impl('gru_b_dense_feature', W, 0*b[:len(b)//2], 'LINEAR', f, hf)
-    dump_grub(model.get_layer('gru_b'), f, hf, model.rnn_units1)
-
-    layer_list = []
-    for i, layer in enumerate(model.layers):
-        if layer.dump_layer(f, hf):
-            layer_list.append(layer.name)
-
-    dump_sparse_gru(model.get_layer('gru_a'), f, hf)
-
-    f.write('#ifndef USE_WEIGHTS_FILE\n')
-    f.write('const WeightArray lpcnet_arrays[] = {\n')
-    for name in array_list:
-        f.write('#ifdef WEIGHTS_{}_DEFINED\n'.format(name))
-        f.write('  {{"{}", WEIGHTS_{}_TYPE, sizeof({}), {}}},\n'.format(name, name, name, name))
-        f.write('#endif\n')
-    f.write('  {NULL, 0, 0, NULL}\n};\n')
-    f.write('#endif\n')
-
-    model_init.write('  return 0;\n}\n')
-    model_init.write('#endif\n')
-    f.write(model_init.getvalue())
-
-    hf.write('#define MAX_RNN_NEURONS {}\n\n'.format(max_rnn_neurons))
-    hf.write('#define MAX_CONV_INPUTS {}\n\n'.format(max_conv_inputs))
-    hf.write('#define MAX_MDENSE_TMP {}\n\n'.format(max_mdense_tmp))
-
-
-    hf.write('typedef struct {\n')
-    for i, name in enumerate(layer_list):
-        hf.write('  float {}_state[{}_STATE_SIZE];\n'.format(name, name.upper()))
-    hf.write('} NNetState;\n\n')
-
-    model_struct.write('} LPCNetModel;\n\n')
-    hf.write(model_struct.getvalue())
-    hf.write('int init_lpcnet_model(LPCNetModel *model, const WeightArray *arrays);\n\n')
-    hf.write('\n\n#endif\n')
-
-    f.close()
-    hf.close()