sample_models.py

from keras import backend as K
from keras.models import Model
from keras.layers import (BatchNormalization, Conv1D, Dense, Input, 
    TimeDistributed, Activation, Bidirectional, SimpleRNN, GRU, LSTM,
    MaxPooling1D, Dropout)


def simple_rnn_model(input_dim, output_dim=29):
    """ Build a recurrent network for speech 
    """
    # Main acoustic input
    input_data = Input(name='the_input', shape=(None, input_dim))
    # Add recurrent layer
    simp_rnn = GRU(output_dim, return_sequences=True, 
                 implementation=2, name='rnn')(input_data)
    # Add softmax activation layer
    y_pred = Activation('softmax', name='softmax')(simp_rnn)
    # Specify the model
    model = Model(inputs=input_data, outputs=y_pred)
    model.output_length = lambda x: x
    print(model.summary())
    return model

def rnn_model(input_dim, units, activation, output_dim=29):
    """ Build a recurrent network for speech 
    """
    # Main acoustic input
    input_data = Input(name='the_input', shape=(None, input_dim))
    # Add recurrent layer
    simp_rnn = GRU(units, activation=activation,
        return_sequences=True, implementation=2, name='rnn')(input_data)
    # TODO: Add batch normalization 
    bn_rnn = BatchNormalization()(simp_rnn)
    # TODO: Add a TimeDistributed(Dense(output_dim)) layer
    time_dense = TimeDistributed(Dense(output_dim))(bn_rnn)
    # Add softmax activation layer
    y_pred = Activation('softmax', name='softmax')(time_dense)
    # Specify the model
    model = Model(inputs=input_data, outputs=y_pred)
    model.output_length = lambda x: x
    print(model.summary())
    return model


def cnn_rnn_model(input_dim, filters, kernel_size, conv_stride,
    conv_border_mode, units, output_dim=29):
    """ Build a recurrent + convolutional network for speech 
    """
    # Main acoustic input
    input_data = Input(name='the_input', shape=(None, input_dim))
    # Add convolutional layer
    conv_1d = Conv1D(filters, kernel_size, 
                     strides=conv_stride, 
                     padding=conv_border_mode,
                     activation='relu',
                     name='conv1d')(input_data)
    # Add batch normalization
    bn_cnn = BatchNormalization(name='bn_conv_1d')(conv_1d)
    # Add a recurrent layer
    simp_rnn = SimpleRNN(units, activation='relu',
        return_sequences=True, implementation=2, name='rnn')(bn_cnn)
    # TODO: Add batch normalization
    bn_rnn = BatchNormalization(name='bn_conv_2d')(simp_rnn)
    # TODO: Add a TimeDistributed(Dense(output_dim)) layer
    time_dense = TimeDistributed(Dense(output_dim))(bn_rnn)
    # Add softmax activation layer
    y_pred = Activation('softmax', name='softmax')(time_dense)
    # Specify the model
    model = Model(inputs=input_data, outputs=y_pred)
    model.output_length = lambda x: cnn_output_length(
        x, kernel_size, conv_border_mode, conv_stride)
    print(model.summary())
    return model

def cnn_output_length(input_length, filter_size, border_mode, stride,
                       dilation=1):
    """ Compute the length of the output sequence after 1D convolution along
        time. Note that this function is in line with the function used in
        Convolution1D class from Keras.
    Params:
        input_length (int): Length of the input sequence.
        filter_size (int): Width of the convolution kernel.
        border_mode (str): Only support `same` or `valid`.
        stride (int): Stride size used in 1D convolution.
        dilation (int)
    """
    if input_length is None:
        return None
    assert border_mode in {'same', 'valid', 'causal'}
    dilated_filter_size = filter_size + (filter_size - 1) * (dilation - 1)
    if border_mode == 'same' or border_mode == 'causal':
        output_length = input_length
    elif border_mode == 'valid':
        output_length = input_length - dilated_filter_size + 1
    return (output_length + stride - 1) // stride

def deep_rnn_model(input_dim, units, recur_layers, output_dim=29):
    """ Build a deep recurrent network for speech 
    """
    # Main acoustic input
    input_data = Input(name='the_input', shape=(None, input_dim))
    bn_rnn = input_data
    # TODO: Add recurrent layers, each with batch normalization
    for i in range(recur_layers):
        bn_rnn = GRU(units, return_sequences=True, implementation=2, name='rnn_' + str(i))(bn_rnn)
        bn_rnn = BatchNormalization(name='bn_rnn_' + str(i))(bn_rnn)
    # TODO: Add a TimeDistributed(Dense(output_dim)) layer
    time_dense = TimeDistributed(Dense(output_dim))(bn_rnn)
    # Add softmax activation layer
    y_pred = Activation('softmax', name='softmax')(time_dense)
    # Specify the model
    model = Model(inputs=input_data, outputs=y_pred)
    model.output_length = lambda x: x
    print(model.summary())
    return model

def bidirectional_rnn_model(input_dim, units, output_dim=29):
    """ Build a bidirectional recurrent network for speech
    """
    # Main acoustic input
    input_data = Input(name='the_input', shape=(None, input_dim))
    # TODO: Add bidirectional recurrent layer
    bidir_rnn = Bidirectional(GRU(units, return_sequences=True, implementation=2, name='rnn'))(input_data)
    # TODO: Add a TimeDistributed(Dense(output_dim)) layer
    time_dense = TimeDistributed(Dense(output_dim))(bidir_rnn)
    # Add softmax activation layer
    y_pred = Activation('softmax', name='softmax')(time_dense)
    # Specify the model
    model = Model(inputs=input_data, outputs=y_pred)
    model.output_length = lambda x: x
    print(model.summary())
    return model

#bidirectional_deep_rnn_model
def bidirectional_deep_rnn_model(input_dim, filters, kernel_size, conv_stride,
    conv_border_mode, units, recur_layers, output_dim=29):
    """ Build a deep network for speech 
    """
    # Main acoustic input
    input_data = Input(name='the_input', shape=(None, input_dim))
    # TODO: Specify the layers in your network
    # Add convolutional layer
    conv_1d = Conv1D(filters, kernel_size, 
                     strides=conv_stride, 
                     padding=conv_border_mode,
                     activation='relu',
                     name='conv1d')(input_data)
    bn_rnn = conv_1d
    # TODO: Add recurrent layers, each with batch normalization
    for i in range(recur_layers):
        bn_rnn = Bidirectional(GRU(units, return_sequences=True, implementation=2, name='brnn_' + str(i)))(bn_rnn)
        #bn_rnn = GRU(units, return_sequences=True, implementation=2, name='rnn_' + str(i))(bn_rnn)
        bn_rnn = BatchNormalization(name='bn_rnn_' + str(i))(bn_rnn)
    # TODO: Add a TimeDistributed(Dense(output_dim)) layer
    time_dense = TimeDistributed(Dense(output_dim))(bn_rnn)
    # TODO: Add softmax activation layer
    y_pred = Activation('softmax', name='softmax')(time_dense)
    # Specify the model
    model = Model(inputs=input_data, outputs=y_pred)
    # TODO: Specify model.output_length
    model.output_length = lambda x: cnn_output_length(
        x, kernel_size, conv_border_mode, conv_stride)
    print(model.summary())
    return model

def bidirectional_deep_rnn_dropout_model(input_dim, filters, kernel_size, conv_stride,
    conv_border_mode, units, recur_layers, 
    recurrent_dropout=0.3, dropout=0.3,
    output_dim=29):
    """ Build a deep network for speech 
    """
    # Main acoustic input
    input_data = Input(name='the_input', shape=(None, input_dim))
    # TODO: Specify the layers in your network
    # Add convolutional layer
    conv_1d = Conv1D(filters, kernel_size, 
                     strides=conv_stride, 
                     padding=conv_border_mode,
                     activation='relu',
                     name='conv1d')(input_data)
    bn_rnn = conv_1d
    # TODO: Add recurrent layers, each with batch normalization
    for i in range(recur_layers):
        bn_rnn = Bidirectional(GRU(units, 
                                   recurrent_dropout=recurrent_dropout,
                                   return_sequences=True, implementation=2, name='brnn_' + str(i)))(bn_rnn)
        #bn_rnn = GRU(units, return_sequences=True, implementation=2, name='rnn_' + str(i))(bn_rnn)
        bn_rnn = BatchNormalization(name='bn_rnn_' + str(i))(bn_rnn)
    # TODO: Add a TimeDistributed(Dense(output_dim)) layer
    time_dense = TimeDistributed(Dense(output_dim))(bn_rnn)
    # TODO: Add softmax activation layer
    y_pred = Activation('softmax', name='softmax')(time_dense)
    # Specify the model
    model = Model(inputs=input_data, outputs=y_pred)
    # TODO: Specify model.output_length
    model.output_length = lambda x: cnn_output_length(
        x, kernel_size, conv_border_mode, conv_stride)
    print(model.summary())
    return model

def bidirectional_deep_rnn_dropout_model2(input_dim, filters, kernel_size, conv_stride,
    conv_border_mode, units, recur_layers, 
    recurrent_dropout=0.3, dropout=0.3,
    output_dim=29):
    """ Build a deep network for speech 
    """
    # Main acoustic input
    input_data = Input(name='the_input', shape=(None, input_dim))
    # TODO: Specify the layers in your network
    # Add convolutional layer
    conv_1d = Conv1D(filters, kernel_size, 
                     strides=conv_stride, 
                     padding=conv_border_mode,
                     activation='relu',
                     name='conv1d')(input_data)
    bn_rnn = conv_1d
    # TODO: Add recurrent layers, each with batch normalization
    for i in range(recur_layers):
        bn_rnn = Bidirectional(GRU(units, 
                                   recurrent_dropout=recurrent_dropout, dropout=dropout,
                                   return_sequences=True, implementation=2, name='brnn_' + str(i)))(bn_rnn)
        #bn_rnn = GRU(units, return_sequences=True, implementation=2, name='rnn_' + str(i))(bn_rnn)
        bn_rnn = BatchNormalization(name='bn_rnn_' + str(i))(bn_rnn)
    # TODO: Add a TimeDistributed(Dense(output_dim)) layer
    time_dense = TimeDistributed(Dense(output_dim))(bn_rnn)
    # TODO: Add softmax activation layer
    y_pred = Activation('softmax', name='softmax')(time_dense)
    # Specify the model
    model = Model(inputs=input_data, outputs=y_pred)
    # TODO: Specify model.output_length
    model.output_length = lambda x: cnn_output_length(
        x, kernel_size, conv_border_mode, conv_stride)
    print(model.summary())
    return model

def causal_cnn_bidirectional_deep_rnn_dropout_model(input_dim, filters, kernel_size, conv_stride,
    conv_border_mode, units, recur_layers, dilation_rate=3,
    recurrent_dropout=0.3, dropout=0.3,
    output_dim=29):
    """ Build a deep network for speech 
    """
    # Main acoustic input
    input_data = Input(name='the_input', shape=(None, input_dim))
    # TODO: Specify the layers in your network
    # Add convolutional layer
    conv_1d = Conv1D(filters, kernel_size, 
                     strides=conv_stride, 
                     padding=conv_border_mode,
                     dilation_rate=dilation_rate,
                     activation='relu',
                     name='conv1d')(input_data)
    bn_rnn = conv_1d
    # TODO: Add recurrent layers, each with batch normalization
    for i in range(recur_layers):
        bn_rnn = Bidirectional(GRU(units, 
                                   recurrent_dropout=recurrent_dropout, dropout=dropout,
                                   return_sequences=True, implementation=2, name='brnn_' + str(i)))(bn_rnn)
        #bn_rnn = GRU(units, return_sequences=True, implementation=2, name='rnn_' + str(i))(bn_rnn)
        bn_rnn = BatchNormalization(name='bn_rnn_' + str(i))(bn_rnn)
    # TODO: Add a TimeDistributed(Dense(output_dim)) layer
    time_dense = TimeDistributed(Dense(output_dim))(bn_rnn)
    # TODO: Add softmax activation layer
    y_pred = Activation('softmax', name='softmax')(time_dense)
    # Specify the model
    model = Model(inputs=input_data, outputs=y_pred)
    # TODO: Specify model.output_length
    model.output_length = lambda x: cnn_output_length(
        x, kernel_size, conv_border_mode, conv_stride)
    print(model.summary())
    return model

def final_model(input_dim, filters, kernel_size, conv_stride,
    conv_border_mode, units, recur_layers, dilation_rate=3,
    cnn_dropout=0.2, recurrent_dropout=0.3, dropout=0.3,
    output_dim=29):
    """ Build a deep network for speech 
    """
    # Main acoustic input
    input_data = Input(name='the_input', shape=(None, input_dim))
    # TODO: Specify the layers in your network
    # Add convolutional layer
    conv_1d = Conv1D(filters, kernel_size, 
                     strides=conv_stride, 
                     padding=conv_border_mode,
                     dilation_rate=dilation_rate,
                     activation='relu',
                     name='conv1d')(input_data)
    bn_cnn = BatchNormalization(name='bn_conv_1d')(conv_1d)
    bn_cnn = Dropout(cnn_dropout)(bn_cnn)
    bn_rnn = bn_cnn
    # TODO: Add recurrent layers, each with batch normalization
    for i in range(recur_layers):
        bn_rnn = Bidirectional(GRU(units, 
                                   recurrent_dropout=recurrent_dropout, dropout=dropout,
                                   return_sequences=True, implementation=2, name='brnn_' + str(i)))(bn_rnn)
        #bn_rnn = GRU(units, return_sequences=True, implementation=2, name='rnn_' + str(i))(bn_rnn)
        bn_rnn = BatchNormalization(name='bn_rnn_' + str(i))(bn_rnn)
    # TODO: Add a TimeDistributed(Dense(output_dim)) layer
    time_dense = TimeDistributed(Dense(output_dim))(bn_rnn)
    # TODO: Add softmax activation layer
    y_pred = Activation('softmax', name='softmax')(time_dense)
    # Specify the model
    model = Model(inputs=input_data, outputs=y_pred)
    # TODO: Specify model.output_length
    model.output_length = lambda x: cnn_output_length(
        x, kernel_size, conv_border_mode, conv_stride)
    print(model.summary())
    return model

def final_model2(input_dim, filters, kernel_size, conv_stride,
    conv_border_mode, units, 
    cnn_layers=2, recur_layers=2, 
    recurrent_dropout=0.3, dropout=0.3,
    dilation_rate=3, output_dim=29):
    """ Build a deep network for speech 
    """
    # Main acoustic input
    input_data = Input(name='the_input', shape=(None, input_dim))
    # TODO: Specify the layers in your network
    # Add convolutional layer
    the_filters = filters
    # CNN layers
    conv_1d = input_data
    conv_1d = Conv1D(filters, kernel_size, 
                     strides=conv_stride, 
                     padding=conv_border_mode,
                     #dilation_rate=dilation_rate,
                     activation='relu',
                     name='conv1d_1')(conv_1d)
    conv_1d = MaxPooling1D(name='mp_1')(conv_1d)
        
    bn_rnn = conv_1d
    # RNN layers
    for i in range(recur_layers):
        # GRU + Bidirectional + dropout + Batch Normalization
        bn_rnn = Bidirectional(GRU(units, recurrent_dropout=recurrent_dropout, dropout=dropout, 
                                   return_sequences=True, implementation=2, 
                                   name='brnn_' + str(i)))(bn_rnn)
        #bn_rnn = GRU(units, return_sequences=True, implementation=2, name='rnn_' + str(i))(bn_rnn)
        bn_rnn = BatchNormalization(name='bn_rnn_' + str(i))(bn_rnn)
        
    # TODO: Add a TimeDistributed(Dense(output_dim)) layer
    time_dense = TimeDistributed(Dense(output_dim))(bn_rnn)
    # TODO: Add softmax activation layer
    y_pred = Activation('softmax', name='softmax')(time_dense)
    # Specify the model
    model = Model(inputs=input_data, outputs=y_pred)
    # TODO: Specify model.output_length
    model.output_length = lambda x: cnn_output_length(
        x, kernel_size, conv_border_mode, conv_stride, dilation_rate)
    print(model.summary())
    return model