def trainCNNmodel(mfcc, label, gpu=0, cpu=4, niter=100, nstep=10, neur=16, test=0.08, num_classes=2, epoch=30, verb=0, thr=0.85, w=False): # Convolutional NN # config = tf.ConfigProto(device_count={'GPU':gpu, 'CPU':cpu}) # sess = tf.Session(config=config) # Train the model for trial in range(niter): if trial % nstep == 0: x_train, y_train, x_test, y_test, scaler, normal = prepareDataSet( mfcc, label, size=test) shapedata = (x_train.shape[1], ) x_train = np.reshape( x_train, (x_train.shape[0], mfcc.shape[1], mfcc.shape[2], 1), order='C') x_test = np.reshape(x_test, (x_test.shape[0], mfcc.shape[1], mfcc.shape[2], 1), order='C') # train the model batch_size = None nnn = neur model = Sequential() model.add( Conv2D(nnn, kernel_size=(3, 3), activation='linear', input_shape=(mfcc.shape[1], mfcc.shape[2], 1), padding='same')) model.add(LeakyReLU(alpha=0.1)) model.add(MaxPooling2D((2, 2), padding='same')) model.add(Dropout(0.25)) model.add(Conv2D(2 * nnn, (3, 3), activation='linear', padding='same')) model.add(LeakyReLU(alpha=0.1)) model.add(MaxPooling2D(pool_size=(2, 2), padding='same')) model.add(Conv2D(4 * nnn, (3, 3), activation='linear', padding='same')) model.add(LeakyReLU(alpha=0.1)) model.add(MaxPooling2D(pool_size=(2, 2), padding='same')) model.add(Dropout(0.4)) model.add(Flatten()) model.add(Dense(4 * nnn, activation='linear')) model.add(LeakyReLU(alpha=0.1)) model.add(Dropout(0.3)) model.add(Dense(num_classes, activation='softmax')) model.compile(optimizer='adam', loss='sparse_categorical_crossentropy', metrics=['accuracy']) train = model.fit(x_train, y_train, epochs=epoch, verbose=verb, validation_data=(x_test, y_test)) res = model.evaluate(x_test, y_test, verbose=0) print('loss ', res[0], 'accuracy ', res[1]) if res[1] >= thr and w == True: print('found good match ', res[1].round(3)) modelDump(model, x_train, y_train, x_test, y_test, scaler, normal, res[1], train) # sess.close() return (model, x_train, y_train, x_test, y_test, scaler, normal, res[1], train)
Conv2D(16, (3, 3), activation='relu', input_shape=(150, 150, 3), padding='same')) model.add(BatchNormalization()) model.add(Dropout(0.3)) model.add(Conv2D(32, (3, 3), activation='relu', padding='same')) model.add(BatchNormalization()) model.add(Conv2D(32, (5, 5), activation='relu', padding='same')) model.add(BatchNormalization()) model.add(Conv2D(32, (5, 5), activation='relu', padding='same')) model.add(BatchNormalization()) model.add(Conv2D(32, (5, 5), activation='relu', padding='same')) model.add(BatchNormalization()) model.add(MaxPooling2D((3, 3))) model.add(Dropout(0.3)) model.add(Flatten()) #2차원 model.add(Dense(128, activation='relu')) model.add(BatchNormalization()) model.add(Dropout(0.3)) model.add(Dense(64, activation='relu')) model.add(BatchNormalization()) model.add(Dense(32, activation='relu')) model.add(BatchNormalization()) model.add(Dropout(0.3)) model.add(Dense(1, activation='sigmoid')) from tensorflow.keras.callbacks import EarlyStopping, ReduceLROnPlateau es = EarlyStopping(monitor='loss', patience=20, mode='auto')
def generator(dir, gen = image.ImageDataGenerator(rescale=1./255), shuffle=True, batch_size=1, target_size=(24,24), class_mode='categorical'): return gen.flow_from_directory(dir, batch_size=batch_size, shuffle=shuffle, color_mode='grayscale', class_mode=class_mode, target_size=target_size) BS= 32 TS=(24,24) train_batch = generator('data/train', shuffle=True, batch_size=BS, target_size=TS) valid_batch = generator('data/valid', shuffle=True, batch_size=BS, target_size=TS) SPE = len(train_batch.classes)//BS VS = len(valid_batch.classes)//BS print("Steps per epoch: ", SPE) print("Validation steps: ", VS) model = Sequential([ Conv2D(32, kernel_size=(3, 3), activation='relu', input_shape=(24,24,1)), MaxPooling2D(pool_size=(1,1)), Conv2D(32, (3, 3), activation='relu'), MaxPooling2D(pool_size=(1,1)), #32 convolution filters used each of size 3x3 #again Conv2D(64, (3, 3), activation='relu'), MaxPooling2D(pool_size=(1, 1)), #64 convolution filters used each of size 3x3 #choose the best features via pooling #randomly turn neurons on and off to improve convergence Dropout(0.25), #flatten since too many dimensions, we only want a classification output Flatten(), #fully connected to get all relevant data
from tensorflow.keras.models import Sequential from tensorflow.keras.layers import Conv2D, MaxPooling2D, Flatten, Dropout, Dense cnn = Sequential([Conv2D(filters=100, kernel_size=(3,3), activation='relu'), MaxPooling2D(pool_size=(2,2)), Conv2D(filters=100, kernel_size=(3,3), activation='relu'), MaxPooling2D(pool_size=(2,2)), Flatten(), Dropout(0.5), Dense(50), Dense(35), Dense(2)]) cnn.compile(optimizer='adam', loss='binary_crossentropy', metrics=['acc']) import cv2 import numpy as np labels_dict={0:'No mask',1:'Mask'} color_dict={0:(0,0,255),1:(0,255,0)} imgsize = 4 #set image resize camera = cv2.VideoCapture(0) # Turn on camera # Identify frontal face classifier = cv2.CascadeClassifier(cv2.data.haarcascades + 'haarcascade_frontalface_default.xml') while True: (rval, im) = camera.read() im=cv2.flip(im,1,1) #mirrow the image imgs = cv2.resize(im, (im.shape[1] // imgsize, im.shape[0] // imgsize)) face_rec = classifier.detectMultiScale(imgs) for i in face_rec: # Overlay rectangle on face (x, y, l, w) = [v * imgsize for v in i] face_img = im[y:y+w, x:x+l]
y_train = to_categorical(y_train) y_test = to_categorical(y_test) print(y_train.shape) #(60000,10) # 2. 모델구성 from tensorflow.keras.models import Sequential, load_model from tensorflow.keras.layers import Conv2D, MaxPooling2D, Dense, Flatten, Dropout model = Sequential() model.add( Conv2D(filters=10, kernel_size=(2, 2), padding='same', strides=1, input_shape=(28, 28, 1))) model.add(MaxPooling2D(pool_size=2)) model.add(Conv2D(9, 2)) model.add(Conv2D(8, 2)) model.add(Dropout(0.2)) model.add(Flatten()) model.add(Dense(40, activation='relu')) model.add(Dense(10, activation='softmax')) # 3. 컴파일, 훈련 from tensorflow.keras.callbacks import EarlyStopping, ModelCheckpoint model.compile(loss='categorical_crossentropy', optimizer='adam', metrics=['acc']) # fit부분에서 가중치만 저장해서 compile은 명시해야함.
def _downsample(self, net: Tensor) -> Tensor: """Downsampling via max pooling""" return MaxPooling2D(pool_size=(2, 2))(net)
from tensorflow.keras.layers import Input, Conv2D, MaxPooling2D, Flatten, Dense from tensorflow.keras.models import Model from tensorflow.keras.datasets import fashion_mnist from tensorflow.keras.utils import to_categorical import numpy as np (x_train, y_train), (x_test, y_test) = fashion_mnist.load_data() x_train = np.reshape(x_train, (len(x_train), 28, 28, 1)) x_test = np.reshape(x_test, (len(x_test), 28, 28, 1)) y_train = to_categorical(y_train) y_test = to_categorical(y_test) ip = Input(shape=(28, 28, 1)) x = Conv2D(16, (3, 3), activation='relu', padding='same')(ip) x = MaxPooling2D((2, 2), padding='same')(x) x = Conv2D(32, (3, 3), activation='relu', padding='same')(x) x = MaxPooling2D((2, 2), padding='same')(x) x = Conv2D(64, (3, 3), activation='relu', padding='same')(x) x = MaxPooling2D((2, 2), padding='same')(x) x = Flatten()(x) x = Dense(512, activation='relu')(x) x = Dense(10, activation='softmax')(x) x = Model(ip, x) x.compile(optimizer='adam', loss='categorical_crossentropy', metrics=['accuracy']) x.fit(x_train, y_train, epochs=10,
img_train = np.expand_dims(img_train, axis=3) img_test = np.expand_dims(img_test, axis=3) # ================================================================= # нормалізація тренувальних і тестових відповідей # перетворення чисел (типу "4") у вектор (типу "[0, 0, 0, 0, 1, 0, 0, 0, 0, 0]") answ_train_cat = keras.utils.to_categorical(answ_train, 10) answ_test_cat = keras.utils.to_categorical(answ_test, 10) # ================================================================= # ініціалізація структури нейронки (вхідний шар, 2 приховані і вихідний + bias) # для прихованих шарів використовується функція активації ReLU, а для вихідного - SoftMax model = keras.Sequential([ Conv2D(32, (3, 3), padding='same', activation='relu', input_shape=(28, 28, 1)), MaxPooling2D((2, 2), strides=2), Flatten(input_shape=(28, 28, 1)), Dense(128, activation='relu'), Dense(128, activation='relu'), Dense(10, activation='softmax'), ]) # ================================================================= # створення моделі з певними параметрами # оптимізація навчання - алгоритм "NAdam" # функція втрат - категоріальна крос ентропія # метрика - точність model.compile(optimizer='nadam', loss='categorical_crossentropy', metrics=['accuracy']) # ================================================================= # навчання моделі і його налаштування
def SegNet(): model = Sequential() #encoder model.add( Conv2D(64, (3, 3), strides=(1, 1), input_shape=(img_w, img_h, 3), padding='same', activation='relu', data_format='channels_last')) model.add(BatchNormalization()) model.add( Conv2D(64, (3, 3), strides=(1, 1), padding='same', activation='relu')) model.add(BatchNormalization()) model.add(MaxPooling2D(pool_size=(2, 2))) #(128,128) model.add( Conv2D(128, (3, 3), strides=(1, 1), padding='same', activation='relu')) model.add(BatchNormalization()) model.add( Conv2D(128, (3, 3), strides=(1, 1), padding='same', activation='relu')) model.add(BatchNormalization()) model.add(MaxPooling2D(pool_size=(2, 2))) #(64,64) model.add( Conv2D(256, (3, 3), strides=(1, 1), padding='same', activation='relu')) model.add(BatchNormalization()) model.add( Conv2D(256, (3, 3), strides=(1, 1), padding='same', activation='relu')) model.add(BatchNormalization()) model.add( Conv2D(256, (3, 3), strides=(1, 1), padding='same', activation='relu')) model.add(BatchNormalization()) model.add(MaxPooling2D(pool_size=(2, 2))) #(32,32) model.add( Conv2D(512, (3, 3), strides=(1, 1), padding='same', activation='relu')) model.add(BatchNormalization()) model.add( Conv2D(512, (3, 3), strides=(1, 1), padding='same', activation='relu')) model.add(BatchNormalization()) model.add( Conv2D(512, (3, 3), strides=(1, 1), padding='same', activation='relu')) model.add(BatchNormalization()) model.add(MaxPooling2D(pool_size=(2, 2))) #(16,16) model.add( Conv2D(512, (3, 3), strides=(1, 1), padding='same', activation='relu')) model.add(BatchNormalization()) model.add( Conv2D(512, (3, 3), strides=(1, 1), padding='same', activation='relu')) model.add(BatchNormalization()) model.add( Conv2D(512, (3, 3), strides=(1, 1), padding='same', activation='relu')) model.add(BatchNormalization()) model.add(MaxPooling2D(pool_size=(2, 2))) #(8,8) #decoder model.add(UpSampling2D(size=(2, 2))) #(16,16) model.add( Conv2D(512, (3, 3), strides=(1, 1), padding='same', activation='relu')) model.add(BatchNormalization()) model.add( Conv2D(512, (3, 3), strides=(1, 1), padding='same', activation='relu')) model.add(BatchNormalization()) model.add( Conv2D(512, (3, 3), strides=(1, 1), padding='same', activation='relu')) model.add(BatchNormalization()) model.add(UpSampling2D(size=(2, 2))) #(32,32) model.add( Conv2D(512, (3, 3), strides=(1, 1), padding='same', activation='relu')) model.add(BatchNormalization()) model.add( Conv2D(512, (3, 3), strides=(1, 1), padding='same', activation='relu')) model.add(BatchNormalization()) model.add( Conv2D(512, (3, 3), strides=(1, 1), padding='same', activation='relu')) model.add(BatchNormalization()) model.add(UpSampling2D(size=(2, 2))) #(64,64) model.add( Conv2D(256, (3, 3), strides=(1, 1), padding='same', activation='relu')) model.add(BatchNormalization()) model.add( Conv2D(256, (3, 3), strides=(1, 1), padding='same', activation='relu')) model.add(BatchNormalization()) model.add( Conv2D(256, (3, 3), strides=(1, 1), padding='same', activation='relu')) model.add(BatchNormalization()) model.add(UpSampling2D(size=(2, 2))) #(128,128) model.add( Conv2D(128, (3, 3), strides=(1, 1), padding='same', activation='relu')) model.add(BatchNormalization()) model.add( Conv2D(128, (3, 3), strides=(1, 1), padding='same', activation='relu')) model.add(BatchNormalization()) model.add(UpSampling2D(size=(2, 2))) #(256,256) model.add( Conv2D(64, (3, 3), strides=(1, 1), input_shape=(img_w, img_h, 3), padding='same', activation='relu', data_format='channels_last')) model.add(BatchNormalization()) model.add( Conv2D(64, (3, 3), strides=(1, 1), padding='same', activation='relu')) model.add(BatchNormalization()) model.add(Conv2D(n_label, (1, 1), strides=(1, 1), padding='same')) model.add(Activation('softmax')) model.compile(loss='categorical_crossentropy', optimizer='sgd', metrics=['accuracy']) model.summary() return model
def build_unet(input_size=(256, 256, 1), n_classes=3, lr=0.0001, momentum=0.99, dropout_rate=0.5): inputs = Input(input_size) conv1 = Conv2D(64, 3, activation='relu', padding='same', kernel_initializer='he_normal')(inputs) conv1 = Conv2D(64, 3, activation='relu', padding='same', kernel_initializer='he_normal')(conv1) pool1 = MaxPooling2D(pool_size=(2, 2))(conv1) conv2 = Conv2D(128, 3, activation='relu', padding='same', kernel_initializer='he_normal')(pool1) conv2 = Conv2D(128, 3, activation='relu', padding='same', kernel_initializer='he_normal')(conv2) pool2 = MaxPooling2D(pool_size=(2, 2))(conv2) conv3 = Conv2D(256, 3, activation='relu', padding='same', kernel_initializer='he_normal')(pool2) conv3 = Conv2D(256, 3, activation='relu', padding='same', kernel_initializer='he_normal')(conv3) pool3 = MaxPooling2D(pool_size=(2, 2))(conv3) conv4 = Conv2D(512, 3, activation='relu', padding='same', kernel_initializer='he_normal')(pool3) conv4 = Conv2D(512, 3, activation='relu', padding='same', kernel_initializer='he_normal')(conv4) drop4 = Dropout(dropout_rate)(conv4) pool4 = MaxPooling2D(pool_size=(2, 2))(drop4) conv5 = Conv2D(1024, 3, activation='relu', padding='same', kernel_initializer='he_normal')(pool4) conv5 = Conv2D(1024, 3, activation='relu', padding='same', kernel_initializer='he_normal')(conv5) drop5 = Dropout(dropout_rate)(conv5) up6 = Conv2D(512, 2, activation='relu', padding='same', kernel_initializer='he_normal')(UpSampling2D(size=(2, 2))(drop5)) merge6 = Concatenate(axis=3)([drop4, up6]) conv6 = Conv2D(512, 3, activation='relu', padding='same', kernel_initializer='he_normal')(merge6) conv6 = Conv2D(512, 3, activation='relu', padding='same', kernel_initializer='he_normal')(conv6) up7 = Conv2D(256, 2, activation='relu', padding='same', kernel_initializer='he_normal')(UpSampling2D(size=(2, 2))(conv6)) merge7 = Concatenate(axis=3)([conv3, up7]) conv7 = Conv2D(256, 3, activation='relu', padding='same', kernel_initializer='he_normal')(merge7) conv7 = Conv2D(256, 3, activation='relu', padding='same', kernel_initializer='he_normal')(conv7) up8 = Conv2D(128, 2, activation='relu', padding='same', kernel_initializer='he_normal')(UpSampling2D(size=(2, 2))(conv7)) merge8 = Concatenate(axis=3)([conv2, up8]) conv8 = Conv2D(128, 3, activation='relu', padding='same', kernel_initializer='he_normal')(merge8) conv8 = Conv2D(128, 3, activation='relu', padding='same', kernel_initializer='he_normal')(conv8) up9 = Conv2D(64, 2, activation='relu', padding='same', kernel_initializer='he_normal')(UpSampling2D(size=(2, 2))(conv8)) merge9 = Concatenate(axis=3)([conv1, up9]) conv9 = Conv2D(64, 3, activation='relu', padding='same', kernel_initializer='he_normal')(merge9) conv9 = Conv2D(64, 3, activation='relu', padding='same', kernel_initializer='he_normal')(conv9) conv10 = Conv2D(n_classes, 1, activation='softmax')(conv9) model = Model(inputs, conv10) model.compile(optimizer=SGD(lr=lr, momentum=momentum), loss='categorical_crossentropy', metrics=['accuracy', dice_coef, jaccard_distance]) #model.summary() return model
def build_dcan(input_shape=(256, 256, 1), n_classes=3, lr=5e-4): inputs = Input(input_shape) conv1 = Conv2DWithBatchNorm(filters=64)(inputs) conv2 = Conv2DWithBatchNorm(filters=64)(conv1) mp1 = MaxPooling2D(pool_size=(2, 2))(conv2) conv3 = Conv2DWithBatchNorm(filters=128)(mp1) conv4 = Conv2DWithBatchNorm(filters=128)(conv3) mp2 = MaxPooling2D(pool_size=(2, 2))(conv4) conv5 = Conv2DWithBatchNorm(filters=256)(mp2) conv6 = Conv2DWithBatchNorm(filters=256)(conv5) mp3 = MaxPooling2D(pool_size=(2, 2))(conv6) conv7 = Conv2DWithBatchNorm(filters=512)(mp3) conv8 = Conv2DWithBatchNorm(filters=512)(conv7) #conv8 size should be 8 times smaller than input mp4 = MaxPooling2D(pool_size=(2, 2))(conv8) conv9 = Conv2DWithBatchNorm(filters=512)(mp4) conv10 = Conv2DWithBatchNorm(filters=512)(conv9) #conv10 size should be 16 times smaller than input mp5 = MaxPooling2D(pool_size=(2, 2))(conv10) conv11 = Conv2DWithBatchNorm(filters=1024)(mp5) conv12 = Conv2DWithBatchNorm(filters=1024)(conv11) #conv12 size should be 32 times smaller than input # Region segmentation region_upsample_1 = Conv2DWithBatchNorm( 64, name="conv2d_regions_upsample1")(UpSampling2D(size=(8, 8))(conv8)) region_upsample_1 = Dropout(0.5)(region_upsample_1) region_upsample_2 = Conv2DWithBatchNorm( 64, name="conv2d_regions_upsample2")(UpSampling2D(size=(16, 16))(conv10)) region_upsample_2 = Dropout(0.5)(region_upsample_2) region_upsample_3 = Conv2DWithBatchNorm( 64, name="conv2d_regions_upsample3")(UpSampling2D(size=(32, 32))(conv12)) region_upsample_3 = Dropout(0.5)(region_upsample_3) region_output = Concatenate()( [region_upsample_1, region_upsample_2, region_upsample_3]) region_output = Conv2D(n_classes, 1, activation="softmax", name="conv2d_regions_output")(region_output) # Region segmentation contours_upsample_1 = Conv2DWithBatchNorm( 64, name="conv2d_contours_upsample1")(UpSampling2D(size=(8, 8))(conv8)) contours_upsample_1 = Dropout(0.5)(contours_upsample_1) contours_upsample_2 = Conv2DWithBatchNorm( 64, name="conv2d_contours_upsample2")(UpSampling2D(size=(16, 16))(conv10)) contours_upsample_2 = Dropout(0.5)(contours_upsample_2) contours_upsample_3 = Conv2DWithBatchNorm( 64, name="conv2d_contours_upsample3")(UpSampling2D(size=(32, 32))(conv12)) contours_upsample_3 = Dropout(0.5)(contours_upsample_3) contours_output = Concatenate()( [contours_upsample_1, contours_upsample_2, contours_upsample_3]) contours_output = Conv2D(n_classes, 1, activation="softmax", name="contours_output")(contours_output) model = Model(inputs, [region_output, contours_output]) model.compile( optimizer=Adam(lr=lr), loss=["categorical_crossentropy", "categorical_crossentropy"], metrics=['accuracy', dice_coef, jaccard_distance]) model.summary() return model
#print(len(X)) #13:30 video print("Voy pal modelo") model = Sequential() #model.add(Flatten(input_shape=(tamano,tamano,3))) #model.add(Dense(64, activation='relu')) #model.add(MaxPooling2D(pool_size=(2, 2))) #model.add(Conv2D(46, (3, 3), activation='relu')) #model.add(MaxPooling2D()) model.add(Conv2D(32, (9, 9), input_shape=X.shape[1:], activation='relu')) model.add(MaxPooling2D()) model.add(Conv2D(64, (3, 3), activation='relu')) model.add(MaxPooling2D()) model.add(Flatten()) model.add(Dense(256, activation='relu')) model.add(Dense(6, activation='softmax')) #model.add(Conv2D(96, (3, 3), activation='relu')) #model.add(MaxPooling2D() #model.add(Conv2D(16, (3, 3), activation='softmax')) #model.add(MaxPooling2D(pool_size=(2, 2))) #model.add(Dense(96, activation='relu'))
supply_decoder = TimeDistributed( Conv2D(16, (3, 3), padding='same', activation='relu'))(supply_encoder) supply_decoder = TimeDistributed(UpSampling2D((2, 2)))(supply_decoder) supply_decoder = TimeDistributed( Conv2D(8, (3, 3), padding='same', activation='relu'))(supply_decoder) supply_decoder = TimeDistributed(UpSampling2D((2, 2)))(supply_decoder) supply_decoder = TimeDistributed( Conv2D(1, (3, 3), padding='same', activation='relu'))(supply_decoder) combine_demand_supply = concatenate([demand_reshape, supply_reshape]) lstm = LSTM(dim, return_sequences=1, input_shape=(timestep, dim * 2))(combine_demand_supply) input_aux = Input(shape=(size, size, 13)) aux_encode = Conv2D(16, (3, 3), padding='same', activation='relu')(input_aux) aux_encode = MaxPooling2D(pool_size=(2, 2))(aux_encode) aux_encode = Conv2D(32, (3, 3), padding='same', activation='relu')(aux_encode) aux_encode = MaxPooling2D(pool_size=(2, 2))(aux_encode) aux_decode = Conv2D(32, (3, 3), padding='same', activation='relu')(aux_encode) aux_decode = UpSampling2D((2, 2))(aux_decode) aux_decode = Conv2D(16, (3, 3), padding='same', activation='relu')(aux_decode) aux_decode = UpSampling2D((2, 2))(aux_decode) aux_decode = Conv2D(13, (3, 3), padding='same', activation='relu', name='autoencoder')(aux_decode) aux_dim = 32 * 4 * 4 aux = Reshape((aux_dim, ))(aux_encode) """ aux_demand = Dense(aux_dim)(aux)
(X_train, _), (X_test, _) = mnist.load_data() X_train = X_train.reshape(X_train.shape[0], 28, 28, 1).astype('float32') / 255 X_test = X_test.reshape(X_test.shape[0], 28, 28, 1).astype('float32') / 255 #생성자 모델을 만듭니다. autoencoder = Sequential() # 인코딩 부분입니다. autoencoder.add( Conv2D(16, kernel_size=3, padding='same', input_shape=(28, 28, 1), activation='relu')) autoencoder.add(MaxPooling2D(pool_size=2, padding='same')) autoencoder.add(Conv2D(8, kernel_size=3, activation='relu', padding='same')) autoencoder.add(MaxPooling2D(pool_size=2, padding='same')) autoencoder.add( Conv2D(8, kernel_size=3, strides=2, padding='same', activation='relu')) # 디코딩 부분이 이어집니다. autoencoder.add(Conv2D(8, kernel_size=3, padding='same', activation='relu')) autoencoder.add(UpSampling2D()) autoencoder.add(Conv2D(8, kernel_size=3, padding='same', activation='relu')) autoencoder.add(UpSampling2D()) autoencoder.add(Conv2D(16, kernel_size=3, activation='relu')) autoencoder.add(UpSampling2D()) autoencoder.add(Conv2D(1, kernel_size=3, padding='same', activation='sigmoid')) # 전체 구조를 확인해 봅니다.
def inception_block_1a(X): """ Implementation of an inception block """ X_3x3 = Conv2D(96, (1, 1), data_format='channels_first', name='inception_3a_3x3_conv1')(X) X_3x3 = BatchNormalization(axis=1, epsilon=0.00001, name='inception_3a_3x3_bn1')(X_3x3) X_3x3 = Activation('relu')(X_3x3) X_3x3 = ZeroPadding2D(padding=(1, 1), data_format='channels_first')(X_3x3) X_3x3 = Conv2D(128, (3, 3), data_format='channels_first', name='inception_3a_3x3_conv2')(X_3x3) X_3x3 = BatchNormalization(axis=1, epsilon=0.00001, name='inception_3a_3x3_bn2')(X_3x3) X_3x3 = Activation('relu')(X_3x3) X_5x5 = Conv2D(16, (1, 1), data_format='channels_first', name='inception_3a_5x5_conv1')(X) X_5x5 = BatchNormalization(axis=1, epsilon=0.00001, name='inception_3a_5x5_bn1')(X_5x5) X_5x5 = Activation('relu')(X_5x5) X_5x5 = ZeroPadding2D(padding=(2, 2), data_format='channels_first')(X_5x5) X_5x5 = Conv2D(32, (5, 5), data_format='channels_first', name='inception_3a_5x5_conv2')(X_5x5) X_5x5 = BatchNormalization(axis=1, epsilon=0.00001, name='inception_3a_5x5_bn2')(X_5x5) X_5x5 = Activation('relu')(X_5x5) X_pool = MaxPooling2D(pool_size=3, strides=2, data_format='channels_first')(X) X_pool = Conv2D(32, (1, 1), data_format='channels_first', name='inception_3a_pool_conv')(X_pool) X_pool = BatchNormalization(axis=1, epsilon=0.00001, name='inception_3a_pool_bn')(X_pool) X_pool = Activation('relu')(X_pool) X_pool = ZeroPadding2D(padding=((3, 4), (3, 4)), data_format='channels_first')(X_pool) X_1x1 = Conv2D(64, (1, 1), data_format='channels_first', name='inception_3a_1x1_conv')(X) X_1x1 = BatchNormalization(axis=1, epsilon=0.00001, name='inception_3a_1x1_bn')(X_1x1) X_1x1 = Activation('relu')(X_1x1) # CONCAT inception = concatenate([X_3x3, X_5x5, X_pool, X_1x1], axis=1) return inception
def XceptionCustom(input_shape, activation_name='selu', include_top=False, pooling='avg'): """customized Xception architecture. # Arguments include_top: whether to include the fully-connected layer at the top of the network. input_shape: optional shape tuple, only to be specified if `include_top` is False (otherwise the input shape has to be `(299, 299, 3)`. It should have exactly 3 inputs channels, and width and height should be no smaller than 71. E.g. `(150, 150, 3)` would be one valid value. pooling: Optional pooling mode for feature extraction when `include_top` is `False`. - `None` means that the output of the model will be the 4D tensor output of the last convolutional block. - `avg` means that global average pooling will be applied to the output of the last convolutional block, and thus the output of the model will be a 2D tensor. - `max` means that global max pooling will be applied. # Returns A Keras model instance. """ img_input = Input(shape=input_shape) # Block 1 x = Conv2D(32, (3, 3), strides=(2, 2), use_bias=False)(img_input) x = BatchNormalization()(x) x = Activation(activation_name)(x) x = Conv2D(64, (3, 3), use_bias=False)(x) x = BatchNormalization()(x) x = Activation(activation_name)(x) residual = Conv2D(128, (1, 1), strides=(2, 2), padding='same', use_bias=False)(x) residual = BatchNormalization()(residual) # Block 2 x = SeparableConv2D(128, (3, 3), padding='same', use_bias=False)(x) x = BatchNormalization()(x) x = Activation(activation_name)(x) x = SeparableConv2D(128, (3, 3), padding='same', use_bias=False)(x) x = BatchNormalization()(x) # Block 2 Pool x = MaxPooling2D((3, 3), strides=(2, 2), padding='same')(x) x = layers.add([x, residual]) residual = Conv2D(256, (1, 1), strides=(2, 2), padding='same', use_bias=False)(x) residual = BatchNormalization()(residual) # Block 3 x = Activation(activation_name)(x) x = SeparableConv2D(256, (3, 3), padding='same', use_bias=False)(x) x = BatchNormalization()(x) x = Activation(activation_name)(x) x = SeparableConv2D(256, (3, 3), padding='same', use_bias=False)(x) x = BatchNormalization()(x) # Block 3 Pool x = MaxPooling2D((3, 3), strides=(2, 2), padding='same')(x) x = layers.add([x, residual]) residual = Conv2D(728, (1, 1), strides=(2, 2), padding='same', use_bias=False)(x) residual = BatchNormalization()(residual) # Block 4 x = Activation(activation_name)(x) x = SeparableConv2D(728, (3, 3), padding='same', use_bias=False)(x) x = BatchNormalization()(x) x = Activation(activation_name)(x) x = SeparableConv2D(728, (3, 3), padding='same', use_bias=False)(x) x = BatchNormalization()(x) x = MaxPooling2D((3, 3), strides=(2, 2), padding='same')(x) x = layers.add([x, residual]) # Block 5 - 12 for i in range(8): residual = x x = Activation(activation_name)(x) x = SeparableConv2D(728, (3, 3), padding='same', use_bias=False)(x) x = BatchNormalization()(x) x = Activation(activation_name)(x) x = SeparableConv2D(728, (3, 3), padding='same', use_bias=False)(x) x = BatchNormalization()(x) x = Activation(activation_name)(x) x = SeparableConv2D(728, (3, 3), padding='same', use_bias=False)(x) x = BatchNormalization()(x) x = layers.add([x, residual]) residual = Conv2D(1024, (1, 1), strides=(2, 2), padding='same', use_bias=False)(x) residual = BatchNormalization()(residual) # Block 13 x = Activation(activation_name)(x) x = SeparableConv2D(728, (3, 3), padding='same', use_bias=False)(x) x = BatchNormalization()(x) x = Activation(activation_name)(x) x = SeparableConv2D(1024, (3, 3), padding='same', use_bias=False)(x) x = BatchNormalization()(x) # Block 13 Pool x = MaxPooling2D((3, 3), strides=(2, 2), padding='same')(x) x = layers.add([x, residual]) # Block 14 x = SeparableConv2D(1536, (3, 3), padding='same', use_bias=False)(x) x = BatchNormalization()(x) x = Activation(activation_name)(x) # Block 14 part 2 x = SeparableConv2D(2048, (3, 3), padding='same', use_bias=False)(x) x = BatchNormalization()(x) x = Activation(activation_name)(x) if include_top: x = layers.GlobalAveragePooling2D(name='avg_pool')(x) x = layers.Dense(classes, activation='softmax', name='predictions')(x) else: if pooling == 'avg': x = layers.GlobalAveragePooling2D()(x) elif pooling == 'max': x = layers.GlobalMaxPooling2D()(x) inputs = img_input # Create model model = Model(inputs, x, name='xception_custom') 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
# Importing the Keras libraries and packages from tensorflow.keras.models import Sequential from tensorflow.keras.layers import Convolution2D from tensorflow.keras.layers import MaxPooling2D from tensorflow.keras.layers import Flatten from tensorflow.keras.layers import Dense # Initialising the CNN classifier = Sequential() # Step 1 - Convolution classifier.add( Convolution2D(32, (3, 3), input_shape=(200, 200, 1), activation='relu')) # Step 2 - Pooling classifier.add(MaxPooling2D(pool_size=(2, 2))) # Adding a second convolutional layer classifier.add(Convolution2D(16, (3, 3), activation='relu')) classifier.add(MaxPooling2D(pool_size=(2, 2))) # Step 3 - Flattening classifier.add(Flatten()) # Step 4 - Full connection classifier.add(Dense(256, activation='relu')) classifier.add(Dense(128, activation='relu')) classifier.add(Dense(13, activation='softmax')) # Compiling the CNN classifier.compile(optimizer='adam',
#dim2=[] #for test_img in os.listdir('train\\'+'cat'): # img = imread('train\\cat\\'+test_img) # d1,d2,_ = img.shape # dim1.append(d1) # dim2.append(d2) #print(np.mean(dim1)) #print(np.mean(dim2)) #Mean image shape is around (356,410,3) image_shape = (356, 410, 3) img_gen = ImageDataGenerator(rescale=1 / 255) model = Sequential() model.add(Conv2D(32, (3, 3), input_shape=image_shape, activation='relu')) model.add(MaxPooling2D(2, 2)) model.add(Conv2D(64, (3, 3), activation='relu')) model.add(MaxPooling2D(2, 2)) model.add(Conv2D(64, (3, 3), activation='relu')) model.add(MaxPooling2D(2, 2)) model.add(Flatten()) model.add(Dense(256, activation='relu')) model.add(Dense(1, activation='sigmoid')) model.compile(loss='binary_crossentropy', optimizer='adam', metrics=['accuracy']) train_generator = img_gen.flow_from_directory('train', target_size=(356, 410), batch_size=16, color_mode='rgb',
def __init__(self): super(Network, self).__init__() self.drop1 = Dropout(0.25) self.drop2 = Dropout(0.25) self.dense1 = Dense(128) self.dense2 = Dense(128) self.dense3 = Dense(64) self.dense4 = Dense(64) self.act01 = Activation('relu') self.act02 = Activation('relu') self.act03 = Activation('relu') self.act04 = Activation('relu') #self.batch01=BatchNormalization() #self.batch02=BatchNormalization() self.conv1 = Conv2D(32, (3, 3)) #self.batch1=BatchNormalization() self.act1 = Activation('relu') self.max1 = MaxPooling2D((3, 3)) self.conv2 = Conv2D(64, (3, 3)) #self.batch2=BatchNormalization() self.act2 = Activation('relu') self.max2 = MaxPooling2D((3, 3)) self.conv3 = Conv2D(128, (3, 3)) #self.batch3=BatchNormalization() self.act3 = Activation('relu') self.max3 = MaxPooling2D((3, 3)) self.conv4 = Conv2D(256, (3, 3)) #self.batch4=BatchNormalization() self.act4 = Activation('relu') self.max4 = MaxPooling2D((2, 2)) self.fl1 = Flatten() self.conv5 = Conv2D(32, (3, 3)) #self.batch5=BatchNormalization() self.act5 = Activation('relu') self.max5 = MaxPooling2D((3, 3)) self.conv6 = Conv2D(64, (3, 3)) #self.batch6=BatchNormalization() self.act6 = Activation('relu') self.max6 = MaxPooling2D((3, 3)) self.conv7 = Conv2D(128, (3, 3)) #self.batch7=BatchNormalization() self.act7 = Activation('relu') self.max7 = MaxPooling2D((3, 3)) self.conv8 = Conv2D(256, (3, 3)) #self.batch8=BatchNormalization() self.act8 = Activation('relu') self.max8 = MaxPooling2D((2, 2)) self.fl2 = Flatten() self.conv9 = Conv2D(32, (3, 3)) #self.batch9=BatchNormalization() self.act9 = Activation('relu') self.max9 = MaxPooling2D((3, 3)) self.conv10 = Conv2D(64, (3, 3)) #self.batch10=BatchNormalization() self.act10 = Activation('relu') self.max10 = MaxPooling2D((3, 3)) self.conv11 = Conv2D(128, (3, 3)) #self.batch11=BatchNormalization() self.act11 = Activation('relu') self.max11 = MaxPooling2D((3, 3)) self.conv12 = Conv2D(256, (3, 3)) #self.batch12=BatchNormalization() self.act12 = Activation('relu') self.max12 = MaxPooling2D((2, 2)) self.fl3 = Flatten() self.fc = FC()
def build_model(self): # Clear Keras session K.clear_session() # Define input input_y = Input(shape=(5, 128, 128, 1), name='Input_MELSPECT') # First LFLB (local feature learning block) y = TimeDistributed(Conv2D(64, kernel_size=(3, 3), strides=(1, 1), padding='same'), name='Conv_1_MELSPECT')(input_y) y = TimeDistributed(BatchNormalization(), name='BatchNorm_1_MELSPECT')(y) y = TimeDistributed(Activation('elu'), name='Activ_1_MELSPECT')(y) y = TimeDistributed(MaxPooling2D(pool_size=(2, 2), strides=(2, 2), padding='same'), name='MaxPool_1_MELSPECT')(y) y = TimeDistributed(Dropout(0.2), name='Drop_1_MELSPECT')(y) # Second LFLB (local feature learning block) y = TimeDistributed(Conv2D(64, kernel_size=(3, 3), strides=(1, 1), padding='same'), name='Conv_2_MELSPECT')(y) y = TimeDistributed(BatchNormalization(), name='BatchNorm_2_MELSPECT')(y) y = TimeDistributed(Activation('elu'), name='Activ_2_MELSPECT')(y) y = TimeDistributed(MaxPooling2D(pool_size=(4, 4), strides=(4, 4), padding='same'), name='MaxPool_2_MELSPECT')(y) y = TimeDistributed(Dropout(0.2), name='Drop_2_MELSPECT')(y) # Third LFLB (local feature learning block) y = TimeDistributed(Conv2D(128, kernel_size=(3, 3), strides=(1, 1), padding='same'), name='Conv_3_MELSPECT')(y) y = TimeDistributed(BatchNormalization(), name='BatchNorm_3_MELSPECT')(y) y = TimeDistributed(Activation('elu'), name='Activ_3_MELSPECT')(y) y = TimeDistributed(MaxPooling2D(pool_size=(4, 4), strides=(4, 4), padding='same'), name='MaxPool_3_MELSPECT')(y) y = TimeDistributed(Dropout(0.2), name='Drop_3_MELSPECT')(y) # Fourth LFLB (local feature learning block) y = TimeDistributed(Conv2D(128, kernel_size=(3, 3), strides=(1, 1), padding='same'), name='Conv_4_MELSPECT')(y) y = TimeDistributed(BatchNormalization(), name='BatchNorm_4_MELSPECT')(y) y = TimeDistributed(Activation('elu'), name='Activ_4_MELSPECT')(y) y = TimeDistributed(MaxPooling2D(pool_size=(4, 4), strides=(4, 4), padding='same'), name='MaxPool_4_MELSPECT')(y) y = TimeDistributed(Dropout(0.2), name='Drop_4_MELSPECT')(y) # Flat y = TimeDistributed(Flatten(), name='Flat_MELSPECT')(y) # LSTM layer y = LSTM(256, return_sequences=False, dropout=0.2, name='LSTM_1')(y) # Fully connected y = Dense(8, activation='softmax', name='FC')(y) # Build final model model = Model(inputs=input_y, outputs=y) return model
def bluche(input_size, output_size, learning_rate=4e-4): """ Gated Convolucional Recurrent Neural Network by Bluche et al. Reference: Bluche, T., Messina, R.: Gated convolutional recurrent neural networks for multilingual handwriting recognition. In: Document Analysis and Recognition (ICDAR), 2017 14th IAPR International Conference on, vol. 1, pp. 646–651, 2017. URL: https://ieeexplore.ieee.org/document/8270042 Moysset, B. and Messina, R.: Are 2D-LSTM really dead for offline text recognition? In: International Journal on Document Analysis and Recognition (IJDAR) Springer Science and Business Media LLC URL: http://dx.doi.org/10.1007/s10032-019-00325-0 """ input_data = Input(name="input", shape=input_size) cnn = Reshape((input_size[0] // 2, input_size[1] // 2, input_size[2] * 4))(input_data) cnn = Conv2D(filters=8, kernel_size=(3, 3), strides=(1, 1), padding="same", activation="tanh")(cnn) cnn = Dropout(rate=0.5)(cnn) cnn = Conv2D(filters=16, kernel_size=(2, 4), strides=(2, 4), padding="same", activation="tanh")(cnn) cnn = Dropout(rate=0.5)(cnn) cnn = GatedConv2D(filters=16, kernel_size=(3, 3), strides=(1, 1), padding="same")(cnn) cnn = Conv2D(filters=32, kernel_size=(3, 3), strides=(1, 1), padding="same", activation="tanh")(cnn) cnn = Dropout(rate=0.5)(cnn) cnn = GatedConv2D(filters=32, kernel_size=(3, 3), strides=(1, 1), padding="same")(cnn) cnn = Conv2D(filters=64, kernel_size=(2, 4), strides=(2, 4), padding="same", activation="tanh")(cnn) cnn = Dropout(rate=0.5)(cnn) cnn = GatedConv2D(filters=64, kernel_size=(3, 3), strides=(1, 1), padding="same")(cnn) cnn = Conv2D(filters=128, kernel_size=(3, 3), strides=(1, 1), padding="same", activation="tanh")(cnn) cnn = Dropout(rate=0.5)(cnn) cnn = MaxPooling2D(pool_size=(1, 4), strides=(1, 4), padding="valid")(cnn) shape = cnn.get_shape() blstm = Reshape((shape[1], shape[2] * shape[3]))(cnn) blstm = Bidirectional(LSTM(units=128, return_sequences=True, dropout=0.5))(blstm) blstm = Dense(units=128, activation="tanh")(blstm) blstm = Bidirectional(LSTM(units=128, return_sequences=True, dropout=0.5))(blstm) output_data = Dense(units=output_size, activation="softmax")(blstm) optimizer = RMSprop(learning_rate=learning_rate) return (input_data, output_data, optimizer)
def UNet_4Band(shape=(None, None, 4)): # (h,w,c) ==> number of input channels is fixed = 4 # Channels -> Blue, Green, Red, NIR # Initialize input inputs = Input(shape) # Contraction path - Encoder # padding = same -> output same size as input # kernel initializer -> initialize starting weights of filter conv1 = Conv2D(64, 3, activation='relu', padding='same', kernel_initializer='random_normal')(inputs) conv1 = Conv2D(64, 3, activation='relu', padding='same', kernel_initializer='random_normal')(conv1) conv1 = BatchNormalization()(conv1) pool1 = MaxPooling2D(pool_size=(2, 2))(conv1) conv2 = Conv2D(128, 3, activation='relu', padding='same', kernel_initializer='random_normal')(pool1) conv2 = Conv2D(128, 3, activation='relu', padding='same', kernel_initializer='random_normal')(conv2) conv2 = BatchNormalization()(conv2) pool2 = MaxPooling2D(pool_size=(2, 2))(conv2) conv3 = Conv2D(256, 3, activation='relu', padding='same', kernel_initializer='random_normal')(pool2) conv3 = Conv2D(256, 3, activation='relu', padding='same', kernel_initializer='random_normal')(conv3) conv3 = BatchNormalization()(conv3) pool3 = MaxPooling2D(pool_size=(2, 2))(conv3) conv4 = Conv2D(512, 3, activation='relu', padding='same', kernel_initializer='random_normal')(pool3) conv4 = Conv2D(512, 3, activation='relu', padding='same', kernel_initializer='random_normal')(conv4) conv4 = BatchNormalization()(conv4) # Add dropouts to reduce overfitting drop4 = Dropout(0.5)(conv4) pool4 = MaxPooling2D(pool_size=(2, 2))(drop4) # Bottle Neck conv5 = Conv2D(1024, 3, activation='relu', padding='same', kernel_initializer='random_normal')(pool4) conv5 = Conv2D(1024, 3, activation='relu', padding='same', kernel_initializer='random_normal')(conv5) conv5 = BatchNormalization()(conv5) drop5 = Dropout(0.5)(conv5) # Expansive path - Decoder. Upsampling starts up6 = Conv2D(512, 2, activation='relu', padding='same', kernel_initializer='random_normal')( UpSampling2D(size=(2, 2))(drop5)) merge6 = concatenate([drop4, up6], axis=3) conv6 = Conv2D(512, 3, activation='relu', padding='same', kernel_initializer='random_normal')(merge6) conv6 = Conv2D(512, 3, activation='relu', padding='same', kernel_initializer='random_normal')(conv6) conv6 = BatchNormalization()(conv6) up7 = Conv2D(256, 2, activation='relu', padding='same', kernel_initializer='random_normal')( UpSampling2D(size=(2, 2))(conv6)) merge7 = concatenate([conv3, up7], axis=3) conv7 = Conv2D(256, 3, activation='relu', padding='same', kernel_initializer='random_normal')(merge7) conv7 = Conv2D(256, 3, activation='relu', padding='same', kernel_initializer='random_normal')(conv7) conv7 = BatchNormalization()(conv7) up8 = Conv2D(128, 2, activation='relu', padding='same', kernel_initializer='random_normal')( UpSampling2D(size=(2, 2))(conv7)) merge8 = concatenate([conv2, up8], axis=3) conv8 = Conv2D(128, 3, activation='relu', padding='same', kernel_initializer='random_normal')(merge8) conv8 = Conv2D(128, 3, activation='relu', padding='same', kernel_initializer='random_normal')(conv8) conv8 = BatchNormalization()(conv8) up9 = Conv2D(64, 2, activation='relu', padding='same', kernel_initializer='random_normal')( UpSampling2D(size=(2, 2))(conv8)) merge9 = concatenate([conv1, up9], axis=3) conv9 = Conv2D(64, 3, activation='relu', padding='same', kernel_initializer='random_normal')(merge9) conv9 = Conv2D(64, 3, activation='relu', padding='same', kernel_initializer='random_normal')(conv9) conv9 = Conv2D(16, 3, activation='relu', padding='same', kernel_initializer='random_normal')(conv9) conv9 = BatchNormalization()(conv9) # Output layer of the U-Net with a softmax activation conv10 = Conv2D(9, 1, activation='softmax')(conv9) model = Model(inputs=inputs, outputs=conv10) model.compile(optimizer=Adam(), loss='categorical_crossentropy', metrics=['accuracy']) model.summary() return model
def flor(input_size, output_size, learning_rate=5e-4): """Gated Convolucional Recurrent Neural Network by Flor.""" input_data = Input(name="input", shape=input_size) cnn = Conv2D(filters=16, kernel_size=(3, 3), strides=(2, 2), padding="same")(input_data) cnn = PReLU(shared_axes=[1, 2])(cnn) cnn = BatchNormalization(renorm=True)(cnn) cnn = FullGatedConv2D(filters=16, kernel_size=(3, 3), padding="same")(cnn) cnn = Conv2D(filters=32, kernel_size=(3, 3), strides=(1, 2), padding="same")(cnn) cnn = PReLU(shared_axes=[1, 2])(cnn) cnn = BatchNormalization(renorm=True)(cnn) cnn = FullGatedConv2D(filters=32, kernel_size=(3, 3), padding="same")(cnn) cnn = Conv2D(filters=40, kernel_size=(2, 4), strides=(2, 2), padding="same")(cnn) cnn = PReLU(shared_axes=[1, 2])(cnn) cnn = BatchNormalization(renorm=True)(cnn) cnn = FullGatedConv2D(filters=40, kernel_size=(3, 3), padding="same", kernel_constraint=MaxNorm(4, [0, 1, 2]))(cnn) cnn = Dropout(rate=0.2)(cnn) cnn = Conv2D(filters=48, kernel_size=(3, 3), strides=(1, 2), padding="same")(cnn) cnn = PReLU(shared_axes=[1, 2])(cnn) cnn = BatchNormalization(renorm=True)(cnn) cnn = FullGatedConv2D(filters=48, kernel_size=(3, 3), padding="same", kernel_constraint=MaxNorm(4, [0, 1, 2]))(cnn) cnn = Dropout(rate=0.2)(cnn) cnn = Conv2D(filters=56, kernel_size=(2, 4), strides=(2, 2), padding="same")(cnn) cnn = PReLU(shared_axes=[1, 2])(cnn) cnn = BatchNormalization(renorm=True)(cnn) cnn = FullGatedConv2D(filters=56, kernel_size=(3, 3), padding="same", kernel_constraint=MaxNorm(4, [0, 1, 2]))(cnn) cnn = Dropout(rate=0.2)(cnn) cnn = Conv2D(filters=64, kernel_size=(3, 3), strides=(1, 1), padding="same")(cnn) cnn = PReLU(shared_axes=[1, 2])(cnn) cnn = BatchNormalization(renorm=True)(cnn) cnn = MaxPooling2D(pool_size=(1, 2), strides=(1, 2), padding="valid")(cnn) shape = cnn.get_shape() bgru = Reshape((shape[1], shape[2] * shape[3]))(cnn) bgru = Bidirectional(GRU(units=128, return_sequences=True, dropout=0.5))(bgru) bgru = TimeDistributed(Dense(units=128))(bgru) bgru = Bidirectional(GRU(units=128, return_sequences=True, dropout=0.5))(bgru) output_data = TimeDistributed( Dense(units=output_size, activation="softmax"))(bgru) optimizer = RMSprop(learning_rate=learning_rate) return (input_data, output_data, optimizer)
def _main(args): config_path = os.path.expanduser(args.config_path) weights_path = os.path.expanduser(args.weights_path) assert config_path.endswith('.cfg'), '{} is not a .cfg file'.format( config_path) assert weights_path.endswith( '.weights'), '{} is not a .weights file'.format(weights_path) output_path = os.path.expanduser(args.output_path) assert output_path.endswith( '.h5'), 'output path {} is not a .h5 file'.format(output_path) output_root = os.path.splitext(output_path)[0] # Load weights and config. print('Loading weights.') weights_file = open(weights_path, 'rb') major, minor, revision = np.ndarray(shape=(3, ), dtype='int32', buffer=weights_file.read(12)) if (major * 10 + minor) >= 2 and major < 1000 and minor < 1000: seen = np.ndarray(shape=(1, ), dtype='int64', buffer=weights_file.read(8)) else: seen = np.ndarray(shape=(1, ), dtype='int32', buffer=weights_file.read(4)) print('Weights Header: ', major, minor, revision, seen) print('Parsing Darknet config.') unique_config_file = unique_config_sections(config_path) cfg_parser = configparser.ConfigParser() cfg_parser.read_file(unique_config_file) print('Creating Keras model.') input_layer = Input(shape=(None, None, 3)) prev_layer = input_layer all_layers = [] weight_decay = float(cfg_parser['net_0']['decay'] ) if 'net_0' in cfg_parser.sections() else 5e-4 count = 0 out_index = [] for section in cfg_parser.sections(): print('Parsing section {}'.format(section)) if section.startswith('convolutional'): filters = int(cfg_parser[section]['filters']) size = int(cfg_parser[section]['size']) stride = int(cfg_parser[section]['stride']) pad = int(cfg_parser[section]['pad']) activation = cfg_parser[section]['activation'] batch_normalize = 'batch_normalize' in cfg_parser[section] padding = 'same' if pad == 1 and stride == 1 else 'valid' # Setting weights. # Darknet serializes convolutional weights as: # [bias/beta, [gamma, mean, variance], conv_weights] prev_layer_shape = K.int_shape(prev_layer) weights_shape = (size, size, prev_layer_shape[-1], filters) darknet_w_shape = (filters, weights_shape[2], size, size) weights_size = np.product(weights_shape) print('conv2d', 'bn' if batch_normalize else ' ', activation, weights_shape) conv_bias = np.ndarray(shape=(filters, ), dtype='float32', buffer=weights_file.read(filters * 4)) count += filters if batch_normalize: bn_weights = np.ndarray(shape=(3, filters), dtype='float32', buffer=weights_file.read(filters * 12)) count += 3 * filters bn_weight_list = [ bn_weights[0], # scale gamma conv_bias, # shift beta bn_weights[1], # running mean bn_weights[2] # running var ] conv_weights = np.ndarray(shape=darknet_w_shape, dtype='float32', buffer=weights_file.read(weights_size * 4)) count += weights_size # DarkNet conv_weights are serialized Caffe-style: # (out_dim, in_dim, height, width) # We would like to set these to Tensorflow order: # (height, width, in_dim, out_dim) conv_weights = np.transpose(conv_weights, [2, 3, 1, 0]) conv_weights = [conv_weights] if batch_normalize else [ conv_weights, conv_bias ] # Handle activation. act_fn = None if activation == 'leaky': pass # Add advanced activation later. elif activation != 'linear': raise ValueError( 'Unknown activation function `{}` in section {}'.format( activation, section)) # Create Conv2D layer if stride > 1: # Darknet uses left and top padding instead of 'same' mode prev_layer = ZeroPadding2D(((1, 0), (1, 0)))(prev_layer) conv_layer = (Conv2D(filters, (size, size), strides=(stride, stride), kernel_regularizer=l2(weight_decay), use_bias=not batch_normalize, weights=conv_weights, activation=act_fn, padding=padding))(prev_layer) if batch_normalize: conv_layer = (BatchNormalization( weights=bn_weight_list))(conv_layer) prev_layer = conv_layer if activation == 'linear': all_layers.append(prev_layer) elif activation == 'leaky': act_layer = LeakyReLU(alpha=0.1)(prev_layer) prev_layer = act_layer all_layers.append(act_layer) elif section.startswith('route'): ids = [int(i) for i in cfg_parser[section]['layers'].split(',')] layers = [all_layers[i] for i in ids] if len(layers) > 1: print('Concatenating route layers:', layers) concatenate_layer = Concatenate()(layers) all_layers.append(concatenate_layer) prev_layer = concatenate_layer else: skip_layer = layers[0] # only one layer to route all_layers.append(skip_layer) prev_layer = skip_layer elif section.startswith('maxpool'): size = int(cfg_parser[section]['size']) stride = int(cfg_parser[section]['stride']) all_layers.append( MaxPooling2D(pool_size=(size, size), strides=(stride, stride), padding='same')(prev_layer)) prev_layer = all_layers[-1] elif section.startswith('shortcut'): index = int(cfg_parser[section]['from']) activation = cfg_parser[section]['activation'] assert activation == 'linear', 'Only linear activation supported.' all_layers.append(Add()([all_layers[index], prev_layer])) prev_layer = all_layers[-1] elif section.startswith('upsample'): stride = int(cfg_parser[section]['stride']) assert stride == 2, 'Only stride=2 supported.' all_layers.append(UpSampling2D(stride)(prev_layer)) prev_layer = all_layers[-1] elif section.startswith('yolo'): out_index.append(len(all_layers) - 1) all_layers.append(None) prev_layer = all_layers[-1] elif section.startswith('net'): pass else: raise ValueError( 'Unsupported section header type: {}'.format(section)) # Create and save model. if len(out_index) == 0: out_index.append(len(all_layers) - 1) model = Model(inputs=input_layer, outputs=[all_layers[i] for i in out_index]) print(model.summary()) if args.weights_only: model.save_weights('{}'.format(output_path)) print('Saved Keras weights to {}'.format(output_path)) else: model.save('{}'.format(output_path)) print('Saved Keras model to {}'.format(output_path)) # Check to see if all weights have been read. remaining_weights = len(weights_file.read()) / 4 weights_file.close() print('Read {} of {} from Darknet weights.'.format( count, count + remaining_weights)) if remaining_weights > 0: print('Warning: {} unused weights'.format(remaining_weights)) if args.plot_model: plot(model, to_file='{}.png'.format(output_root), show_shapes=True) print('Saved model plot to {}.png'.format(output_root))
def puigcerver(input_size, output_size, learning_rate=3e-4): """ Convolucional Recurrent Neural Network by Puigcerver et al. Reference: Puigcerver, J.: Are multidimensional recurrent layers really necessary for handwritten text recognition? In: Document Analysis and Recognition (ICDAR), 2017 14th IAPR International Conference on, vol. 1, pp. 67–72. IEEE (2017) """ input_data = Input(name="input", shape=input_size) cnn = Conv2D(filters=16, kernel_size=(3, 3), strides=(1, 1), padding="same")(input_data) cnn = BatchNormalization()(cnn) cnn = LeakyReLU(alpha=0.01)(cnn) cnn = MaxPooling2D(pool_size=(2, 2), strides=(2, 2), padding="valid")(cnn) cnn = Conv2D(filters=32, kernel_size=(3, 3), strides=(1, 1), padding="same")(cnn) cnn = BatchNormalization()(cnn) cnn = LeakyReLU(alpha=0.01)(cnn) cnn = MaxPooling2D(pool_size=(2, 2), strides=(2, 2), padding="valid")(cnn) cnn = Dropout(rate=0.2)(cnn) cnn = Conv2D(filters=48, kernel_size=(3, 3), strides=(1, 1), padding="same")(cnn) cnn = BatchNormalization()(cnn) cnn = LeakyReLU(alpha=0.01)(cnn) cnn = MaxPooling2D(pool_size=(2, 2), strides=(2, 2), padding="valid")(cnn) cnn = Dropout(rate=0.2)(cnn) cnn = Conv2D(filters=64, kernel_size=(3, 3), strides=(1, 1), padding="same")(cnn) cnn = BatchNormalization()(cnn) cnn = LeakyReLU(alpha=0.01)(cnn) cnn = Dropout(rate=0.2)(cnn) cnn = Conv2D(filters=80, kernel_size=(3, 3), strides=(1, 1), padding="same")(cnn) cnn = BatchNormalization()(cnn) cnn = LeakyReLU(alpha=0.01)(cnn) shape = cnn.get_shape() blstm = Reshape((shape[1], shape[2] * shape[3]))(cnn) blstm = Bidirectional(LSTM(units=256, return_sequences=True, dropout=0.5))(blstm) blstm = Bidirectional(LSTM(units=256, return_sequences=True, dropout=0.5))(blstm) blstm = Bidirectional(LSTM(units=256, return_sequences=True, dropout=0.5))(blstm) blstm = Bidirectional(LSTM(units=256, return_sequences=True, dropout=0.5))(blstm) blstm = Bidirectional(LSTM(units=256, return_sequences=True, dropout=0.5))(blstm) blstm = Dropout(rate=0.5)(blstm) output_data = Dense(units=output_size, activation="softmax")(blstm) optimizer = RMSprop(learning_rate=learning_rate) return (input_data, output_data, optimizer)
target_size=(48, 48), batch_size=64, color_mode='grayscale', class_mode='categorical') test_generator = val_datagen.flow_from_directory(test_dir, target_size=(48, 48), batch_size=64, color_mode='grayscale', class_mode='categorical') #Defining the model architecture...Using a Dropout layers to reduce overfitting. model = Sequential([ Conv2D(32, (3, 3), activation='relu', input_shape=(48, 48, 1)), Conv2D(64, (3, 3), activation='relu'), BatchNormalization(), MaxPooling2D(2, 2), Dropout(0.25), Conv2D(128, (3, 3), activation='relu'), Conv2D(128, (3, 3), activation='relu'), BatchNormalization(), MaxPooling2D(2, 2), Dropout(0.25), Conv2D(256, (3, 3), activation='relu'), Flatten(), Dense(1024, activation='relu'), Dropout(0.5), Dense(7, activation='softmax') ]) #Compiling the model with Adam Optimizer model.compile(loss='categorical_crossentropy',
def pooling_func(x): if pooltype == 1: return AveragePooling2D((2, 2), strides=(2, 2))(x) else: return MaxPooling2D((2, 2), strides=(2, 2))(x)
testGen = valAug.flow_from_directory( TEST_PATH, class_mode="categorical", target_size=(150, 150), color_mode="rgb", shuffle=False, batch_size=BS ) # if os.path.exists('{}.meta'.format(MODEL_NAME)): # model.load(MODEL_NAME) # print('model loaded!') # else: model = Sequential() model.add(Conv2D(16, kernel_size=(3, 3), strides=(1, 1), activation='relu', input_shape=(150, 150, 3))) model.add(MaxPooling2D(pool_size=(2,2))) model.add(Conv2D(32, kernel_size=(3, 3), activation='relu')) model.add(MaxPooling2D(pool_size=(2,2))) model.add(Conv2D(32, kernel_size=(3, 3), activation='relu')) model.add(Conv2D(32, kernel_size=(5, 5), activation='relu')) model.add(MaxPooling2D(pool_size=(2,2))) model.add(Conv2D(64, kernel_size=(5, 5), activation='relu')) model.add(Conv2D(64, kernel_size=(5, 5), activation='relu')) model.add(MaxPooling2D(pool_size=(2,2))) model.add(Flatten()) model.add(Dense(128, activation='relu')) model.add(Dense(2, activation='softmax'))
def build_model(hyper_params, input_shape=(const.HEIGHT, const.LENGTH, 1), num_classes=const.N_CLASSES, num_subclasses=const.N_SUBCLASSES): print('Building model...') #input layer visible = Input(shape=input_shape) #classification layers #encoder conv0 = Conv2D(16, kernel_size=hyper_params['conv_size'], padding='same', activation='relu')(visible) pool1 = MaxPooling2D((2, 2), padding='same')(conv0) conv1 = Conv2D(32, kernel_size=hyper_params['conv_size'], padding='same', activation='relu')(pool1) pool2 = MaxPooling2D((2, 2), padding='same')(conv1) conv2 = Conv2D(64, kernel_size=hyper_params['conv_size'], padding='same', activation='relu')(pool2) pool3 = MaxPooling2D((2, 2), padding='same')(conv2) #decoder conv3 = Conv2D(64, kernel_size=hyper_params['conv_size'], padding='same', activation='relu')(pool3) unpool1 = UpSampling2D((2, 2))(conv3) conv4 = Conv2D(32, kernel_size=hyper_params['conv_size'], padding='same', activation='relu')(unpool1) unpool2 = UpSampling2D((2, 2))(conv4) conv5 = Conv2D(16, kernel_size=hyper_params['conv_size'], padding='same', activation='relu')(unpool2) unpool2 = UpSampling2D((2, 2))(conv5) conv6 = Conv2D(1, kernel_size=hyper_params['conv_size'], padding='same', activation='sigmoid')(unpool2) dropout = Dropout(hyper_params['dropout_rate'])(conv6) flatten = Flatten()(dropout) #classes output classes_output = Dense(num_classes, activation='softmax')(flatten) #subclasses_output dense1 = Dense(hyper_params['hidden_size'])(flatten) dense2 = Dense(hyper_params['hidden_size'] / 2)(dense1) dense3 = Dense(hyper_params['hidden_size'] / 4)(dense2) subclasses_output = Dense(num_subclasses, activation='softmax')(dense3) model = Model(inputs=visible, outputs=[classes_output, subclasses_output]) # summarize layers print(model.summary()) # plot graph # plot_model(model, to_file='multiple_outputs.png') if hyper_params['optimizer'] == 'Adam': optimizer = keras.optimizers.Adam(lr=hyper_params['learning_rate']) else: optimizer = keras.optimizers.SGD(lr=hyper_params['learning_rate'], momentum=0.9) model.compile(loss=keras.losses.categorical_crossentropy, optimizer=optimizer, metrics=[keras.metrics.categorical_accuracy]) return model