Example #1
0
def cherry_net(_input_shape, _n_classes):
    '''
    Expected Image Size for CIFAR10: 32x32xd (channel last)
            |
            v
    Conv2D: 3x3 D_OUT= D
            |
            v
    Cherry_Block0: {
        [(D_IN -> (1x1xD_IN, GROUP(3x3xDENSE_OUT)) -> D_OUT= D_IN + (G_RATE * NUM_DENSE))]  * (LAYERS_PER_BLOCK=2)
        [(D_IN -> (1x1xD_IN, GROUP(3x3xDENSE_OUT)) -> D_OUT= D_IN + (G_RATE * NUM_DENSE))]  * (LAYERS_PER_BLOCK=2)
        Dense_Transition:
        IN: (NxN, D_IN = D_OUT)-> (COMPRESS, MAXPOOL) -> OUT: (N/2 x N/2, D_OUT=COMPRESS_D0)
            |
            v    
    Cherry_Block1: {
        [(D_IN -> (1x1xD_IN, GROUP(3x3xDENSE_OUT)) -> D_OUT= D_IN + (G_RATE * NUM_DENSE))]  * (LAYERS_PER_BLOCK=2)
        [(D_IN -> (1x1xD_IN, GROUP(3x3xDENSE_OUT)) -> D_OUT= D_IN + (G_RATE * NUM_DENSE))]  * (LAYERS_PER_BLOCK=2)
        Dense_Transition:
        IN: (N/2xN/2, D_IN = D_OUT)-> (COMPRESS, MAXPOOL) -> OUT: (N/4 x N/4, D_OUT=COMPRESS_D1)
            |
            v    
    Cherry_Block2: {
        [(D_IN -> (1x1xD_IN, GROUP(3x3xDENSE_OUT)) -> D_OUT= D_IN + (G_RATE * NUM_DENSE))]  * (LAYERS_PER_BLOCK=2)
        [(D_IN -> (1x1xD_IN, GROUP(3x3xDENSE_OUT)) -> D_OUT= D_IN + (G_RATE * NUM_DENSE))]  * (LAYERS_PER_BLOCK=2)
            |
            v    
    Conv2D: D_IN -> (1x1xCOMPRESS_D2) -> D_OUT = COMPRESS_D2
            |
            v    
    GlobalAveragePool: OUT: 1 x 1, D_OUT = COMPRESS_D2
            |
            v
    Dense+Softmax Activation: D_OUT = N_CLASSES
            |
            v
    '''
    print('Architecture: Cherry Network')
    _d_init = 128  # Initial Depth
    _C = 8  # Cardinality
    _n_cherry_blocks = 3  # Number of spore blocks
    # Number of dense layers per cherry block
    _n_dense_layers_per_cherry_block = 2
    _n_cherry_layers_per_block = 2  # Number of Cherry Layers per block
    compress_factor = 1  # Compress Factor during Transition
    # Growth Rate for dense layers
    growth_rate = (_d_init // (_C * _n_dense_layers_per_cherry_block))
    _growth_rate_mul = 2  # Growth Rate Multiplier
    _max_d_out = 256  # Max Depth Out of Transition
    input_layer = _create_input_layer(_input_shape)
    intermed = Conv2D(_d_init, kernel_size=(3, 3), padding='same')(input_layer)
    # Always new_depth must be divisible by _C (cardinality)
    new_depth = _d_init
    '''
    Output Sizes:
    *************
    Input Size = 32 x 32
    Output Size After ith Dense Transition to Cherry Block:
        1: 16 x 16
        2: 8 x 8
        
    Depth Sizes:
    ************
    Depth In = 64 
        1: 64 (64-> Cherry Layers ->256)
        2: 256 (256-> Cherry Layers -> 1024 -> Dense Transition ->256)
        3: 512 (256-> Cherry Layers -> 1024)
    Compress: 1024 -> ID -> 256
    Depth Out = 256
    '''
    for cherry_block_idx in range(_n_cherry_blocks):
        print('Block IDX = {0}'.format(cherry_block_idx))
        # Dense Block
        for cherry_layer_idx in range(_n_cherry_layers_per_block):
            intermed = _cherry_layer(intermed, _C, new_depth, growth_rate,
                                     _n_dense_layers_per_cherry_block)
            growth_rate = int(growth_rate * _growth_rate_mul)
            new_depth *= 2
        # Dynamic Compress Factor: No compression until depth exceeds Max_D_OUT
        compress_factor = min(1, _max_d_out / new_depth)
        # Compression Factor based growth rate
        growth_rate = (growth_rate if compress_factor == 1 else
                       (_max_d_out // (_C * _n_dense_layers_per_cherry_block)))
        if cherry_block_idx != (_n_cherry_blocks - 1):
            # Dense Transition for every block exept last
            intermed = _dense_transition(intermed, new_depth,
                                         int(compress_factor * new_depth))
        new_depth = int(new_depth * compress_factor)

    intermed = _preactivation_layers(intermed)
    intermed = Conv2D(_max_d_out, kernel_size=(1, 1))(intermed)
    gap_out = GlobalAveragePooling2D()(intermed)
    final_out = Dense(_n_classes, activation='softmax')(gap_out)
    model = Model(inputs=input_layer, outputs=final_out, name='Cherry_Net')
    return model
def mer_spectro_net(_input_shape, _n_out=120):
    '''
    Input 1: Spectrogram Input Shape
    Input 2: Number of Arousal + Valence Values (Default: 60 + 60 = 120)
    Output: MER Spectro Net  Model
    Architecture:
        
        Expected Image Size for Spectrogram: 120 x 240, where 240 represents
        the frequency and 120 represents the time i.e. Transposed Spectrogram
                    |
                    v
           Conv2D: 2x2, D_OUT
                    |
                    v
          Max Pooling Across Time Axis: 60 x 240 x D_OUT
                    |
                    v
          (Conv2D (Freq Dim) + Activation + Conv2D (Freq Dim) + Max Pooling)x4
                    |
                    v
             Time Distributed Flatten = 60 x D_OUT
                    |
                    v
             Time Distributed Dense = 60 x 1024
             |                                   |  
             v                                   v
          (V) Bidirectional LSTM (N_Hidden)   (A) Bidirectional LSTM (N_Hidden)
                    |                                   |
                    v                                   v
    (V) Bidirectional LSTM (N_Hidden/2)     (A) Bidirectional LSTM (N_Hidden/2)
                    |
                    v
                 Dense: 120x1
                    
    '''

    _d_init = 64
    _freq_d = [128, 256, 256, 384]
    _hidden_units_LSTM = 256

    input_layer = _create_input_layer(_input_shape)
    down_sample_time = Conv2D(_d_init,
                              kernel_size=(2, 2),
                              strides=(1, 1),
                              padding='same')(input_layer)
    conv1_out = _preactivation_layers(down_sample_time)
    mp_out = MaxPooling2D(pool_size=(2, 1), strides=(2, 1))(conv1_out)
    intermed_out = mp_out
    # Create frequency scaling time invariant layers
    for freq_conv_idx, num_filters in enumerate(_freq_d):
        intermed_out = _preactivation_layers(intermed_out)
        intermed_out = Conv2D(num_filters, kernel_size=(1, 3))(intermed_out)
        intermed_out = _preactivation_layers(intermed_out)
        intermed_out = Conv2D(num_filters, kernel_size=(1, 3))(intermed_out)
        intermed_out = MaxPooling2D(pool_size=(1, 2),
                                    strides=(1, 2))(intermed_out)
    intermed_out = BatchNormalization()(intermed_out)
    # Distribute Output with respect to Time
    f_time_dis_out = TimeDistributed(Flatten())(intermed_out)
    f_time_dis_out = TimeDistributed(Dense(1024,
                                           activation='tanh'))(f_time_dis_out)
    f_time_dis_out = TimeDistributed(Dropout(0.2))(f_time_dis_out)

    # Feed each time distributed input to 2 BLSTM: for Valence and Arousal
    valence_lstm_out = Bidirectional(
        LSTM(_hidden_units_LSTM, return_sequences=True,
             activation='tanh'))(f_time_dis_out)
    v_dropout_out = Dropout(0.2)(valence_lstm_out)
    valence_lstm_out = Bidirectional(
        LSTM(_hidden_units_LSTM // 2, activation='tanh'))(v_dropout_out)

    arousal_lstm_out = Bidirectional(
        LSTM(_hidden_units_LSTM, return_sequences=True,
             activation='tanh'))(f_time_dis_out)
    a_dropout_out = Dropout(0.2)(arousal_lstm_out)
    arousal_lstm_out = Bidirectional(
        LSTM(_hidden_units_LSTM // 2, activation='tanh'))(a_dropout_out)

    # Arousal and Valence values are between -1 and 1, use tanh activation
    valence_dense = Dense(_n_out // 2, activation='tanh')(valence_lstm_out)
    arousal_dense = Dense(_n_out // 2, activation='tanh')(arousal_lstm_out)
    final_dense = concatenate([valence_dense, arousal_dense])
    model = Model(inputs=input_layer,
                  outputs=final_dense,
                  name='MER_Spectro_Net')
    return model
def agg_res_net(_input_shape, _n_classes):
    '''
    Expected Image Size for CIFAR10: 32x32xd (channel last)
            |
            v
    Conv2D: 3x3 D_OUT= D
            |
            v
    Agg_Res_Block0: (D_IN = 2D->(1x1, 3x3, 1x1) -> D_OUT=4D) * (LAYERS_PER_BLOCK=6)
            |
            v
    Agg_Res_Block1: (D_IN = 4D->(1x1, 3x3, 1x1) -> D_OUT=8D) * (LAYERS_PER_BLOCK=6)
            |
            v
    Agg_Res_Block2: (D_IN = 8D->(1x1, 3x3, 1x1) -> D_OUT=16D) * (LAYERS_PER_BLOCK=6)
            |
            v
    GlobalAveragePool: OUT: 1 x 1, D_OUT = 16D
            |
            v
    Dense+Softmax Activation: D_OUT = N_CLASSES
            |
            v
    '''
    print('Architecture: Aggregated Residual Network')
    _d_init = 32  # Initial Depth
    _C = 8  # Cardinality
    _n_agg_blocks = 3  # Number of Aggregate Residual Blocks
    _n_agg_layer_per_block = 6  # Number of Aggregate Residual Layers per Block

    input_layer = _create_input_layer(_input_shape)
    intermed = Conv2D(_d_init, kernel_size=(3, 3), padding='same')(input_layer)
    new_depth = _d_init * 2
    '''
    Output Sizes:
    *************
    Input Size = 32 x 32
    Output Size After ith block:
        1: 16 x 16
        2: 8 x 8
        3: 4 x 4

    Depth Sizes:
    ************
    Depth to 1st Block = 64
    Depth to the ith (i > 1) block:
        2: 128
        3: 256
    Depth Out = 512
    '''
    for agg_block_idx in range(_n_agg_blocks):
        print('Block IDX = {0}'.format(agg_block_idx))
        for agg_layer_idx in range(_n_agg_layer_per_block):
            # Double the stride once per block to halve the output size
            strides = 2 if agg_layer_idx == 0 else 1
            # Can't add shorcut between input and downsampled input
            intermed = _agg_res_layer(intermed, new_depth, 2 * new_depth, _C,
                                      strides)
        '''
        Double the depth after a block to capture the bigger receptive field
        since each block involves 1 stride of 2
        '''
        new_depth *= 2
    gap_out = GlobalAveragePooling2D()(intermed)
    final_out = Dense(_n_classes, activation='softmax')(gap_out)
    model = Model(inputs=input_layer, outputs=final_out, name='Agg_Res_Net')
    return model
Example #4
0
def dense_net(_input_shape, _n_classes):
    '''
    Expected Image Size for CIFAR10: 32x32xd (channel last)
            |
            v
    Conv2D: 3x3 D_OUT= D
            |
            v
    Dense_Block0: (D_IN = D->([1x1xGR_LIMIT], 3x3) -> D_OUT= D_IN + G_RATE) * (LAYERS_PER_BLOCK=4)
    Dense_Transition:
        IN: (NxN, D_IN = Dense_Block0_D_OUT)-> (COMPRESS, MAXPOOL) -> OUT: (N/2 x N/2, D_OUT=COMPRESS_D0)
            |
            v
    Dense_Block1: (D_IN = D->([1x1xGR_LIMIT], 3x3) -> D_OUT= D_IN + G_RATE) * (LAYERS_PER_BLOCK=4)
    Dense_Transition:
        IN: (N/2 x N/2, D_IN = Dense_Block1_D_OUT)-> (COMPRESS, MAXPOOL) -> OUT: (N/4 x N/4, D_OUT=COMPRESS_D1)
            |
            v
    Dense_Block2: (D_IN = D->([1x1xGR_LIMIT], 3x3) -> D_OUT= D_IN + G_RATE) * (LAYERS_PER_BLOCK=4)
    Dense_Transition:
        IN: (N/4 x N/4 , D_IN = Dense_Block2_D_OUT)-> (COMPRESS, MAXPOOL) -> OUT: (N/8 x N/8, D_OUT=COMPRESS_D2)
            |
            v
    Dense_Block3: (D_IN = D->([1x1xGR_LIMIT], 3x3) -> D_OUT= D_IN + G_RATE) * (LAYERS_PER_BLOCK=4)
            |
            v
    GlobalAveragePool: OUT: 1 x 1, D_OUT = Dense_Block3_D_OUT
            |
            v
    Dense+Softmax Activation: D_OUT = N_CLASSES
            |
            v
    '''
    print('Architecture: Dense Network')
    _d_init = 64  # Initial Depth
    _growth_limit = 376  #  Growth Limit
    _n_dense_blocks = 4  # Number of Dense Blocks
    _n_dense_layers_per_block = 4  # Number of Dense Layers per block
    _compress_factor = 1.0  # Compress Factor during Transition
    growth_rate = 16  # Growth Rate for dense layers
    _growth_rate_mul = 2  # Growth Rate Multiplier to be used between blocks

    input_layer = _create_input_layer(_input_shape)
    intermed = Conv2D(_d_init, kernel_size=(3, 3), padding='same')(input_layer)
    new_depth = _d_init
    '''
    Output Sizes:
    *************
    Input Size = 32 x 32
    Output Size After ith Transition:
        1: 16 x 16
        2: 8 x 8
        3: 4 x 4

    Depth Sizes:
    ************
    Depth to 1st Block = 64
    Depth to the ith (i > 1) block:
        2: 128
        3: 256
        4: 512
    Depth Out = 1024
    '''
    for dense_block_idx in range(_n_dense_blocks):
        print('Block IDX = {0}'.format(dense_block_idx))
        for dense_layer_idx in range(_n_dense_layers_per_block):
            intermed = _dense_layer(intermed, new_depth, growth_rate,
                                    _growth_limit)
            new_depth += growth_rate
        if dense_block_idx != (_n_dense_blocks - 1):
            # No Dense Transition for last layer
            intermed = _dense_transition(intermed, new_depth,
                                         int(_compress_factor * new_depth))
        # Impose Dynamic Growth Rate
        growth_rate = int(growth_rate * _growth_rate_mul)
        new_depth = int(_compress_factor * new_depth)

    gap_out = GlobalAveragePooling2D()(intermed)
    final_out = Dense(_n_classes, activation='softmax')(gap_out)
    model = Model(inputs=input_layer, outputs=final_out, name='Dense_Net')
    return model
def spore_net(_input_shape, _n_classes):
    '''
    Expected Image Size for CIFAR10: 32x32xd (channel last)
            |
            v
    Conv2D: 3x3 D_OUT= D
            |
            v
    Dense_Block0: (D_IN = D->([1x1xGR_LIMIT], 3x3) -> D_OUT= D_IN + G_RATE) * (LAYERS_PER_BLOCK=2)
    Dense_Transition:
        IN: (NxN, D_IN = Dense_Block0_D_OUT)-> (COMPRESS, MAXPOOL) -> OUT: (N/2 x N/2, D_OUT=COMPRESS_D0)
    Agg_Res_Block0: (D_IN = COMPRESS_D0 ->(1x1, 3x3, 1x1) -> D_OUT= 2 * COMPRESS_D0) * (LAYERS_PER_BLOCK=2)
            |
            v    
    Dense_Block1: (D_IN ->([1x1xGR_LIMIT], 3x3) -> D_OUT= D_IN + G_RATE) * (LAYERS_PER_BLOCK=2)
    Dense_Transition:
        IN: (N/2 x N/2, D_IN = Dense_Block1_D_OUT)-> (COMPRESS, MAXPOOL) -> OUT: (N/4 x N/4, D_OUT=COMPRESS_D1)
    Agg_Res_Block1: (D_IN = COMPRESS_D1 ->(1x1, 3x3, 1x1) -> D_OUT= 2 * COMPRESS_D1) * (LAYERS_PER_BLOCK=2)
            |
            v    
    Dense_Block2: (D_IN ->([1x1xGR_LIMIT], 3x3) -> D_OUT= D_IN + G_RATE) * (LAYERS_PER_BLOCK=2)
    Dense_Transition:
        IN: (N/4 x N/4, D_IN = Dense_Block2_D_OUT)-> (COMPRESS, MAXPOOL) -> OUT: (N/8 x N/8, D_OUT=COMPRESS_D2)
    Agg_Res_Block2: (D_IN = COMPRESS_D2->(1x1, 3x3, 1x1) -> D_OUT= 2 * COMPRESS_D2) * (LAYERS_PER_BLOCK=2)
            |
            v    
    GlobalAveragePool: OUT: 1 x 1, D_OUT = Agg_Res_Block2_D_OUT
            |
            v
    Dense+Softmax Activation: D_OUT = N_CLASSES
            |
            v
    '''
    print('Architecture: Spore Network')
    _d_init = 64 # Initial Depth
    _C = 8 # Cardinality
    _n_spore_blocks = 3 # Number of spore blocks
    _n_agg_layer_per_block = 2 # Number of Aggregate Residual Layers per Block
    _growth_limit = 512 # Growth Limit
    _max_d_out = 256
    _n_dense_layers_per_block = 2 # Number of Dense Layers per block
    compress_factor = 1 # Compress Factor during Transition
    _strides = 1 # Strides (2 = Halve the output size, 1 = Retain output size)
    growth_rate = 32 # Growth Rate for dense layers
    _growth_rate_mul = 2 # Growth Rate Multiplier
    
    input_layer = _create_input_layer(_input_shape)
    intermed = Conv2D(_d_init, kernel_size=(3,3), padding='same')(input_layer)
    # Always new_depth must be divisible by _C (cardinality)
    new_depth = _d_init
    '''
    Output Sizes:
    *************
    Input Size = 32 x 32
    Output Size After ith Dense Transition to Agg Res Block:
        1: 16 x 16
        2: 8 x 8
        3: 4 x 4
        
    Depth Sizes:
    ************
    Depth In = 64 
        1: 64 (64-> Dense Layers->Dense Transition-> 128-> Agg Res Layers ->256)
        2: 256 (256-> Dense Layers->Dense Transition-> 256-> Agg Res Layers ->512)
        3: 512 (512-> Dense Layers->Dense Transition-> 256-> Agg Res Layers ->512)
    Depth Out = 512
    '''
    for spore_block_idx in range(_n_spore_blocks):
        print('Block IDX = {0}'.format(spore_block_idx))
        # Dense Block
        for dense_layer_idx in range(_n_dense_layers_per_block):
            intermed = _dense_layer(intermed, new_depth, growth_rate,
                                    _growth_limit)
            new_depth += growth_rate
        # Dynamic Compress Factor: No compression until depth exceeds Max_D_OUT
        compress_factor = min(1, _max_d_out/new_depth)
        # Dense Transition
        intermed = _dense_transition(intermed, new_depth,
                                         int(compress_factor * new_depth))
        new_depth = int(new_depth * compress_factor)
        growth_rate = int(growth_rate * _growth_rate_mul)
        # Aggregrated Residual Block
        for agg_layer_idx in range(_n_agg_layer_per_block):
            intermed = _agg_res_layer(intermed, new_depth, new_depth * 2,
                                      _C, _strides)
        new_depth *= 2
            
    gap_out = GlobalAveragePooling2D()(intermed)
    final_out = Dense(_n_classes, activation='softmax')(gap_out)
    model = Model(inputs=input_layer, outputs=final_out, name='Spore_Net')
    return model