weight_path = os.path.join(save_dir, weight_name)
# x_train,y_train,x_test,y_test = image_crop.read_data()
# x_train_resized = image_crop.resize_imgs(x_train)
# y = to_categorical(y_train,num_classes=34)
model = MobileNet(include_top=True,
weights=None,
classes=8,
pooling='max',
input_shape=(150, 150, 3))
checkpoint = ModelCheckpoint(filepath=os.path.join(
save_dir, 'MobileNet_weight.{epoch:02d}-{loss:.2f}.hdf5'),
verbose=1)
opt = RMSprop(lr=2e-5)
model.compile(optimizer=opt,
loss=losses.categorical_crossentropy,
metrics=[metrics.categorical_accuracy])
# model.fit(x_train_resized,y,epochs=10,batch_size=36,callbacks=[checkpoint])
model.fit_generator(train_generator,
steps_per_epoch=300,
epochs=10,
validation_data=validation_generator,
validation_steps=100)
model.save(model_path)
model.save_weights(weight_path)
callbacks = [
ReduceLROnPlateau(monitor='val_categorical_accuracy', factor=0.5, patience=5, mode='max', cooldown=3, verbose=1),
ModelCheckpoint(MODEL_WEIGHTS_FILE, monitor='val_categorical_accuracy', save_best_only=True, verbose=1),
]
model = MobileNet(input_shape=(size, size, 1), alpha=1., weights=None, classes=NCATS)
model.compile(optimizer=Adam(lr=learning_rate), loss='categorical_crossentropy',
metrics=[categorical_crossentropy, categorical_accuracy, top_3_accuracy])
print(model.summary())
model.fit_generator(
train_datagen,
steps_per_epoch=STEPS,
# initial_epoch = initial_epoch,
epochs=EPOCHS,
verbose=1,
validation_data=(x_valid, y_valid),
callbacks = callbacks
)
model.load_weights(MODEL_WEIGHTS_FILE)
valid_predictions = model.predict(x_valid, batch_size=128, verbose=1)
map3 = mapk(valid_df[['y']].values, preds2catids(valid_predictions).values)
print('Map3: {:.3f}'.format(map3))
test = pd.read_csv(os.path.join(INPUT_DIR, 'test_simplified.csv'))
test.head()
x_test = df_to_image_array_xd(test, size)
classes=num_classes,
weights=None)
model.compile(optimizer='nadam',
loss='categorical_crossentropy',
metrics=['accuracy'])
model.summary()
# model callbacks
early_stop = EarlyStopping('val_loss', patience=patience)
reduce_lr = ReduceLROnPlateau('val_loss',
factor=0.1,
patience=int(patience / 2),
verbose=1)
csv_logger = CSVLogger(log_file_path, append=False)
model_names = trained_models_path + '.{epoch:02d}-{val_acc:.2f}.hdf5'
model_checkpoint = ModelCheckpoint(model_names,
monitor='val_loss',
verbose=1,
save_best_only=True,
save_weights_only=False)
callbacks = [model_checkpoint, csv_logger, early_stop, reduce_lr]
# training model
model.fit_generator(image_generator.flow(mode='train'),
steps_per_epoch=int(len(train_keys) / batch_size),
epochs=num_epochs,
verbose=1,
callbacks=callbacks,
validation_data=image_generator.flow('val'),
validation_steps=int(len(val_keys) / batch_size))
callbacks=[earlystop,checkpoint]
model.compile(loss='binary_crossentropy',
optimizer=RMSprop(lr=0.0001),
metrics= ['accuracy'])
nb_train_samples=800
nb_validation_sample=150
epochs=10
batch_size=16
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_sample // batch_size)
# In[ ]:
from keras.models import load_model
# In[ ]:
classifier=load_model('face_recog.h5')
# callbacks
log_file_path = base_path + dataset_name + '_emotion_training.log'
csv_logger = CSVLogger(log_file_path, append=False)
early_stop = EarlyStopping('val_loss', patience=patience)
reduce_lr = ReduceLROnPlateau('val_loss',
factor=0.1,
patience=int(patience / 4),
verbose=1)
trained_models_path = base_path + dataset_name + '_mobilenet'
model_names = trained_models_path + '.{epoch:02d}-{val_acc:.2f}.hdf5'
model_checkpoint = ModelCheckpoint(model_names,
'val_loss',
verbose=1,
save_best_only=True)
callbacks = [model_checkpoint, csv_logger, early_stop, reduce_lr]
# loading dataset
data_loader = DataManager(dataset_name, image_size=input_shape[:2])
faces, emotions = data_loader.get_data()
faces = preprocess_input(faces)
num_samples, num_classes = emotions.shape
train_data, val_data = split_data(faces, emotions, validation_split)
train_faces, train_emotions = train_data
model.fit_generator(data_generator.flow(train_faces, train_emotions,
batch_size),
steps_per_epoch=len(train_faces) / batch_size,
epochs=num_epochs,
verbose=1,
callbacks=callbacks,
validation_data=val_data)
from keras.applications import MobileNet
model = MobileNet(weights='../input/mobilenet-h5/mobilenet_1_0_128_tf.h5')
model.summary()
type(model)
x = model.layers[-6].output
predictions = Dense(29,activation='softmax')(x)
model = Model(inputs = model.input, outputs=predictions)
model.summary()
for layer in model.layers[:-23]:
layer.trainable = False
model.compile(Adam(lr = 0.001),loss = 'categorical_crossentropy',metrics = ['accuracy'])
model.fit_generator(train_batches, steps_per_epoch = 3627, validation_data = valid_batches, validation_steps = 723, epochs = 10, verbose = 2)
model.save('sign_language.h5')
####### model build and saved upto here
from keras.models import load_model
class SignLanguageModel():
Signs = ["A", "B","C","D","E","F","G","H","I","J","K","L","M","N","O","P","Q","R","S","T","U","V","W","X","Y","Z",
"del", "nothing",
"space"]
def __init__(self):
filepath='weights_keras/{epoch:02d}-{val_loss:.2f}.hdf5',
monitor='val_acc',
save_best_only=True)
tb = TensorBoard(log_dir='./logs_keras', histogram_freq=1, batch_size=128)
from keras.applications import MobileNetV2
from keras.applications import MobileNet
k_model = MobileNet(input_shape=(224, 224, 3),
alpha=1.0,
depth_multiplier=1,
dropout=1e-3,
include_top=True,
weights=None,
input_tensor=None,
pooling=None,
classes=200)
k_model.compile(optimizer='adam',
metrics=['accuracy'],
loss='categorical_crossentropy')
k_model.summary()
k_model.fit_generator(train_generator,
validation_data=val_generator,
epochs=35,
callbacks=[ckpt],
workers=6,
use_multiprocessing=True)
axs[1].grid()
axs[1].legend(loc=0)
fig.savefig(address_hist, dpi=300)
plt.show();
img_gen = Generate_Data(train_num = 128*4)
length = get_char_length()
input_shape = (IMAGE_HEIGHT,IMAGE_WIDTH,CHANNEL)
model = MobileNet(input_shape=input_shape,alpha=1.,weights=None,classes=CHAR_NUM*length)
#parallel_model = multi_gpu_model(model, 4)
adam = keras.optimizers.Adam(lr = 0.005, beta_1=0.9, beta_2=0.999,decay=0.01)
model.compile(loss='categorical_crossentropy', optimizer=adam, metrics=[accuracy,categorical_accuracy,categorical_crossentropy])
cbk = MyCbk(model)
tensorboard = TensorBoard(log_dir=address_tensorboard,histogram_freq=0)
eva = Evaluate(img_gen.test())
moniter = ReduceLROnPlateau(monitor='val_accuracy', factor=0.5, patience=5, mode='max', cooldown=3, verbose=1)
hists = []
hist = model.fit_generator(generator=img_gen.next_train(),
steps_per_epoch = 600,
epochs = 16,
validation_data = img_gen.next_val(),
validation_steps = 1,
verbose = 1,
callbacks = [cbk,eva,moniter,tensorboard])
hists.append(hist)
draw_hist(hists)
zoom_range = 0.2,
horizontal_flip = True)
validation_datagen_1 = ImageDataGenerator()
history_2 = pre_trained_model_1.fit_generator(train_datagen_1.flow(train_x, train_y, batch_size=32),
steps_per_epoch=len(train_x) / 32,
epochs=10,
validation_data=validation_datagen_1.flow(val_x, val_y, batch_size=32),
validation_steps=len(val_x) / 32)X
# Try MobileNet transfer learning
from keras.applications import MobileNet
from keras.applications.mobilenet import preprocess_input
model_3 = MobileNet(input_shape=(100, 100, 3), alpha=1., weights=None, classes=5005)
model_3.compile(loss='categorical_crossentropy', optimizer="adam", metrics=['accuracy'])
from tensorflow.keras.preprocessing.image import ImageDataGenerator
train_datagen_2 = ImageDataGenerator(rotation_range = 40,
width_shift_range = 0.2,
height_shift_range = 0.2,
shear_range = 0.2,
zoom_range = 0.2,
horizontal_flip = True)
validation_datagen_2 = ImageDataGenerator()
history_3 =model_3.fit_generator(train_datagen_2.flow(X, yy, batch_size=32),
steps_per_epoch=len(X) / 32,
epochs=10)
ReduceLROnPlateau(monitor='val_categorical_accuracy', factor=0.5, patience=1, mode='max', cooldown=3, verbose=1),
ModelCheckpoint(MODEL_WEIGHTS_FILE, monitor='val_categorical_accuracy', save_best_only=True, verbose=1),
]
#model = model_ResNet50(NCATS)
model = MobileNet(input_shape=(size, size, 3), alpha=1., weights=None, classes=NCATS)
model.compile(optimizer=Adam(lr=learning_rate), loss='categorical_crossentropy',
metrics=[categorical_crossentropy, categorical_accuracy, top_3_accuracy])
print(model.summary())
model.fit_generator(
train_datagen,
steps_per_epoch=STEPS,
# initial_epoch = initial_epoch,
epochs=EPOCHS,
verbose=1,
validation_data=valid_datagen , #(x_valid, y_valid),
validation_steps = valSTEPS,
max_q_size=10,
callbacks = callbacks
)
model.load_weights(MODEL_WEIGHTS_FILE)
k = 100
test = pd.read_csv(os.path.join(INPUT_DIR, 'test_simplified.csv'))
test1 = test[:10000]
x_test = df_to_image_array_xd(test1,size=size)
test_predictions1 = model.predict(x_test, batch_size=128, verbose=1)
optim = SGD(lr=learning_rate, momentum=0.9)
else:
optim = Adam(lr=learning_rate)
model.compile(
optimizer=Adam(lr=learning_rate),
loss='categorical_crossentropy',
metrics=[categorical_crossentropy, categorical_accuracy, top_3_accuracy])
print(model.summary())
model.fit_generator(
generator=train_datagen,
steps_per_epoch=math.ceil(n_samples // batch_size),
nb_epoch=nb_epoch,
callbacks=callbacks,
validation_data=(x_valid, y_valid),
# validation_data=val_gen,
# validation_steps = math.ceil(2468645 / batch_size),
max_q_size=10,
workers=4,
verbose=VERBOSEFLAG)
test_df = pd.read_csv("../input/test_simplified.csv")
n_samples = test_df.shape[0]
pick_per_epoch = math.ceil(n_samples / batch_size)
pick_order = np.arange(test_df.shape[0])
all_preds = []
for i in trange(pick_per_epoch):
if __name__ == '__main__':
input_shape = (299, 299, 3)
# hdf = "m1.h5"
hdf = "temporal_vg_smoke_v1.h5"
m = MobileNet(input_shape=(299, 299, 20), weights=None, classes=2)
# load_model(hdf)
m.load_weights(hdf)
m.compile("adam", categorical_crossentropy, metrics=["accuracy"])
# plot_model(m, show_shapes=True)
m.summary()
# data_dir = "/blender/storage/datasets/smoking/gifs/"
data_dir = "/blender/storage/datasets/vg_smoke"
train_seq = SmokeGifSequence(data_dir, neg_txt='negatives.txt', pos_txt='positives.txt',
input_shape_hwc=input_shape,
only_temporal=True)
# val_seq = SmokeGifSequence(data_dir, neg_txt='validate_neg.txt', pos_txt='validate_pos.txt',
# input_shape_hwc=input_shape,
# only_temporal=True)
log_dir = os.path.join("./logs", os.path.basename(hdf))
m.fit_generator(train_seq, len(train_seq), epochs=20,
use_multiprocessing=True, workers=5,
# validation_data=val_seq, validation_steps=len(val_seq),
verbose=1, callbacks=[TensorBoard(log_dir), ModelCheckpoint(hdf)],
)
samplewise_std_normalization=False, # divide each input by its std
zca_whitening=False, # apply ZCA whitening
rotation_range=0, # randomly rotate images in the range (degrees, 0 to 180)
width_shift_range=0.1, # randomly shift images horizontally (fraction of total width)
height_shift_range=0.1, # randomly shift images vertically (fraction of total height)
horizontal_flip=True, # randomly flip images
vertical_flip=False) # randomly flip images
# Compute quantities required for feature-wise normalization
# (std, mean, and principal components if ZCA whitening is applied).
datagen.fit(x_train)
# Fit the model on the batches generated by datagen.flow().
model.fit_generator(datagen.flow(x_train, y_train,
batch_size=batch_size),
epochs=epochs,
validation_data=(x_test, y_test),
workers=4)
# Save model and weights
if not os.path.isdir(save_dir):
os.makedirs(save_dir)
model_path = os.path.join(save_dir, model_name)
model.save(model_path)
print('Saved trained model at %s ' % model_path)
# Score trained model.
scores = model.evaluate(x_test, y_test, verbose=1)
print('Test loss:', scores[0])
print('Test accuracy:', scores[1])
