#1-1. 데이터 전처리 scaler = StandardScaler() x = scaler.fit_transform(x) # print(x[0]) x = x.reshape(-1, 5, 2, 1) # print(x.shape) # (442,5,2,1) x_train, x_test, y_train, y_test = train_test_split(x, y, random_state=99, train_size=0.8) #2. 모델 input1 = Input(shape=(5, 2, 1)) dense1 = Conv2D(10, (2, 1), padding='same')(input1) dense1 = Conv2D(20, (2, 1), padding='same')(dense1) dense1 = Conv2D(40, (2, 1), padding='same')(dense1) dense1 = Conv2D(60, (2, 1), padding='same')(dense1) dense1 = Conv2D(80, (2, 1), padding='same')(dense1) dense1 = MaxPooling2D(pool_size=2, padding='same')(dense1) dense1 = Conv2D(70, (2, 1), padding='same')(dense1) dense1 = Conv2D(50, (2, 1), padding='same')(dense1) dense1 = Conv2D(30, (2, 1), padding='same')(dense1) dense1 = Conv2D(10, (2, 1), padding='same')(dense1) dense1 = MaxPooling2D(pool_size=2, padding='same')(dense1) dense1 = Flatten()(dense1) output1 = Dense(1)(dense1) model = Model(inputs=input1, outputs=output1)
def main(job_dir, **args): ##Setting up the path for saving logs logs_path = job_dir + 'logs/tensorboard-{}'.format(int(time.time())) logs_dir = job_dir + 'logs/tensorboard/' ##Using the GPU with tf.device('/device:GPU:0'): with file_io.FileIO(job_dir + 'dataset/train_data.pickle', mode='rb') as file: train_set = pickle.load(file) with file_io.FileIO(job_dir + 'dataset/train_label.pickle', mode='rb') as file: train_label = pickle.load(file) dense_layers = [0, 1, 2] layer_sizes = [8, 16, 32, 64] conv_layers = [1, 2, 3] for dense_layer in dense_layers: for layer_size in layer_sizes: for conv_layer in conv_layers: NAME = "{}-conv-{}-nodes-{}-dense-{}".format( conv_layer, layer_size, dense_layer, int(time.time())) model = Sequential() model.add( Conv2D(layer_size, (3, 3), input_shape=(64, 64, 3))) model.add(Activation('relu')) model.add(MaxPooling2D(pool_size=(2, 2))) for l in range(conv_layer - 1): model.add(Conv2D(layer_size, (3, 3))) model.add(Activation('relu')) model.add(MaxPooling2D(pool_size=(2, 2))) model.add(Flatten()) for _ in range(dense_layer): model.add(Dense(layer_size)) model.add(Activation('relu')) model.add(Dense(13)) model.add(Activation('sigmoid')) tensorboard = callbacks.TensorBoard(log_dir=logs_dir + "{}".format(NAME)) # checkpoint = ModelCheckpoint('model-checkpoint-{}.h5'.format(NAME), # monitor='val_loss', verbose=1, # save_best_only=True, mode='min') model.compile( loss='categorical_crossentropy', optimizer='adam', metrics=['accuracy'], ) model.fit(train_set, train_label, batch_size=40, epochs=15, validation_split=0.3, callbacks=[tensorboard]) model.save('model-{}.h5'.format(NAME)) with file_io.FileIO('model-{}.h5'.format(NAME), mode='r') as input_f: with file_io.FileIO(job_dir + 'model/' + 'model-{}.h5'.format(NAME), mode='w+') as output_f: output_f.write(input_f.read())
# Load data set (x_train, y_train), (x_test, y_test) = cifar10.load_data() # Normalize data set to 0-to-1 range x_train = x_train.astype('float32') x_test = x_test.astype('float32') x_train /= 255 x_test /= 255 # Convert class vectors to binary class matrices y_train = keras.utils.to_categorical(y_train, 10) y_test = keras.utils.to_categorical(y_test, 10) # Create a model and add layers model = Sequential() model.add(Conv2D(32, (3, 3), padding='same', activation= 'relu', input_shape=(32, 32, 3))) #input is not an image so we have no padding model.add(Conv2D(32, (3, 3), activation= 'relu')) #to speed up the process we add max pool model.add(MaxPooling2D(pool_size=(2,2))) #to prevent neuron co-adaptation to avoid overfitting model.add(Dropout(0.25)) model.add(Conv2D(64, (3, 3), padding='same', activation='relu')) model.add(Conv2D(64, (3, 3), activation='relu')) model.add(MaxPooling2D(pool_size=(2,2))) model.add(Dropout(0.25)) #to tell Dense layer that we are no longer on 2D data (do this flatten layer whenever you go from convolutional to dense layer) model.add(Flatten()) model.add(Dense(512, activation="relu"))
print("y_test",y_test.shape) # 2. reshape train and test data to 4D arrays # note: the CNN expects 4D tensors as input for the # convolutional layers! X_train = X_train.reshape(X_train.shape[0], 20, 11, 1) X_test = X_test.reshape(X_test.shape[0], 20, 11, 1) y_train_hot = np_utils.to_categorical(y_train) y_test_hot = np_utils.to_categorical(y_test) # 3. setup a CNN model = Sequential() model.add(Conv2D(20, kernel_size=(3, 3), activation='relu', input_shape=(20, 11, 1))) model.add(MaxPooling2D(pool_size=(2, 2))) model.add(Conv2D(40, kernel_size=(3, 3), activation='relu')) model.add(MaxPooling2D(pool_size=(2, 2))) model.add(Flatten()) model.add(Dense(50, activation='relu')) model.add(Dense(3, activation='softmax')) model.compile(loss=keras.losses.categorical_crossentropy, optimizer=keras.optimizers.Adadelta(), metrics=['accuracy']) # 4. train the CNN model.fit(X_train, y_train_hot, batch_size=100, epochs=50,
kernel_size = 3 latent_dim = 16 # Encoder/Decoder number of CNN layers and filters per layer layer_filters = [32, 64] # Build the Autoencoder Model # First build the Encoder Model inputs = Input(shape=input_shape, name='encoder_input') x = inputs # Stack of Conv2D blocks # Notes: # 1) Use Batch Normalization before ReLU on deep networks # 2) Use MaxPooling2D as alternative to strides>1 # - faster but not as good as strides>1 for filters in layer_filters: x = Conv2D(filters=filters, kernel_size=kernel_size, strides=2, activation='relu', padding='same')(x) # Shape info needed to build Decoder Model shape = K.int_shape(x) # Generate the latent vector x = Flatten()(x) latent = Dense(latent_dim, name='latent_vector')(x) # Instantiate Encoder Model encoder = Model(inputs, latent, name='encoder') encoder.summary() # Build the Decoder Model latent_inputs = Input(shape=(latent_dim,), name='decoder_input') x = Dense(shape[1] * shape[2] * shape[3])(latent_inputs)
train_generator = generator(train_samples) validation_generator = generator(validation_samples) print('generators setup') from keras.models import Sequential from keras.layers import Dense, Activation, Flatten, Conv2D, Lambda from keras.layers.convolutional import Cropping2D from keras.layers.normalization import BatchNormalization from keras.layers.pooling import MaxPooling2D from keras.optimizers import Adam model = Sequential() model.add( Cropping2D(cropping=((50, 20), (0, 0)), input_shape=(height, width, 3))) model.add(Lambda(lambda x: x / 127.5 - 1)) model.add(Conv2D(24, 5, 5)) model.add(MaxPooling2D(pool_size=(2, 2))) model.add(Conv2D(36, 5, 5)) model.add(MaxPooling2D(pool_size=(2, 2))) model.add(Conv2D(48, 5, 5)) model.add(MaxPooling2D(pool_size=(2, 2))) model.add(Conv2D(64, 3, 3)) model.add(Conv2D(64, 3, 3)) model.add(Flatten()) model.add(Dense(100)) model.add(Dense(50)) model.add(Dense(10)) model.add(Dense(1)) model.compile(optimizer=Adam(lr=0.001), loss='mse', metrics=['accuracy']) #model.summary()
y_train = np_utils.to_categorical(y_train) y_test = np_utils.to_categorical(y_test) print(y_train.shape) # (60000, 10) -> one hot encoding x_train = x_train.reshape(60000,28,28,1).astype('float32')/255.0 # CNN 모델에 input 하기 위해 4차원으로 만들면서 실수형으로 형변환 & 0과 1 사이로 Minmax정규화 x_test = x_test.reshape(10000,28,28,1).astype('float32')/255.0 # ____________모델 구성____________________ from keras.models import Sequential from keras.layers import Dense, Flatten, Conv2D, MaxPool2D, Dropout, BatchNormalization model= Sequential() model.add(Conv2D(64, (3,3), input_shape = (28, 28, 1), padding='same')) model.add(BatchNormalization()) model.add(Conv2D(32, (3,3), activation = 'relu', strides= 1, padding='same')) model.add(BatchNormalization()) model.add(MaxPool2D(pool_size= 2)) model.add(Dropout(0.20)) model.add(Conv2D(64, (3,3), input_shape = (28, 28, 1), padding='same')) model.add(BatchNormalization()) model.add(Conv2D(64, (2,2), activation = 'relu', strides= 1, padding='same')) model.add(BatchNormalization()) model.add(MaxPool2D(pool_size= 2)) model.add(Dropout(0.3)) model.add(Conv2D(128, (3,3), activation = 'relu', strides= 1, padding='same')) model.add(BatchNormalization())
# weights=[embeddingMatrix], # input_length=maxLength, # trainable=False) sequenceInput = Input(shape=(maxLength, ), dtype='int32') embedding = Embedding(input_dim = len(wordIdMap) + 1, output_dim = embeddingDim, weights = [embeddingMatrix], input_length = maxLength, trainable = False)(sequenceInput) # embeddedSequences = embeddingLayer(sequenceInput) finalEmbeddedSeq = Reshape((maxLength, embeddingDim, 1))(embedding) conv_0 = Conv2D(numOfFilters, kernel_size=(filterSizes[0], embeddingDim), padding='valid', kernel_initializer='normal', activation='relu')(finalEmbeddedSeq) conv_1 = Conv2D(numOfFilters, kernel_size=(filterSizes[1], embeddingDim), padding='valid', kernel_initializer='normal', activation='relu')(finalEmbeddedSeq) conv_2 = Conv2D(numOfFilters, kernel_size=(filterSizes[2], embeddingDim), padding='valid', kernel_initializer='normal', activation='relu')(finalEmbeddedSeq) maxpool_0 = MaxPooling2D(pool_size=(maxLength - filterSizes[0] + 1, 1), strides=(1,1), padding='valid')(conv_0) maxpool_1 = MaxPooling2D(pool_size=(maxLength - filterSizes[1] + 1, 1), strides=(1,1), padding='valid')(conv_1) maxpool_2 = MaxPooling2D(pool_size=(maxLength - filterSizes[2] + 1, 1), strides=(1,1), padding='valid')(conv_2) concatenated_tensor = Concatenate(axis=1)([maxpool_0, maxpool_1, maxpool_2]) flatten = Flatten()(concatenated_tensor) dropout = Dropout(drop)(flatten) output = Dense(units = numOfLabels, activation = 'softmax')(dropout) model = Model(inputs=sequenceInput, outputs=output) # checkpoint = ModelCheckpoint('weights.{epoch:03d}-{val_acc:.4f}.hdf5', monitor='val_acc', verbose=1, save_best_only=True, mode='auto')
y = BatchNormalization()(y) y = Activation('relu')(y) y = Conv2D(filters, (f_size, f_size), padding='same')(y) y = BatchNormalization()(y) y = Add()([layer_input, y]) return Activation('relu')(y) IMG_HEIGHT, IMG_WIDTH = 128, 128 inputs = Input((None, None, 1)) x = Conv2D(64, 9, padding='same')(inputs) x = BatchNormalization()(x) x = Activation('relu')(x) x = resnet_block(x) x = resnet_block(x) x = resnet_block(x) outputs = Conv2D(1, 3, padding='same', activation='sigmoid')(x) model = Model(inputs=inputs, outputs=outputs) model.summary() if LOAD_WEIGHTS: model.load_weights('model4.h5')
def CreateModel(self): ''' 定义CNN/LSTM/CTC模型,使用函数式模型 输入层:200维的特征值序列,一条语音数据的最大长度设为1600(大约16s) 隐藏层:卷积池化层,卷积核大小为3x3,池化窗口大小为2 隐藏层:全连接层 输出层:全连接层,神经元数量为self.MS_OUTPUT_SIZE,使用softmax作为激活函数, CTC层:使用CTC的loss作为损失函数,实现连接性时序多输出 ''' input_data = Input(name='the_input', shape=(self.AUDIO_LENGTH, self.AUDIO_FEATURE_LENGTH, 1)) layer_h1 = Conv2D(32, (3, 3), use_bias=False, activation='relu', padding='same', kernel_initializer='he_normal')(input_data) # 卷积层 layer_h1 = Dropout(0.05)(layer_h1) layer_h2 = Conv2D(32, (3, 3), use_bias=True, activation='relu', padding='same', kernel_initializer='he_normal')(layer_h1) # 卷积层 layer_h3 = MaxPooling2D(pool_size=2, strides=None, padding="valid")(layer_h2) # 池化层 #layer_h3 = Dropout(0.2)(layer_h2) # 随机中断部分神经网络连接,防止过拟合 layer_h3 = Dropout(0.05)(layer_h3) layer_h4 = Conv2D(64, (3, 3), use_bias=True, activation='relu', padding='same', kernel_initializer='he_normal')(layer_h3) # 卷积层 layer_h4 = Dropout(0.1)(layer_h4) layer_h5 = Conv2D(64, (3, 3), use_bias=True, activation='relu', padding='same', kernel_initializer='he_normal')(layer_h4) # 卷积层 layer_h6 = MaxPooling2D(pool_size=2, strides=None, padding="valid")(layer_h5) # 池化层 layer_h6 = Dropout(0.1)(layer_h6) layer_h7 = Conv2D(128, (3, 3), use_bias=True, activation='relu', padding='same', kernel_initializer='he_normal')(layer_h6) # 卷积层 layer_h7 = Dropout(0.15)(layer_h7) layer_h8 = Conv2D(128, (3, 3), use_bias=True, activation='relu', padding='same', kernel_initializer='he_normal')(layer_h7) # 卷积层 layer_h9 = MaxPooling2D(pool_size=2, strides=None, padding="valid")(layer_h8) # 池化层 layer_h9 = Dropout(0.15)(layer_h9) layer_h10 = Conv2D(128, (3, 3), use_bias=True, activation='relu', padding='same', kernel_initializer='he_normal')(layer_h9) # 卷积层 layer_h10 = Dropout(0.2)(layer_h10) layer_h11 = Conv2D(128, (3, 3), use_bias=True, activation='relu', padding='same', kernel_initializer='he_normal')(layer_h10) # 卷积层 layer_h12 = MaxPooling2D(pool_size=1, strides=None, padding="valid")(layer_h11) # 池化层 layer_h12 = Dropout(0.2)(layer_h12) layer_h13 = Conv2D(128, (3, 3), use_bias=True, activation='relu', padding='same', kernel_initializer='he_normal')(layer_h12) # 卷积层 layer_h13 = Dropout(0.2)(layer_h13) layer_h14 = Conv2D(128, (3, 3), use_bias=True, activation='relu', padding='same', kernel_initializer='he_normal')(layer_h13) # 卷积层 layer_h15 = MaxPooling2D(pool_size=1, strides=None, padding="valid")(layer_h14) # 池化层 #test=Model(inputs = input_data, outputs = layer_h12) #test.summary() layer_h16 = Reshape((200, 3200))(layer_h15) #Reshape层 #layer_h5 = LSTM(256, activation='relu', use_bias=True, return_sequences=True)(layer_h4) # LSTM层 #layer_h6 = Dropout(0.2)(layer_h5) # 随机中断部分神经网络连接,防止过拟合 layer_h16 = Dropout(0.3)(layer_h16) layer_h17 = Dense(128, activation="relu", use_bias=True, kernel_initializer='he_normal')(layer_h16) # 全连接层 layer_h17 = Dropout(0.3)(layer_h17) layer_h18 = Dense(self.MS_OUTPUT_SIZE, use_bias=True, kernel_initializer='he_normal')(layer_h17) # 全连接层 y_pred = Activation('softmax', name='Activation0')(layer_h18) model_data = Model(inputs=input_data, outputs=y_pred) #model_data.summary() labels = Input(name='the_labels', shape=[self.label_max_string_length], dtype='float32') input_length = Input(name='input_length', shape=[1], dtype='int64') label_length = Input(name='label_length', shape=[1], dtype='int64') # Keras doesn't currently support loss funcs with extra parameters # so CTC loss is implemented in a lambda layer #layer_out = Lambda(ctc_lambda_func,output_shape=(self.MS_OUTPUT_SIZE, ), name='ctc')([y_pred, labels, input_length, label_length])#(layer_h6) # CTC loss_out = Lambda(self.ctc_lambda_func, output_shape=(1, ), name='ctc')( [y_pred, labels, input_length, label_length]) model = Model(inputs=[input_data, labels, input_length, label_length], outputs=loss_out) model.summary() # clipnorm seems to speeds up convergence #sgd = SGD(lr=0.0001, decay=1e-6, momentum=0.9, nesterov=True, clipnorm=5) #opt = Adadelta(lr = 0.01, rho = 0.95, epsilon = 1e-06) opt = Adam(lr=0.0001, beta_1=0.9, beta_2=0.999, decay=0.0, epsilon=10e-8) #model.compile(loss={'ctc': lambda y_true, y_pred: y_pred}, optimizer=sgd) model.compile(loss={ 'ctc': lambda y_true, y_pred: y_pred }, optimizer=opt) # captures output of softmax so we can decode the output during visualization test_func = K.function([input_data], [y_pred]) #print('[*提示] 创建模型成功,模型编译成功') print('[*Info] Create Model Successful, Compiles Model Successful. ') return model, model_data
#Import the required packages from keras.models import Sequential from keras.layers import Conv2D from keras.layers import MaxPooling2D from keras.layers import Flatten from keras.layers import Dense #Initializing the CNN (classifier nueral network) classifier = Sequential( ) #sequential is the function call for the neural network model #--------------Step 1 - Convolution #adding first layer 64 x 64 pixels each with 3 values #input shape needs to match your data #conv2D is conversion 2D. used to convert the photo to a 2 dimensional setup classifier.add(Conv2D(32, (3, 3), input_shape=(64, 64, 3), activation='relu')) #--------------Step 2 Adding a second convolutional layer classifier.add(Conv2D(32, (3, 3), activation='relu')) classifier.add( MaxPooling2D(pool_size=(2, 2))) #Pooling. changing the dimension to 2D? #--------------Step 3 Flattening classifier.add( Flatten()) #flattening to a single array without multiple dimensions #--------------Step 4 Full connection #adding final two dense layers to reduce the layer classifier.add(Dense(units=128, activation='relu')) classifier.add(Dense(units=1, activation='sigmoid'))
def build_model(self): # Input inp = Input(shape=self.input_shape, name='input_1') x = Conv2D(32, kernel_size=3, padding='same', activation='relu')(inp) x = Conv2D(32, kernel_size=3, padding='same', activation='relu')(x) x = BatchNormalization()(x) x = MaxPool2D(pool_size=3, strides=2)(x) x = Conv2D(64, kernel_size=3, padding='same', activation='relu')(x) x = BatchNormalization()(x) x = Conv2D(64, kernel_size=3, padding='same', activation='relu')(x) x = BatchNormalization()(x) x = Conv2D(64, kernel_size=3, padding='same', activation='relu')(x) x = BatchNormalization()(x) x = MaxPool2D(pool_size=3, strides=2)(x) x = Dropout(0.3)(x) x = Conv2D(128, kernel_size=3, padding='same', activation='relu')(x) x = BatchNormalization()(x) x = Conv2D(128, kernel_size=3, padding='same', activation='relu')(x) x = BatchNormalization()(x) x = Conv2D(128, kernel_size=3, padding='same', activation='relu')(x) x = BatchNormalization()(x) x = MaxPool2D(pool_size=3, strides=2)(x) x = Dropout(0.3)(x) x = Conv2D(256, kernel_size=3, padding='same', activation='relu')(x) x = BatchNormalization()(x) x = Conv2D(256, kernel_size=3, padding='same', activation='relu')(x) x = BatchNormalization()(x) x = Conv2D(256, kernel_size=3, padding='same', activation='relu')(x) x = BatchNormalization()(x) x = MaxPool2D(pool_size=3, strides=2)(x) x = Dropout(0.3)(x) x = Flatten()(x) x = Dense(512, activation='relu')(x) x = Dropout(0.3)(x) x = Dense(512, activation='relu')(x) x = Dropout(0.3)(x) out = Dense(self.classes, activation='softmax')(x) model = Model(inputs=inp, outputs=out) #model.compile(loss='binary_crossentropy', optimizer='adam', metrics=['accuracy']) return model
def ResNet50(input_shape = (64, 64, 3), classes = 6): """ Implementation of the popular ResNet50 the following architecture: CONV2D -> BATCHNORM -> RELU -> MAXPOOL -> CONVBLOCK -> IDBLOCK*2 -> CONVBLOCK -> IDBLOCK*3 -> CONVBLOCK -> IDBLOCK*5 -> CONVBLOCK -> IDBLOCK*2 -> AVGPOOL -> TOPLAYER Arguments: input_shape -- shape of the images of the dataset classes -- integer, number of classes Returns: model -- a Model() instance in Keras """ # Define the input as a tensor with shape input_shape X_input = Input(input_shape) # Zero-Padding X = ZeroPadding2D((3, 3))(X_input) # Stage 1 X = Conv2D(64, (7, 7), strides = (2, 2), name = 'conv1', kernel_initializer = glorot_uniform(seed=0))(X) X = BatchNormalization(axis = 3, name = 'bn_conv1')(X) X = Activation('relu')(X) X = MaxPooling2D((3, 3), strides=(2, 2))(X) # Stage 2 X = convolutional_block(X, f = 3, filters = [64, 64, 256], stage = 2, block='a', s = 1) X = identity_block(X, 3, [64, 64, 256], stage=2, block='b') X = identity_block(X, 3, [64, 64, 256], stage=2, block='c') ### START CODE HERE ### # Stage 3 (≈4 lines) X = convolutional_block(X, f = 3, filters = [128,128,512], stage = 3, block='a', s = 2) X = identity_block(X, 3, [128,128,512], stage=3, block='b') X = identity_block(X, 3, [128,128,512], stage=3, block='c') X = identity_block(X, 3, [128,128,512], stage=3, block='d') # Stage 4 (≈6 lines) X = convolutional_block(X, f = 3, filters = [256, 256, 1024], stage = 4, block='a', s = 2) X = identity_block(X, 3, [256, 256, 1024], stage=4, block='b') X = identity_block(X, 3, [256, 256, 1024], stage=4, block='c') X = identity_block(X, 3, [256, 256, 1024], stage=4, block='d') X = identity_block(X, 3, [256, 256, 1024], stage=4, block='e') X = identity_block(X, 3, [256, 256, 1024], stage=4, block='f') # Stage 5 (≈3 lines) X = convolutional_block(X, f = 3, filters = [512, 512, 2048], stage = 5, block='a', s = 2) X = identity_block(X, 3,[512, 512, 2048], stage=5, block='b') X = identity_block(X, 3,[512, 512, 2048], stage=5, block='c') # AVGPOOL (≈1 line). Use "X = AveragePooling2D(...)(X)" X = AveragePooling2D(pool_size=(2,2))(X) ### END CODE HERE ### # output layer X = Flatten()(X) X = Dense(classes, activation='softmax', name='fc' + str(classes), kernel_initializer = glorot_uniform(seed=0))(X) # Create model model = Model(inputs = X_input, outputs = X, name='ResNet50') return model
def faceRecoModel(input_shape): """ Implementation of the Inception model used for FaceNet Arguments: input_shape -- shape of the images of the dataset Returns: model -- a Model() instance in Keras """ # Define the input as a tensor with shape input_shape X_input = Input(input_shape) # Zero-Padding X = ZeroPadding2D((3, 3))(X_input) # First Block X = Conv2D(64, (7, 7), strides = (2, 2), name = 'conv1')(X) X = BatchNormalization(axis = 1, name = 'bn1')(X) X = Activation('relu')(X) # Zero-Padding + MAXPOOL X = ZeroPadding2D((1, 1))(X) X = MaxPooling2D((3, 3), strides = 2)(X) # Second Block X = Conv2D(64, (1, 1), strides = (1, 1), name = 'conv2')(X) X = BatchNormalization(axis = 1, epsilon=0.00001, name = 'bn2')(X) X = Activation('relu')(X) # Zero-Padding + MAXPOOL X = ZeroPadding2D((1, 1))(X) # Second Block X = Conv2D(192, (3, 3), strides = (1, 1), name = 'conv3')(X) X = BatchNormalization(axis = 1, epsilon=0.00001, name = 'bn3')(X) X = Activation('relu')(X) # Zero-Padding + MAXPOOL X = ZeroPadding2D((1, 1))(X) X = MaxPooling2D(pool_size = 3, strides = 2)(X) # Inception 1: a/b/c X = inception_block_1a(X) X = inception_block_1b(X) X = inception_block_1c(X) # Inception 2: a/b X = inception_block_2a(X) X = inception_block_2b(X) # Inception 3: a/b X = inception_block_3a(X) X = inception_block_3b(X) # Top layer X = AveragePooling2D(pool_size=(3, 3), strides=(1, 1), data_format='channels_first')(X) X = Flatten()(X) X = Dense(128, name='dense_layer')(X) # L2 normalization X = Lambda(lambda x: K.l2_normalize(x,axis=1))(X) # Create model instance model = Model(inputs = X_input, outputs = X, name='FaceRecoModel') return model
from keras.layers import Input, Dense, Conv2D, MaxPooling2D, UpSampling2D, Flatten, Reshape (previsores_treinamento, _), (previsores_teste, _) = mnist.load_data() previsores_treinamento = previsores_treinamento.reshape( (len(previsores_treinamento), 28, 28, 1)) previsores_teste = previsores_teste.reshape((len(previsores_teste), 28, 28, 1)) previsores_treinamento = previsores_treinamento.astype('float32') / 255 previsores_teste = previsores_teste.astype('float32') / 255 autoencoder = Sequential() # Encoder autoencoder.add( Conv2D(filters=16, kernel_size=(3, 3), activation='relu', input_shape=(28, 28, 1))) autoencoder.add(MaxPooling2D(pool_size=(2, 2))) autoencoder.add( Conv2D(filters=8, kernel_size=(3, 3), activation='relu', padding='same')) autoencoder.add(MaxPooling2D(pool_size=(2, 2), padding='same')) # 4, 4, 8 autoencoder.add( Conv2D(filters=8, kernel_size=(3, 3), activation='relu', padding='same', strides=(2, 2)))
def _build_inception_model(self): #model = InceptionV3(include_top=True, weights='imagenet', input_tensor=None, input_shape=None, pooling=None, classes=1000) # create the base pre-trained model #base_model = InceptionV3(include_top=False, weights='imagenet', input_tensor=None, input_shape=state_size, pooling=None, classes=100) inputA = Input(shape=(22, 22, 1)) # add a global spatial average pooling layer tower_1 = Conv2D(64, (1, 1), padding='same', activation='relu')(inputA) tower_1 = Conv2D(64, (3, 3), padding='same', activation='relu')(tower_1) tower_2 = Conv2D(64, (1, 1), padding='same', activation='relu')(inputA) tower_2 = Conv2D(64, (5, 5), padding='same', activation='relu')(tower_2) tower_3 = MaxPooling2D((3, 3), strides=(1, 1), padding='same')(inputA) tower_3 = Conv2D(64, (1, 1), padding='same', activation='relu')(tower_3) output = keras.layers.concatenate([tower_1, tower_2, tower_3], axis=1) tower_1 = Conv2D(64, (1, 1), padding='same', activation='relu')(output) tower_1 = Conv2D(64, (3, 3), padding='same', activation='relu')(tower_1) tower_2 = Conv2D(64, (1, 1), padding='same', activation='relu')(output) tower_2 = Conv2D(64, (5, 5), padding='same', activation='relu')(tower_2) tower_3 = MaxPooling2D((3, 3), strides=(1, 1), padding='same')(output) tower_3 = Conv2D(64, (1, 1), padding='same', activation='relu')(tower_3) output = keras.layers.concatenate([tower_1, tower_2, tower_3], axis=1) # let's add a fully-connected layer output = Flatten()(output) x = Dense(16, activation='relu')(output) x = Dense(16, activation='relu')(x) x = Dense(16, activation='relu')(x) x = Model(inputA, outputs=x) inputB = Input(shape=(state_info, )) y = Dense(16, activation="relu")(inputB) y = Dense(16, activation="relu")(y) y = Model(inputs=inputB, outputs=y) combined = concatenate([x.output, y.output]) z = Dense(32, activation="relu")(combined) z = Dense(32, activation="linear")(z) # and a logistic layer -- let's say we have self.action_size classes predictions = Dense(self.action_size, activation='softmax')(z) # this is the model we will train model = Model(inputs=[inputA, inputB], outputs=predictions) model.compile(loss='mse', optimizer=Adam(lr=self.learning_rate)) model.summary return model
def get_crfrnn_model_def(): """ Returns Keras CRN-RNN model definition. Currently, only 500 x 500 images are supported. However, one can get this to work with different image sizes by adjusting the parameters of the Cropping2D layers below. """ channels, height, weight = 3, 500, 500 # Input input_shape = (height, weight, 3) img_input = Input(shape=input_shape) # Add plenty of zero padding x = ZeroPadding2D(padding=(100, 100))(img_input) # VGG-16 convolution block 1 x = Conv2D(64, (3, 3), activation='relu', padding='valid', name='conv1_1')(x) x = Conv2D(64, (3, 3), activation='relu', padding='same', name='conv1_2')(x) x = MaxPooling2D((2, 2), strides=(2, 2), name='pool1')(x) # VGG-16 convolution block 2 x = Conv2D(128, (3, 3), activation='relu', padding='same', name='conv2_1')(x) x = Conv2D(128, (3, 3), activation='relu', padding='same', name='conv2_2')(x) x = MaxPooling2D((2, 2), strides=(2, 2), name='pool2', padding='same')(x) # VGG-16 convolution block 3 x = Conv2D(256, (3, 3), activation='relu', padding='same', name='conv3_1')(x) x = Conv2D(256, (3, 3), activation='relu', padding='same', name='conv3_2')(x) x = Conv2D(256, (3, 3), activation='relu', padding='same', name='conv3_3')(x) x = MaxPooling2D((2, 2), strides=(2, 2), name='pool3', padding='same')(x) pool3 = x # VGG-16 convolution block 4 x = Conv2D(512, (3, 3), activation='relu', padding='same', name='conv4_1')(x) x = Conv2D(512, (3, 3), activation='relu', padding='same', name='conv4_2')(x) x = Conv2D(512, (3, 3), activation='relu', padding='same', name='conv4_3')(x) x = MaxPooling2D((2, 2), strides=(2, 2), name='pool4', padding='same')(x) pool4 = x # VGG-16 convolution block 5 x = Conv2D(512, (3, 3), activation='relu', padding='same', name='conv5_1')(x) x = Conv2D(512, (3, 3), activation='relu', padding='same', name='conv5_2')(x) x = Conv2D(512, (3, 3), activation='relu', padding='same', name='conv5_3')(x) x = MaxPooling2D((2, 2), strides=(2, 2), name='pool5', padding='same')(x) # Fully-connected layers converted to convolution layers x = Conv2D(4096, (7, 7), activation='relu', padding='valid', name='fc6')(x) x = Dropout(0.5)(x) x = Conv2D(4096, (1, 1), activation='relu', padding='valid', name='fc7')(x) x = Dropout(0.5)(x) x = Conv2D(21, (1, 1), padding='valid', name='score-fr')(x) # Deconvolution score2 = Conv2DTranspose(21, (4, 4), strides=2, name='score2')(x) # Skip connections from pool4 score_pool4 = Conv2D(21, (1, 1), name='score-pool4')(pool4) score_pool4c = Cropping2D((5, 5))(score_pool4) score_fused = Add()([score2, score_pool4c]) score4 = Conv2DTranspose(21, (4, 4), strides=2, name='score4', use_bias=False)(score_fused) # Skip connections from pool3 score_pool3 = Conv2D(21, (1, 1), name='score-pool3')(pool3) score_pool3c = Cropping2D((9, 9))(score_pool3) # Fuse things together score_final = Add()([score4, score_pool3c]) # Final up-sampling and cropping upsample = Conv2DTranspose(21, (16, 16), strides=8, name='upsample', use_bias=False)(score_final) upscore = Cropping2D(((31, 37), (31, 37)))(upsample) output = CrfRnnLayer(image_dims=(height, weight), num_classes=21, theta_alpha=160., theta_beta=3., theta_gamma=3., num_iterations=10, name='crfrnn')([upscore, img_input]) # Build the model model = Model(img_input, output, name='crfrnn_net') return model
import cv2 from skimage.io import imshow from keras.models import Sequential from keras.layers import Conv2D,Conv2DTranspose, Cropping2D, Dense, Activation, Dropout, Flatten,MaxPooling2D, Merge, Average from keras.preprocessing import image from keras.applications.vgg16 import VGG16, preprocess_input, decode_predictions # Number of classes n_classes = 21 input_shape = (224, 224, 3) #fcn-32s architecture #block1 FCN32 = Sequential() FCN32.add(Conv2D(64,(3, 3), activation='relu', input_shape=input_shape, padding='same',name = 'conv1_1')) FCN32.add(Conv2D(64,(3, 3), activation='relu', name = 'conv1_2',padding='same')) FCN32.add(MaxPooling2D(pool_size=(2,2), strides = (2,2), name = 'block1_pool')) #block2 FCN32.add(Conv2D(128,(3, 3), activation='relu', name = 'conv2_1',padding='same')) FCN32.add(Conv2D(128,(3, 3), activation='relu', name = 'conv2_2',padding='same')) FCN32.add(MaxPooling2D(pool_size=(2,2), strides = (2,2), name = 'block2_pool')) #block3 FCN32.add(Conv2D(256,(3, 3), activation='relu', name = 'conv3_1',padding='same')) FCN32.add(Conv2D(256,(3, 3), activation='relu', name = 'conv3_2',padding='same')) FCN32.add(Conv2D(256,(3, 3), activation='relu', name = 'conv3_3',padding='same')) FCN32.add(MaxPooling2D(pool_size=(2,2), strides = (2,2), name = 'block3_pool')) #block4
X_train = X_train.reshape(X_train.shape[0], 28, 28, 1) X_test = X_test.reshape(X_test.shape[0], 28, 28, 1) X_train = X_train.astype('float32') X_test = X_test.astype('float32') X_train /= 255 X_test /= 255 y_train = np_utils.to_categorical(y_train) y_test = np_utils.to_categorical(y_test) model = Sequential() model.add( Conv2D(32, 3, 3, activation='relu', padding='same', input_shape=(28, 28, 1))) model.add(Conv2D(32, 3, 3, activation='relu')) model.add(MaxPooling2D(pool_size=(2, 2))) model.add(Dropout(0.25)) model.add(Flatten()) model.add(Dense(128, activation='relu')) model.add(Dropout(0.25)) model.add(Dense(10, activation='softmax')) model.compile(loss='categorical_crossentropy', optimizer='adam', metrics=['accuracy'])
validation_generator = validation_datagen.flow_from_directory( validation_data_dir, color_mode='grayscale', target_size=(img_rows, img_cols), batch_size=batch_size, class_mode='categorical', shuffle=True) model = Sequential() # Block-1 model.add( Conv2D(32, (3, 3), padding='same', kernel_initializer='he_normal', input_shape=(img_rows, img_cols, 1))) model.add(Activation('elu')) model.add(BatchNormalization()) model.add( Conv2D(32, (3, 3), padding='same', kernel_initializer='he_normal', input_shape=(img_rows, img_cols, 1))) model.add(Activation('elu')) model.add(BatchNormalization()) model.add(MaxPooling2D(pool_size=(2, 2))) model.add(Dropout(0.2)) # Block-2
img = cv2.imread(DATA_PATH+"/train/Parasitized/{}".format(file)) img = cv2.resize(img,dsize=(130,130),interpolation=cv2.INTER_AREA) cv2.imwrite(os.getcwd()+"/train/1/{}".format(file),img) for file in tqdm(uni): img = cv2.imread(DATA_PATH+"/train/Uninfected/{}".format(file)) img = cv2.resize(img,dsize=(130,130),interpolation=cv2.INTER_AREA) cv2.imwrite(os.getcwd()+"/train/0/{}".format(file),img) # Deep Neural Network # In[ ]: model = Sequential() model.add(Conv2D(filters=64,kernel_size=(5,5),activation='relu',input_shape=IMG_SIZE)) model.add(Conv2D(filters=32,kernel_size=(3,3),activation='relu')) model.add(MaxPooling2D(pool_size=(2,2))) model.add(BatchNormalization()) model.add(Conv2D(filters=16,kernel_size=(5,5),activation='relu')) model.add(Conv2D(filters=8,kernel_size=(5,5),activation='relu')) model.add(MaxPooling2D(pool_size=(2,2))) model.add(BatchNormalization()) model.add(Dropout(0.5)) model.add(Conv2D(filters=4,kernel_size=(3,3),activation='relu')) model.add(MaxPooling2D(pool_size=(2,2))) model.add(BatchNormalization()) model.add(Flatten()) model.add(Dense(256,activation='relu')) model.add(Dropout(0.25))
return mushroom_files, mushroom_targets train_files, train_targets = load_dataset('data/train') valid_files, valid_targets = load_dataset('data/valid') test_files, test_targets = load_dataset('data/test') train_tensors = paths_to_tensor(train_files).astype('float32')/255 valid_tensors = paths_to_tensor(valid_files).astype('float32')/255 test_tensors = paths_to_tensor(test_files).astype('float32')/255 print(train_tensors.shape) model = Sequential() model.add(BatchNormalization(input_shape=(150, 150, 3))) model.add(Conv2D(filters=16, kernel_size=3, kernel_initializer='lecun_normal', activation='relu')) model.add(MaxPooling2D(pool_size=2)) model.add(BatchNormalization()) model.add(Conv2D(filters=32, kernel_size=3, kernel_initializer='lecun_normal', activation='relu')) model.add(MaxPooling2D(pool_size=2)) model.add(BatchNormalization()) model.add(Conv2D(filters=64, kernel_size=3, kernel_initializer='lecun_normal', activation='relu')) model.add(MaxPooling2D(pool_size=2)) model.add(BatchNormalization()) model.add(Conv2D(filters=128, kernel_size=3, kernel_initializer='lecun_normal', activation='relu')) model.add(MaxPooling2D(pool_size=2)) model.add(BatchNormalization())
def define_NN_architecture(): wavelet_inputs = Input(shape=(248, 16, 1), name='wavelet_input') rms_inputs = Input(shape=(16, ), name='rms_input') RMS_out = BatchNormalization( momentum=0.99, epsilon=0.001, center=True, scale=True, beta_initializer='zeros', gamma_initializer='ones', moving_mean_initializer='zeros', moving_variance_initializer='ones' )(rms_inputs) x = Conv2D( 32, (3, 3), padding='same', )(wavelet_inputs) x = BatchNormalization( momentum=0.99, epsilon=0.001, center=True, scale=True, beta_initializer='zeros', gamma_initializer='ones', moving_mean_initializer='zeros', moving_variance_initializer='ones' )(x) x = ReLU()(x) x_parallel = x x_parallel = MaxPooling2D((2, 2), padding='same')(x_parallel) x = Conv2D( 32, (3, 3), padding='same', )(x) x = BatchNormalization( momentum=0.99, epsilon=0.001, center=True, scale=True, beta_initializer='zeros', gamma_initializer='ones', moving_mean_initializer='zeros', moving_variance_initializer='ones' )(x) x = ReLU()(x) x = Dropout(0.5)(x) x = Conv2D( 32, (3, 3), strides=(2, 2), padding='same', )(x) x = keras.layers.concatenate([x, x_parallel], axis=3) x_parallel = x x_parallel = MaxPooling2D((2, 2), padding='same')(x_parallel) x = BatchNormalization( momentum=0.99, epsilon=0.001, center=True, scale=True, beta_initializer='zeros', gamma_initializer='ones', moving_mean_initializer='zeros', moving_variance_initializer='ones' )(x) x = ReLU()(x) x = Dropout(0.5)(x) x = Conv2D( 32, (3, 3), padding='same', )(x) x = BatchNormalization( momentum=0.99, epsilon=0.001, center=True, scale=True, beta_initializer='zeros', gamma_initializer='ones', moving_mean_initializer='zeros', moving_variance_initializer='ones' )(x) x = ReLU()(x) x = Dropout(0.5)(x) x = Conv2D( 32, (3, 3), strides=(2, 2), padding='same', )(x) x = keras.layers.concatenate([x, x_parallel], axis=3) x = Flatten()(x) x = BatchNormalization( momentum=0.99, epsilon=0.001, center=True, scale=True, beta_initializer='zeros', gamma_initializer='ones', moving_mean_initializer='zeros', moving_variance_initializer='ones' )(x) wavelet_out = ReLU()(x) combined_inputs = keras.layers.concatenate( [RMS_out, wavelet_out] ) x = Dense(120, activation='relu' )(combined_inputs) x = Dropout(0.5)(x) predictions = Dense(18, activation='softmax' )(x) model = Model(inputs=[wavelet_inputs, rms_inputs], outputs=predictions) return model
'''how many times should it repeat''' epochs = 100 '''dimensions of the images''' img_rows, img_cols = 64, 64 """Size""" TrainSize = 606 TestSize = 140 # Initialising the CNN classifier = Sequential() # Step 1 - Convolution classifier.add(Conv2D(32, (3, 3), input_shape = (img_rows, img_cols, 1), activation = 'relu')) classifier.add(Dropout(rate = 0.3)) # Step 2 - Pooling classifier.add(MaxPooling2D(pool_size = (2, 2))) # Adding a third convolutional layer classifier.add(Conv2D(64, (3, 3), activation='relu')) classifier.add(MaxPooling2D(pool_size=(2, 2))) classifier.add(Dropout(rate = 0.3)) # Step 3 - Flattening classifier.add(Flatten()) # Step 4 - Full connection classifier.add(Dense(units = 64, activation = 'relu'))
import keras from keras.models import Sequential from keras.layers import Dense, Dropout, Flatten from keras.layers import Conv2D, MaxPooling2D from keras.callbacks import TensorBoard import numpy as np import os import random # Setting up the model structure model = Sequential() model.add( Conv2D(32, (3, 3), padding='same', input_shape=(176, 200, 3), activation='relu')) model.add(MaxPooling2D(pool_size=(2, 2))) model.add(Dropout(0.2)) model.add(Conv2D(64, (3, 3), padding='same', activation='relu')) model.add(MaxPooling2D(pool_size=(2, 2))) model.add(Dropout(0.2)) model.add(Conv2D(128, (3, 3), padding='same', activation='relu')) model.add(MaxPooling2D(pool_size=(2, 2))) model.add(Dropout(0.2)) model.add(Flatten()) model.add(Dense(512, activation='relu')) model.add(Dropout(0.5))
from keras.utils.np_utils import to_categorical from keras.optimizers import SGD from keras.models import Model from keras.layers import Dense , Conv2D , MaxPooling2D , Input , Reshape from keras.layers import BatchNormalization , Dropout , regularizers , Flatten , Activation , GlobalAveragePooling2D from keras.optimizers import Adam , Adadelta , RMSprop , SGD import matplotlib.pyplot as plt import numpy as np size=96 train_x = np.load("train.npy") train_y = np.load("label.npy") train_y=to_categorical(train_y) X_train, X_test, y_train, y_test = train_test_split(train_x, train_y, test_size=0.3, random_state=0) print(X_train.shape,X_test.shape,y_train.shape,y_test.shape) input_data = Input(shape=[size ,size, 3]) conv1 = Conv2D(filters=32 , kernel_size=[3 , 3] , padding='same' , kernel_initializer='he_normal' , use_bias=True , activation='relu')(input_data) conv1 = BatchNormalization()(conv1) conv2 = Conv2D(filters=32 , kernel_size=[3 , 3] , padding='same' , kernel_initializer='he_normal' , use_bias=True , activation='relu')(conv1) conv2 = BatchNormalization()(conv2) pool1 = MaxPooling2D(pool_size=[2 ,2] , strides=[2 , 2])(conv2) pool1 = Dropout(0.1)(pool1) conv3 = Conv2D(filters=64 , kernel_size=[3 , 3] , padding='same' , kernel_initializer='he_normal' , use_bias=True , activation='relu')(pool1) conv3 = BatchNormalization()(conv3) conv4 = Conv2D(filters=64 , kernel_size=[3 , 3] , padding='same' , kernel_initializer='he_normal' , use_bias=True , activation='relu')(conv3) conv4 = BatchNormalization()(conv4) pool2 = MaxPooling2D(pool_size=[2 , 2] ,strides=[2 , 2])(conv4) pool2 = Dropout(0.1)(pool2) conv5 = Conv2D(filters=128 , kernel_size=[3 , 3] , padding='same' , kernel_initializer='he_normal' , use_bias=True , activation='relu')(pool2) conv5 = BatchNormalization()(conv5)
# dimensions of images. img_width, img_height = 64,64 train_data_dir = 'data/train' validation_data_dir = 'data/test' nb_train_samples = 25473 nb_validation_samples = 7000 epochs = 50 batch_size = 64 if K.image_data_format() == 'channels_first': input_shape = (3, img_width, img_height) else: input_shape = (img_width, img_height, 3) model = Sequential() convout1 = Conv2D(32, kernel_size=6, strides=2, input_shape=input_shape) model.add(convout1) activ1 = Activation('relu') model.add(activ1) convout2 = Conv2D(64, kernel_size=5, strides=1) model.add(convout2) activ2 = Activation('relu') model.add(activ2) pool1 = MaxPooling2D(pool_size=(3, 3), strides=1) model.add(pool1) convout3 = Conv2D(128, kernel_size=4, strides=2) model.add(convout3) activ3 = Activation('relu') model.add(activ3) convout4 = Conv2D(128, kernel_size=3, strides=1)
# Installing Keras # pip install --upgrade keras # Part 1 - Building the CNN # Importing the Keras libraries and packages from keras.models import Sequential from keras.layers import Conv2D, MaxPooling2D, Flatten, Dense, Dropout from keras.optimizers import Adam # Initialising the CNN classifier = Sequential() # Step 1 - Convolution classifier.add(Conv2D(32, (3, 3), padding = 'same', input_shape = (32, 32, 3), activation = 'relu')) # Step 2 - Pooling classifier.add(MaxPooling2D(pool_size = (2, 2))) # Adding more convolutional layers classifier.add(Conv2D(32, (3, 3), padding = 'same', activation = 'relu')) classifier.add(MaxPooling2D(pool_size = (2, 2))) classifier.add(Conv2D(64, (3, 3), padding = 'same', activation = 'relu')) classifier.add(MaxPooling2D(pool_size = (2, 2))) # Step 3 - Flattening classifier.add(Flatten()) # Step 4 - Full connection
x_test = [np.matrix(xi) for xi in x_test] pca = TruncatedSVD(n_components=10).fit(x_train) x_train = pca.transform(X_train) x_test = pca.transform(X_test) """ ############ ## Construct model ############# ## check if first part can be trained using unsupervised set. ############################### # 1. first learn representation ## get physionet data # 2. then supervised learning. model = Sequential() model.add( Conv2D(16, kernel_size=(3, 3), activation='relu', input_shape=input_shape)) model.add(Conv2D(8, (3, 3), activation='relu')) model.add(MaxPooling2D(pool_size=(2, 2))) model.add(Dropout(2)) model.add(Flatten()) model.add(Dense(8, activation='relu')) model.add(Dropout(2)) model.add(Dense(num_classes, activation='softmax')) model.compile(loss=keras.losses.categorical_crossentropy, optimizer=keras.optimizers.Adadelta(lr=0.000001), metrics=['accuracy']) model.fit(x_train, y_train, batch_size=batch_size,
def conv_block(input_tensor, kernel_size, filters, stage, block, strides=(2, 2)): '''conv_block is the block that has a conv layer at shortcut # Arguments input_tensor: input tensor kernel_size: defualt 3, the kernel size of middle conv layer at main path filters: list of integers, the nb_filters of 3 conv layer at main path stage: integer, current stage label, used for generating layer names block: 'a','b'..., current block label, used for generating layer names Note that from stage 3, the first conv layer at main path is with subsample=(2,2) And the shortcut should have subsample=(2,2) as well ''' eps = 1.1e-5 nb_filter1, nb_filter2, nb_filter3 = filters conv_name_base = 'res' + str(stage) + block + '_branch' bn_name_base = 'bn' + str(stage) + block + '_branch' scale_name_base = 'scale' + str(stage) + block + '_branch' x = Conv2D(nb_filter1, 1, 1, subsample=strides, name=conv_name_base + '2a', bias=False)(input_tensor) x = BatchNormalization(epsilon=eps, axis=bn_axis, name=bn_name_base + '2a')(x) x = Scale(axis=bn_axis, name=scale_name_base + '2a')(x) x = Activation('relu', name=conv_name_base + '2a_relu')(x) x = ZeroPadding2D((1, 1), name=conv_name_base + '2b_zeropadding')(x) x = Conv2D(nb_filter2, kernel_size, kernel_size, name=conv_name_base + '2b', bias=False)(x) x = BatchNormalization(epsilon=eps, axis=bn_axis, name=bn_name_base + '2b')(x) x = Scale(axis=bn_axis, name=scale_name_base + '2b')(x) x = Activation('relu', name=conv_name_base + '2b_relu')(x) x = Conv2D(nb_filter3, 1, 1, name=conv_name_base + '2c', bias=False)(x) x = BatchNormalization(epsilon=eps, axis=bn_axis, name=bn_name_base + '2c')(x) x = Scale(axis=bn_axis, name=scale_name_base + '2c')(x) shortcut = Conv2D(nb_filter3, 1, 1, subsample=strides, name=conv_name_base + '1', bias=False)(input_tensor) shortcut = BatchNormalization(epsilon=eps, axis=bn_axis, name=bn_name_base + '1')(shortcut) shortcut = Scale(axis=bn_axis, name=scale_name_base + '1')(shortcut) x = merge([x, shortcut], mode='sum', name='res' + str(stage) + block) x = Activation('relu', name='res' + str(stage) + block + '_relu')(x) return x