def data_generator(model, train_data, val_data):
train_gen = DataGenerator(root_dir, model, train_data, batch_size,
target_dim, n_classes)
val_gen = DataGenerator(root_dir, model, val_data, batch_size, target_dim,
n_classes)
return train_gen, val_gen
def train(sr_model, opt, loss, tr_hr, tr_lr, vl_hr, vl_lr, epochs, batch_size,
path_save):
patch_gen(tr_hr, "train", path_save)
patch_gen(vl_hr, "validation", path_save)
val_txt = open(path_save + "validation.txt", "r+")
tr_txt = open(path_save + "train.txt", "r+")
tr_patch_list = tr_txt.readlines()
val_patch_list = (val_txt.readlines())
if loss == "ssim_loss":
loss = ssim_loss
elif loss == "psnr_loss":
loss = psnr_loss
tr_generator = DataGenerator(tr_patch_list, batch_size, tr_hr, tr_lr)
vl_generator = DataGenerator(val_patch_list, batch_size, vl_hr, vl_lr)
sr_model.compile(optimizer=opt, loss=loss)
sr_model.fit(tr_generator, epochs=epochs, validation_data=vl_generator)
def __init__(self):
pygame.init()
self.display = pygame.display.set_mode((600, 660), pygame.SRCALPHA, 32)
# Game level (Probably should modify this)
self.frames = 0
self.speed = 15
# Game essentials
self.grid = Grid()
self.gGrid = Grid()
self.piece = Piece.generate_piece(randint(1, 7))
# Data generation for the neural network
self.data_gen = DataGenerator()
# Arg flags
self.is_human = True
self.debug_mode = False
self.model = None
self.flag_setup()
def do_eval(model_path):
# Load saved Model
model = load_model(model_path,
custom_objects={
'soft_dice_loss': soft_dice_loss,
'mean_iou': mean_iou
})
# Load Test Img-GT Paths
img2gt_paths = get_data_paths(train=False)
# Initialize DataGenerator
generator = DataGenerator(img2gt_paths, batch_size=1)
loss, acc, m_iou = model.evaluate_generator(generator,
steps=len(img2gt_paths))
print('Pixel level accuracy: {}'.format(acc))
print('Mean IoU: {}'.format(m_iou))
def predict(model, data):
print("Prediction: #samples {}".format(len(data)))
generator = DataGenerator(root_dir, model, data, batch_size, target_dim,
n_classes)
_, infests = zip(*generator.image_infest_list)
labels = [infest_to_class_ind(n_classes, infest) for infest in infests]
predictions = model.predict_generator(generator, verbose=True)
label_predictions = predictions.argmax(axis=1)
n_match = sum(y_pred == y_true
for y_pred, y_true in zip(label_predictions, labels))
if n_classes > 2:
fpr, tpr, _ = roc_curve(labels, predictions[:, 1])
auc_keras = auc(fpr, tpr)
plot_ROC(fpr, tpr, auc_keras)
print("Test acc {}".format(n_match / len(labels)))
print(classification_report(labels, label_predictions))
def do_train(batch_size, save_name):
# Load the Train Img-GT Paths
img2gt_paths = get_data_paths(train=True)
# Initialize Data Generator
generator = DataGenerator(img2gt_paths, batch_size=batch_size)
# Create Model and Transfer Caffe weights
model = create_model()
model.compile(optimizer=keras.optimizers.Adam(lr=0.0001),
loss=soft_dice_loss,
metrics=['accuracy', mean_iou])
model.fit_generator(generator=generator,
steps_per_epoch=int(
np.floor(len(img2gt_paths) / batch_size)),
epochs=8,
use_multiprocessing=True,
workers=8)
model.save(save_name)
"/saved-model-{epoch:02d}-{val_classifier_accuracy:.2f}.hdf5"
checkpoint = callbacks.ModelCheckpoint(filepath,
monitor='val_classifier_accuracy',
verbose=1,
save_best_only=False,
mode='max')
BATCH = 32
file_names_train, gt_train, n_train = data_preprocessing.load_metadata('train')
file_names_test, gt_test, n_test = data_preprocessing.load_metadata('test')
gt_train, gt_test, shape_mean, shape_std = normalize_data(gt_train, gt_test)
training_generator = DataGenerator(list(range(len(file_names_train))),
file_names_train,
train_image_path,
gt_train,
dim=(50, 50),
batch_size=BATCH,
shuffle=True)
validation_generator = DataGenerator(list(range(len(file_names_test))),
file_names_test,
test_image_path,
gt_test,
dim=(50, 50),
batch_size=BATCH,
shuffle=False)
model = FullyConnected()
epochs = 1000
opt = Adam()
# print(len(train_d.keys()))
# train_d = dict(filter(lambda elem: select_fights(elem[0]), train_d.items()))
print(len(train_d.keys()))
print(Counter(list(train_d.values())))
print(Counter(list(val_d.values())))
# print(Counter(list(test_d.values())))
train_keys = list(train_d.keys()) * n_mul_train
val_keys = list(val_d.keys()) * n_mul_val
# test_keys = list(test_d.keys())
# Generators
print("Params for DataGen:", params)
training_generator = DataGenerator(train_keys,
train_d,
**params,
type_gen='train')
validation_generator = DataGenerator(val_keys,
val_d,
**params,
type_gen='test')
# params['shuffle'] = False
# params['batch_size'] = 2
# testing_generator = DataGenerator(test_keys, test_d, **params, type_gen='test')
X, Y = training_generator[0] # returns variables and labels pair
print(X[0].shape, X[1].shape, Y.shape)
X0 = X[0]
X1 = X[1]
fig = plt.figure(figsize=(8, 8))
################################################################################
dataset_type = 'data'
dirname = 'MichelEnergyImageData' if 'Data' in args.input else 'MichelEnergyImage'
n_channels = 1
conv_depth = 2
patch_w, patch_h = 160, 160
batch_size = 16
steps = 0
################################################################################
print('Building data generator')
test_gen = DataGenerator(dataset_type=dataset_type,
dirname=dirname,
batch_size=batch_size,
shuffle=False,
root_data=args.input,
patch_w=patch_w,
patch_h=patch_h,
patch_depth=n_channels)
################################################################################
sess = tf.InteractiveSession()
with sess.as_default():
print('Loading model')
if 'inception' in args.weights:
model = inception_unet(inputshape=(patch_w, patch_h, n_channels),
conv_depth=int(args.weights.split('_')[2][-1]),
number_base_nodes=int(
args.weights.split('_')[1][-2:]))
else:
def evaluate(config, weights_path):
###### Parameters setting
dim = (config['model']['input_width'], config['model']['input_height']
) # for MobileNetV2
n_sequence = config['model']['sequence'] # for LSTM
n_channels = config['model']['channels'] # color channel(RGB)
n_output = config['model']['class_num'] # number of output class
batch_size = config['train']['batch_size']
n_mul_train = 1 # To increase sample of train set
n_mul_test = 4 # To increase sample of test set
path_dataset = config['train']['data_dir']
######
params = {
'dim': dim,
'batch_size': batch_size,
'n_sequence': n_sequence,
'n_channels': n_channels,
'path_dataset': path_dataset,
'option': 'RGBdiff',
'shuffle': False
}
test_txt = config['valid']['file_list']
test_d = readfile_to_dict(test_txt)
key_list = list(test_d.keys()) * n_mul_test # IDs
# validation_generator = DataGeneratorBKB(partition['validation'] , labels, **params, type_gen='test') # for evalutate_generator
predict_generator = DataGenerator(key_list,
test_d,
**params,
type_gen='predict')
# evaluate
eval_graph = tf.Graph()
eval_sess = tf.Session(graph=eval_graph, config=tf_config)
keras.backend.set_session(eval_sess)
with eval_graph.as_default():
keras.backend.set_learning_phase(0)
model = create_model(n_output)
model.load_weights(weights_path)
# Example for evaluate generator
# If you want to use, just uncomment it
# loss, acc = model.evaluate_generator(validation_generator, verbose=0)
# print(loss,acc)
# #### Confusion Matrix
y_pred_prob = model.predict_generator(predict_generator, workers=0)
test_y = np.array(list(test_d.values()) * n_mul_test)
print("-----------")
print(y_pred_prob.shape)
print(len(test_y))
y_pred = np.argmax(y_pred_prob, axis=1)
normalize = True
all_y = len(test_y)
sum = all_y
for i in range(len(y_pred)):
if test_y[i] != y_pred[i]:
sum -= 1
print(key_list[i], ' actual:', test_y[i], 'predict:', y_pred[i])
cm = confusion_matrix(test_y, y_pred)
if normalize:
cm = cm.astype('float') / cm.sum(axis=1)[:, np.newaxis]
print("Normalized confusion matrix")
else:
print('Confusion matrix, without normalization')
accuracy = sum / all_y
print("accuracy:", accuracy)
classes = [*range(1, n_output + 1)] # [1,2,3,...,18]
df_cm = pd.DataFrame(cm, columns=classes, index=classes)
df_cm.index.name = 'Actual'
df_cm.columns.name = 'Predicted'
fig, ax = plt.subplots(figsize=(5, 5))
sn.set(font_scale=0.6) #for label size
sn.heatmap(df_cm,
cmap="Blues",
annot=True,
fmt=".2f",
annot_kws={"size": 8}) # font size
# ax.set_ylim(5, 0)
# plt.show()
plt.savefig('eval_model.png')
class GameManager:
'''Game manager class. Manages the main game loop and will manage other things as events.'''
def __init__(self):
pygame.init()
self.display = pygame.display.set_mode((600, 660), pygame.SRCALPHA, 32)
# Game level (Probably should modify this)
self.frames = 0
self.speed = 15
# Game essentials
self.grid = Grid()
self.gGrid = Grid()
self.piece = Piece.generate_piece(randint(1, 7))
# Data generation for the neural network
self.data_gen = DataGenerator()
# Arg flags
self.is_human = True
self.debug_mode = False
self.model = None
self.flag_setup()
def flag_setup(self):
'''Setup function for whatever is needed'''
arguments = sys.argv[1:]
if '-ai' in arguments:
print('AI is working')
self.is_human = False
ai_file = arguments[arguments.index('-ai') + 1]
self.model = load(ai_file)
if '-debug' in arguments:
self.debug_mode = True
if '-o' in arguments:
pass
def handle_events(self):
'''Handle all events in the event queue'''
for event in pygame.event.get():
if event.type == pygame.QUIT:
print('Bye bye')
exit()
if self.is_human:
self.handle_human_input(event)
if not self.is_human:
row = []
for i in range(self.gGrid.height):
for j in range(self.gGrid.width):
row.append(int(self.gGrid[i][j] > 0))
row.append(self.piece.piece_type)
reshaped_row = np.asarray(row).reshape(1, -1)
move = self.model.predict(reshaped_row)[0]
if move == 1:
self.rotate()
elif move == 2:
self.dropdown()
elif move == 3:
self.move_right()
elif move == 4:
self.move_left()
def handle_human_input(self, event):
'''Handle human input if control is given'''
if event.type == pygame.KEYDOWN:
# Rotation
if event.key == pygame.K_r:
self.rotate()
self.data_gen.write_grid(self.gGrid, self.piece.piece_type, 1)
# Drop down
elif event.key == pygame.K_s:
self.dropdown()
self.data_gen.write_grid(self.gGrid, self.piece.piece_type, 2)
elif event.key == pygame.K_d:
self.move_right()
self.data_gen.write_grid(self.gGrid, self.piece.piece_type, 3)
elif event.key == pygame.K_a:
self.move_left()
self.data_gen.write_grid(self.gGrid, self.piece.piece_type, 4)
def rotate(self):
self.piece.rotate(self.grid)
def dropdown(self):
self.piece.pos_y += self.piece.dropdown(self.grid)
def move_right(self):
if self.piece.can_place(
piece=self.piece.shape,
grid=self.grid,
dx=1,
) == PieceState.CAN_PLACE:
self.piece.pos_x += 1
def move_left(self):
if self.piece.can_place(
piece=self.piece.shape,
grid=self.grid,
dx=-1,
) == PieceState.CAN_PLACE:
self.piece.pos_x += -1
def update(self):
'''Update part from the loop. All logic should be managed from here.'''
if self.frames % self.speed == 0:
if self.piece.can_place(
#piece=self.piece,
piece=self.piece.shape,
grid=self.grid,
dy=1,
) == PieceState.CAN_PLACE:
self.piece.pos_y += 1
if self.is_human:
self.data_gen.write_grid(self.gGrid, self.piece.piece_type,
0)
else:
# Place piece
self.grid.set_piece(self.piece)
self.grid.check_completition()
self.piece = Piece.generate_piece(randint(1, 7))
self.gGrid.grid = deepcopy(self.grid.grid)
self.gGrid.set_piece(self.piece)
def render(self):
'''Render method of the game loop. Here everything will be rendered.'''
self.display.fill((100, 100, 100))
self.gGrid.render(self.display, x=10, y=20)
pygame.display.update()
def print(self):
'''
Print part from the loop. The grid will be printed from here.
If there is enough time, print will be eventually be made into a render function
for functional graphics.
'''
system('clear')
self.gGrid.print()
print('Piece type: ', self.piece.piece_type)
def loop(self):
'''Game loop'''
clock = pygame.time.Clock()
# self.setup()
while True:
clock.tick(30)
self.frames += 1
self.handle_events()
self.update()
self.render()
if self.debug_mode:
self.print()
# Parameters
params = {
'dim': (30, 30),
'batch_size': 200,
'n_channels': 3,
'shuffle': True
}
# Datasets
partition = create_partition(10000)
# Generators
data_generators = {
'training_generator':
DataGenerator(partition['train'], **params),
'validation_generator':
DataGenerator(partition['validation'], **params),
'test_generator':
DataGenerator(partition['test'], **params),
'predition_generator':
PredictionDataGenerator(partition['test'], dim=(30, 30))
}
model = create_model()
history, result, predictions = evaluate_model(
model,
data_generators,
'checkpoints/model3/cp-{epoch:04d}.ckpt',
period=1,
epochs=40,
name += '_basenodes' + str(number_base_nodes)
name += '_layers' + str(number_layers)
name += '_convdepth' + str(conv_depth)
name += '_patchsize' + str(patch_w)
name += '_final'
################################################################################
if use_generator:
print ('Using generator')
number_keys = 100 if test_sample else 0
train_gen = DataGenerator(root_data = args.input,
dataset_type = 'train',
dirname = 'MichelEnergyImage',
batch_size = batch_size,
patch_w = patch_w,
patch_h = patch_h,
patch_depth = n_channels,
number_keys = number_keys)
val_gen = DataGenerator(root_data = args.input,
dataset_type = 'val',
dirname = 'MichelEnergyImage',
batch_size = batch_size,
patch_w = patch_w,
patch_h = patch_h,
patch_depth = n_channels,
number_keys = number_keys)
else:
print ('Using large batches')
#perm = np.random.permutation(full_data_size)
perm = range(full_data_size)
partition = {
'train': [str(perm[i]) for i in xrange(train_size)],
'validation':
[str(perm[i]) for i in xrange(train_size, train_size + val_size)],
'test': [
str(perm[i]) for i in xrange(train_size + val_size, train_size +
val_size + test_size)
]
#'validation':[ str(perm[i]) for i in xrange(val_size) ],
#'test':[ str(perm[i]) for i in xrange(test_size) ]
}
print noEpochs, train_size, val_size, test_size
training_generator = DataGenerator(partition['train'], **params)
validation_generator = DataGenerator(partition['validation'], **params)
test_generator = DataGenerator(partition['test'], **params)
print('Traning:')
model.fit_generator(generator=training_generator,
validation_data=validation_generator,
epochs=noEpochs,
use_multiprocessing=True,
workers=12,
verbose=1)
print('Testing')
pred_labels = np.array(
model.predict_generator(generator=test_generator,
use_multiprocessing=True,
""" Fetch files for train(ing)/test(ing). """
def fetch_files(purpose):
subdirectory = MAIN_DIRECTORY + purpose
all_folders = [
folder for folder in Path(subdirectory).iterdir() if folder.is_dir()
]
all_files = []
for folder in all_folders:
all_files.extend([
str(x) for x in Path(folder).iterdir() if str(x).endswith('.npy')
])
return all_files
if __name__ == "__main__":
# obtain relevant files
training_files = fetch_files('train')
validation_files = fetch_files('test')
# get data generators
training_gen = DataGenerator(training_files, **params)
validation_gen = DataGenerator(validation_files, **params, shuffle=False)
model = nn_model()
model.fit_generator(generator=training_gen,
validation_data=validation_gen,
use_multiprocessing=True,
workers=NUM_WORKERS,
epochs=NUM_EPOCHS)
model.save('../predict_emo.h5')
inter.add(Dense(50, activation='softmax'))
# x = MaxPooling2D(pool_size=(2,2))(x)
# x = Flatten()(x)
# x = Dense(1000)(x)
# x = Dense(500)(x)
# preds = Dense(50, activation='softmax')(x)
#
# final_model = Model(inputs=noise.input, outputs=preds)
sgd = SGD(lr=0.001, decay=0.00004)
top3_acc = functools.partial(metrics.top_k_categorical_accuracy, k=3)
top3_acc.__name__ = 'top3_acc'
inter.compile(loss='categorical_crossentropy', optimizer=sgd, metrics=['accuracy', top3_acc])
inter.summary()
feat_dict = get_vector_from_cats()
training_generator = DataGenerator(train_imgs, train_labels, feat_dict)
validation_generator = DataGenerator(val_imgs, val_labels, feat_dict)
testing_generator = DataGenerator(test_imgs, test_labels, feat_dict)
cp_callback = ModelCheckpoint('/home/ad0915/Desktop/CV_final/VGG19_weights/aug_bce_rms.h5', monitor='val_acc', verbose=1, save_best_only=True, period=4)
#inter.fit_generator(generator=training_generator, validation_data=validation_generator, validation_steps=int(np.floor(850/8)), epochs=400, use_multiprocessing=True, workers=8, callbacks=[cp_callback])
model = load_model('./VGG19_weights/base_msle_sgd0.03_all_noise.h5', custom_objects={'top3_acc':top3_acc})
model.summary()
loss, acc, top3_acc = model.evaluate_generator(testing_generator, verbose=1)
print(' Testing Accuracy = {:5.2f}%'.format(100*acc))
'dim': dim,
'batch_size': batch_size,
'n_sequence': n_sequence,
'n_channels': n_channels,
'path_dataset': path_dataset,
'option': 'RGBdiff',
'shuffle': False
}
test_txt = "dataset_list/testlist.txt"
test_d = readfile_to_dict(test_txt)
key_list = list(test_d.keys()) * n_mul_test # IDs
# validation_generator = DataGeneratorBKB(partition['validation'] , labels, **params, type_gen='test') # for evalutate_generator
predict_generator = DataGenerator(key_list,
test_d,
**params,
type_gen='predict')
model = create_model_pretrain(dim, n_sequence, n_channels, n_output)
model.load_weights(weights_path)
# Example for evaluate generator
# If you want to use, just uncomment it
# loss, acc = model.evaluate_generator(validation_generator, verbose=0)
# print(loss,acc)
# #### Confusion Matrix
y_pred_prob = model.predict_generator(predict_generator, workers=0)
test_y = np.array(list(test_d.values()) * n_mul_test)
print("-----------")
print(y_pred_prob.shape)
import numpy as np
import cv2
from data_gen import DataGenerator
batch_size = 32
num_classes = 10
im_size = 64
num_epochs = 100
train_path = '/data/ImageNet/data64/train'
val_path = '/data/ImageNet/data64/val'
saveDir = '/data/ImageNet/autoencoder/dae_keras/64'
if not os.path.isdir(saveDir):
os.makedirs(saveDir)
training_generator = DataGenerator(train_path)
validation_generator = DataGenerator(val_path)
input_img = Input(shape=(im_size, im_size, 3))
x = Conv2D(32, (3, 3), padding='same')(input_img)
x = BatchNormalization()(x)
x = Activation('relu')(x)
x = MaxPooling2D((2, 2), padding='same')(x)
x = Conv2D(32, (3, 3), padding='same')(x)
x = BatchNormalization()(x)
x = Activation('relu')(x)
x = MaxPooling2D((2, 2), padding='same')(x)
x = Conv2D(32, (3, 3), padding='same')(x)
x = BatchNormalization()(x)
def train(annotation_path, taxonomy_path, emb_dir, output_dir, exp_id,
label_mode="fine", batch_size=64, num_epochs=1000,
patience=20, learning_rate=1e-4, dropout_size=0.5,
ef_mode=4, l2_reg=1e-5, standardize=True,
timestamp=None, random_state=0):
"""
Train and evaluate a MIL MLP model.
Parameters
----------
annotation_path
emb_dir
output_dir
label_mode
batch_size
num_epochs
patience
learning_rate
dropout_size
l2_reg
standardize
timestamp
random_state
Returns
-------
"""
np.random.seed(random_state)
random.seed(random_state)
# Load annotations and taxonomy
print("* Loading dataset.")
annotation_data = pd.read_csv(annotation_path).sort_values('audio_filename')
with open(taxonomy_path, 'r') as f:
taxonomy = yaml.load(f, Loader=yaml.Loader)
annotation_data_trunc = annotation_data[['audio_filename',
'latitude',
'longitude',
'year',
'week',
'day',
'hour']].drop_duplicates()
file_list = annotation_data_trunc['audio_filename'].to_list()
latitude_list = annotation_data_trunc['latitude'].to_list()
longitude_list = annotation_data_trunc['longitude'].to_list()
year_list = annotation_data_trunc['year'].to_list() #### added
week_list = annotation_data_trunc['week'].to_list()
day_list = annotation_data_trunc['day'].to_list()
hour_list = annotation_data_trunc['hour'].to_list()
full_fine_target_labels = ["{}-{}_{}".format(coarse_id, fine_id, fine_label)
for coarse_id, fine_dict in taxonomy['fine'].items()
for fine_id, fine_label in fine_dict.items()]
fine_target_labels = [x for x in full_fine_target_labels
if x.split('_')[0].split('-')[1] != 'X']
coarse_target_labels = ["_".join([str(k), v])
for k,v in taxonomy['coarse'].items()]
print("* Preparing training data.")
# For fine, we include incomplete labels in targets for computing the loss
fine_target_list = get_file_targets(annotation_data, full_fine_target_labels)
coarse_target_list = get_file_targets(annotation_data, coarse_target_labels)
train_file_idxs, valid_file_idxs = get_subset_split(annotation_data)
if label_mode == "fine":
target_list = fine_target_list
labels = fine_target_labels
elif label_mode == "coarse":
target_list = coarse_target_list
labels = coarse_target_labels
else:
raise ValueError("Invalid label mode: {}".format(label_mode))
num_classes = len(labels)
print(np.shape(target_list[0]), np.shape(labels))
embeddings = load_embeddings(file_list[:1], emb_dir)
print(np.shape(embeddings[0]))
dim = np.shape(embeddings[0]) #(11,597)
num_frames = len(embeddings[0])
print(num_frames)
params = {'dim': dim,
'batch_size': batch_size,
'shuffle': True}
scaler = None
training_generator = DataGenerator(file_list, target_list, train_file_idxs,
latitude_list, longitude_list, year_list, week_list, day_list, hour_list,
len(target_list[0]), emb_dir, **params)
validation_generator = DataGenerator(file_list, target_list, valid_file_idxs,
latitude_list, longitude_list, year_list, week_list, day_list, hour_list,
len(target_list[0]), emb_dir, **params)
model = construct_mlp(dim,
num_classes, num_frames,
ef_mode=ef_mode,
dropout_size=dropout_size,
l2_reg=l2_reg)
if not timestamp:
timestamp = datetime.datetime.now().strftime("%Y%m%d%H%M%S")
results_dir = os.path.join(output_dir, exp_id, timestamp)
if scaler is not None:
scaler_path = os.path.join(results_dir, 'stdizer.pkl')
with open(scaler_path, 'wb') as f:
pk.dump(scaler, f)
if label_mode == "fine":
full_coarse_to_fine_terminal_idxs = np.cumsum(
[len(fine_dict) for fine_dict in taxonomy['fine'].values()])
incomplete_fine_subidxs = [len(fine_dict) - 1 if 'X' in fine_dict else None
for fine_dict in taxonomy['fine'].values()]
coarse_to_fine_end_idxs = np.cumsum([len(fine_dict) - 1 if 'X' in fine_dict else len(fine_dict)
for fine_dict in taxonomy['fine'].values()])
# Create loss function that only adds loss for fine labels for which
# the we don't have any incomplete labels
def masked_loss(y_true, y_pred):
loss = None
for coarse_idx in range(len(full_coarse_to_fine_terminal_idxs)):
true_terminal_idx = full_coarse_to_fine_terminal_idxs[coarse_idx]
true_incomplete_subidx = incomplete_fine_subidxs[coarse_idx]
pred_end_idx = coarse_to_fine_end_idxs[coarse_idx]
if coarse_idx != 0:
true_start_idx = full_coarse_to_fine_terminal_idxs[coarse_idx-1]
pred_start_idx = coarse_to_fine_end_idxs[coarse_idx-1]
else:
true_start_idx = 0
pred_start_idx = 0
if true_incomplete_subidx is None:
true_end_idx = true_terminal_idx
sub_true = y_true[:, true_start_idx:true_end_idx]
sub_pred = y_pred[:, pred_start_idx:pred_end_idx]
else:
# Don't include incomplete label
true_end_idx = true_terminal_idx - 1
true_incomplete_idx = true_incomplete_subidx + true_start_idx
assert true_end_idx - true_start_idx == pred_end_idx - pred_start_idx
assert true_incomplete_idx == true_end_idx
# 1 if not incomplete, 0 if incomplete
mask = K.expand_dims(1 - y_true[:, true_incomplete_idx])
# Mask the target and predictions. If the mask is 0,
# all entries will be 0 and the BCE will be 0.
# This has the effect of masking the BCE for each fine
# label within a coarse label if an incomplete label exists
sub_true = y_true[:, true_start_idx:true_end_idx] * mask
sub_pred = y_pred[:, pred_start_idx:pred_end_idx] * mask
if loss is not None:
loss += K.sum(K.binary_crossentropy(sub_true, sub_pred))
else:
loss = K.sum(K.binary_crossentropy(sub_true, sub_pred))
return loss
loss_func = masked_loss
else:
loss_func = None
training = True
prediction = True
if training == True:
#history = train_model(model, X_train, y_train, X_valid, y_valid,
# results_dir, loss=loss_func,
# batch_size=batch_size, num_epochs=num_epochs,
# patience=patience, learning_rate=learning_rate)
history = train_model(model, training_generator, validation_generator,
results_dir, loss=loss_func,
batch_size=batch_size, num_epochs=num_epochs,
patience=patience, learning_rate=learning_rate)
# Reload checkpointed file
if prediction == True:
model = construct_mlp(dim,
num_classes, num_frames,
ef_mode=ef_mode,
dropout_size=dropout_size,
l2_reg=l2_reg)
#model = multi_gpu_model(model, gpus=2)
#model.summary()
params = {'dim': dim,
'batch_size': 1,
'shuffle': False}
scaler = None
training_generator = DataGenerator(file_list, target_list, train_file_idxs,
latitude_list, longitude_list, year_list, week_list, day_list, hour_list,
len(target_list[0]), emb_dir, **params)
validation_generator = DataGenerator(file_list, target_list, valid_file_idxs,
latitude_list, longitude_list, year_list, week_list, day_list, hour_list,
len(target_list[0]), emb_dir, **params)
out_dir = os.listdir(results_dir)
out_dir.sort()
count = 0
for i in out_dir:
if i[-2:] == "h5":
from keras.models import load_model
from keras.models import model_from_json
model_weight_file = os.path.join(results_dir, i)
model.load_weights(model_weight_file)
print("* Saving model predictions.")
results = {}
results['train'] = model.predict_generator(training_generator, use_multiprocessing=True, workers=8).tolist()
results['validate'] = model.predict_generator(validation_generator, use_multiprocessing=True, workers=8).tolist()
results_path = os.path.join(results_dir, "results.json")
with open(results_path, "w") as f:
json.dump(results, f, indent=2)
generate_output_file(results['validate'], valid_file_idxs, results_dir,
file_list, label_mode, taxonomy, count)
print(np.shape(results['validate']), np.shape(valid_file_idxs))
count = count + 1
MaxPooling3D)
from keras.layers.advanced_activations import LeakyReLU
from keras.losses import categorical_crossentropy
from keras.models import Sequential
from keras.optimizers import Adam
from keras.utils import np_utils
from keras.utils.vis_utils import plot_model
from sklearn.model_selection import train_test_split
from data_gen import DataGenerator
from config import Config
import data_gen
from pre_recall import *
root_data_path = 'data_files'
data_gen_obj = DataGenerator(root_data_path,
temporal_stride=4,
temporal_length=16,
resize=224)
train_data = data_gen_obj.load_samples(data_cat='train')
test_data = data_gen_obj.load_samples(data_cat='test')
print('num of train_samples: {}'.format(len(train_data)))
print('num of test_samples: {}'.format(len(test_data)))
train_generator = data_gen_obj.data_generator(train_data,
batch_size=4,
shuffle=True)
test_generator = data_gen_obj.data_generator(test_data,
batch_size=4,
shuffle=True)
################################################################################
if not (args.input and args.weights):
print('Please provide data, model, and weights')
exit()
n_channels = 3
conv_depth = 3
patch_w, patch_h = 160, 160
batch_size = 1
print('Building data generator')
test_gen = DataGenerator(dataset_type='data',
dirname='MichelEnergyImageData',
batch_size=batch_size,
shuffle=False,
root_data=args.input,
patch_w=patch_w,
patch_h=patch_h,
patch_depth=n_channels)
sess = tf.InteractiveSession()
with sess.as_default():
print('Loading model')
model = unet(inputshape=(patch_w, patch_h, n_channels),
conv_depth=conv_depth)
model.load_weights(args.weights)
print('Reformating data')
test_x = np.zeros((test_gen.__len__(), patch_w, patch_h, n_channels))
test_y = np.zeros((test_gen.__len__(), patch_w, patch_h, 1))
params = {
'dim': dim,
'batch_size': 1,
# 'n_classes': 6,
'n_sequence': n_sequence,
'n_channels': n_channels,
'path_dataset': path_dataset,
'shuffle': False
}
## dataset
test_d = readfile_to_dict("dataset_list/trainlistUCF.txt")
labels = test_d.copy()
partition = {'validation': list(test_d.keys())} # IDs
validation_generator = DataGenerator(partition['validation'],
labels,
**params,
type_gen='test')
predict_generator = DataGenerator(partition['validation'],
labels,
**params,
type_gen='predict')
weights_path = 'pretrain/mobileNet-47-0.97.hdf5' # 15 frame
model = create_model_pretrain(dim, n_sequence, n_channels, n_output,
'MobileNet')
model.load_weights(weights_path)
## evaluate
# loss, acc = model.evaluate_generator(validation_generator, verbose=0)
# print(loss,acc)
def train(config):
###### Parameters setting
dim = (config['model']['input_width'], config['model']['input_height']
) # for MobileNetV2
n_sequence = config['model']['sequence'] # for LSTM
n_channels = config['model']['channels'] # color channel(RGB)
n_output = config['model']['class_num'] # number of output class
batch_size = config['train']['batch_size']
n_mul_train = 1 # To increase sample of train set
n_mul_test = 4 # To increase sample of test set
path_dataset = config['train']['data_dir']
######
# Keyword argument
params = {
'dim': dim,
'batch_size': batch_size, # you can increase for faster training
'n_sequence': n_sequence,
'n_channels': n_channels,
'path_dataset': path_dataset,
'option': 'RGBdiff',
'shuffle': True
}
train_txt = config['train']['file_list']
test_txt = config['valid']['file_list']
# Read file
# train_d and test_d is dictionary that contain name of video as key and label as value
# For example, {'a01\a01_s08_e01': 0, 'a01\a01_s08_e02': 0, .... }
# It's used for getting label(Y)
train_d = readfile_to_dict(train_txt)
test_d = readfile_to_dict(test_txt)
# Prepare key, name of video(X)
train_keys = list(train_d.keys()) * n_mul_train
test_keys = list(test_d.keys()) * n_mul_test
# Generators
training_generator = DataGenerator(train_keys,
train_d,
**params,
type_gen='train')
validation_generator = DataGenerator(test_keys,
test_d,
**params,
type_gen='test')
# define logs for tensorboard
tensorboard = TensorBoard(log_dir='logs', histogram_freq=0)
# train
train_graph = tf.Graph()
train_sess = tf.Session(graph=train_graph, config=tf_config)
keras.backend.set_session(train_sess)
with train_graph.as_default():
# Design model
model = create_model(n_output)
# model.compile(optimizer=tf.train.AdamOptimizer(), loss='sparse_categorical_crossentropy', metrics=['acc'])
model.compile(optimizer='adam',
loss='sparse_categorical_crossentropy',
metrics=['acc'])
model.summary()
start_epoch = 0
# Load weight of unfinish training model(optional)
pretrained_weights = config['train'][
'pretrained_weights'] # name of model
if pretrained_weights != '':
start_epoch = config['train']['start_epoch']
model.load_weights(pretrained_weights)
# Set callback
wgtdir = 'save_weight'
if not os.path.exists(wgtdir):
os.makedirs(wgtdir)
validate_freq = 5
filepath = os.path.join(
wgtdir, "weight-{epoch:02d}-{acc:.2f}-{val_acc:.2f}.hdf5")
checkpoint = ModelCheckpoint(filepath,
monitor='val_acc',
verbose=1,
save_best_only=False,
period=validate_freq)
callbacks_list = [checkpoint, tensorboard]
# Train model on dataset
model.fit_generator(generator=training_generator,
validation_data=validation_generator,
epochs=config['train']['nb_epochs'],
callbacks=callbacks_list,
initial_epoch=start_epoch,
validation_freq=validate_freq)
if not (args.input and args.weights):
print('Please provide data, model, and weights')
exit()
n_channels = 3
conv_depth = 3
patch_w, patch_h = 160, 160
batch_size = 64
steps = 1
print('Building data generator')
test_gen = DataGenerator(dataset_type='data',
dirname='MichelEnergyImage',
batch_size=batch_size,
shuffle=False,
root_data=args.input,
patch_w=patch_w,
patch_h=patch_h,
patch_depth=n_channels)
sess = tf.InteractiveSession()
with sess.as_default():
print('Loading model')
model = unet(inputshape=(patch_w, patch_h, n_channels),
conv_depth=conv_depth)
model.load_weights(args.weights)
print('Loading charge info')
if steps == 0:
test_charge = np.zeros(
'n_channels': 3,
'shuffle': True,
'datapath': f'/vagrant/imgs/training_data2/{PADDING}'
}
partition = get_pickled_partition('all', PADDING)
print(len(partition['test']))
prediction_data = []
for i in range(0, len(partition['test']), 200):
prediction_data.append(partition['test'][i:i + 200])
print(len(prediction_data))
# 1/0
data_generators = {
'test_generator': DataGenerator(partition['test'], **params),
'predition_generator': PredictionDataGenerator(partition['test'],
dim=(48, 48))
}
# for image_path in partition['test']:
# p = os.path.join(params['datapath'], image_path)
# img = cv2.imread(p)
# if img.shape != (95, 95, 3):
# print(img.shape)
# 1/0
checkpoint_path = 'checkpoints/model6-3/cp-0038.ckpt'
model = create_model()
model.load_weights(checkpoint_path)
predictions = []
