def TrainModel(path, train_dir, val_dir, batch_size,
epochs, out_nums, nb_train_samples,
nb_val_samples, img_width=256, img_height=256, freeze=13):
#生成训练和验证数据
train_datagen = ImageDataGenerator(
preprocessing_function=preprocess_input,
rotation_range=40,
# width_shift_range=0.2,
# height_shift_range=0.2,
# shear_range=0.2,
# zoom_range=0.2,
horizontal_flip=True, ) # 训练数据预处理器，随机水平翻转
test_datagen = ImageDataGenerator(preprocessing_function=preprocess_input) # 测试数据预处理器
train_generator = train_datagen.flow_from_directory(train_dir,
target_size=(img_width, img_height),
batch_size=batch_size,
# class_mode='binary'
) # 训练数据生成器
validation_generator = test_datagen.flow_from_directory(val_dir,
target_size=(img_width, img_height),
batch_size=batch_size,
# class_mode='binary',
shuffle=True) # 验证数据生成器
base_model = VGG16(weights=path, include_top=False, #加载迁移学习模型
input_shape=(img_width, img_height, 3))
for ix, layers in enumerate(base_model.layers):
if ix < freeze: #冻结指定层
layers.trainable = False
# layers.trainable = False #冻结指定层数层
#添加新的层用于训练
model = Flatten()(base_model.output)
model = Dense(256, activation='relu', name='fc1')(model)
model = Dropout(0.5, name='dropout1')(model)
#=========================新加一层全连接=======================
# model = Dense(64, activation='relu', name='fc2')(model)
# model = Dropout(0.5, name='dropout2')(model)
#==============================================================
model = Dense(out_nums, activation='softmax')(model)
# model = Dense(out_nums, activation='sigmoid')(model)
model_final = Model(inputs=base_model.input, outputs=model)
model_final.compile(loss='categorical_crossentropy', optimizer=SGD(lr=0.0001, momentum=0.9),
metrics=['accuracy'])
# model_final.compile(loss='binary_crossentropy',
# optimizer=SGD(lr=0.0001, momentum=0.9),
# metrics=['accuracy'])
print(model_final.summary())
callbacks = [
EarlyStopping(patience=2, verbose=1),
ModelCheckpoint('savemodel_1fc256.h5', monitor='val_acc', verbose=1, save_best_only=True, mode='max')
# ModelCheckpoint('savemodel_1fc256_3conv_binary.h5', verbose=1, save_best_only=False, mode='max')
]
# 训练&评估
model_final.fit_generator(train_generator, steps_per_epoch=nb_train_samples // batch_size, epochs=epochs,
validation_data=validation_generator, validation_steps=nb_val_samples // batch_size,
callbacks=callbacks, initial_epoch=0) # 每轮一行输出结果
def evaluate_on_cifar10():
total_depth = 36
n_blocks = 3
basic_block_count = total_depth // n_blocks
# region Model
input_layer = Input(shape=[32, 32, 3])
layer = input_layer
kernel_initializer = ResBlock2D.get_fixup_initializer(total_depth)
for k in range(n_blocks):
strides = 2 if k < (n_blocks - 1) else 1
layer = ResBlock2D(filters=16 * (2**k),
basic_block_count=basic_block_count,
strides=strides,
kernel_initializer=kernel_initializer,
use_residual_bias=True)(layer)
if k == (n_blocks - 1):
layer = AveragePooling2D(pool_size=8)(layer)
layer = Flatten()(layer)
layer = Dense(units=10, activation="softmax")(layer)
model = Model(inputs=input_layer, outputs=layer)
model.summary()
model.compile(optimizer="adam",
loss="categorical_crossentropy",
metrics=["acc"])
# endregion
# region Data
(x_train, y_train), (x_test, y_test) = cifar10.load_data()
x_train = x_train.astype(np.float32) / 255.0
x_test = x_test.astype(np.float32) / 255.0
y_train = to_categorical(y_train, num_classes=10)
y_test = to_categorical(y_test, num_classes=10)
generator = ImageDataGenerator(rotation_range=15,
width_shift_range=5. / 32,
height_shift_range=5. / 32,
horizontal_flip=True)
generator.fit(x_train, seed=0)
# endregion
log_dir = "../logs/tests/res_block_cifar10/{}".format(int(time()))
log_dir = os.path.normpath(log_dir)
tensorboard = TensorBoard(log_dir=log_dir, profile_batch=0)
model.fit_generator(generator.flow(x_train, y_train, batch_size=64),
steps_per_epoch=100,
epochs=300,
validation_data=(x_test, y_test),
validation_steps=100,
verbose=1,
callbacks=[tensorboard])
def train_raw():
# show class indices
print('****************')
for cls, idx in train_batches.class_indices.items():
print('Class #{} = {}'.format(idx, cls))
print('****************')
# build our classifier model based on pre-trained InceptionResNetV2:
# 1. we don't include the top (fully connected) layers of InceptionResNetV2
# 2. we add a DropOut layer followed by a Dense (fully connected)
# layer which generates softmax class score for each class
# 3. we compile the final model using an Adam optimizer, with a
# low learning rate (since we are 'fine-tuning')
net = InceptionResNetV2(include_top=False,
weights='imagenet',
input_tensor=None,
input_shape=(IMAGE_SIZE[0], IMAGE_SIZE[1], 3))
x = net.output
x = Flatten()(x)
x = Dropout(0.5)(x)
output_layer = Dense(NUM_CLASSES, activation='softmax', name='softmax')(x)
net_final = Model(inputs=net.input, outputs=output_layer)
for layer in net_final.layers[:FREEZE_LAYERS]:
layer.trainable = False
for layer in net_final.layers[FREEZE_LAYERS:]:
layer.trainable = True
net_final.compile(optimizer=Adam(lr=1e-5),
loss='categorical_crossentropy',
metrics=['accuracy'])
#print(net_final.summary())
# train the model
for i in range(1):
net_final.fit_generator(
train_batches,
steps_per_epoch=train_batches.samples // BATCH_SIZE // 10,
validation_data=valid_batches,
validation_steps=valid_batches.samples // BATCH_SIZE // 10,
epochs=1)
gen_sub(net_final, testdf, sn=i)
WEIGHTS_FINAL = f'./output/model-inception_resnet_v{i}-27.h5'
# save trained weights
net_final.save(WEIGHTS_FINAL)
print(f'weight save to {WEIGHTS_FINAL}')
return WEIGHTS_FINAL
async def training():
if not os.path.exists(file_path):
flatten = Flatten()(merged)
dense = Dense(64)(flatten)
activation = Activation('softmax')(dense)
dropout = Dropout(0.5)(activation)
dense = Dense(1591)(dropout)
activation = Activation('softmax')(dense)
base_model = Model(input_img, activation)
else:
base_model = load_model(file_path)
for layer in base_model.layers:
if layer.name is 'inception4_branch_3' \
and layer.name is 'inception4d_activation_branch_3' \
and layer.name is 'inception4e_activation_branch_3' \
and layer.name is 'inception5a_activation_branch_3' \
and layer.name is 'inception5b_4_branch_3':
layer.trainable = False
# base_model.load_weights(file_path)
base_model.summary()
train_generator_lr = datagen.flow_from_directory(
str(path_data_set + '/train'),
target_size=(img_width, img_height),
batch_size=batch_size,
class_mode='categorical',
shuffle=True)
validation_generator_lr = datagen.flow_from_directory(
str(path_data_set + '/validate'),
target_size=(img_width, img_height),
batch_size=batch_size,
class_mode='categorical',
shuffle=True)
print('training: ')
base_model.compile(loss='categorical_crossentropy',
optimizer=sgd,
metrics=['accuracy'])
checkpoint = ModelCheckpoint(file_path,
monitor='val_loss',
save_best_only=True,
mode='auto',
verbose=1)
callbacks_list = [checkpoint]
history = base_model.fit_generator(generator=train_generator_lr,
steps_per_epoch=num_train_images //
batch_size,
epochs=epochs,
validation_data=validation_generator_lr,
validation_steps=800 // batch_size,
callbacks=callbacks_list)
common_func = common_function.CommonFunction()
common_func.plot_training(history, 'TBE-CNN (2 Branch - Epoch 40)')
def fit_train(train_path, test_path):
train_datagen = ImageDataGenerator()
test_datagen = ImageDataGenerator()
print("获取测试数据... ...")
test_generator = test_datagen.flow_from_directory(test_path,
target_size=(224, 224),
batch_size=32)
print("获取训练数据... ...")
train_generator = train_datagen.flow_from_directory(train_path,
target_size=(224, 224),
batch_size=32)
print("开始训练... ...")
logging = TensorBoard(log_dir='/home/app/program/micro_emotion/log')
early_stopping = EarlyStopping(monitor='val_loss',
min_delta=0,
patience=5,
verbose=1)
model_check = ModelCheckpoint(filepath=pre_model,
monitor='val_loss',
save_best_only=True)
lr_decay = ReduceLROnPlateau(monitor='val_loss',
factor=0.1,
patience=3,
min_delta=0.001)
model = RN.resnet10(include_top=False,
weights=ori_model,
pooling='avg',
input_shape=(224, 224, 3),
classes=7)
x = model.output
x = Dense(7, activation='softmax', name='fc8_5')(x)
model = Model(inputs=model.input, outputs=x)
model.compile(loss="categorical_crossentropy",
optimizer=SGD(lr=0.01, momentum=0.9, decay=0.1 / 20),
metrics=['accuracy'])
history = model.fit_generator(
train_generator,
steps_per_epoch=346,
epochs=60,
validation_data=test_generator,
validation_steps=38,
callbacks=[logging, early_stopping, model_check, lr_decay])
model = Model(inputs=inputs, outputs=outputs, name='CNN')
model.summary()
# training
# https://github.com/keras-team/keras/issues/10842
# https://stackoverflow.com/questions/52932406/is-the-class-generator-inheriting-sequence-thread-safe-in-keras-tensorflow
# use_multiprocessing not working on Windows
if gpus <= 1:
# 1 gpu
model.compile(optimizer=Adam(lr=1e-3),
loss='mean_squared_error',
metrics=[r_squared])
original_weights = keras.backend.batch_get_value(model.weights)
model.fit_generator(generator=training_generator,
validation_data=validation_generator,
epochs=epochs,
use_multiprocessing=False,
callbacks=callbacks,
workers=4)
# check weights
weights = keras.backend.batch_get_value(model.weights)
if all([np.all(w == ow) for w, ow in zip(weights, original_weights)]):
print('Weights in the template model have not changed')
else:
print('Weights in the template model have changed')
else:
# 2 gpus
original_weights = keras.backend.batch_get_value(model.weights)
parallel_model = multi_gpu_model(model,
gpus=gpus,
cpu_relocation=False,
cpu_merge=True)
K.clear_session()
basemodel = VGG16(weights='imagenet')
LAYER = "fc2"
headModel = basemodel.get_layer(LAYER).output
headModel = Dense(50, activation="softmax")(headModel)
model = Model(inputs=basemodel.input, outputs=headModel)
opt = optimizers.SGD(lr=1e-3, momentum=0.9)
model.compile(loss="categorical_crossentropy",
optimizer=opt,
metrics=["accuracy"])
for layer in basemodel.layers:
layer.trainable = False
train_generator = DataGenerator(indexes=train, **generator_parameters)
val_generator = DataGenerator(indexes=test, **generator_parameters)
model.fit_generator(generator=train_generator,
validation_data=val_generator,
epochs=8)
model.save("%s/VGG16_%s.h5" % (dump_folder, fold_id))
generator_parameters["shuffle"] = False
val_generator = DataGenerator(indexes=test, **generator_parameters)
y_pred_raw = model.predict_generator(val_generator)
y_pred = np.argmax(y_pred_raw, axis=-1)
y_true = np.argmax(y[test], axis=-1)
model_predictions = ({
"path":
np.array(metadata_df.path.values.tolist())[test],
"y_true":
y_true,
"y_pred":
y_pred,
return loss_mean
optimizer = optimizers.RMSprop()
decoder_target = tf.placeholder(dtype='int32', shape=(None, None))
language_model.compile(optimizer=optimizer,
loss=sparse_cross_entropy,
target_tensors=[decoder_target])
path_checkpoint = 'model_weights.keras'
callback_checkpoint = ModelCheckpoint(filepath=path_checkpoint,
verbose=1,
save_weights_only=True)
callback_tensorboard = TensorBoard(log_dir='./train_logs/',
histogram_freq=0,
write_graph=False)
callbacks = [callback_checkpoint, callback_tensorboard]
for i in range(epoch_start, epoch_end, 1):
generator = data_generator(train_tokens,
id_map,
vgg_activations,
batch_size=batch_size,
single_caption=False)
steps = int(len(all_caps_train) / batch_size)
language_model.fit_generator(generator,
steps_per_epoch=steps,
epochs=i + 1,
callbacks=callbacks,
initial_epoch=i)
def evaluate_on_cifar10():
total_depth = 100
n_blocks = 3
depth = (total_depth - 4) // n_blocks
growth_rate = 12
filters = growth_rate * 2
# region Model
input_layer = Input(shape=[32, 32, 3])
layer = input_layer
layer = Conv2D(filters=filters, kernel_size=3, strides=1,
padding="same")(layer)
for k in range(n_blocks):
layer = DenseBlock2D(kernel_size=3,
growth_rate=growth_rate,
depth=depth,
use_batch_normalization=True)(layer)
if k < (n_blocks - 1):
filters += growth_rate * depth // 4
layer = transition_block(layer, filters)
else:
layer = AveragePooling2D(pool_size=8)(layer)
layer = Flatten()(layer)
layer = Dense(units=10, activation="softmax")(layer)
model = Model(inputs=input_layer, outputs=layer)
model.summary()
model.compile(optimizer="adam",
loss="categorical_crossentropy",
metrics=["acc"])
# endregion
# region Data
(x_train, y_train), (x_test, y_test) = cifar10.load_data()
x_train = x_train.astype(np.float32) / 255.0
x_test = x_test.astype(np.float32) / 255.0
y_train = to_categorical(y_train, num_classes=10)
y_test = to_categorical(y_test, num_classes=10)
generator = ImageDataGenerator(rotation_range=15,
width_shift_range=5. / 32,
height_shift_range=5. / 32,
horizontal_flip=True)
generator.fit(x_train, seed=0)
# endregion
log_dir = "../logs/tests/dense_block_cifar10/{}".format(int(time()))
log_dir = os.path.normpath(log_dir)
tensorboard = TensorBoard(log_dir=log_dir, profile_batch=0)
model.fit_generator(generator.flow(x_train, y_train, batch_size=64),
steps_per_epoch=100,
epochs=300,
validation_data=(x_test, y_test),
validation_steps=100,
verbose=1,
callbacks=[tensorboard])
model.compile(optimizer='rmsprop', loss='binary_crossentropy', metrics=['acc',
recall,
precision])
history = History()
npt_monitor = NeptuneMonitor(hprm['BATCH_SIZE'])
# ---------------------------------------------------------------------------------------------------------------------
# ---------------------------------------------
# TRAIN TOP LAYERS ON NEW DATA FOR A FEW EPOCHS|
# ---------------------------------------------
post_training_model = model.fit_generator(training_generator,
steps_per_epoch=((hprm['TRAIN_SIZE'] // hprm['BATCH_SIZE'])+1),
epochs=10, # number of epochs, training cycles
validation_data=validation_generator, # performance eval on test set
validation_steps=((hprm['TEST_SIZE'] // hprm['BATCH_SIZE'])+1),
verbose=1,
callbacks=[history,
npt_monitor])
# validation_output_callback])
y_pred = model.predict_generator(validation_generator,
steps=(hprm['TEST_SIZE'] // hprm['BATCH_SIZE'])+1,
callbacks=[],
verbose=1)
# ---------------------------------------------------------------------------------------------------------------------
# --------------------------------------
# EXPORT MODEL ARCHITECTURE AND WEIGHTS |
# --------------------------------------
# export model structure to json file:
class BaseModel(object):
"""Base Model Interface
Methods
----------
fit(train_data, valid_data, epohcs, batch_size, **kwargs)
predict(X)
evaluate(X, y)
Examples
----------
>>> model = Model("example", inference, "model.h5")
>>> model.fit([X_train, y_train], [X_val, y_val])
"""
def __init__(self, name, fn, model_path):
"""Constructor for BaseModel
Parameters
----------
name : str
Name of this model
fn : function
Inference function, y = fn(X)
model_path : str
Path to a model.h5
"""
X = Input(shape=[28, 28, 1])
y = fn(X)
self.model = Model(X, y, name=name)
self.model.compile("adam", "categorical_crossentropy", ["accuracy"])
self.model.summary()
self.path = model_path
self.name = name
##self.load()
def fit(self, train_data, valid_data, epochs=10, batchsize=128, **kwargs):
"""Training function
Evaluate at each epoch against validation data
Save the best model according to the validation loss
Parameters
----------
train_data : tuple, (X_train, y_train)
X_train.shape == (N, H, W, C)
y_train.shape == (N, N_classes)
valid_data : tuple
(X_val, y_val)
epochs : int
Number of epochs to train
batchsize : int
Minibatch size
**kwargs
Keywords arguments for `fit_generator`
"""
callback_best_only = ModelCheckpoint(self.path, save_best_only=True)
train_gen, val_gen = train_generator()
X_train, y_train = train_data
X_val, y_val = valid_data
N = X_train.shape[0]
print("[DEBUG] N -> {}", X_train.shape)
N_val = X_val.shape[0]
self.model.fit_generator(train_gen.flow(X_train, y_train, batchsize),
steps_per_epoch=N / batchsize,
validation_data=val_gen.flow(
X_val, y_val, batchsize),
validation_steps=N_val / batchsize,
epochs=epochs,
callbacks=[callback_best_only],
**kwargs)
def save(self):
"""Save weights
Should not be used manually
"""
self.model.save_weights(self.path)
def freeze(self, export_dir):
""" Save Freeze Model
"""
tf.saved_model.simple_save(
K.get_session(),
os.path.join(export_dir, str(int(time.time()))),
inputs={'inputs': self.model.input},
outputs={t.name: t
for t in self.model.outputs})
def load(self):
"""Load weights from self.path """
if os.path.isfile(self.path):
self.model.load_weights(self.path)
print("Model loaded")
else:
print("No model is found")
def predict(self, X):
"""Return probabilities for each classes
Parameters
----------
X : array-like (N, H, W, C)
Returns
----------
y : array-like (N, N_classes)
Probability array
"""
return self.model.predict(X)
def evaluate(self, X, y):
"""Return an accuracy
Parameters
----------
X : array-like (N, H, W, C)
y : array-like (N, N_classes)
Returns
----------
acc : float
Accuracy
"""
return self.model.evaluate(X, y)
verbose=1,
factor=0.2,
min_lr=0.0001)
tensor_board = TensorBoard(log_dir='./graph')
callbacks = [early_stop, checkpoint, learning_rate_reduction, tensor_board]
model.compile(loss='categorical_crossentropy',
optimizer=Adam(lr=0.001),
metrics=['accuracy'])
nb_train_samples = 28789
nb_validation_samples = 3589
epochs = 25
history = model.fit_generator(train_generator,
steps_per_epoch=nb_train_samples // batch_size,
epochs=epochs,
callbacks=callbacks,
validation_data=validation_generator,
validation_steps=nb_validation_samples //
batch_size)
model_json = model.to_json()
with open("emotion_classification_mobilenet_7_emotions.json",
"w") as json_file:
json_file.write(model_json)
outputs=[center_output],
name='CenterNet')
optimizer = Adam(lr=learning_rate)
model.compile(loss='mean_squared_error', optimizer=optimizer)
model.summary()
''' Train '''
checkpoint = ModelCheckpoint('models/'+model_name+'.h5',
monitor='val_loss', verbose=1, save_best_only=True, mode='min')
early_stopping = EarlyStopping(
monitor='val_loss', mode='min', verbose=1, patience=50)
history = model.fit_generator(generator(X_img_train, X_route_train, X_lane_train, y_train, batch_size), epochs=epochs, steps_per_epoch=X_img_train.shape[0]/batch_size,
validation_data=generator(X_img_test, X_route_test, X_lane_test, y_test, batch_size),
validation_steps=X_img_test.shape[0]/batch_size,
callbacks=[checkpoint, early_stopping])
''' Save graph '''
# inputs: ['dense_input']
print('inputs: ', [input.op.name for input in model.inputs])
# outputs: ['dense_4/Sigmoid']
print('outputs: ', [output.op.name for output in model.outputs])
# model.save(model_name+'.h5')
frozen_graph = freeze_session(tf.keras.backend.get_session(), output_names=[
out.op.name for out in model.outputs])
tf.train.write_graph(frozen_graph, 'models', model_name+'.pbtxt', as_text=True)
## NN ends here
# callbacks
# tensorboard = TensorBoard(log_dir="logs/{}".format(time()))
model_name = str(config[parser_args.task]['MODEL_FOLDER']) + '_temporal' + curr_time + '.h5'
model_checkpoint = ModelCheckpoint(model_name, verbose=1, monitor='val_loss',save_best_only=True, mode='auto')
early_stopping = EarlyStopping(monitor="val_loss", verbose=1, patience=8)
log_file_name = os.path.join(config['plotting']['MEASURE_FOLDER'], 'evals-{}.json'.format(curr_time))
csv_logger = CSVLogger(filename=log_file_name, append = True)
# generate a model by training
history = model.fit_generator(train_generator,
epochs=num_epochs,
steps_per_epoch=36690//batch_size,
validation_data= val_generator,
validation_steps=12227//batch_size,
verbose=1,
callbacks=[model_checkpoint, early_stopping, csv_logger])
with open('{}-config_{}.ini'.format(config[parser_args.task]['MODEL_FOLDER'], curr_time), 'w') as cfgfile:
newConfig = configparser.ConfigParser()
newConfig[parser_args.task] = config[parser_args.task]
#print(config[parser_args.task])
newConfig.write(cfgfile)
print("Model is saved at: {}".format(model_name))
# model history generate plot
visualize.visualize_curves(n_epochs=num_epochs, tr=history.history['loss'], val=history.history['val_loss'], filename='{}/loss_{}.png'.format(plot_path, curr_time), network='temporal', optimizer='adam', learning_rate=learning_rate, epsilon=epsilon, clf_type=parser_args.task, batch_size=batch_size, viz_type="loss", early_stopping=True)
metrics=['accuracy'])
"""
8. 重新训练组合的新模型，仍然保持 VGG16 的 15 个最低层处于冻结状态。在这个特定的例子中，也使用 Image Augumentator 来增强训练集：
"""
train_datagen = ImageDataGenerator(rescale=1. / 255, horizontal_flip=True)
test_datagen = ImageDataGenerator(rescale=1. / 255)
train_generator = train_datagen.flow_from_directory(train_data_dir,
target_size=(img_height,
img_width),
batch_size=batch_size,
class_mode='binary')
validation_generator = test_datagen.flow_from_directory(
validation_data_dir,
target_size=(img_height, img_width),
batch_size=batch_size,
class_mode='binary',
shuffle=False)
model.fit_generator(train_generator,
steps_per_epoch=nb_train_samples // batch_size,
epochs=epochs,
validation_data=nb_validation_samples // batch_size,
verbose=2,
workers=12)
"""
9. 在组合网络上评估结果
"""
score = model.evaluate_generator(validation_generator,
nb_validation_samples / batch_size)
scores = model.predict_generator(validation_generator,
nb_validation_samples / batch_size)
# print(score, scores)
ModelCheckpoint(monitor='val_loss',
filepath=root_dir + 'weights/' + weight_name,
save_best_only=True,
save_weights_only=True,
mode='min'),
TQDMCallback(),
TensorBoard(log_dir=root_dir + weight_name.split('.')[0],
histogram_freq=0,
write_graph=True,
write_images=True)
]
history = model.fit_generator(
generator=train_generator(batch_size),
steps_per_epoch=int((train_df.shape[0] / batch_size) / 18), #344,
epochs=50,
verbose=2,
callbacks=callbacks,
validation_data=valid_generator(batch_size),
validation_steps=int(np.ceil(valid_df.shape[0] / batch_size)))
model.load_weights(root_dir + 'weights/' + weight_name)
test_paths = glob(os.path.join(root_dir, 'test/audio/*wav'))
def get_test_set_1d(path, tta=1):
if tta == 1:
x_batch = []
x_batch.append(process_wav_file(path, phase='TEST', dim='1D'))
x_batch = np.array(x_batch)
return x_batch
x = Dense(len(POSSIBLE_LABELS), activation='sigmoid')(x)
model = Model(inputs=x_in, outputs=x)
model.compile(optimizer='rmsprop',
loss='categorical_crossentropy',
metrics=['accuracy'])
model.summary()
# In[ ]:
from keras_tqdm import TQDMNotebookCallback
from tensorflow.python.keras.callbacks import EarlyStopping, ModelCheckpoint, ReduceLROnPlateau
history = model.fit_generator(generator=train_generator(64),
steps_per_epoch=344,
epochs=10,
verbose=1,
validation_data=valid_generator(64),
validation_steps=int(
np.ceil(valid_df.shape[0] / 64)))
# In[ ]:
# In[ ]:
test_paths = glob(os.path.join('./data/', 'test/audio/*wav'))
# In[ ]:
def read():
tmp = []
x = Dropout(0.5)(x)
# 增加 Dense layer，以 softmax 產生個類別的機率值
output_layer = Dense(NUM_CLASSES, activation='softmax', name='softmax')(x)
# 設定凍結與要進行訓練的網路層
net_final = Model(inputs=net.input, outputs=output_layer)
for layer in net_final.layers[:FREEZE_LAYERS]:
layer.trainable = False
for layer in net_final.layers[FREEZE_LAYERS:]:
layer.trainable = True
# 使用 Adam optimizer，以較低的 learning rate 進行 fine-tuning
net_final.compile(optimizer=Adam(lr=1e-5),
loss='categorical_crossentropy',
metrics=['accuracy'])
# 輸出整個網路結構
print(net_final.summary())
# 訓練模型
history = net_final.fit_generator(
train_datagen.flow(x_train, y_train, batch_size=BATCH_SIZE),
steps_per_epoch=x_train.shape[0] // BATCH_SIZE,
validation_data=(x_val, y_val),
epochs=50,
callbacks=[
ModelCheckpoint('ResNet_transferlearning.model',
monitor='val_acc',
save_best_only=True)
])
def iterative_prune_model():
# build the inception v3 network
base_model = inception_v3.InceptionV3(include_top=False,
weights='imagenet',
pooling='avg',
input_shape=(299, 299, 3))
print('Model loaded.')
top_output = Dense(5, activation='softmax')(base_model.output)
# add the model on top of the convolutional base
model = Model(base_model.inputs, top_output)
del base_model
model.load_weights(tuned_weights_path)
# compile the model with a SGD/momentum optimizer
# and a very slow learning rate.
model.compile(loss='categorical_crossentropy',
optimizer=SGD(lr=1e-4, momentum=0.9),
metrics=['accuracy'])
# Set up data generators
train_datagen = ImageDataGenerator(
preprocessing_function=inception_v3.preprocess_input,
shear_range=0.2,
zoom_range=0.2,
horizontal_flip=True)
train_generator = train_datagen.flow_from_directory(
train_data_dir,
target_size=(img_height, img_width),
batch_size=batch_size,
class_mode='categorical')
train_steps = train_generator.n // train_generator.batch_size
test_datagen = ImageDataGenerator(
preprocessing_function=inception_v3.preprocess_input)
validation_generator = test_datagen.flow_from_directory(
validation_data_dir,
target_size=(img_height, img_width),
batch_size=val_batch_size,
class_mode='categorical')
val_steps = validation_generator.n // validation_generator.batch_size
# Evaluate the model performance before pruning
loss = model.evaluate_generator(validation_generator,
validation_generator.n //
validation_generator.batch_size)
print('original model validation loss: ', loss[0], ', acc: ', loss[1])
total_channels = get_total_channels(model)
n_channels_delete = int(math.floor(percent_pruning / 100 * total_channels))
# Incrementally prune the network, retraining it each time
percent_pruned = 0
# If percent_pruned > 0, continue pruning from previous checkpoint
if percent_pruned > 0:
checkpoint_name = ('inception_flowers_pruning_' + str(percent_pruned)
+ 'percent')
model = load_model(output_dir + checkpoint_name + '.h5')
while percent_pruned <= total_percent_pruning:
# Prune the model
apoz_df = get_model_apoz(model, validation_generator)
percent_pruned += percent_pruning
print('pruning up to ', str(percent_pruned),
'% of the original model weights')
model = prune_model(model, apoz_df, n_channels_delete)
# Clean up tensorflow session after pruning and re-load model
checkpoint_name = ('inception_flowers_pruning_' + str(percent_pruned)
+ 'percent')
model.save(output_dir + checkpoint_name + '.h5')
del model
tensorflow.python.keras.backend.clear_session()
tf.reset_default_graph()
model = load_model(output_dir + checkpoint_name + '.h5')
# Re-train the model
model.compile(loss='categorical_crossentropy',
optimizer=SGD(lr=1e-4, momentum=0.9),
metrics=['accuracy'])
checkpoint_name = ('inception_flowers_pruning_' + str(percent_pruned)
+ 'percent')
csv_logger = CSVLogger(output_dir + checkpoint_name + '.csv')
model.fit_generator(train_generator,
steps_per_epoch=train_steps,
epochs=epochs,
validation_data=validation_generator,
validation_steps=val_steps,
workers=4,
callbacks=[csv_logger])
# Evaluate the final model performance
loss = model.evaluate_generator(validation_generator,
validation_generator.n //
validation_generator.batch_size)
print('pruned model loss: ', loss[0], ', acc: ', loss[1])
# Step 2-1: Replace softmax Layer and add one dense layer
# include top = false will remove the last softmax layer, remove 1000 neutron from the model
base_model = VGG16(weights='imagenet', include_top=False)
x = base_model.output
x = GlobalAveragePooling2D()(x)
x = Dense(1024, activation='relu')(x)
prediction = Dense(2, activation='softmax')(x)
model = Model(inputs=base_model.input, outputs=prediction)
for layer in model.layers:
layer.trainable = False
model.compile(loss='binary_crossentropy',
optimizer=optimizers.SGD(lr=1e-4, momentum=0.9),
metrics=['accuracy'])
model.fit_generator(train_generator, steps_per_epoch=10, epochs=epochs)
# Step 2-2: Unfreeze and train the top 5 layers
for layer in model.layers[:5]:
layer.trainable = False
for layer in model.layers[5:]:
layer.trainable = True
model.compile(loss='binary_crossentropy',
optimizer=optimizers.SGD(lr=1e-4, momentum=0.9),
metrics=['accuracy'])
model.fit_generator(train_generator, steps_per_epoch=10, epochs=epochs)
# Save fine tuned weight
model.save('./model/vgg16_cat_dog.h5')
subset='validation',
batch_size=64,
class_mode='categorical')
model.compile(optimizer='Adam',
loss='categorical_crossentropy',
metrics=['accuracy'])
print(train_generator.n)
print(train_generator.batch_size)
print(239 // 32)
# train the model
step_size_train = train_generator.n // train_generator.batch_size
r = model.fit_generator(generator=train_generator,
steps_per_epoch=step_size_train,
epochs=25,
validation_data=val_generator)
#save model
from tensorflow.python.keras.models import load_model
keras.models.save_model(model,
'tumor_prediction.h5',
overwrite=True,
include_optimizer=True)
model.save('tumor_prediction.h5')
train_datagen = ImageDataGenerator(preprocessing_function=preprocess_input)
train_generator = train_datagen.flow_from_directory('./train_dataset',
target_size=(224, 224),
adam = Adam(lr=0.0)
metrics = ['accuracy']
model.compile(optimizer=adam, metrics=metrics, loss=categorical_crossentropy)
model.fit_generator(
train_generator,
validation_data=test_generator,
epochs=100,
use_multiprocessing=False,
workers=10,
callbacks=[
ModelCheckpoint(
'%s/model_{epoch:d}_loss{loss:.4f}_acc_{acc:.4f}.h5' % folder,
monitor='val_loss',
verbose=1,
save_best_only=False,
save_weights_only=True,
mode='auto',
period=1),
CSVLogger(logger, append=log_append),
lr_scheduler(initial_lr=3e-4, decay_factor=0.75, step_size=5, min_lr=1e-8)
],
max_queue_size=30,
)
elif mode == 'testing':
adam = tf.train.AdamOptimizer(learning_rate=1e-3)
model.compile(loss="categorical_crossentropy", optimizer=adam, metrics=['accuracy'])
res = model.evaluate_generator(
test_sequence,
def start_training(tn,vn,ims,bas,epc):
training_num = tn
validation_num = vn
image_size = ims
batch_size = bas
epochs = epc
WEIGHTS_FOLDER = './weights/'
#WEIGHTS_FOLDER = save_path
if not os.path.exists(WEIGHTS_FOLDER):
os.mkdir(WEIGHTS_FOLDER)
# Check if image dimension is correct.
if type(image_size) is list:
val1 = image_size[0]
val2 = image_size[1]
if val1 < 139 or val2 < 139:
print("The size is not ok....")
sys.exit(2)
elif type(image_size) is int:
if image_size <139:
print("The size is not ok...")
sys.exit(2)
# Show the training condition
print("Image size is {}".format(image_size))
print("The batch_size is {}".format(batch_size))
print("The epochs is {}".format(epochs))
# Load images and data from cifar 10
(x_train,y_train),(x_validation,y_validation) = cifar10.load_data()
# Load part of train and test data.
x_train = x_train[:training_num]
x_validation = x_validation[:validation_num]
Y_train = y_train[:training_num]
Y_validation = y_validation[:validation_num]
print("Total Train & Validation Num as shown below")
print("Num of training images : {}".format(x_train.shape[0]))
print("Num of validation images : {}".format(x_validation.shape[0]))
X_train,X_validation = helpResize(x_train,x_validation,image_size)
# Check if both of the list has the correct length.
Y_new_train = np.array([np.zeros(10) for x in range(len(Y_train))],dtype='float32')
for i,x in enumerate(Y_train):
Y_new_train[i][x] = 1
Y_new_val = np.array([np.zeros(10) for x in range(len(Y_validation))],dtype='float32')
for i,x in enumerate(Y_validation):
Y_new_val[i][x] = 1
# This could also be the output of a different Keras model or layer
if type(image_size) is list:
input_shape = tuple(image_size) + (3,)
else:
input_shape = (image_size,image_size,3)
base_model = InceptionV3(weights='imagenet', include_top=False,input_shape=input_shape)
# Get the output of the Inception V3 pretrain model.
x = base_model.output
# Works same as Flatten(), but Flatten has larger dense layers, it might cause worse overfitting.
# However, if the user has a larger dataset then the user can use Flatten() instead of GlobalAveragePooling2D or GlobalMaxPooling2D
x = GlobalAveragePooling2D()(x)
x = Dense(1024, activation='relu')(x)
predictions = Dense(10, activation='softmax')(x)
model = Model(inputs=base_model.input, outputs=predictions)
# Use SGD as an optimizer
model.compile(optimizer=SGD(lr=0.0001, momentum=0.9),
loss='categorical_crossentropy',
metrics=['accuracy'])
datagen = ImageDataGenerator(
rotation_range=0, # Randomly rotate images in the range (degrees, 0 to 180)
# Randomly shift images horizontally (fraction of total width)
width_shift_range=0.1,
# Randomly shift images vertically (fraction of total height)
height_shift_range=0.1,
zoom_range=0., # set range for random zoom
# Set the mode for filling points outside the input boundaries
horizontal_flip=True, # randomly flip images
)
datagen.fit(X_train)
histories = NCHC_CallBack()
c_time = "{}_{}_{}_{}_{}".format(time.localtime().tm_year,time.localtime().tm_mon,time.localtime().tm_mday,time.localtime().tm_hour,time.localtime().tm_min)
mc = ModelCheckpoint(WEIGHTS_FOLDER+c_time+"_weights.{epoch:02d}-acc-{acc:.2f}-loss-{loss:.2f}.hdf5",
monitor='val_loss',
verbose=0,
save_best_only=False,
save_weights_only=False,
mode='auto', period=1)
# Fit the model on the batches generated by datagen.flow().
model.fit_generator(datagen.flow(X_train,
Y_new_train,
batch_size=batch_size),
callbacks = [ histories,mc ], #added here
epochs=epochs,
validation_data=(X_validation, Y_new_val)
)
K.clear_session()
del model
for layer in net_final.layers[FREEZE_LAYERS:]:
layer.trainable = True
# 使用 Adam optimizer，以較低的 learning rate 進行 fine-tuning
net_final.compile(optimizer=Adam(lr=1e-5),
loss='categorical_crossentropy',
metrics=['accuracy'])
# 輸出整個網路結構
print(net_final.summary())
# 訓練模型
history = net_final.fit_generator(
train_batches,
steps_per_epoch=train_batches.samples // BATCH_SIZE,
validation_data=valid_batches,
validation_steps=valid_batches.samples // BATCH_SIZE,
epochs=NUM_EPOCHS,
callbacks=[model_checkpoint_callback])
data_file_path = r'C:\Users\user\Documents\history.pkl'
plt.figure(figsize=(15, 5))
plt.subplot(1, 2, 1)
plt.plot(range(1, NUM_EPOCHS + 1), history.history['acc'])
plt.plot(range(1, NUM_EPOCHS + 1), history.history['val_acc'])
plt.title('model accuracy')
plt.ylabel('accuracy')
plt.xlabel('epoch')
plt.legend(['train', 'val'], loc='upper left')
x = Dropout(0.5)(x)
#Fully connected layer 1
fc1 = tf.keras.layers.Dense(100, activation='relu', name="AddedDense1")(x)
# Use softmax
output_layer = Dense(NUM_CLASSES, activation='softmax', name='softmax')(fc1)
net_final = Model(inputs=net.input, outputs=output_layer)
for layer in net_final.layers[:FREEZE_LAYERS]:
layer.trainable = False
for layer in net_final.layers[FREEZE_LAYERS:]:
layer.trainable = True
# Use Adam optimizer
net_final.compile(optimizer=Adam(lr=0.00001),
loss='categorical_crossentropy',
metrics=['accuracy'])
# Whole network
print(net_final.summary())
# Training model
net_final.fit_generator(train_batches,
steps_per_epoch=train_batches.samples // BATCH_SIZE,
validation_data=valid_batches,
validation_steps=valid_batches.samples // BATCH_SIZE,
epochs=NUM_EPOCHS,
callbacks=callbacks)
net_final.save(WEIGHTS_FINAL)
class STSTask():
def __init__(self, c):
self.c = c
def load_resc(self, dictname):
self.embed = Embedder(dictname, self.c['wordvectdim'])
def load_data(self, trainfile, validfile, testfile):
self.traindata = self._load_data(trainfile)
self.validdata = self._load_data(validfile)
self.testdata = self._load_data(testfile)
def _load_data(self, filename):
global ADD_PREFIX
print(filename)
s0, s1, labels = [], [], []
lines = open(filename, 'r', encoding='utf8').read().splitlines()
for line in lines:
try:
s0x, s1x, label = line.rstrip().split('\t')
labels.append(float(label))
if ADD_PREFIX:
prefix = ''
if filename == 'Dataset/train_set.csv' or filename == 'Dataset/dev_set.csv':
prefix = 'en/'
else:
prefix = 'es/'
s0.append([
prefix + word for word in word_tokenize(s0x)
if word not in string.punctuation
])
s1.append([
prefix + word for word in word_tokenize(s1x)
if word not in string.punctuation
])
#s0.append([prefix+word.lower() for word in word_tokenize(s0x) if word not in string.punctuation])
#s1.append([prefix+word.lower() for word in word_tokenize(s1x) if word not in string.punctuation])
else:
s0.append([
word for word in word_tokenize(s0x)
if word not in string.punctuation
])
s1.append([
word for word in word_tokenize(s1x)
if word not in string.punctuation
])
#s0.append([word.lower() for word in word_tokenize(s0x) if word not in string.punctuation])
#s1.append([word.lower() for word in word_tokenize(s1x) if word not in string.punctuation])
except:
print('Error in line: ' + str(line))
m0 = self.embed.matrixize(s0, self.c['sentencepad'])
m1 = self.embed.matrixize(s1, self.c['sentencepad'])
classes = np.zeros((len(labels), self.c['num_classes']))
for i, label in enumerate(labels):
if np.floor(label) + 1 < self.c['num_classes']:
classes[i, int(np.floor(label)) + 1] = label - np.floor(label)
classes[i, int(np.floor(label))] = np.floor(label) - label + 1
#print(classes)
return {
'labels': labels,
's0': s0,
's1': s1,
'classes': classes,
'm0': m0,
'm1': m1
}
def create_model(self):
K.clear_session()
input0 = Input(shape=(self.c['sentencepad'], self.c['wordvectdim']))
input1 = Input(shape=(self.c['sentencepad'], self.c['wordvectdim']))
Convolt_Layer = []
MaxPool_Layer = []
Flatten_Layer = []
for kernel_size, filters in self.c['cnnfilters'].items():
Convolt_Layer.append(
Convolution1D(filters=filters,
kernel_size=kernel_size,
padding='valid',
activation=self.c['cnnactivate'],
kernel_initializer=self.c['cnninitial']))
MaxPool_Layer.append(
MaxPooling1D(pool_size=int(self.c['sentencepad'] -
kernel_size + 1)))
Flatten_Layer.append(Flatten())
Convolted_tensor0 = []
Convolted_tensor1 = []
for channel in range(len(self.c['cnnfilters'])):
Convolted_tensor0.append(Convolt_Layer[channel](input0))
Convolted_tensor1.append(Convolt_Layer[channel](input1))
MaxPooled_tensor0 = []
MaxPooled_tensor1 = []
for channel in range(len(self.c['cnnfilters'])):
MaxPooled_tensor0.append(MaxPool_Layer[channel](
Convolted_tensor0[channel]))
MaxPooled_tensor1.append(MaxPool_Layer[channel](
Convolted_tensor1[channel]))
Flattened_tensor0 = []
Flattened_tensor1 = []
for channel in range(len(self.c['cnnfilters'])):
Flattened_tensor0.append(Flatten_Layer[channel](
MaxPooled_tensor0[channel]))
Flattened_tensor1.append(Flatten_Layer[channel](
MaxPooled_tensor1[channel]))
if len(self.c['cnnfilters']) > 1:
Flattened_tensor0 = concatenate(Flattened_tensor0)
Flattened_tensor1 = concatenate(Flattened_tensor1)
else:
Flattened_tensor0 = Flattened_tensor0[0]
Flattened_tensor1 = Flattened_tensor1[0]
absDifference = Lambda(lambda X: K.abs(X[0] - X[1]))(
[Flattened_tensor0, Flattened_tensor1])
mulDifference = multiply([Flattened_tensor0, Flattened_tensor1])
allDifference = concatenate([absDifference, mulDifference])
for ilayer, densedimension in enumerate(self.c['densedimension']):
allDifference = Dense(
units=int(densedimension),
activation=self.c['denseactivate'],
kernel_initializer=self.c['denseinitial'])(allDifference)
output = Dense(
name='output',
units=self.c['num_classes'],
activation='softmax',
kernel_initializer=self.c['denseinitial'])(allDifference)
self.model = Model(inputs=[input0, input1], outputs=output)
self.model.compile(loss='mean_squared_error',
optimizer=self.c['optimizer'])
#self.model.compile(loss={'output': self._lossfunction}, optimizer=self.c['optimizer'])
def _lossfunction(self, y_true, y_pred):
ny_true = y_true[:,
1] #+ 2*y_true[:,2] + 3*y_true[:,3] + 4*y_true[:,4] + 5*y_true[:,5]
ny_pred = y_pred[:,
1] #+ 2*y_pred[:,2] + 3*y_pred[:,3] + 4*y_pred[:,4] + 5*y_pred[:,5]
my_true = K.mean(ny_true)
my_pred = K.mean(ny_pred)
var_true = (ny_true - my_true)**2
var_pred = (ny_pred - my_pred)**2
return -K.sum(
(ny_true - my_true) * (ny_pred - my_pred), axis=-1) / (K.sqrt(
K.sum(var_true, axis=-1) * K.sum(var_pred, axis=-1)))
def eval_model(self):
global TEXT_EVAL
results = []
for data in [self.traindata, self.validdata, self.testdata]:
predictionclasses = []
for dataslice, _ in self._sample_pairs(data,
len(data['classes']),
shuffle=False,
once=True):
predictionclasses += list(self.model.predict(dataslice))
#print(predictionclasses)
scores = []
for p in predictionclasses:
if p[0] > p[1]:
scores.append(0)
else:
scores.append(1)
#prediction = np.dot(np.array(predictionclasses),np.arange(self.c['num_classes']))
gold_scores = data['labels']
result = sklearn.metrics.log_loss(gold_scores, scores)
TP, FP, TN, FN = perf_measure(gold_scores, scores)
acc = np.sum(
np.array(gold_scores) == np.array(scores)) / len(gold_scores)
print('Log Loss: ' + str(result))
print('Acc: ' + str(acc))
print('TP: ' + str(TP) + '\tFP: ' + str(FP) + '\tTN: ' + str(TN) +
'\tFN: ' + str(FN))
#print(scores)
#print(gold_scores)
results.append([result, acc, TP, FP, TN, FN])
#result=pearsonr(prediction, goldlabels)[0]
#results.append(round(result,4))
print('TEST:' + str(results[0]))
print('DEV:' + str(results[1]))
print('TEST:' + str(results[2]))
#print(results)
return results
def fit_model(self, wfname):
kwargs = dict()
kwargs['generator'] = self._sample_pairs(self.traindata,
self.c['batch_size'])
kwargs['steps_per_epoch'] = self.c['num_batchs']
kwargs['epochs'] = self.c['num_epochs']
class Evaluate(Callback):
def __init__(self, task, wfname):
self.task = task
self.bestresult = 0.0
self.wfname = wfname
def on_epoch_end(self, epoch, logs={}):
results = self.task.eval_model()
if results[1][0] > self.bestresult:
self.bestresult = results[1][0]
self.task.model.save(self.wfname)
#_,validresult,_,_,_,_,_ = self.task.eval_model()
#if validresult > self.bestresult:
# self.bestresult = validresult
# self.task.model.save(self.wfname)
kwargs['callbacks'] = [Evaluate(self, wfname)]
return self.model.fit_generator(verbose=2, **kwargs)
def _sample_pairs(self, data, batch_size, shuffle=True, once=False):
num = len(data['classes'])
idN = int((num + batch_size - 1) / batch_size)
ids = list(range(num))
while True:
if shuffle: random.shuffle(ids)
datacopy = copy.deepcopy(data)
for name, value in datacopy.items():
valuer = copy.copy(value)
for i in range(num):
valuer[i] = value[ids[i]]
datacopy[name] = valuer
for i in range(idN):
sl = slice(i * batch_size, (i + 1) * batch_size)
dataslice = dict()
for name, value in datacopy.items():
dataslice[name] = value[sl]
x = [dataslice['m0'], dataslice['m1']]
y = dataslice['classes']
yield (x, y)
if once: break
shape=(None, None)) #为解码器的输出创建一个占位符变量
#编译训练模型
decoder_output = connect_decoder(transfer_values=transfer_values_input)
decoder_model = Model(inputs=[transfer_values_input, decoder_input],
outputs=[decoder_output])
decoder_model.compile(optimizer=optimizer,
loss=sparse_cross_entropy,
target_tensors=[decoder_target])
#编写检查点回调
path_checkpoint = '22_checkpoint.keras'
callback_checkpoint = ModelCheckpoint(filepath=path_checkpoint,
verbose=1,
save_weights_only=True)
callback_tensorboard = TensorBoard(log_dir='./22_logs/',
histogram_freq=0,
write_graph=False)
callbacks = [callback_checkpoint, callback_tensorboard]
path_checkpoint = '22_checkpoint.keras'
try:
decoder_model.load_weights(path_checkpoint)
except Exception as error:
print("Error trying to load checkpoint.")
print(error)
#开始训练
decoder_model.fit_generator(generator=generator,
steps_per_epoch=steps_per_epoch,
epochs=50,
callbacks=callbacks)
def train(run_name,
start_epoch,
stop_epoch,
img_w,
build_word_count,
max_string_len,
mono_fraction,
save_model_path=None):
# Input Parameters
img_h = 64
words_per_epoch = 16000
val_split = 0.2
val_words = int(words_per_epoch * (val_split))
# Network parameters
conv_filters = 16
kernel_size = (3, 3)
pool_size = 2
time_dense_size = 32
# GRU output NAN when rnn_size=512 with my GPU, but CPU or rnn_size=256 is ok.
# Tensorflow 1.10 appears, but vanishes in 1.12!
rnn_size = 512
minibatch_size = 32
# if start_epoch >= 12:
# minibatch_size = 8 # 32 is to large for my poor GPU
if K.image_data_format() == 'channels_first':
input_shape = (1, img_w, img_h)
else:
input_shape = (img_w, img_h, 1)
img_gen = TextImageGenerator(minibatch_size=minibatch_size,
img_w=img_w,
img_h=img_h,
downsample_factor=(pool_size**2),
val_split=words_per_epoch - val_words,
build_word_count=build_word_count,
max_string_len=max_string_len,
mono_fraction=mono_fraction)
act = 'relu'
kernel_init = 'he_normal'
input_data = Input(name='the_input', shape=input_shape, dtype='float32')
inner = Conv2D(conv_filters,
kernel_size,
padding='same',
activation=None,
kernel_initializer=kernel_init,
name='conv1')(input_data)
inner = BatchNormalization(axis=3, scale=False, name='bn1')(inner)
inner = Activation(activation=act)(inner)
inner = MaxPooling2D(pool_size=(pool_size, pool_size), name='max1')(inner)
inner = Conv2D(conv_filters,
kernel_size,
padding='same',
activation=None,
kernel_initializer=kernel_init,
name='conv2')(inner)
inner = BatchNormalization(axis=3, scale=False, name='bn2')(inner)
inner = Activation(activation=act)(inner)
inner = MaxPooling2D(pool_size=(pool_size, pool_size), name='max2')(inner)
conv_to_rnn_dims = (img_w // (pool_size**2),
(img_h // (pool_size**2)) * conv_filters)
inner = Reshape(target_shape=conv_to_rnn_dims, name='reshape')(inner)
# cuts down input size going into RNN:
inner = Dense(time_dense_size, activation=act, name='dense1')(inner)
# bidirectional GRU, GRU seems to work as well, if not better than LSTM:
gru_1 = GRU(rnn_size,
return_sequences=True,
kernel_initializer=kernel_init,
name='gru1')(inner)
gru_1b = GRU(rnn_size,
return_sequences=True,
go_backwards=True,
kernel_initializer=kernel_init,
name='gru1_b')(inner)
gru1_merged = concatenate([gru_1, gru_1b])
# transforms RNN output to character activations:
inner = Dense(img_gen.get_output_size(),
kernel_initializer=kernel_init,
name='dense2')(gru1_merged)
y_pred = Activation('softmax', name='softmax')(inner)
labels = Input(name='the_labels',
shape=[img_gen.max_string_len],
dtype='float32')
input_length = Input(name='input_length', shape=[1], dtype='int64')
label_length = Input(name='label_length', shape=[1], dtype='int64')
# Keras doesn't currently support loss funcs with extra parameters
# so CTC loss is implemented in a lambda layer
loss_out = Lambda(ctc_lambda_func, output_shape=(1, ),
name='ctc')([y_pred, labels, input_length, label_length])
# clipnorm seems to speeds up convergence
sgd = SGD(lr=0.02, decay=1e-6, momentum=0.9, nesterov=True, clipnorm=5)
model = Model(inputs=[input_data, labels, input_length, label_length],
outputs=loss_out)
# the loss calc occurs elsewhere, so use a dummy lambda func for the loss
model.compile(loss={
'ctc': lambda y_true, y_pred: y_pred
},
optimizer=sgd,
metrics=['accuracy'])
if start_epoch > 0:
weight_file = os.path.join(
OUTPUT_DIR,
os.path.join(run_name, 'weights%02d.h5' % (start_epoch - 1)))
model.load_weights(weight_file)
print("load_weight: ", weight_file)
# captures output of softmax so we can decode the output during visualization
test_func = K.function([input_data], [y_pred])
viz_cb = VizCallback(run_name, test_func, img_gen.next_val())
model.fit_generator(generator=img_gen.next_train(),
steps_per_epoch=(words_per_epoch - val_words) //
minibatch_size,
epochs=stop_epoch,
validation_data=img_gen.next_val(),
validation_steps=val_words // minibatch_size,
callbacks=[viz_cb, img_gen],
initial_epoch=start_epoch,
verbose=1)
if save_model_path:
predict_model = Model(inputs=input_data, outputs=y_pred)
predict_model.save(save_model_path)
class ConvMnist:
def __init__(self, filename=None):
'''
学習済みモデルファイルをロードする (optional)
'''
self.model = None
if filename is not None:
print('load model: ', filename)
self.model = load_model(filename)
self.model.summary()
def preprocess_input(x, **kwargs):
'''
画像前処理(ここでは何もしない)
'''
# x = 255 - x
return x.astype(np.float32)
def train(self):
'''
学習する
'''
# Convolutionモデルの作成
input = Input(shape=(MODEL_WIDTH, MODEL_HEIGHT, 1))
conv1 = Conv2D(filters=8,
kernel_size=(3, 3),
strides=(1, 1),
padding='same',
activation='relu')(input)
pool1 = MaxPooling2D(pool_size=(2, 2))(conv1)
conv2 = Conv2D(filters=4,
kernel_size=(3, 3),
strides=(1, 1),
padding='same',
activation='relu')(pool1)
dropout1 = Dropout(0.2)(conv2)
flatten1 = Flatten()(dropout1)
output = Dense(units=10, activation='softmax')(flatten1)
self.model = Model(inputs=[input], outputs=[output])
self.model.summary()
self.model.compile(optimizer='adam',
loss='categorical_crossentropy',
metrics=['accuracy'])
## fit_generatorを使用する場合。windowsだと遅い(画像読み込みをうまく並列化できない)
# データセットをディレクトリ内画像から読み込む用意
idg_train = ImageDataGenerator(
validation_split=0.2,
rescale=1 / 255.,
# preprocessing_function=preprocess_input
)
# training用データのgenerator(全学習画像の内80%)
img_itr_train = idg_train.flow_from_directory(
'mnist_images/train',
subset="training",
color_mode="grayscale",
target_size=(MODEL_WIDTH, MODEL_HEIGHT),
batch_size=BATCH_SIZE,
class_mode='categorical',
)
# validation用データのgenerator(全学習画像の内20%)
img_itr_validation = idg_train.flow_from_directory(
'mnist_images/train',
subset="validation",
color_mode="grayscale",
target_size=(MODEL_WIDTH, MODEL_HEIGHT),
batch_size=BATCH_SIZE,
class_mode='categorical',
)
# Convolutionモデルの学習
self.model.fit_generator(
img_itr_train,
steps_per_epoch=math.ceil(img_itr_train.samples / BATCH_SIZE),
epochs=EPOCH_NUM,
validation_data=img_itr_validation,
validation_steps=math.ceil(img_itr_validation.samples /
BATCH_SIZE),
)
# テスト用データで評価する
idg_test = ImageDataGenerator(
rescale=1 / 255.,
# preprocessing_function=preprocess_input
)
img_itr_test = idg_test.flow_from_directory('mnist_images/test',
color_mode="grayscale",
target_size=(MODEL_WIDTH,
MODEL_HEIGHT),
batch_size=BATCH_SIZE,
class_mode=None,
shuffle=False)
# 識別処理実施
probs = self.model.predict_generator(
img_itr_test, steps=math.ceil(img_itr_test.samples / BATCH_SIZE))
# 識別精度を計算
predictions = np.argmax(probs, axis=1)
print("score: " +
str(1.0 * np.sum(predictions == img_itr_test.classes) /
img_itr_test.n))
def save_trained_model(self, filename):
'''
学習済みモデルをファイル(h5)に保存する
'''
self.model.save(filename)
def predict(self, input_image):
'''
1つのグレースケール入力画像(28x28のndarray)に対して、数字(0～9)を判定する
ret: result, score
'''
if input_image.shape != (MODEL_WIDTH, MODEL_HEIGHT):
return -1, -1
input_image = input_image.reshape(1, input_image.shape[0],
input_image.shape[1], 1)
input_image = input_image / 255.
probs = self.model.predict(input_image)
result = np.argmax(probs[0])
return result, probs[0][result]
def main(cfg):
print("Training has Started!")
sess = tf.Session()
graph = tf.get_default_graph()
set_session(sess)
#print(sess)
batch_size = 32
test_train_split = cfg['test_train_split']
max_epoch = cfg['epochs']
shape = (224, 224)
#dropout_prob = 0.3
#train_size_per_label = 500
#test_size_per_label = 100
meta = {}
meta['img_fmt'] = cfg['image_extension']
meta['shape'] = shape
input_train, input_test, out_train, out_test, classes = fe.util.get_local_images(
cfg['pth_data'], test_train_split, meta['img_fmt'], shape)
meta['classes'] = classes
print("input_test shape: {}".format(input_test.shape))
x = fe.util.get_cifar10()
print("cifar10 shape: {}".format(x[0].shape))
total_train_steps = len(input_train) // batch_size
out_train = to_categorical(out_train, len(classes))
out_test = to_categorical(out_test, len(classes))
print(
"\nloading ResNet50... this could take a bit of time. I'll let you know when I'm done.\n"
)
st = time.time()
resnet50 = fe.util.get_resnet50(shape=shape + (3, ))
bottleneck_train_features = resnet50.predict(input_train)
bottleneck_test_features = resnet50.predict(input_test)
print("\nCompleted loading ResNet50 in {0:.2f}s \n".format(time.time() -
st))
in_layer = Input(shape=(bottleneck_train_features.shape[1:]))
x = Conv2D(filters=100, kernel_size=2)(in_layer)
x = Dropout(0.4)(x)
x = GlobalAveragePooling2D()(x)
x = Dropout(0.3)(x)
predictions = Dense(len(classes), activation='softmax')(x)
model = Model(inputs=in_layer, outputs=predictions)
print(model.summary())
def save_model(cfg, epoch):
pth_save = os.path.join(
cfg['pth_model_save'], "{}-{:05d}".format(cfg['data_to_train_on'],
epoch))
print("saving model to {}".format(pth_save))
if not os.path.exists('my_folder'): os.makedirs(pth_save)
pth_modl = os.path.join(pth_save, SAVED_MODEL_NAME)
tf.keras.models.save_model(model,
pth_modl,
overwrite=True,
include_optimizer=True,
save_format=None)
pth_meta = os.path.join(pth_save, SAVED_META_NAME)
with open(pth_meta, "w") as write_file:
json.dump(meta, write_file)
class RecordAccuracy(Callback):
def on_epoch_begin(self, epoch, logs=None):
print(f'Running epoch {epoch}. Total {total_train_steps} batches')
def on_batch_end(self, batch, logs=None):
loss = logs['loss']
if not batch % 10:
print(f'Running batch {batch}: train loss - {loss}')
def on_epoch_end(self, epoch, logs=None):
loss = logs["loss"]
val_acc = logs["val_acc"]
print(
f'Epoch {epoch}: train loss - {loss}. test accuracy - {val_acc}'
)
save_model(cfg, epoch)
model.compile(optimizer='adam',
loss='categorical_crossentropy',
metrics=['acc'])
model.fit_generator(batch_generator(bottleneck_train_features, out_train),
steps_per_epoch=len(bottleneck_train_features) //
batch_size,
validation_data=(bottleneck_test_features, out_test),
verbose=2,
epochs=max_epoch,
callbacks=[RecordAccuracy(),
TensorBoard()])
print(asci_eye.format("Training Complete!"))
save_model(cfg, max_epoch)
