def advanced_autoencoder(x_in, x, epochs, batch_size, activations, depth, neurons):
sess = tf.Session(graph=tf.get_default_graph(), config=session_conf)
K.set_session(sess)
num_stock = len(x_in.columns)
# activation functions
if activations == 'elu':
function = ELU(alpha=1.0)
elif activations == 'lrelu':
function = LeakyReLU(alpha=0.1)
else:
function = ReLU(max_value=None, negative_slope=0.0, threshold=0.0)
autoencoder = Sequential()
# encoding layers of desired depth
for n in range(1, depth + 1):
# input layer
if n == 1:
# autoencoder.add(GaussianNoise(stddev=0.01, input_shape=(num_stock,)))
autoencoder.add(Dense(int(neurons / n), input_shape=(num_stock,)))
autoencoder.add(function)
else:
autoencoder.add(Dense(int(neurons / n)))
autoencoder.add(function)
# decoding layers of desired depth
for n in range(depth, 1, -1):
autoencoder.add(Dense(int(neurons / (n - 1))))
autoencoder.add(function)
# output layer
autoencoder.add(Dense(num_stock, activation='linear'))
# autoencoder.compile(optimizer='sgd', loss='mean_absolute_error', metrics=['accuracy'])
autoencoder.compile(optimizer='adam', loss='mean_squared_error', metrics=['accuracy'])
# checkpointer = ModelCheckpoint(filepath='weights.{epoch:02d}-{val_loss:.2f}.txt', verbose=0, save_best_only=True)
earlystopper = EarlyStopping(monitor='val_loss', min_delta=0, patience=10, verbose=0, mode='auto', baseline=None,
restore_best_weights=True)
history = autoencoder.fit(x_in, x_in, epochs=epochs, batch_size=batch_size, \
shuffle=False, validation_split=0.15, verbose=0, callbacks=[earlystopper])
# errors = np.add(autoencoder.predict(x_in),-x_in)
y = autoencoder.predict(x)
# saving results of error distribution tests
# A=np.zeros((5))
# A[0]=chi2test(errors)
# A[1]=pesarantest(errors)
# A[2]=portmanteau(errors,1)
# A[3]=portmanteau(errors,3)
# A[4]=portmanteau(errors,5)
# autoencoder.summary()
# plot accuracy and loss of autoencoder
# plot_accuracy(history)
# plot_loss(history)
# plot original, encoded and decoded data for some stock
# plot_two_series(x_in, 'Original data', auto_data, 'Reconstructed data')
# the histogram of the data
# make_histogram(x_in, 'Original data', auto_data, 'Reconstructed data')
# CLOSE TF SESSION
K.clear_session()
return y
def _cnn(imgs_dim, compile_=True):
model = Sequential()
model.add(_convolutional_layer(nb_filter=16, input_shape=imgs_dim))
model.add(BatchNormalization(axis=-1))
model.add(ReLU())
model.add(_convolutional_layer(nb_filter=16))
model.add(BatchNormalization(axis=-1))
model.add(ReLU())
model.add(MaxPooling2D(pool_size=(2, 2)))
model.add(_convolutional_layer(nb_filter=16))
model.add(BatchNormalization(axis=-1))
model.add(ReLU())
model.add(MaxPooling2D(pool_size=(2, 2)))
"""
model.add(_convolutional_layer(nb_filter=32))
model.add(BatchNormalization(axis=-1))
model.add(ReLU())
model.add(_convolutional_layer(nb_filter=32))
model.add(BatchNormalization(axis=-1))
model.add(ReLU())
"""
model.add(_convolutional_layer(nb_filter=32))
model.add(BatchNormalization(axis=-1))
model.add(ReLU())
model.add(MaxPooling2D(pool_size=(2, 2)))
"""
model.add(_convolutional_layer(nb_filter=64))
model.add(BatchNormalization(axis=-1))
model.add(ReLU()
model.add(_convolutional_layer(nb_filter=64))
model.add(BatchNormalization(axis=-1))
model.add(ReLU())
model.add(_convolutional_layer(nb_filter=64))
model.add(BatchNormalization(axis=-1))
model.add(ReLU())
model.add(MaxPooling2D(pool_size=(2, 2)))
model.add(_convolutional_layer(nb_filter=128))
model.add(BatchNormalization(axis=-1))
model.add(ReLU())
model.add(_convolutional_layer(nb_filter=128))
model.add(BatchNormalization(axis=-1))
model.add(ReLU())
"""
model.add(_convolutional_layer(nb_filter=128))
model.add(BatchNormalization(axis=-1))
model.add(ReLU())
model.add(MaxPooling2D(pool_size=(2, 2)))
"""
model.add(_convolutional_layer(nb_filter=256))
model.add(BatchNormalization(axis=-1))
model.add(ReLU())
model.add(_convolutional_layer(nb_filter=256))
model.add(BatchNormalization(axis=-1))
model.add(ReLU())
"""
model.add(_convolutional_layer(nb_filter=256))
model.add(BatchNormalization(axis=-1))
model.add(ReLU())
model.add(MaxPooling2D(pool_size=(2, 2)))
model.add(Dropout(rate=0.5))
model.add(Flatten())
model.add(_dense_layer(output_dim=PENULTIMATE_SIZE))
model.add(BatchNormalization())
model.add(ReLU())
model.add(_dense_layer(output_dim=PENULTIMATE_SIZE))
model.add(BatchNormalization())
model.add(ReLU())
if compile_:
model.add(Dropout(rate=0.5))
model.add(_dense_layer(output_dim=SOFTMAX_SIZE))
model.add(BatchNormalization())
model.add(Activation(activation='softmax'))
return compile_model(model)
return model
def train(self, tr_x, tr_y, va_x=None, va_y=None):
# データのセット・スケーリング
self.scaler = StandardScaler().fit(tr_x)
tr_x = self.scaler.transform(tr_x)
# tr_y = np_utils.to_categorical(tr_y)
validation = va_x is not None
if validation:
va_x = self.scaler.transform(va_x)
# va_y = np_utils.to_categorical(va_y)
# パラメータ
num_classes = self.params["num_classes"]
input_dropout = self.params['input_dropout']
hidden_layers = int(self.params['hidden_layers'])
hidden_units = int(self.params['hidden_units'])
hidden_activation = self.params['hidden_activation']
hidden_dropout = self.params['hidden_dropout']
batch_norm = self.params['batch_norm']
output_activation = self.params["output_activation"]
optimizer_type = self.params['optimizer']['type']
optimizer_lr = self.params['optimizer']['lr']
loss = self.params['loss']
metrics = self.params['metrics']
batch_size = int(self.params['batch_size'])
# モデルの構築
self.model = Sequential()
# 入力層
self.model.add(Dropout(input_dropout, input_shape=(tr_x.shape[1], )))
# 中間層
for i in range(hidden_layers):
self.model.add(Dense(hidden_units))
if batch_norm == 'before_act':
self.model.add(BatchNormalization())
if hidden_activation == 'prelu':
self.model.add(PReLU())
elif hidden_activation == 'relu':
self.model.add(ReLU())
else:
raise NotImplementedError
self.model.add(Dropout(hidden_dropout))
# 出力層
self.model.add(Dense(num_classes, activation=output_activation))
# オプティマイザ
if optimizer_type == 'sgd':
optimizer = SGD(lr=optimizer_lr,
decay=1e-6,
momentum=0.9,
nesterov=True)
elif optimizer_type == 'adam':
optimizer = Adam(lr=optimizer_lr,
beta_1=0.9,
beta_2=0.999,
decay=0.)
else:
raise NotImplementedError
# 目的関数、評価指標などの設定
self.model.compile(loss=loss, optimizer=optimizer, metrics=metrics)
# エポック数、アーリーストッピング、学習の実行
# あまりepochを大きくすると、小さい学習率のときに終わらないことがあるので注意
nb_epoch = 1000
patience = 100
if validation:
early_stopping = EarlyStopping(monitor='val_loss',
patience=patience,
restore_best_weights=True)
history = self.model.fit(tr_x,
tr_y,
epochs=nb_epoch,
batch_size=batch_size,
verbose=0,
validation_data=(va_x, va_y),
callbacks=[early_stopping])
else:
self.model.fit(tr_x,
tr_y,
nb_epoch=nb_epoch,
batch_size=batch_size,
verbose=0)
hists.append(pd.DataFrame(history.history))
from keras.layers.normalization import BatchNormalization from keras.layers.advanced_activations import LeakyReLU,ReLU from keras.optimizers import RMSprop, Adam from keras.models import Model, Sequential """Use a neuro-network.""" sentence_input = Input(shape=(768,1), name='sentence_input') droprate = 0.3 dimension = 128 x = Dense(dimension)(sentence_input) x = Dropout(droprate)(x) # x = LeakyReLU(alpha=0.01)(x) x = ReLU()(x) x = Bidirectional(LSTM(dimension, return_sequences=True, activation='tanh'))(x) x = Bidirectional(LSTM(dimension, return_sequences=False, activation='tanh'))(x) x = Dropout(droprate)(x) x = Dense(dimension)(x) x = ReLU()(x) output = Dense(1, activation='softmax')(x) discriminator = Model(sentence_input ,output) discriminator.summary() optimizer = Adam(lr=0.001) discriminator.compile(optimizer=optimizer, loss='binary_crossentropy', metrics=['accuracy'])
def main():
import pynvml
pynvml.nvmlInit()
# 这里的0是GPU id
handle2 = pynvml.nvmlDeviceGetHandleByIndex(2)
handle3 = pynvml.nvmlDeviceGetHandleByIndex(3)
# meminfo = pynvml.nvmlDeviceGetMemoryInfo(handle)
# print(meminfo.used)
parser = argparse.ArgumentParser(
description='simple 3D convolution for action recognition')
parser.add_argument('--batch', type=int, default=128)
parser.add_argument('--epoch', type=int, default=100)
parser.add_argument('--videos',
type=str,
default='UCF101',
help='directory where videos are stored')
parser.add_argument('--nclass', type=int, default=101)
parser.add_argument('--output', type=str, required=True)
parser.add_argument('--color', type=bool, default=False)
parser.add_argument('--skip', type=bool, default=True)
parser.add_argument('--depth', type=int, default=10)
parser.add_argument('--dataset', type=str, default='ucf101')
args = parser.parse_args()
img_rows, img_cols, frames = 64, 64, args.depth
channel = 3 if args.color else 1
fname_npz = 'dataset_{}_{}_{}_{}.npz'.format(args.dataset, args.nclass,
args.depth, args.skip)
vid3d = videoto3d.Videoto3D(img_rows, img_cols, frames, args.dataset)
nb_classes = args.nclass
if os.path.exists(fname_npz):
loadeddata = np.load(fname_npz)
X, Y = loadeddata["X"], loadeddata["Y"]
else:
x, y = loaddata(args.videos, vid3d, args.nclass, args.output,
args.dataset, frames, args.color, args.skip)
X = x.reshape((x.shape[0], img_rows, img_cols, frames, channel))
Y = np_utils.to_categorical(y, nb_classes)
X = X.astype('float32')
np.savez(fname_npz, X=X, Y=Y)
print('Saved dataset to dataset.npz.')
print('X_shape:{}\nY_shape:{}'.format(X.shape, Y.shape))
# Define model
# conv3D + Relu + Conv3D + Softmax + Pooling3D + DropOut
input_x = Input(shape=(img_rows, img_cols, frames, channel))
#
# # C3D-conv1
# convLayer = Conv3D(32, kernel_size= (3, 3, 3),padding='same')(input_x)
# convLayer = ReLU()(convLayer)
#
# convLayer = Conv3D(32, kernel_size= (3, 3, 3), padding='same')(convLayer)
# convLayer = Softmax()(convLayer)
# convLayer = MaxPooling3D(pool_size=(3,3,3), padding='same')(convLayer)
# convLayer = Dropout(0.25)(convLayer)
#
# # C3D-conv2
# convLayer = Conv3D(64, kernel_size= (3, 3, 3),padding='same')(convLayer)
# convLayer = ReLU()(convLayer)
#
# convLayer = Conv3D(64, kernel_size= (3, 3, 3), padding='same')(convLayer)
# convLayer = Softmax()(convLayer)
# convLayer = MaxPooling3D(pool_size=(3,3,3), padding='same')(convLayer)
# convLayer = Dropout(0.25)(convLayer)
#
#
# maskLayer = Conv3D(64*frames, kernel_size=(3,3,2), padding='same')(convLayer)
# maskLayer = Lambda(mean_filter)(maskLayer) # [None,1, 64], each point represent a mask of input region of 8x8 points
# # maskLayer = BatchNormalization()(maskLayer)
# maskLayer = Lambda(K.sigmoid)(maskLayer)
# # maskLayer = ReLU()(maskLayer)
# # maskLayer = Lambda(bi_trans, arguments={'th':0.5})(maskLayer)
# maskLayer = Reshape(( 8, 8, frames, 1))(maskLayer) #reshape_filter(maskLayer, shape=[None,8,8,1,1])
# # maskLayer = Lambda(normalize)(maskLayer)
# maskLayerForLoss = maskLayer
# maskLayer = Lambda(repeat_filter,arguments={'rep':8, 'axis':1})(maskLayer)
# maskLayer = Lambda(repeat_filter,arguments={'rep':8, 'axis':2})(maskLayer)
# # maskLayer = Lambda(repeat_filter,arguments={'rep':frames, 'axis':3})(maskLayer)
# maskLayer = Lambda(repeat_filter,arguments={'rep':channel, 'axis':4})(maskLayer)
#
# # maskLayer = Lambda(repeat_filter,arguments={'rep':2, 'axis':3})(maskLayer)
# # maskLayer = Lambda(repeat_filter,arguments={'rep':64, 'axis':4})(maskLayer)
#
#
# convLayer = Multiply()([maskLayer,input_x])
#
#
# C3D-conv1
convLayer = Conv3D(32, kernel_size=(3, 3, 3), padding='same')(input_x)
convLayer = ReLU()(convLayer)
convLayer = Conv3D(32, kernel_size=(3, 3, 3), padding='same')(convLayer)
convLayer = Softmax()(convLayer)
convLayer = MaxPooling3D(pool_size=(3, 3, 3), padding='same')(convLayer)
convLayer = Dropout(0.25)(convLayer)
# C3D-conv2
convLayer = Conv3D(64, kernel_size=(3, 3, 3), padding='same')(convLayer)
convLayer = ReLU()(convLayer)
convLayer = Conv3D(64, kernel_size=(3, 3, 3), padding='same')(convLayer)
convLayer = Softmax()(convLayer)
convLayer = MaxPooling3D(pool_size=(3, 3, 3), padding='same')(convLayer)
convLayer = Dropout(0.25)(convLayer)
fc1 = Flatten()(convLayer)
fc = Dense(512, activation='sigmoid')(fc1)
fc = Dropout(0.5)(fc)
dense_out = Dense(nb_classes, activation='softmax')(fc)
dense_out_converse = Dense(nb_classes)(fc)
# model = Model(input_x, [dense_out, dense_out_converse])
model = Model(input_x, [dense_out, dense_out_converse])
# loss of 2 parts
losses = {'dense_2': K.categorical_crossentropy, 'dense_3': unlikely_loss}
lossWeights = {'dense_2': 1, 'dense_3': 1}
model.compile(loss=losses,
loss_weights=lossWeights,
optimizer=Adam(lr=0.001),
metrics=['accuracy'])
# model.compile(loss=categorical_crossentropy, optimizer=Adam(lr=0.001),metrics=['accuracy'])
model.summary()
plot_model(model,
show_shapes=True,
to_file=os.path.join(args.output, 'model.png'))
X_train, X_test, Y_train, Y_test = train_test_split(X,
Y,
test_size=0.1,
random_state=43)
X_train, X_val, Y_train, Y_val = train_test_split(X_train,
Y_train,
test_size=0.1,
random_state=43)
# history = model.fit_generator(myGenerator(X_train, X_test, Y_train, Y_test, nb_classes, args.batch),
# samples_per_epoch=X_train.shape[0], epochs=args.epoch, verbose=1,
# callbacks=callbacks_list,
# shuffle=True)
# check GPUs status , once a GPU is available, change os environment parameters and break
# is none of the GPUs are ready ,sleep for 2 secs and retry.
cnt = 0
while True:
cnt += 1
processinfo = pynvml.nvmlDeviceGetComputeRunningProcesses(handle2)
if len(processinfo) == 0:
os.environ['CUDA_VISIBLE_DEVICES'] = '2'
print('GPU 2 is available, use GPU 2\n')
break
processinfo = pynvml.nvmlDeviceGetComputeRunningProcesses(handle3)
if len(processinfo) == 0:
os.environ['CUDA_VISIBLE_DEVICES'] = '3'
print('GPU 3 is available, use GPU 3\n')
break
sleep(2)
print('\rretry time: {}'.format(cnt), end='')
history = model.fit(X_train, [Y_train, Y_train],
validation_data=(X_val, [Y_val, Y_val]),
batch_size=args.batch,
epochs=args.epoch,
verbose=1,
shuffle=True)
# history = model.fit(X_train, Y_train,
# validation_data=(X_val, Y_val),
# batch_size=args.batch,
# epochs=args.epoch, verbose=1, shuffle=True)
# loss, acc = model.evaluate(X_test, Y_test, verbose=0)
model_json = model.to_json()
if not os.path.isdir(args.output):
os.makedirs(args.output)
with open(
os.path.join(
args.output, '{}_{}_{}_ucf101_3dcnnmodel.json'.format(
current_time, nb_classes, args.depth)), 'w') as json_file:
json_file.write(model_json)
model.save_weights(
os.path.join(
args.output,
'{}_{}_{}_ucf101_3dcnnmodel.hd5'.format(current_time, nb_classes,
args.depth)))
loss = model.evaluate(X_test, [Y_test, Y_test], verbose=0)
# loss, acc = model.evaluate(X_test, Y_test, verbose=0)
print('Test loss:', loss)
plot_history(history, args.output)
save_history(history, args.output)
print('Test loss:', loss)
def BN_CONV(self, x, FNum, FSize, strides=(1, 1)):
# The activation is relu default(it will add other activation in future)
x = Conv2D(FNum, FSize, padding='same', strides=strides)(x)
x = BatchNormalization()(x)
x = ReLU()(x)
return x
def uk(layer_input, filters, f_size=3, i_norm=True) :
d = Deconv2D(filters, kernel_size=f_size, padding="valid")(layer_input)
if i_norm == True:
d = InstanceNormalization()(d)
d = ReLU()(d)
return d
def relu6(x):
# return K.relu(x, max_value=6)
return ReLU(max_value=6)(x)
import matplotlib.pyplot as plt import glob from keras.preprocessing.image import load_img, array_to_img, img_to_array, ImageDataGenerator from keras.utils import multi_gpu_model import shutil import os from tensorflow.keras.preprocessing.image import img_to_array, array_to_img generator_ = Sequential() generator_.add(Dense(256 * 7 * 7, input_dim=100)) generator_.add(Reshape((7, 7, 256))) generator_.add(Conv2DTranspose(1024, 4, strides=1, padding='same')) generator_.add(BatchNormalization(momentum=0.1, epsilon=1e-05)) generator_.add(ReLU()) generator_.add(Conv2DTranspose(512, 4, strides=2, padding='same')) generator_.add(BatchNormalization(momentum=0.1, epsilon=1e-05)) generator_.add(ReLU()) generator_.add(Conv2DTranspose(256, 4, strides=2, padding='same')) generator_.add(BatchNormalization(momentum=0.1, epsilon=1e-05)) generator_.add(ReLU()) generator_.add(Conv2DTranspose(128, 4, strides=2, padding='same')) generator_.add(BatchNormalization(momentum=0.1, epsilon=1e-05)) generator_.add(ReLU()) generator_.add(Conv2DTranspose(64, 4, strides=2, padding='same')) generator_.add(BatchNormalization(momentum=0.1, epsilon=1e-05))
def dk(layer_input, filters, f_size=3, i_norm=True) :
d = Conv2D(filters, kernel_size=f_size, strides=2, padding="same")(layer_input)
if i_norm == True :
d = InstanceNormalization()(d)
d = ReLU()(d)
return d
def fit(self, tr_x, tr_y, va_x, va_y):
# 매개변수
input_dropout = self.params['input_dropout']
hidden_layers = int(self.params['hidden_layers'])
hidden_units = int(self.params['hidden_units'])
hidden_activation = self.params['hidden_activation']
hidden_dropout = self.params['hidden_dropout']
batch_norm = self.params['batch_norm']
optimizer_type = self.params['optimizer']['type']
optimizer_lr = self.params['optimizer']['lr']
batch_size = int(self.params['batch_size'])
# 표준화
self.scaler = StandardScaler()
tr_x = self.scaler.fit_transform(tr_x)
va_x = self.scaler.transform(va_x)
self.model = Sequential()
# 입력계층
self.model.add(Dropout(input_dropout, input_shape=(tr_x.shape[1], )))
# 은닉계층
for i in range(hidden_layers):
self.model.add(Dense(hidden_units))
if batch_norm == 'before_act':
self.model.add(BatchNormalization())
if hidden_activation == 'prelu':
self.model.add(PReLU())
elif hidden_activation == 'relu':
self.model.add(ReLU())
else:
raise NotImplementedError
self.model.add(Dropout(hidden_dropout))
# 출력 계층
self.model.add(Dense(1, activation='sigmoid'))
# 최적화(옵티마이저)
if optimizer_type == 'sgd':
optimizer = SGD(lr=optimizer_lr,
decay=1e-6,
momentum=0.9,
nesterov=True)
elif optimizer_type == 'adam':
optimizer = Adam(lr=optimizer_lr,
beta_1=0.9,
beta_2=0.999,
decay=0.)
else:
raise NotImplementedError
# 목적함수, 평가지표 등의 설정
self.model.compile(loss='binary_crossentropy',
optimizer=optimizer,
metrics=['accuracy'])
# 에폭 수, 조기 종료
# 에폭을 너무 크게 하면 작은 학습률일 때 끝나지 않을 수 있으므로 주의
nb_epoch = 200
patience = 20
early_stopping = EarlyStopping(patience=patience,
restore_best_weights=True)
# 학습의 실행
history = self.model.fit(tr_x,
tr_y,
epochs=nb_epoch,
batch_size=batch_size,
verbose=1,
validation_data=(va_x, va_y),
callbacks=[early_stopping])
def conv_layer(feature_batch, feature_map, kernel_size=(3, 3),strides=(1,1), padding='same'):
conv = Conv2D(filters=feature_map, kernel_size=kernel_size, strides=strides,
padding=padding)(feature_batch)
act = ReLU()(conv)
bn = BatchNormalization(axis=3)(act)
return bn
def bottleneck_encoder(tensor, nfilters, downsampling=False, dilated=False, asymmetric=False, normal=False, drate=0.1, name=''):
y = tensor
skip = tensor
stride = 1
ksize = 1
if downsampling:
stride = 2
ksize = 2
skip = MaxPooling2D(pool_size=(2, 2), name=f'max_pool_{name}')(skip)
skip = Permute((1,3,2), name=f'permute_1_{name}')(skip) #(B, H, W, C) -> (B, H, C, W)
ch_pad = nfilters - K.int_shape(tensor)[-1]
skip = ZeroPadding2D(padding=((0,0),(0,ch_pad)), name=f'zeropadding_{name}')(skip)
skip = Permute((1,3,2), name=f'permute_2_{name}')(skip) #(B, H, C, W) -> (B, H, W, C)
y = Conv2D(filters=nfilters//4, kernel_size=(ksize, ksize), kernel_initializer='he_normal', strides=(stride, stride), padding='same', use_bias=False, name=f'1x1_conv_{name}')(y)
y = BatchNormalization(momentum=0.1, name=f'bn_1x1_{name}')(y)
y = ReLU(name=f'prelu_1x1_{name}')(y)
if normal:
y = Conv2D(filters=nfilters//4, kernel_size=(3, 3), kernel_initializer='he_normal', padding='same', name=f'3x3_conv_{name}')(y)
elif asymmetric:
y = Conv2D(filters=nfilters//4, kernel_size=(5, 1), kernel_initializer='he_normal', padding='same', use_bias=False, name=f'5x1_conv_{name}')(y)
y = Conv2D(filters=nfilters//4, kernel_size=(1, 5), kernel_initializer='he_normal', padding='same', name=f'1x5_conv_{name}')(y)
elif dilated:
y = Conv2D(filters=nfilters//4, kernel_size=(3, 3), kernel_initializer='he_normal', dilation_rate=(dilated, dilated), padding='same', name=f'dilated_conv_{name}')(y)
y = BatchNormalization(momentum=0.1, name=f'bn_main_{name}')(y)
y = ReLU(name=f'prelu_{name}')(y)
y = Conv2D(filters=nfilters, kernel_size=(1, 1), kernel_initializer='he_normal', use_bias=False, name=f'final_1x1_{name}')(y)
y = BatchNormalization(momentum=0.1, name=f'bn_final_{name}')(y)
y = SpatialDropout2D(rate=drate, name=f'spatial_dropout_final_{name}')(y)
y = Add(name=f'add_{name}')([y, skip])
y = ReLU(name=f'prelu_out_{name}')(y)
return y
def train(self, tr_x, tr_y, va_x=None, va_y=None):
"""
tr_x : List[str] (example.) [ "I am happy", "hello" ]
tr_y : List[label]
embedding_model : gensim.models.KeyedVectors Object
"""
# scaling
validation = va_x is not None
# パラメータ
nb_classes = 5
embedding_dropout = self.params['embedding_dropout']
lstm_dropout = self.params['lstm_dropout']
lstm_recurrent_dropout = self.params['recurrent_dropout']
hidden_layers = int(self.params['hidden_layers'])
hidden_units = int(self.params['hidden_units'])
hidden_activation = self.params['hidden_activation']
hidden_dropout = self.params['hidden_dropout']
batch_norm = self.params['batch_norm']
optimizer_type = self.params['optimizer']['type']
optimizer_lr = self.params['optimizer']['lr']
batch_size = int(self.params['batch_size'])
nb_epoch = int(self.params['nb_epoch'])
embedding_model = self.params['embedding_model']
bidirectional = self.params['Bidirectional']
use_pre_embedding = not (embedding_model is None)
# using keras tokenizer here
token = Tokenizer(num_words=None)
max_len = 70
if validation:
token.fit_on_texts(list(tr_x) + list(va_x))
else:
token.fit_on_texts(list(tr_x))
xtrain_seq = token.texts_to_sequences(tr_x)
tr_x = pad_sequences(xtrain_seq, maxlen=max_len)
tr_y = np_utils.to_categorical(tr_y, num_classes=5)
if validation:
xvalid_seq = token.texts_to_sequences(va_x)
va_x = pad_sequences(xvalid_seq, maxlen=max_len)
va_y = np_utils.to_categorical(va_y, num_classes=5)
word_index = token.word_index
if use_pre_embedding:
# create an embedding matrix
vector_dim = embedding_model.vector_size
embedding_matrix = np.zeros((len(word_index) + 1, vector_dim))
for word, i in tqdm(word_index.items()):
embedding_vector = embedding_model.wv[word]
if embedding_vector is not None:
embedding_matrix[i] = embedding_vector
inputs = Input(shape=(max_len, ))
# input layer
if use_pre_embedding:
self.model.add(Embedding(
input_dim=len(word_index) + 1,
output_dim=vector_dim,
input_length=max_len,
weights=[embedding_matrix],
trainable=False))
else:
self.model.add(Embedding(input_dim=len(word_index) + 1,
output_dim=300,
input_length=max_len))
self.model.add(SpatialDropout1D(embedding_dropout))
if bidirectional:
self.model.add(Bidirectional(LSTM(300, dropout=lstm_dropout, recurrent_dropout=lstm_recurrent_dropout)))
else:
self.model.add(LSTM(100, dropout=lstm_dropout, recurrent_dropout=lstm_recurrent_dropout))
# 中間層
for i in range(hidden_layers):
self.model.add(Dense(hidden_units))
if batch_norm == 'before_act':
self.model.add(BatchNormalization())
if hidden_activation == 'prelu':
self.model.add(PReLU())
elif hidden_activation == 'relu':
self.model.add(ReLU())
else:
raise NotImplementedError
self.model.add(Dropout(hidden_dropout))
# 出力層
self.model.add(Dense(nb_classes, activation='sigmoid'))
# オプティマイザ
if optimizer_type == 'sgd':
optimizer = SGD(lr=optimizer_lr, decay=1e-6, momentum=0.9, nesterov=True)
elif optimizer_type == 'adam':
optimizer = Adam(lr=optimizer_lr, beta_1=0.9, beta_2=0.999, decay=0.)
else:
raise NotImplementedError
# 目的関数、評価指標などの設定
self.model.compile(loss='categorical_crossentropy', optimizer=optimizer, metrics=['accuracy'])
# エポック数、アーリーストッピング
# あまりepochを大きくすると、小さい学習率のときに終わらないことがあるので注意
patience = 20
# 学習の実行
if validation:
early_stopping = EarlyStopping(monitor='val_loss', patience=patience,
verbose=1, restore_best_weights=True)
history = self.model.fit(tr_x, tr_y, epochs=nb_epoch, batch_size=batch_size, verbose=2,
validation_data=(va_x, va_y), callbacks=[early_stopping])
else:
history = self.model.fit(tr_x, tr_y, nb_epoch=nb_epoch, batch_size=batch_size, verbose=2)
def get_net(input_shape=(Height, Weight, Channel),
load_weight_path=None) -> Model: #期待返回类型为model
inputs = Input(shape=input_shape, name="input")
x = inputs
##################################################################################################################
x_ident_1 = x
x_ident_1 = AveragePooling2D(pool_size=(2, 2),
strides=(2, 2),
border_mode='valid')(x_ident_1)
# 1st layer group
x = Convolution2D(16,
3,
3,
activation=None,
border_mode='same',
name='conv1a',
subsample=(1, 1))(x)
x = BatchNormalization()(x)
x = ReLU()(x)
x = Convolution2D(16,
3,
3,
activation=None,
border_mode='same',
name='conv1b',
subsample=(1, 1))(x)
x = BatchNormalization()(x)
x = ReLU()(x)
x = MaxPooling2D(pool_size=(2, 2),
strides=(2, 2),
border_mode='valid',
name='pool1')(x)
x = Concatenate(axis=3)([x, x_ident_1])
##################################################################################################################
x_ident_1 = AveragePooling2D(pool_size=(2, 2),
strides=(2, 2),
border_mode='valid')(x_ident_1)
x_ident_2 = AveragePooling2D(pool_size=(2, 2),
strides=(2, 2),
border_mode='valid')(x)
# 2nd layer group
x = Convolution2D(32,
3,
3,
activation=None,
border_mode='same',
name='conv2a',
subsample=(1, 1))(x)
x = BatchNormalization()(x)
x = ReLU()(x)
x = Convolution2D(32,
3,
3,
activation=None,
border_mode='same',
name='conv2b',
subsample=(1, 1))(x)
x = BatchNormalization()(x)
x = ReLU()(x)
x = MaxPooling2D(pool_size=(2, 2),
strides=(2, 2),
border_mode='valid',
name='pool2')(x)
x = Concatenate(axis=3)([x, x_ident_1, x_ident_2])
##################################################################################################################
x_ident_1 = AveragePooling2D(pool_size=(2, 2),
strides=(2, 2),
border_mode='valid')(x_ident_1)
x_ident_2 = AveragePooling2D(pool_size=(2, 2),
strides=(2, 2),
border_mode='valid')(x_ident_2)
x_ident_3 = AveragePooling2D(pool_size=(2, 2),
strides=(2, 2),
border_mode='valid')(x)
# 3rd layer group
x = Convolution2D(64,
3,
3,
activation=None,
border_mode='same',
name='conv3a',
subsample=(1, 1))(x)
x = BatchNormalization()(x)
x = ReLU()(x)
x = Convolution2D(64,
3,
3,
activation=None,
border_mode='same',
name='conv3b',
subsample=(1, 1))(x)
x = BatchNormalization()(x)
x = ReLU()(x)
x = MaxPooling2D(pool_size=(2, 2),
strides=(2, 2),
border_mode='valid',
name='pool3')(x)
x = Concatenate(axis=3)([x, x_ident_1, x_ident_2, x_ident_3])
##################################################################################################################
x_ident_1 = AveragePooling2D(pool_size=(2, 2),
strides=(2, 2),
border_mode='valid')(x_ident_1)
x_ident_2 = AveragePooling2D(pool_size=(2, 2),
strides=(2, 2),
border_mode='valid')(x_ident_2)
x_ident_3 = AveragePooling2D(pool_size=(2, 2),
strides=(2, 2),
border_mode='valid')(x_ident_3)
x_ident_4 = AveragePooling2D(pool_size=(2, 2),
strides=(2, 2),
border_mode='valid')(x)
# 4th layer group
x = Convolution2D(
128,
3,
3,
activation=None,
border_mode='same',
name='conv4a',
subsample=(1, 1),
)(x)
x = BatchNormalization()(x)
x = ReLU()(x)
x = Convolution2D(
128,
3,
3,
activation=None,
border_mode='same',
name='conv4b',
subsample=(1, 1),
)(x)
x = BatchNormalization()(x)
x = ReLU()(x)
x = MaxPooling2D(pool_size=(2, 2),
strides=(2, 2),
border_mode='valid',
name='pool4')(x)
x = Concatenate(axis=3)([x, x_ident_1, x_ident_2, x_ident_3, x_ident_4])
x = GlobalMaxPooling2D()(x)
x = BatchNormalization(name="final_features_344")(x)
##################################################################################################################
if USE_DROPOUT:
x = Dropout(p=0.3)(x)
x = Dense(64, activation='relu', name="final_features_64")(x)
out_class = Dense(5, activation='softmax', name='out_class')(x)
model = Model(input=inputs, output=out_class)
if load_weight_path is not None:
model.load_weights(load_weight_path, by_name=False)
#编译模型
model.compile(optimizer=SGD(lr=LEARN_RATE, momentum=0.9, nesterov=True),
loss={"out_class": "categorical_crossentropy"},
metrics={
"out_class":
[categorical_accuracy, categorical_crossentropy]
})
model.summary(line_length=120)
return model
Y_train = np.asarray(Y_train)
X_val = np.asarray(X_val)
Y_val = np.asarray(Y_val)
X_train = X_train.reshape(lt, 2304)
X_val = X_val.reshape(lv, 2304)
inputs = Input(shape=(2304, ))
x = inputs
i = 0
while i < 3:
x = Dense(254)(x)
x = ReLU()(x) #Non-linearily
x = Dropout(0.5)(x)
i = i + 1
predictions = Dense(nb_classes, activation='softmax')(x)
model = Model(input=inputs, output=predictions)
sgd = SGD(lr=0.01, decay=1e-6, momentum=0.9, nesterov=True)
model.compile(optimizer=sgd,
loss='categorical_crossentropy',
metrics=['accuracy'])
# model.summary()
history = model.fit(X_train,
def conv_block(x, nb_filter, filter_size, atrous_rate=(1, 1)):
x = Conv2D(nb_filter, filter_size, dilation_rate=atrous_rate, kernel_initializer='he_normal', padding='same')(x)
x = bn_block(x)
x = ReLU()(x)
return x
def DarknetConv2D_BN_RELU(*args, **kwargs):
"""Darknet Convolution2D followed by BatchNormalization and LeakyReLU."""
no_bias_kwargs = {'use_bias': False}
no_bias_kwargs.update(kwargs)
return compose(DarknetConv2D(*args, **no_bias_kwargs),
BatchNormalization(), ReLU())
def BN_Relu(out):
bacth_conv = BatchNormalization(axis=3)(out)
relu_batch_norm = ReLU()(bacth_conv)
return relu_batch_norm
def train(self, tr_x, tr_y, va_x=None, va_y=None):
# scaling
validation = va_x is not None
# パラメータ
nb_classes = self.params['nb_class']
input_dropout = self.params['input_dropout']
hidden_layers = int(self.params['hidden_layers'])
hidden_units = int(self.params['hidden_units'])
hidden_activation = self.params['hidden_activation']
hidden_dropout = self.params['hidden_dropout']
batch_norm = self.params['batch_norm']
optimizer_type = self.params['optimizer']['type']
optimizer_lr = self.params['optimizer']['lr']
batch_size = int(self.params['batch_size'])
nb_epoch = int(self.params['nb_epoch'])
if issparse(tr_x):
scaler = StandardScaler(with_mean=False)
else:
scaler = StandardScaler()
scaler.fit(tr_x)
tr_x = scaler.transform(tr_x)
tr_y = np_utils.to_categorical(tr_y, num_classes=nb_classes)
if validation:
va_x = scaler.transform(va_x)
va_y = np_utils.to_categorical(va_y, num_classes=nb_classes)
self.model = Sequential()
# input layer
self.model.add(Dropout(input_dropout, input_shape=(tr_x.shape[1], )))
# 中間層
for i in range(hidden_layers):
self.model.add(Dense(hidden_units))
if batch_norm == 'before_act':
self.model.add(BatchNormalization())
if hidden_activation == 'prelu':
self.model.add(PReLU())
elif hidden_activation == 'relu':
self.model.add(ReLU())
else:
raise NotImplementedError
self.model.add(Dropout(hidden_dropout))
# 出力層
self.model.add(Dense(nb_classes, activation='softmax'))
# オプティマイザ
if optimizer_type == 'sgd':
optimizer = SGD(lr=optimizer_lr,
decay=1e-6,
momentum=0.9,
nesterov=True)
elif optimizer_type == 'adam':
optimizer = Adam(lr=optimizer_lr,
beta_1=0.9,
beta_2=0.999,
decay=0.)
else:
raise NotImplementedError
# 目的関数、評価指標などの設定
self.model.compile(loss='categorical_crossentropy',
optimizer=optimizer,
metrics=['accuracy'])
# エポック数、アーリーストッピング
# あまりepochを大きくすると、小さい学習率のときに終わらないことがあるので注意
patience = 12
# 学習の実行
if validation:
early_stopping = EarlyStopping(monitor='val_loss',
patience=patience,
verbose=2,
restore_best_weights=True)
history = self.model.fit(tr_x,
tr_y,
epochs=nb_epoch,
batch_size=batch_size,
verbose=2,
validation_data=(va_x, va_y),
callbacks=[early_stopping])
else:
history = self.model.fit(tr_x,
tr_y,
nb_epoch=nb_epoch,
batch_size=batch_size,
verbose=2)
self.scaler = scaler
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')
weights_header = np.int64(np.ndarray(
shape=(4, ), dtype='int32', buffer=weights_file.read(16)))
major = weights_header[0]
minor = weights_header[1]
if (major*10 + minor) >= 2 and major < 1000 and minor < 1000:
final = np.int64(np.ndarray(shape=(1, ), dtype='int32', buffer=weights_file.read(4)))
weights_header[3] = np.bitwise_or(np.left_shift(final, 4), weights_header[3])
print('Weights Header: ', weights_header)
# TODO: Check transpose flag when implementing fully connected layers.
# transpose = (weight_header[0] > 1000) or (weight_header[1] > 1000)
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.')
if args.fully_convolutional:
image_height, image_width = None, None
else:
image_height = int(cfg_parser['net_0']['height'])
image_width = int(cfg_parser['net_0']['width'])
prev_layer = Input(shape=(image_height, image_width, 3))
all_layers = [prev_layer]
weight_decay = float(cfg_parser['net_0']['decay']
) if 'net_0' in cfg_parser.sections() else 5e-4
count = 0
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]
if(int('groups' in cfg_parser[section])==1):
groups_count = int(cfg_parser[section]['groups'])
else:
groups_count = 1
# padding='same' is equivalent to Darknet pad=1
padding = 'same' if pad == 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)
# TODO: This assumes channel last dim_ordering.
weights_shape = (size, size, int(prev_layer_shape[-1]/groups_count), 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)
print('darknet_w_shape:',darknet_w_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
# TODO: Keras BatchNormalization mistakenly refers to var
# as std.
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)
# TODO: Add check for Theano dim ordering.
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 =='relu':
pass
elif activation != 'linear':
raise ValueError(
'Unknown activation function `{}` in section {}'.format(
activation, section))
# Create Conv2D layer
conv_layer = (Conv2D(
filters, (size, size),
strides=(stride, stride),
groups = groups_count,
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 activation == 'relu':
act_layer = ReLU()(prev_layer)
prev_layer = act_layer
all_layers.append(act_layer)
elif section.startswith('maxpool'):
size = int(cfg_parser[section]['size'])
stride = int(cfg_parser[section]['stride'])
all_layers.append(
MaxPooling2D(
padding='same',
pool_size=(size, size),
strides=(stride, stride))(prev_layer))
prev_layer = all_layers[-1]
elif section.startswith('avgpool'):
if cfg_parser.items(section) != []:
raise ValueError('{} with params unsupported.'.format(section))
all_layers.append(GlobalAveragePooling2D()(prev_layer))
prev_layer = all_layers[-1]
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('reorg'):
block_size = int(cfg_parser[section]['stride'])
assert block_size == 2, 'Only reorg with stride 2 supported.'
all_layers.append(
Lambda(
space_to_depth_x2,
output_shape=space_to_depth_x2_output_shape,
name='space_to_depth_x2')(prev_layer))
prev_layer = all_layers[-1]
elif section.startswith('region'):
with open('{}_anchors.txt'.format(output_root), 'w') as f:
print(cfg_parser[section]['anchors'], file=f)
elif (section.startswith('net') or section.startswith('cost') or
section.startswith('softmax')):
pass # Configs not currently handled during model definition.
else:
raise ValueError(
'Unsupported section header type: {}'.format(section))
# Create and save model.
model = Model(inputs=all_layers[0], outputs=all_layers[-1])
print(model.summary())
model.save('{}'.format(output_path))
print('Saved Keras model to {}'.format(output_path))
image = cv2.imread('YAD2K/images/1.jpg')
dummy_array = np.zeros((1,1,1,1,50,4))
input_image = cv2.resize(image, (320, 224))
input_image = np.expand_dims(input_image, 0)
netout = model.predict([input_image, dummy_array])
print(netout)
#image = draw_boxes(image, boxes, labels=['person'])
cv2.imwrite('output.jpg', image)
# 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 BN_FC(self, x, FNum):
x = Dense(FNum)(x)
x = BatchNormalization()(x)
x = ReLU()(x)
return x
def fit(self, tr_x, tr_y, va_x=None, va_y=None):
# パラメータ
input_dropout = self.params['input_dropout']
hidden_layers = int(self.params['hidden_layers'])
hidden_units = int(self.params['hidden_units'])
hidden_activation = self.params['hidden_activation']
hidden_dropout = self.params['hidden_dropout']
batch_norm = self.params['batch_norm']
optimizer_type = self.params['optimizer']['type']
optimizer_lr = self.params['optimizer']['lr']
batch_size = int(self.params['batch_size'])
#標準化
y_scaler = StandardScaler()
tr_y_std = y_scaler.fit_transform(np.log1p(tr_y.values.reshape(-1, 1)))
# データのセット・スケーリング
validation = va_x is not None
if validation:
va_y_std = y_scaler.transform(np.log1p(va_y.values.reshape(-1, 1)))
# モデルの構築
# 入力層
self.model = Sequential()
self.model.add(Dense(512, input_shape=(tr_x.shape[1], )))
self.model.add(PReLU())
self.model.add(Dropout(input_dropout))
# 中間層
for i in range(hidden_layers):
self.model.add(Dense(hidden_units))
if batch_norm == 'before_act':
self.model.add(BatchNormalization())
if hidden_activation == 'prelu':
self.model.add(PReLU())
elif hidden_activation == 'relu':
self.model.add(ReLU())
else:
raise NotImplementedError
self.model.add(Dropout(hidden_dropout))
self.model.add(Dense(1, activation="linear"))
# オプティマイザ
if optimizer_type == 'sgd':
optimizer = SGD(lr=optimizer_lr,
decay=1e-6,
momentum=0.9,
nesterov=True)
elif optimizer_type == 'adam':
optimizer = Adam(lr=optimizer_lr,
beta_1=0.9,
beta_2=0.999,
decay=0.)
else:
raise NotImplementedError
# 目的関数、評価指標などの設定
self.model.compile(loss=root_mean_squared_error, optimizer=optimizer)
if validation:
early_stopping = EarlyStopping(monitor='val_loss',
patience=5,
verbose=1,
restore_best_weights=True)
self.model.fit(tr_x,
tr_y_std,
epochs=200,
batch_size=64,
verbose=1,
validation_data=(va_x, va_y_std),
callbacks=[early_stopping])
else:
self.model.fit(tr_x,
tr_y_std,
epochs=200,
batch_size=64,
verbose=1)
# モデル・スケーラーの保持
self.scaler = y_scaler
def build_model(WINDOW_SIZE):
abits = 16
wbits = 16
kernel_lr_multiplier = 10
def quantized_relu(x):
return quantize_op(x,nb=abits)
def binary_tanh(x):
return binary_tanh_op(x)
# network_type = 'float'
#network_type ='qnn'
# network_type = 'full-qnn'
network_type ='bnn'
# network_type = 'full-bnn'
H = 1.
if network_type =='float':
Conv_ = lambda f, s, c, n: Conv1D(kernel_size=s, filters=f, padding='same', activation='linear',
input_shape = (c,1), name = n)
Conv = lambda f, s, n: Conv1D(kernel_size= s, filters=f, padding='same', activation='linear', name = n)
Dense_ = lambda f, n: Dense(units = f, kernel_initializer='normal', activation='relu', name = n)
Act = lambda: ReLU()
elif network_type=='qnn':
# sys.exit(0)
Conv_ = lambda f, s, c, n: QuantizedConv1D(kernel_size= s, H=1, nb=wbits, filters=f, strides=1,
padding='same', activation='linear',
input_shape = (c,1),name = n)
Conv = lambda f, s, n: QuantizedConv1D(kernel_size=s, H=1, nb=wbits, filters=f, strides= 1,
padding='same', activation='linear',
name = n)
Act = lambda: ReLU()
Dense_ = lambda f, n: QuantizedDense(units = f, nb = wbits, name = n)
elif network_type=='full-qnn':
#sys.exit(0)
Conv_ = lambda f, s, c, n: QuantizedConv1D(kernel_size= s, H=1, nb=wbits, filters=f, strides=1,
padding='same', activation='linear',
input_shape = (c,1),name = n)
Conv = lambda f, s, n: QuantizedConv1D(kernel_size=s, H=1, nb=wbits, filters=f, strides= 1,
padding='same', activation='linear',
name = n)
Act = lambda: Activation(quantized_relu)
Dense_ = lambda f, n: QuantizedDense(units = f, nb = wbits, name = n)
elif network_type=='bnn':
# sys.exit(0)
Conv_ = lambda f,s,c,n: BinaryConv1D(kernel_size= s, H=1, filters=f, strides=1, padding='same',
activation='linear',
input_shape = (c,1),
name = n)
Conv = lambda f,s,n: BinaryConv1D(kernel_size=s, H=1, filters=f, strides=1, padding='same',
activation='linear',
name = n )
Dense_ = lambda f, n: BinaryDense(units = f, name = n)
Act = lambda: ReLU()
elif network_type=='full-bnn':
#sys.exit(0)
Conv_ = lambda f,s,c,n: BinaryConv1D(kernel_size= s, H=1, filters=f, strides=1, padding='same',
activation='linear',
input_shape = (c,1),
name = n)
Conv = lambda f,s,n: BinaryConv1D(kernel_size=s, H=1, filters=f, strides=1, padding='same',
activation='linear',
name = n )
Act = lambda: Activation(binary_tanh)
else:
#sys.exit(0)
print('wrong network type, the supported network types in this repo are float, qnn, full-qnn, bnn and full-bnn')
model = Sequential()
OUTPUT_CLASS = 4 # output classes
#model = Sequential()
model.add(Conv_(64, 55, WINDOW_SIZE, 'conv1') )
model.add(Act())
model.add(MaxPooling1D(10))
model.add(Dropout(0.5))
model.add(Conv(64, 25, 'conv2' ))
model.add(Act())
model.add(MaxPooling1D(5))
model.add(Dropout(0.5))
model.add(Conv(64, 10, 'conv3'))
model.add(Act())
model.add(GlobalAveragePooling1D())
model.add(Dense_(256, 'den6'))
model.add(Dropout(0.5))
model.add(Dense_(128, 'den7'))
model.add(Dropout(0.5))
model.add(Dense_(64, 'den8'))
model.add(Dropout(0.5))
model.add(Dense(OUTPUT_CLASS, kernel_initializer='normal', activation='softmax', name = 'den9'))
model.compile(loss='categorical_crossentropy', optimizer='adam', metrics=['accuracy'])
print(model.summary())
plot_model(model, to_file='my_model.png')
return model
from PIL import Image
INPUT_SCALE = 2
img_shape = (32, 32, 1)
model = Sequential()
img = image.load_img('./data/Set1/comic.bmp', color_mode = "grayscale")
# img = image.img_to_array(img)
# img = img[0:8,0:8,0]
#input_img = Input(shape=(IMG_SIZE[0]/INPUT_SCALE, IMG_SIZE[1]/INPUT_SCALE, 1))
input_img = Input(batch_shape=(1,img.size[1],img.size[0],1))
#特征提取阶段
model = Conv2D(64,(3,3),padding='same',kernel_initializer='he_normal')(input_img)
model = ReLU()(model)
model = Conv2D(64,(3,3),padding='same',kernel_initializer='he_normal')(model)
model = ReLU()(model)
model = Conv2D(64,(3,3),padding='same',kernel_initializer='he_normal')(model)
#非线性映射阶段
model = Conv2D(16,(1,1),padding='same',kernel_initializer='he_normal')(model)
model = ReLU()(model)
model = Conv2D(16,(3,3),padding='same',kernel_initializer='he_normal')(model)
model = ReLU()(model)
model = Conv2D(16,(3,3),padding='same',kernel_initializer='he_normal')(model)
model = ReLU()(model)
model = Conv2D(16,(3,3),padding='same',kernel_initializer='he_normal')(model)
model = ReLU()(model)