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
