예제 #1
0
def train_model(airport):
    # Import data
    params = ["z", "z", "z"]
    levels = [500, 850, 1000]

    in1_var = get_era_full(params[0], levels[0])
    in2_var = get_era_full(params[1], levels[1])
    in3_var = get_era_full(params[2], levels[2])

    x = np.concatenate(
        (np.expand_dims(in1_var, axis=3), np.expand_dims(
            in2_var, axis=3), np.expand_dims(in3_var, axis=3)),
        axis=3)

    X = np.zeros((13141, 80, 120, 8, 3))
    for i in range(13141):
        X[i, :, :, :, :] = np.rollaxis(x[i:i + 8, :, :, :], 0, 3)

    Y = get_rains(airport)[7:]
    b = np.zeros((Y.shape[0], 2))
    b[np.arange(Y.shape[0]), Y] = 1

    model = None
    if os.path.isfile('model_3d_{}.h5'.format(airport)):
        model = load_model('model_3d_{}.h5'.format(airport))
    else:
        model = Sequential()
        model.add(
            Convolution3D(128, (3, 3, 3),
                          padding='same',
                          activation='relu',
                          name='block1_conv1',
                          input_shape=(80, 120, 8, 3)))
        model.add(MaxPooling3D((2, 2, 2), strides=(2, 2, 2)))

        model.add(
            Convolution3D(256, (3, 3, 3),
                          padding='same',
                          activation='relu',
                          name='block2_conv1'))
        model.add(MaxPooling3D((2, 2, 2), strides=(2, 2, 2)))

        model.add(Flatten())
        model.add(Dense(2, activation='softmax', name='final_fully_connected'))

        adagrad = Adagrad(lr=0.0002)
        model.compile(loss='categorical_crossentropy',
                      optimizer=adagrad,
                      metrics=['accuracy'])

    csv_logger = CSVLogger('{}.log'.format(airport))
    model.fit(X,
              b,
              batch_size=20,
              epochs=100,
              verbose=1,
              validation_split=0.2,
              callbacks=[csv_logger])

    model.save('model_3d_{}.h5'.format(airport))
예제 #2
0
def conv_block(input_tensor, kernel_size, filters, stage, block, strides=(2, 2), trainable=True):
    nb_filter1, nb_filter2, nb_filter3 = filters
    bn_axis = 4

    conv_name_base = 'res' + str(stage) + block + '_branch'
    bn_name_base = 'bn' + str(stage) + block + '_branch'

    x = Convolution3D(nb_filter1, (1, 1, 1), strides=strides, name=conv_name_base + '2a', trainable=trainable)(
        input_tensor)
    x = BatchNormalization(axis=bn_axis, name=bn_name_base + '2a')(x)
    x = Activation('relu')(x)

    x = Convolution3D(nb_filter2, (kernel_size, kernel_size, kernel_size), padding='same', name=conv_name_base + '2b',
                      trainable=trainable)(x)
    x = BatchNormalization(axis=bn_axis, name=bn_name_base + '2b')(x)
    x = Activation('relu')(x)

    x = Convolution3D(nb_filter3, (1, 1, 1), name=conv_name_base + '2c', trainable=trainable)(x)
    x = BatchNormalization(axis=bn_axis, name=bn_name_base + '2c')(x)

    shortcut = Convolution3D(nb_filter3, (1, 1, 1), strides=strides, name=conv_name_base + '1', trainable=trainable)(
        input_tensor)
    shortcut = BatchNormalization(axis=bn_axis, name=bn_name_base + '1')(shortcut)

    x = Add()([x, shortcut])
    x = Activation('relu')(x)
    return x
예제 #3
0
def create_cnn_network(input_dim, no_conv_filt, dense_n):
    '''Base network to be shared (eq. to feature extraction).
    '''
    seq = Sequential()
    kern_size = 3

    # conv layers
    # 1
    seq.add(Convolution3D(int(no_conv_filt/2), kern_size, kern_size, kern_size, input_shape=input_dim,
                          border_mode='valid', dim_ordering='th', activation='relu'))
    seq.add(Dropout(.1))
    seq.add(BatchNormalization(mode=2))
    # 1
    seq.add(Convolution3D(no_conv_filt, kern_size, kern_size, kern_size, input_shape=input_dim,
                          border_mode='valid', dim_ordering='th', activation='relu'))
    seq.add(Dropout(.1))
    seq.add(BatchNormalization(mode=2))

    # dense layers
    seq.add(Flatten())
    seq.add(Dense(dense_n, activation='relu'))
    seq.add(BatchNormalization(mode=2))
    # seq.add(Dense(50, activation='relu'))
    # seq.add(BatchNormalization(mode=2))
    return seq
예제 #4
0
def identity_block_td(input_tensor, kernel_size, filters, stage, block, trainable=True):
    # identity block time distributed

    nb_filter1, nb_filter2, nb_filter3 = filters
    bn_axis = 4

    conv_name_base = 'res' + str(stage) + block + '_branch'
    bn_name_base = 'bn' + str(stage) + block + '_branch'

    x = TimeDistributed(Convolution3D(nb_filter1, (1, 1, 1), trainable=trainable, kernel_initializer='normal'),
                        name=conv_name_base + '2a')(input_tensor)
    x = TimeDistributed(BatchNormalization(axis=bn_axis), name=bn_name_base + '2a')(x)
    x = Activation('relu')(x)

    x = TimeDistributed(
        Convolution3D(nb_filter2, (kernel_size, kernel_size, kernel_size), trainable=trainable,
                      kernel_initializer='normal',
                      padding='same'), name=conv_name_base + '2b')(x)
    x = TimeDistributed(BatchNormalization(axis=bn_axis), name=bn_name_base + '2b')(x)
    x = Activation('relu')(x)

    x = TimeDistributed(Convolution3D(nb_filter3, (1, 1, 1), trainable=trainable, kernel_initializer='normal'),
                        name=conv_name_base + '2c')(x)
    x = TimeDistributed(BatchNormalization(axis=bn_axis), name=bn_name_base + '2c')(x)

    x = Add()([x, input_tensor])
    x = Activation('relu')(x)

    return x
예제 #5
0
def identity_block(input_tensor,
                   kernel_size,
                   filters,
                   bn_axis=4,
                   trainable=True):
    x = Convolution3D(filters[0], 1, 1, 1, trainable=trainable)(input_tensor)
    x = BatchNormalization(axis=bn_axis)(x)
    x = Activation('relu')(x)

    x = Convolution3D(filters[1],
                      kernel_size,
                      kernel_size,
                      kernel_size,
                      border_mode='same',
                      trainable=trainable)(x)

    x = BatchNormalization(axis=bn_axis)(x)
    x = Activation('relu')(x)

    x = Convolution3D(filters[2], 1, 1, 1, trainable=trainable)(x)
    x = BatchNormalization(axis=bn_axis)(x)

    x = merge([x, input_tensor], mode='sum')
    x = Activation('relu')(x)
    return x
예제 #6
0
def model_26(GPUS = 1, box_size = 9):
  """ one dense: 3000 """
  model = Sequential()
  model.add(Convolution3D(50, kernel_size = (3, 3, 3), strides = (1, 1, 1), input_shape = (box_size, box_size, box_size, 20))) # 32 output nodes, kernel_size is your moving window, activation function, input shape = auto calculated
  model.add(BatchNormalization())
  model.add(Activation(activation = 'relu'))
  model.add(Convolution3D(100, (2, 2, 2))) 
  model.add(BatchNormalization())
  model.add(Activation(activation = 'relu'))
  model.add(Convolution3D(150, (2, 2, 2))) 
  model.add(BatchNormalization())
  model.add(Activation(activation = 'relu'))
  model.add(Convolution3D(200, (2, 2, 2))) 
  model.add(BatchNormalization())
  model.add(Activation(activation = 'relu'))
  model.add(Flatten()) # now our layers have been combined to one
  model.add(Dense(1000)) # 300 nodes in the last hidden layer
  model.add(BatchNormalization())
  model.add(Activation(activation = 'relu'))
  model.add(Dense(20, activation = 'softmax')) # output layer has 20 possible classes (amino acids 0 - 19)
  
  if GPUS >= 2:
    model = multi_gpu_model(model, gpus=GPUS)

  return model
def classifier(input_shape, kernel_size, pool_size):
	model = Sequential()

	model.add(Convolution3D(16, kernel_size[0], kernel_size[1], kernel_size[2], border_mode='valid', input_shape=input_shape))
	model.add(Activation('relu'))
	model.add(MaxPooling3D(pool_size=pool_size))
	model.add(Convolution2D(32, kernel_size[0], kernel_size[1], kernel_size[2]))
	model.add(Activation('relu'))
	model.add(MaxPooling3D(pool_size=pool_size))
	model.add(Convolution3D(64, kernel_size[0], kernel_size[1], kernel_size[2]))
	model.add(Activation('relu'))
	model.add(MaxPooling3D(pool_size=pool_size))
	model.add(Dropout(0.25))

	model.add(Flatten())
	model.add(Dense(512))
	model.add(Activation('relu'))
	model.add(Dropout(0.5))
	model.add(Dense(128))
	model.add(Activation('relu'))
	model.add(Dropout(0.5))
	model.add(Dense(2))
	model.add(Activation('softmax'))

	return model
    def residual_block(x, nb_filters=16, subsample_factor=1):
      prev_nb_channels = K.int_shape(x)[4]

      if subsample_factor > 1:
        subsample = (subsample_factor, subsample_factor, subsample_factor)
        # shortcut: subsample + zero-pad channel dim
        shortcut = MaxPooling3D(pool_size=subsample)(x)
      else:
        subsample = (1, 1, 1)
        # shortcut: identity
        shortcut = x

      if nb_filters > prev_nb_channels:
        shortcut = Lambda(zero_pad_channels,
                          arguments={
                              'pad': nb_filters - prev_nb_channels})(shortcut)

      y = BatchNormalization(axis=4)(x)
      y = Activation('relu')(y)
      y = Convolution3D(nb_filters, 3, 3, 3, subsample=subsample,
                        init='he_normal', border_mode='same')(y)
      y = BatchNormalization(axis=4)(y)
      y = Activation('relu')(y)
      y = Convolution3D(nb_filters, 3, 3, 3, subsample=(1, 1, 1),
                        init='he_normal', border_mode='same')(y)

      out = merge([y, shortcut], mode='sum')

      return out
예제 #9
0
 def up_conv_block(self,input_tensor,filters,stage,block,stride=(1,1,1),size=(2,2,2),padding='same',layer=None):
     filters1,filters2,filters3=filters
     shortcut=input_tensor
     if K.image_data_format()=='channels_last':
         bn_axis=4
     else:
         bn_axis=1
     up_conv_name_base = 'up' + str(stage) + block + '_branch'
     conv_name_base = 'res' + str(stage) + block + '_branch'
     bn_name_base = 'bn' + str(stage) + block + '_branch'
     x=UpSampling3D(size,name=up_conv_name_base + '2a')(input_tensor)
     x=Convolution3D(filters1,kernel_size=1, strides=stride,name=conv_name_base + '2a',kernel_regularizer=l2(1e-4))(x)
     if layer==None:   
         x=BatchNormalization(axis=bn_axis, name=bn_name_base + '2a')(x)
     x=Activation('relu')(x)
     x=Convolution3D(filters2,kernel_size=3,padding=padding,name=conv_name_base + '2b',kernel_regularizer=l2(1e-4))(x)
     if layer==None:
         x=BatchNormalization(axis=bn_axis,name=bn_name_base + '2b')(x)
     x=Activation('relu')(x)
     x=Convolution3D(filters3,kernel_size=1,name=conv_name_base + '2c',kernel_regularizer=l2(1e-4))(x)
     if layer==None:
         x=BatchNormalization(axis=bn_axis,name=bn_name_base + '2c')(x)
     shortcut=UpSampling3D(size, name=up_conv_name_base + '1')(input_tensor)
     shortcut=Convolution3D(filters3,kernel_size=1,strides=stride,padding=padding,name=conv_name_base + '1',kernel_regularizer=l2(1e-5))(shortcut)
     if layer==None:
         shortcut = BatchNormalization(axis=bn_axis, name=bn_name_base + '1')(shortcut)
     x=Add()([x,shortcut])
     x=Activation('relu')(x)
     return x
예제 #10
0
def my_model():
    '''Creation of the model Sequential and return a model
    for the training
    '''
    model = Sequential()
    # Conv layer 1
    model.add(
        Convolution3D(
            input_shape=(14, 32, 32, 32),
            filters=64,
            kernel_size=6,
            data_format='channels_first',
        ))

    model.add(LeakyReLU(alpha=0.1))
    # Dropout 1
    model.add(Dropout(0.2))
    # Conv layer 2
    model.add(
        Convolution3D(
            filters=64,
            kernel_size=3,
            padding='valid',
            data_format='channels_first',
        ))
    model.add(LeakyReLU(alpha=0.1))
    # Maxpooling 1
    model.add(
        MaxPooling3D(pool_size=(2, 2, 2),
                     strides=None,
                     padding='valid',
                     data_format='channels_first'))
    # conv Layer 2
    model.add(
        Convolution3D(
            filters=64,
            kernel_size=1,
            padding='valid',
            data_format='channels_first',
        ))
    model.add(LeakyReLU(alpha=0.1))
    # Maxpooling 1
    model.add(
        MaxPooling3D(
            pool_size=(2, 2, 2),
            strides=None,
            padding='valid',  # Padding method
            data_format='channels_first'))
    # Dropout 2
    model.add(Dropout(0.4))
    # FC 1
    model.add(Flatten())
    model.add(Dense(128))  #
    model.add(LeakyReLU(alpha=0.1))
    # Dropout 3
    # Fully connected layer 2 to shape (3) for 3 classes
    model.add(Dense(3))
    model.add(Activation('sigmoid'))
    model.summary()
    return model
예제 #11
0
def qc_model():
#    data_dim = 160*256*224
    nb_classes = 2

    model = Sequential()

    model.add(Convolution3D(7, 3, 3, 3, activation='relu', input_shape=(1, 160, 256, 224)))
    model.add(BatchNormalization())
    model.add(MaxPooling3D(pool_size=(2, 2, 2)))
#    model.add(SpatialDropout2D(0.5))

    model.add(Convolution3D(8, 3, 3, 3, activation='relu'))
    model.add(BatchNormalization())
#    model.add(MaxPooling2D(pool_size=(3, 3)))
#    model.add(SpatialDropout2D(0.5))

    model.add(Convolution3D(12, 3, 3, 3, activation='relu'))
    model.add(BatchNormalization())
    model.add(MaxPooling3D(pool_size=(2, 2, 2)))
#    model.add(SpatialDropout2D(0.2))
#
    model.add(Flatten())
    model.add(Dense(10, init='uniform', activation='relu'))
#    model.add(Dropout(0.5))
    model.add(Dense(10, init='uniform', activation='relu'))
    model.add(Dense(nb_classes, init='uniform'))
    model.add(Activation('softmax'))

    model.compile(loss='categorical_crossentropy',
                  optimizer='sgd',
                  metrics=["accuracy"])

    return model
예제 #12
0
    def classifier_3d(self):
        model = Sequential()

        model.add(Convolution3D(16, 3, 3, 3, input_shape=self.input_shape))
        model.add(Activation('relu'))
        model.add(MaxPooling3D(pool_size=(2, 2, 2)))
        model.add(Convolution3D(32, 3, 3, 3))
        model.add(Activation('relu'))
        model.add(MaxPooling3D(pool_size=(2, 2, 2)))
        model.add(Convolution3D(64, 3, 3, 3))
        model.add(Activation('relu'))
        model.add(MaxPooling3D(pool_size=(2, 2, 2)))
        model.add(Dropout(0.25))

        model.add(Flatten())
        model.add(Dense(512))
        model.add(Activation('relu'))
        model.add(Dropout(0.5))
        model.add(Dense(128))
        model.add(Activation('relu'))
        model.add(Dropout(0.5))
        model.add(Dense(2))
        model.add(Activation('softmax'))

        model.compile(optimizer='adam',
                      loss='categorical_crossentropy',
                      metrics=['accuracy'])

        return model
예제 #13
0
def arch_c(out=2, shape=(1, 26, 40, 40)):
    # Determine proper input shape
    if K.image_dim_ordering() != 'th':
        print('Wrong dim ordering: should be TH')

    patch_input = Input(shape=shape)
    x = Dropout(.2)(patch_input)
    bn_axis = 1

    #   shape:  1, 26, 40, 40
    x = Convolution3D(64, 3, 5, 5, border_mode='same')(x)
    x = BatchNormalization(axis=bn_axis)(x)
    x = Activation('relu')(x)
    x = MaxPooling3D((2, 2, 2))(x)

    #   shape:  64, 13, 20, 20
    x = Convolution3D(64, 3, 5, 5, border_mode='same')(x)
    x = BatchNormalization(axis=bn_axis)(x)
    x = Activation('relu')(x)

    #   shape:  64, 13, 20, 20
    x = Convolution3D(64, 3, 5, 5, border_mode='same')(x)
    x = BatchNormalization(axis=bn_axis)(x)
    x = Activation('relu')(x)

    x = Flatten()(x)

    x = Dense(250, activation='relu')(x)
    x = Dense(2, activation='softmax')(x)

    return Model(patch_input, x)
def mnist_conv():
    nb_filters = 32
    kernel_size = (3, 3, 3)
    pool_size = (2, 2, 2)
    model = Sequential()
    model.add(
        Convolution3D(nb_filters,
                      kernel_size[0],
                      kernel_size[1],
                      kernel_size[2],
                      border_mode='valid',
                      input_shape=input_shape))
    model.add(Activation('relu'))
    model.add(
        Convolution3D(nb_filters, kernel_size[0], kernel_size[1],
                      kernel_size[2]))
    model.add(Activation('relu'))
    model.add(MaxPooling3D(pool_size=pool_size))
    model.add(Dropout(0.05))
    model.add(Flatten())
    model.add(Dense(32))
    model.add(Activation('relu'))
    model.add(Dropout(0.05))
    model.add(Dense(Y_test.shape[1]))
    model.add(Activation('softmax'))
    return model
예제 #15
0
def conv_block_api(kernel_size, filters, bn_axis=4):
    interm_layers = [
        Convolution3D(filters[0],
                      1,
                      1,
                      1,
                      subsample=(1, 1, 1),
                      border_mode='same'),
        BatchNormalization(axis=bn_axis),
        Activation('relu'),
        Convolution3D(filters[1],
                      kernel_size,
                      kernel_size,
                      kernel_size,
                      subsample=(1, 1, 1),
                      border_mode='same'),
        BatchNormalization(axis=bn_axis),
        Activation('relu'),
        Convolution3D(filters[2],
                      1,
                      1,
                      1,
                      subsample=(1, 1, 1),
                      border_mode='same'),
        BatchNormalization(axis=bn_axis),
        Activation('relu')
    ]

    shortcut = [
        Convolution3D(filters[2], 1, 1, 1, subsample=(1, 1, 1)),
        BatchNormalization(axis=bn_axis)
    ]

    return interm_layers, shortcut
예제 #16
0
def sumModelSimple(Inputs,nclasses,nregressions,dropoutRate=0.05,momentum=0.6):
    
    x=Inputs[1]
    globals=Inputs[0]
    x=BatchNormalization(momentum=momentum)(x)
    x = GaussianDropout(dropoutRate)(x)
    x=Convolution3D(12,kernel_size=(3,3,3),strides=(1,1,1),padding='valid', 
                    activation='relu',kernel_initializer='lecun_uniform',name='conv3D_0a')(x)
    
    x=Convolution3D(12,kernel_size=(3,3,3),strides=(2,2,2),padding='valid', 
                    activation='relu',kernel_initializer='lecun_uniform',name='conv3D_0')(x)
    
    x=Convolution3D(16,kernel_size=(5,5,5),strides=(2,2,2),padding='same', 
                    activation='relu',kernel_initializer='lecun_uniform',name='conv3D_1')(x)
    x=BatchNormalization(momentum=momentum)(x)
                    
    x=Convolution3D(4,kernel_size=(3,3,5),strides=(2,2,3),padding='same', 
                    activation='relu',kernel_initializer='lecun_uniform',name='conv3D_2')(x)
    x=BatchNormalization(momentum=momentum)(x)
    x=Flatten()(x)
    x=Concatenate()( [globals,x])
    x=Dense(128, activation='relu',kernel_initializer='lecun_uniform')(x)
    
    predictID=Dense(nclasses, activation='softmax',kernel_initializer='lecun_uniform',name='ID_pred')(x)
    predictE=Dense(1, activation='linear',kernel_initializer='lecun_uniform',name='pre_Epred')(x)
    predictions = [predictID,predictE]
                   
    model = Model(inputs=Inputs, outputs=predictions)
    return model
def create_cnn_network(input_dim):
    '''Base network to be shared (eq. to feature extraction).
    '''
    seq = Sequential()

    # conv layers
    kern_size = 3
    seq.add(Convolution3D(5, kern_size, kern_size, kern_size, input_shape=input_dim,
                          border_mode='valid', dim_ordering='th', activation='relu'))
    seq.add(Dropout(.2))
    # seq.add(BatchNormalization(mode=2))

    kern_size = 3
    seq.add(Convolution3D(10, kern_size, kern_size, kern_size,
                          border_mode='valid', dim_ordering='th', activation='relu'))
    seq.add(Dropout(.2))
    # seq.add(BatchNormalization(mode=2))
    # seq.add(MaxPooling3D((2, 2, 2), dim_ordering='th'))

    # dense layers
    seq.add(Flatten())
    seq.add(Dense(50, activation='relu'))
    seq.add(Dropout(.2))
    # seq.add(BatchNormalization(mode=2))
    return seq
예제 #18
0
파일: test_net.py 프로젝트: mgm79/GPINN
def test_unet_from_layers(box_size, i, o):
    inputs = Input([box_size] * 3 + [i])
    conv1 = Convolution3D(filters=3,
                          kernel_size=1,
                          activation='elu',
                          padding='same')(inputs)
    outputs = Convolution3D(filters=o,
                            kernel_size=1,
                            activation='sigmoid',
                            padding='same')(conv1)

    model = UNet(inputs=inputs,
                 outputs=outputs,
                 box_size=box_size,
                 input_channels=i,
                 output_channels=o)
    assert hasattr(model, 'data_handle')
    assert model.data_handle is None

    with pytest.raises(ValueError, match='input should be 5D'):
        UNet(inputs=inputs[0], outputs=inputs)

    with pytest.raises(ValueError, match='output should be 5D'):
        UNet(inputs=inputs, outputs=outputs[1])

    with pytest.raises(ValueError,
                       match='input and output shapes do not match'):
        UNet(inputs=inputs, outputs=concatenate([outputs, outputs], 1))
예제 #19
0
def initModelRegAux(imageSize, numberOfAuxInputs):
    # initialize regression model with auxiliary inputs
    input_image = Input(shape=imageSize + [1])
    input_aux = Input(shape=(numberOfAuxInputs, ))

    x = Convolution3D(filters=32,
                      kernel_size=(3, 3, 3),
                      strides=(1, 1, 1),
                      activation='relu')(input_image)
    x = Convolution3D(filters=32,
                      kernel_size=(3, 3, 3),
                      strides=(1, 1, 1),
                      activation='relu')(x)
    x = MaxPooling3D((2, 2, 2))(x)
    x = Convolution3D(filters=64,
                      kernel_size=(3, 3, 3),
                      strides=(1, 1, 1),
                      activation='relu')(x)
    x = Convolution3D(filters=64,
                      kernel_size=(3, 3, 3),
                      strides=(1, 1, 1),
                      activation='relu')(x)
    x = MaxPooling3D((2, 2, 2))(x)
    conv_flat = Flatten()(x)
    conv_flat2 = Dense(64, activation='relu')(conv_flat)

    merged = concatenate([conv_flat2, input_aux])
    predictions = Dense(1, activation='linear')(merged)

    model = Model(inputs=[input_image, input_aux], outputs=predictions)
    model.compile(loss='mean_absolute_error', optimizer='adam')
    return model
    def build_model(self):
        model = Sequential()
        model.add(Convolution3D(8, (3, 3, 3), input_shape=self.__input_dim))
        model.add(MaxPooling3D())

        model.add(Convolution3D(8, (3, 3, 3)))
        model.add(MaxPooling3D())

        model.add(Convolution3D(8, (3, 3, 3)))
        model.add(MaxPooling3D())

        model.add(Convolution3D(8, (3, 3, 3)))
        model.add(MaxPooling3D())

        model.add(Flatten())
        model.add(Dense(1024, activation='relu', name='dense1'))
        model.add(Dropout(0.5, name='dropout1'))

        model.add(Dense(512, activation='relu', name='dense2'))
        model.add(Dropout(0.5, name='dropout2'))

        model.add(Dense(self.__no_classes, activation='softmax'))

        if self.weights_path:
            model.load_weights(self.weights_path)
        return model
예제 #21
0
def res_block(input_tensor, nb_filters=16, block=0, subsample_factor=1):
    subsample = (subsample_factor, subsample_factor, subsample_factor)

    x = BatchNormalization(axis=4)(input_tensor)
    x = Activation('relu')(x)
    x = Convolution3D(nb_filters,
                      3,
                      3,
                      3,
                      subsample=subsample,
                      border_mode='same')(x)
    x = BatchNormalization(axis=4)(x)
    x = Activation('relu')(x)
    x = Convolution3D(nb_filters,
                      3,
                      3,
                      3,
                      subsample=(1, 1, 1),
                      border_mode='same')(x)

    if subsample_factor > 1:
        shortcut = Convolution3D(nb_filters,
                                 1,
                                 1,
                                 1,
                                 subsample=subsample,
                                 border_mode='same')(input_tensor)
    else:
        shortcut = input_tensor

    x = merge([x, shortcut], mode='sum')
    return x
예제 #22
0
def conv_block_td(input_tensor, kernel_size, filters, stage, block, input_shape, strides=(2, 2, 2), trainable=True):
    # conv block time distributed

    nb_filter1, nb_filter2, nb_filter3 = filters
    bn_axis = 4

    conv_name_base = 'res' + str(stage) + block + '_branch'
    bn_name_base = 'bn' + str(stage) + block + '_branch'

    x = TimeDistributed(
        Convolution3D(nb_filter1, (1, 1, 1), strides=strides, trainable=trainable, kernel_initializer='normal'),
        input_shape=input_shape, name=conv_name_base + '2a')(input_tensor)
    x = TimeDistributed(BatchNormalization(axis=bn_axis), name=bn_name_base + '2a')(x)
    x = Activation('relu')(x)

    x = TimeDistributed(
        Convolution3D(nb_filter2, (kernel_size, kernel_size, kernel_size), padding='same', trainable=trainable,
                      kernel_initializer='normal'), name=conv_name_base + '2b')(x)
    x = TimeDistributed(BatchNormalization(axis=bn_axis), name=bn_name_base + '2b')(x)
    x = Activation('relu')(x)

    x = TimeDistributed(Convolution3D(nb_filter3, (1, 1, 1), kernel_initializer='normal'), name=conv_name_base + '2c',
                        trainable=trainable)(x)
    x = TimeDistributed(BatchNormalization(axis=bn_axis), name=bn_name_base + '2c')(x)

    shortcut = TimeDistributed(
        Convolution3D(nb_filter3, (1, 1, 1), strides=strides, trainable=trainable, kernel_initializer='normal'),
        name=conv_name_base + '1')(input_tensor)
    shortcut = TimeDistributed(BatchNormalization(axis=bn_axis), name=bn_name_base + '1')(shortcut)

    x = Add()([x, shortcut])
    x = Activation('relu')(x)
    return x
예제 #23
0
    def get_model(self):
        inputlayer = Input((self.size_image[0], self.size_image[1],
                            self.size_image[2], self.num_channels_in))
        hiddenlayer_next = inputlayer

        list_hiddenlayer_skipconn = []
        # ENCODING LAYERS
        for i in range(self.num_layers):
            for j in range(self.num_convols_downlayers):
                hiddenlayer_next = Convolution3D(
                    self.num_featmaps_layers[i],
                    self.size_convolfilter_downlayers[i],
                    activation=self.type_activate_hidden,
                    padding=self.type_padding_convol)(hiddenlayer_next)
            #endfor

            if self.isuse_dropout and self.where_dropout_downlayers[i]:
                hiddenlayer_next = Dropout(self.dropout_rate)(hiddenlayer_next)
            if self.isuse_batchnormalize and self.where_batchnormalize_downlayers[
                    i]:
                hiddenlayer_next = BatchNormalization()(hiddenlayer_next)
            if i != self.num_layers - 1:
                list_hiddenlayer_skipconn.append(hiddenlayer_next)
                hiddenlayer_next = MaxPooling3D(
                    pool_size=self.size_pooling_downlayers[i])(
                        hiddenlayer_next)
        #endfor

        # DECODING LAYERS
        for i in range(self.num_layers - 2, -1, -1):
            hiddenlayer_next = UpSampling3D(
                size=self.size_upsample_uplayers[i])(hiddenlayer_next)
            hiddenlayer_next = merge(
                [hiddenlayer_next, list_hiddenlayer_skipconn[i]],
                mode='concat',
                concat_axis=-1)

            for j in range(self.num_convols_downlayers):
                hiddenlayer_next = Convolution3D(
                    self.num_featmaps_layers[i],
                    self.size_convolfilter_uplayers[i],
                    activation=self.type_activate_hidden,
                    padding=self.type_padding_convol)(hiddenlayer_next)
            #endfor

            if self.isuse_dropout and self.where_dropout_uplayers[i]:
                hiddenlayer_next = Dropout(self.dropout_rate)(hiddenlayer_next)
            if self.isuse_batchnormalize and self.where_batchnormalize_uplayers[
                    i]:
                hiddenlayer_next = BatchNormalization()(hiddenlayer_next)
        #endfor

        outputlayer = Convolution3D(
            self.num_classes_out, (1, 1, 1),
            activation=self.type_activate_output)(hiddenlayer_next)

        out_model = Model(input=inputlayer, output=outputlayer)

        return out_model
예제 #24
0
def create_model(input_size=[2900, 15, 15]):
    t, h, w = input_size
    input_sequence = Input(shape=(1, t, h,
                                  w))  # (channels,frames,height,width)

    # conv1: spatial convolution (3 x 3), spatial pooling (2 x 2)
    conv_1 = Convolution3D(50, 1, 3, 3, activation='relu', border_mode='same')
    conv1 = conv_1(input_sequence)
    bn1 = BatchNormalization(axis=1)(conv1)

    pool_1 = MaxPooling3D(pool_size=(1, 2, 2), strides=(1, 2, 2))
    pool1 = pool_1(bn1)  # output size: t, h/2, w/2

    # conv2: temporal convolution (4), temporal pooling (2)
    conv_2 = Convolution3D(50, 5, 1, 1, activation='relu', border_mode='same')
    conv2 = conv_2(pool1)
    bn2 = BatchNormalization(axis=1)(conv2)

    pool_2 = MaxPooling3D(pool_size=(2, 1, 1), strides=(2, 1, 1))
    pool2 = pool_2(bn2)  # output size: t/2, h/2, w/2

    drop3 = Dropout(0.5)(pool2)

    # conv3: spatial convolution (3 x 3), spatial pooling (2 x 2)
    conv_3 = Convolution3D(50, 1, 3, 3, activation='relu', border_mode='same')
    conv3 = conv_3(drop3)
    bn3 = BatchNormalization(axis=1)(conv3)

    pool_3 = MaxPooling3D(pool_size=(1, 2, 2), strides=(1, 2, 2))
    pool3 = pool_3(bn3)  # output size: t/2, h/4, w/4

    # conv4: temporal convolution (4), temporal pooling (2)
    conv_4 = Convolution3D(50, 4, 1, 1, activation='relu', border_mode='same')
    conv4 = conv_4(pool3)
    bn4 = BatchNormalization(axis=1)(conv4)

    pool_4 = MaxPooling3D(pool_size=(2, 1, 1), strides=(2, 1, 1))
    pool4 = pool_4(bn4)  # output size: t/4, h/4, w/4

    pool_5 = MaxPooling3D(pool_size=(t / 4, 1, 1), strides=(t / 4, 1, 1))
    pool5 = pool_5(pool4)  # output size: 1, h/4, w/4

    drop5 = Dropout(0.5)(pool5)

    # fully connected layers
    reshape6 = Reshape((50 * (h / 4) * (w / 4), ))(drop5)
    fc_6 = Dense(1000, activation='relu')
    fc6 = fc_6(reshape6)

    fc_7 = Dense(2, activation='softmax')
    fc7 = fc_7(fc6)

    model = Model(input=input_sequence, output=fc7)
    sgd = SGD(lr=0.1, decay=1e-6, momentum=0.9, nesterov=True)
    model.compile(optimizer=sgd,
                  loss='categorical_crossentropy',
                  metrics=['accuracy'])

    return model
예제 #25
0
def create_graph(cell_size=27, load_file=None, l2_lambda=0.01):
    model = Sequential()
    model.add(
        Convolution3D(8, (7, 7, 7),
                      input_shape=(cell_size, cell_size, cell_size, 4),
                      activation='relu',
                      kernel_regularizer=K.regularizers.l2(l2_lambda)))
    model.add(
        Convolution3D(16, (5, 5, 5),
                      activation='relu',
                      kernel_regularizer=K.regularizers.l2(l2_lambda)))
    model.add(
        Convolution3D(32, (5, 5, 5),
                      activation='relu',
                      kernel_regularizer=K.regularizers.l2(l2_lambda)))
    model.add(
        Convolution3D(64, (5, 5, 5),
                      activation='relu',
                      kernel_regularizer=K.regularizers.l2(l2_lambda)))
    model.add(
        Convolution3D(128, (5, 5, 5),
                      activation='relu',
                      kernel_regularizer=K.regularizers.l2(l2_lambda)))
    model.add(MaxPooling3D((2, 2, 2), strides=(2, 2, 2)))
    model.add(Flatten())

    model.add(
        Dense(512,
              activation='relu',
              kernel_regularizer=K.regularizers.l2(l2_lambda)))
    model.add(
        Dense(256,
              activation='relu',
              kernel_regularizer=K.regularizers.l2(l2_lambda)))
    model.add(
        Dense(128,
              activation='relu',
              kernel_regularizer=K.regularizers.l2(l2_lambda)))
    model.add(
        Dense(64,
              activation='relu',
              kernel_regularizer=K.regularizers.l2(l2_lambda)))
    model.add(
        Dense(32,
              activation='relu',
              kernel_regularizer=K.regularizers.l2(l2_lambda)))
    model.add(
        Dense(2,
              activation='relu',
              kernel_regularizer=K.regularizers.l2(l2_lambda)))

    print(model.summary())
    exit()

    if load_file is not None:
        model.load_weights(load_file)
    optim = Nadam()
    model.compile(optimizer=optim, loss=rmsle)
    return model
예제 #26
0
def get_net(input_shape=(64, 64, 64, 1), load_weight_path=None, features=False) -> Model:
    inputs = Input(shape=input_shape, name="input_1")
    x = inputs
    x = AveragePooling3D(strides=(2, 1, 1), pool_size=(2, 1, 1), padding="same")(x)

    x = Convolution3D(64, (3, 3, 3), activation='relu', strides=(1, 1, 1), padding='same', name='conv1', )(x)
    x = MaxPooling3D(pool_size=(1, 2, 2), strides=(1, 2, 2), padding='valid', name='pool1')(x)


    x = Convolution3D(128, (3, 3, 3), activation='relu', padding='same', name='conv2', strides=(1, 1, 1))(x)
    x = MaxPooling3D(pool_size=(2, 2, 2), strides=(2, 2, 2), padding='valid', name='pool2')(x)

    if USE_DROPOUT:
        x = Dropout(rate=0.3)(x)

    x = Convolution3D(256, (3, 3, 3), activation='relu', padding='same', name='conv3a', strides=(1, 1, 1))(x)
    x = Convolution3D(256, (3, 3, 3), activation='relu', padding='same', name='conv3b', strides=(1, 1, 1))(x)
    x = MaxPooling3D(pool_size=(2, 2, 2), strides=(2, 2, 2), padding='valid', name='pool3')(x)

    if USE_DROPOUT:
        x = Dropout(rate=0.4)(x)

    x = Convolution3D(512, (3, 3, 3), activation='relu', padding='same', name='conv4a', strides=(1, 1, 1))(x)
    x = Convolution3D(512, (3, 3, 3), activation='relu', padding='same', name='conv4b', strides=(1, 1, 1),)(x)
    x = MaxPooling3D(pool_size=(2, 2, 2), strides=(2, 2, 2), padding='valid', name='pool4')(x)

    if USE_DROPOUT:
        x = Dropout(rate=0.5)(x)

    # 新加部分
    x = Convolution3D(512, (3, 3, 3), activation='relu', padding='same', name='conv5a', strides=(1, 1, 1))(x)
    x = Convolution3D(512, (3, 3, 3), activation='relu', padding='same', name='conv5b', strides=(1, 1, 1), )(x)
    x = MaxPooling3D(pool_size=(2, 2, 2), strides=(2, 2, 2), padding='valid', name='pool5')(x)

    last64 = Convolution3D(64, (2, 2, 2), activation="relu", name="last_64")(x)

    out_class = Convolution3D(5, (1, 1, 1), activation="softmax", name="out_class_last")(last64)
    out_class = Flatten(name="out_class")(out_class)
    # 1*1*1*1:一个像素点,即一个值
    # out_malignancy = Convolution3D(1, (1, 1, 1), activation=None, name="out_malignancy_last")(last64)
    # out_malignancy = Flatten(name="out_malignancy")(out_malignancy)

    # 定义一个有一个输入一个输出的模型
    model = Model(inputs=inputs, outputs=out_class)
    if load_weight_path is not None:
        model.load_weights(load_weight_path, by_name=False)
    # 定义损失函数、优化函数、和评测方法
    # optimzer:SGD()是随机梯度下降以及对应参数
    # loss:计算损失函数,这里指定了两个损失函数,分别对应两个输出结果,out_class:binary_crossentropy,  out_malignancy:mean_absolute_error
    # metris:性能评估函数,这里指定了两个性能评估函数
    # binary_accuracy: 对二分类问题,计算在所有预测值上的平均正确率,binary_crossentropy是对数损失
    model.compile(optimizer=SGD(lr=LEARN_RATE, momentum=0.9, nesterov=True),
                  loss=categorical_crossentropy, metrics=[categorical_crossentropy, categorical_accuracy])

    if features:
        model = Model(input=inputs, output=[last64])
    # 打印出模型概况
    model.summary(line_length=140)
    return model
예제 #27
0
def rpn(base_layers, num_anchors):
    x = Convolution3D(512, (3, 3, 3), padding='same', activation='relu', kernel_initializer='normal', name='rpn_conv1')(
        base_layers)
    x_class = Convolution3D(num_anchors, (1, 1, 1), activation='sigmoid', kernel_initializer='uniform',
                            name='rpn_out_class')(x)
    x_regr = Convolution3D(num_anchors * 4, (1, 1, 1), activation='linear', kernel_initializer='zero',
                           name='rpn_out_regress')(x)
    return [x_class, x_regr, base_layers]
예제 #28
0
파일: model.py 프로젝트: dansbecker/unblur
def make_disc_model_body(input_shape, n_disc_filters):
    def make_disc_encoder(input_shape, n_disc_filters):
        output = Sequential(name='disc_layer_stack')
        output.add(
            Convolution2D(n_disc_filters[0],
                          1,
                          1,
                          border_mode='same',
                          input_shape=input_shape))
        output.add(LeakyReLU(0.2))
        for n_filters_in_block in n_disc_filters:
            output.add(
                Convolution2D(n_filters_in_block,
                              3,
                              3,
                              subsample=(2, 2),
                              border_mode='same'))
            output.add(LeakyReLU(0.2))
            output.add(Convolution2D(n_filters_in_block, 1, 1))
            output.add(LeakyReLU(0.2))

        # Add an extra dimension on front of this output, to allow convolving images together
        curr_output_shape = output.output_shape
        new_shape = (1, curr_output_shape[1], curr_output_shape[2],
                     curr_output_shape[3])
        output.add(Reshape(new_shape))
        return output

    disc_encoder = make_disc_encoder(input_shape, n_disc_filters)

    blurry_img = Input(shape=input_shape)
    blurry_branch = disc_encoder(blurry_img)
    clear_img = Input(shape=input_shape)
    clear_branch = disc_encoder(clear_img)

    # SHould probably concat on axis 0 and convolve the images
    disc_merged = merge([blurry_branch, clear_branch],
                        mode='concat',
                        concat_axis=1)

    for i in range(2):
        encoded_pair = Convolution3D(32, 1, 1, 1,
                                     border_mode='same')(disc_merged)
        encoded_pair = LeakyReLU(0.2)(encoded_pair)
        encoded_pair = Convolution3D(32, 1, 3, 3,
                                     border_mode='same')(encoded_pair)
        encoded_pair = LeakyReLU(0.2)(encoded_pair)
        encoded_pair = MaxPooling3D(pool_size=(1, 2, 2))(encoded_pair)

    encoded_pair = Flatten()(encoded_pair)
    disc_output = Dense(50, name='disc_output')(encoded_pair)
    disc_output = LeakyReLU(0.2)(disc_output)
    disc_output = Dense(1, activation='sigmoid',
                        name='disc_output')(encoded_pair)
    disc_model_body = Model(input=[blurry_img, clear_img],
                            output=disc_output,
                            name='disc_model_body')
    return disc_model_body
예제 #29
0
def srcnn3(input_shape=(33,33,110,1)):
    print '82'
    model = Sequential()
    model.add(Convolution3D(64, 9, 9, 7, input_shape=input_shape, activation='relu'))
    model.add(Convolution3D(32, 1, 1, 1, activation='relu'))
    model.add(Convolution3D(9, 1, 1, 1, activation='relu'))
    model.add(Convolution3D(1, 5, 5, 3))
    model.compile(Adam(lr=0.00005), 'mse')
    return model
예제 #30
0
def AddConvolutionalLayer(model, filter_size, kernel_size, padding, activation, normalization, input_shape=None):
    if not input_shape == None: model.add(Convolution3D(filter_size, kernel_size, padding=padding, input_shape=input_shape))
    else: model.add(Convolution3D(filter_size, kernel_size, padding=padding))

    # add activation layer
    if activation == 'LeakyReLU': model.add(LeakyReLU(alpha=0.001))
    else: model.add(Activation(activation))
    
    # add normalization after activation
    if normalization: model.add(BatchNormalization())