def load_data(args):
"""
Modify this to load your data and labels
"""
validation_data_params = {
"dim": (args.patch_dim, args.patch_dim, args.patch_dim),
"batch_size": 1,
"n_in_channels": args.number_input_channels,
"n_out_channels": 1,
"train_test_split": args.train_test_split,
"augment": False,
"shuffle": False,
"seed": args.random_seed
}
validation_generator = DataGenerator(False, args.data_path,
**validation_data_params)
# for batch_idx in tqdm(range(validation_generator.num_batches),
# desc="Predicting on batch"):
batch_idx = 0
imgs, msks = validation_generator.get_batch(batch_idx)
fileIDs = validation_generator.get_batch_fileIDs(batch_idx)
"""
OpenVINO uses channels first tensors (NCHWD).
TensorFlow usually does channels last (NHWDC).
So we need to transpose the axes.
"""
imgs = imgs.transpose((0, 4, 1, 2, 3))
msks = msks.transpose((0, 4, 1, 2, 3))
return imgs, msks, fileIDs
def main(args):
print("Starting")
callbacks_list = list()
logdir = 'logs/scalars/' + datetime.now().strftime('%Y%m%d-%H%M%S')
# Keras Tensorboard callback
tb_callback = keras.callbacks.TensorBoard(log_dir=logdir)
callbacks_list.append(tb_callback)
print(callbacks_list)
train_loader = DataGenerator(mode='train')
val_loader = DataGenerator(mode='val')
print('loaded data generators')
model = siamese_architecture()
print('training')
train(n_epochs=args.n_epochs,
lr=args.lr,
model=model,
train_gen=train_loader,
val_gen=val_loader,
callbacks_list=callbacks_list)
def __init__(self):
self.epoch = 150
self.lr = 0.005
self.lr_drop = 5
self.batch_size = 1
self.model = build_model()
self.trainLoader = DataGenerator('./data/rgb_train.txt',
batch_size=self.batch_size,
random_shift=True,
transform=trainAug())
self.valLoader = DataGenerator('./data/rgb_val.txt',
batch_size=self.batch_size,
random_shift=False,
transform=valAug())
def handle_camera():
# Load input video
data_loader = CameraLoader().start()
(fourcc, fps, frameSize) = data_loader.videoinfo()
print('the video is {} f/s'.format(fps))
# =========== end video ===============
# Load detection loader
print('Loading YOLO model..')
sys.stdout.flush()
det_loader = DetectionLoader(data_loader, batchSize=args.detbatch).start()
# start a thread to read frames from the file video stream
det_processor = DetectionProcessor(det_loader).start()
# Load pose model
runtime_profile = {'dt': [], 'pt': [], 'pn': []}
#Data generator
generator = DataGenerator(det_processor, args.fast_inference).start()
print(enumerate())
# # Data writer
# save_path = os.path.join(args.outputpath, 'AlphaPose_' + ntpath.basename(video_file).split('.')[0] + '.avi')
# # writer = DataWriter(args.save_video, save_path, cv2.VideoWriter_fourcc(*'XVID'), fps, frameSize).start()
# writer = DataWriter(args.save_video).start()
print('Start pose estimation...')
return generator
def train_function(conf, args, input, label, ch_indicator):
"""
train function
input args:
conf:
args:
input:
label:
ch_indcator:
"""
# initialize the network model
gan = KernelNet(conf, args, input, ch_indicator)
# data generation
dataset = DataGenerator(conf, gan, input, label)
# batch size
batch_size = conf.batch_size
for iteration in range(conf.max_iters):
# learning rate adjust
if iteration % conf.update_l_rate_freq == 0:
for params in gan.optimizer_G.param_groups:
params['lr'] /= conf.update_l_rate_rate
# generate a batch of input and label
for batch_index in range(iteration*batch_size, (iteration+1)*batch_size, 1):
[g_in, d_in] = dataset.__getitem__(batch_index)
if batch_index == iteration*batch_size:
# if the batch index is the first of the batch, copy it
g_batch = g_in
d_batch = d_in
else:
# generate the batch, concat the rest input
g_batch = np.concatenate((g_batch, g_in), axis=0)
d_batch = np.concatenate((d_batch, d_in), axis=0)
g_batch = torch.from_numpy(g_batch).float()
d_batch = torch.from_numpy(d_batch).float()
g_batch = g_batch.cuda()
d_batch = d_batch.cuda()
gan.train(g_batch, d_batch, iteration)
reduce_lr = K.callbacks.ReduceLROnPlateau(monitor="val_loss", factor=0.2,
patience=5, min_lr=0.0001)
callbacks = [checkpoint, tb_logs, reduce_lr]
training_data_params = {"dim": (args.patch_height, args.patch_width, args.patch_depth),
"batch_size": args.bz,
"n_in_channels": args.number_input_channels,
"n_out_channels": 1,
"train_test_split": args.train_test_split,
"validate_test_split": args.validate_test_split,
"augment": True,
"shuffle": True,
"seed": args.random_seed}
training_generator = DataGenerator("train", args.data_path,
**training_data_params)
training_generator.print_info()
validation_data_params = {"dim": (args.patch_height, args.patch_width, args.patch_depth),
"batch_size": 1,
"n_in_channels": args.number_input_channels,
"n_out_channels": 1,
"train_test_split": args.train_test_split,
"validate_test_split": args.validate_test_split,
"augment": False,
"shuffle": False,
"seed": args.random_seed}
validation_generator = DataGenerator("validate", args.data_path,
**validation_data_params)
validation_generator.print_info()
"combined_dice_ce_loss": combined_dice_ce_loss
})
print("Loading images and masks from test set")
validation_data_params = {
"dim": (args.patch_height, args.patch_width, args.patch_depth),
"batch_size": 1,
"n_in_channels": args.number_input_channels,
"n_out_channels": 1,
"train_test_split": args.train_test_split,
"augment": False,
"shuffle": False,
"seed": args.random_seed
}
validation_generator = DataGenerator(False, args.data_path,
**validation_data_params)
m = model.evaluate_generator(validation_generator,
verbose=1,
max_queue_size=args.num_prefetched_batches,
workers=args.num_data_loaders,
use_multiprocessing=False)
print("\n\nTest metrics")
print("============")
i = 0
for name in model.metrics_names:
print("{} = {:.4f}".format(name, m[i]))
i += 1
save_directory = "predictions_directory"
K.backend.set_session(SESS)
unet_model = unet(channels_last = True) # channels first or last
model = K.models.load_model(args.saved_model, custom_objects=unet_model.custom_objects)
print("Loading images and masks from test set")
validation_data_params = {"dim": (args.patch_height, args.patch_width, args.patch_depth),
"batch_size": 1,
"n_in_channels": args.number_input_channels,
"n_out_channels": 1,
"train_test_split": args.train_test_split,
"augment": False,
"shuffle": False, "seed": args.random_seed}
testing_generator = DataGenerator("test", args.data_path,
**validation_data_params)
testing_generator.print_info()
m = model.evaluate_generator(testing_generator, verbose=1,
max_queue_size=args.num_prefetched_batches,
workers=args.num_data_loaders,
use_multiprocessing=False)
print("\n\nTest metrics")
print("============")
for idx, name in enumerate(model.metrics_names):
print("{} = {:.4f}".format(name, m[idx]))
save_directory = "predictions_directory"
try:
class_weights = class_weight.compute_class_weight('balanced',
np.unique(y_train),
y_train)
print(class_weights)
sample_array = []
BATCH_SIZE = 8
IMG_WIDTH, IMG_HEIGHT = 1024, 1024
TRAIN_IMG_PATH = '/media/parth/DATA/datasets/aptos_2019/train_cropped'
print('---------------------Initialized Training---------------------\n')
# Add Image augmentation to our generator
train_datagen = DataGenerator(TRAIN_IMG_PATH,
batch_size=BATCH_SIZE,
dataframe=train,
dim=(IMG_HEIGHT, IMG_WIDTH),
split=True)
print('Found {} Train Images'.format(train_datagen.__len__() * BATCH_SIZE))
val_datagen = DataGenerator(TRAIN_IMG_PATH,
batch_size=BATCH_SIZE,
dataframe=test,
dim=(IMG_HEIGHT, IMG_WIDTH),
split=True)
print('Found {} Val Images\n'.format(val_datagen.__len__() * BATCH_SIZE))
# print('\n\n')
# print(len(train_datagen))
model = create_model((IMG_HEIGHT // 2, IMG_WIDTH // 2),
class_weights,
split=True)
momentum=0.9,
decay=0,
nesterov=False)
# mobilenet.model.compile(optimizer=opt, loss=bce_dice_loss, metrics=[iou_metric])
mobilenet.model.compile(optimizer=opt,
loss='categorical_crossentropy',
metrics=['accuracy'])
# Get data generators
train_folder = "/home/dep_pic/AI_Data/AI_Train_Data/LIP/LIP/TrainVal_images/train_all"
train_label_folder = "/home/dep_pic/AI_Data/AI_Train_Data/LIP/LIP/TrainVal_parsing_annotations/train_all"
train_id_file = "/home/dep_pic/AI_Data/AI_Train_Data/LIP/LIP/TrainVal_images/train_id.txt"
train_generator = DataGenerator(df=train_folder,
lf=train_label_folder,
id_file=train_id_file,
resize=(224, 224),
shuffle=True,
augmentations=True,
cla_num=cla_num)
val_folder = "/home/dep_pic/AI_Data/AI_Train_Data/LIP/LIP/TrainVal_images/val_half"
val_label_folder = "/home/dep_pic/AI_Data/AI_Train_Data/LIP/LIP/TrainVal_parsing_annotations/train_all"
val_id_file = "/home/dep_pic/AI_Data/AI_Train_Data/LIP/LIP/TrainVal_images/val_id.txt"
val_generator = DataGenerator(df=val_folder,
lf=val_label_folder,
id_file=val_id_file,
resize=(224, 224),
shuffle=False,
augmentations=False,
cla_num=cla_num)
'num_class': num_class,
'split_set': 'Train',
'shuffle': True}
params_valid = {'batch_size': 200,
'label_type': label_type,
'num_class': num_class,
'split_set': 'Validation',
'shuffle': False}
# Output models saving folder
if not os.path.isdir('./Models/'):
os.makedirs('./Models/')
# Generators
training_generator = DataGenerator(root_dir, **params_train)
validation_generator = DataGenerator(root_dir, **params_valid)
# Model Settings
if label_type == 'attr':
filepath='./Models/DenseNN_model[epoch'+str(epochs)+'-batch'+str(batch_size)+'-nodes'+str(num_nodes)+']_'+label_type+'.hdf5'
elif label_type == 'class':
filepath='./Models/DenseNN_model[epoch'+str(epochs)+'-batch'+str(batch_size)+'-nodes'+str(num_nodes)+']_'+num_class+'.hdf5'
checkpoint = ModelCheckpoint(filepath, monitor='val_loss', verbose=1, save_best_only=True, mode='min')
callbacks_list = [checkpoint]
# Model structure loading
if label_type == 'attr':
model = dense_network_MTL(num_nodes=num_nodes)
elif label_type == 'class':
model = dense_network_class(num_nodes=num_nodes, num_class=int(num_class.split('-')[0]))
#imgs_test = np.load(os.path.join(sys.path[0],"imgs_test_3d.npy"))
#msks_test = np.load(os.path.join(sys.path[0],"msks_test_3d.npy"))
seed = hvd.rank() # Make sure each worker gets different random seed
training_data_params = {
"dim": (args.patch_height, args.patch_width, args.patch_depth),
"batch_size": args.bz,
"n_in_channels": args.number_input_channels,
"n_out_channels": 1,
"train_test_split": args.train_test_split,
"augment": True,
"shuffle": True,
"seed": seed
}
training_generator = DataGenerator(True, args.data_path,
**training_data_params)
validation_data_params = {
"dim": (args.patch_height, args.patch_width, args.patch_depth),
"batch_size": 1,
"n_in_channels": args.number_input_channels,
"n_out_channels": 1,
"train_test_split": args.train_test_split,
"augment": False,
"shuffle": False,
"seed": args.random_seed
}
validation_generator = DataGenerator(False, args.data_path,
**validation_data_params)
# Fit the model
dataloader = DataLoader(tokenizer,
config['max_len'],
use_vae=True,
batch_size=config["batch_size"],
ae_epochs=config['ae_epochs'])
dataloader.set_train(config['train_path'])
dataloader.set_dev(config['dev_path'])
dataloader.save_autoencoder(
os.path.join(config['save_dir'], 'autoencoder.weights'))
dataloader.save_vocab(os.path.join(config['save_dir'], 'vocab.pickle'))
accuracy_list = []
f1_list = []
for idx in range(1, config['iterations'] + 1):
print("build generator")
generator = DataGenerator(config['batch_size'], config['max_len'])
generator.set_dataset(dataloader.train_set)
metrics_callback = Metrics(
config['batch_size'], config['max_len'], dataloader.dev_set,
os.path.join(config['save_dir'], 'clf_model.weights'))
config['steps_per_epoch'] = generator.steps_per_epoch
config['output_size'] = dataloader.label_size
model = AGNClassifier(config)
print("start to fitting...")
model.model.fit(generator.__iter__(),
steps_per_epoch=generator.steps_per_epoch,
epochs=config['epochs'],
callbacks=[metrics_callback],
verbose=config['verbose'])
accuracy = max(metrics_callback.history["val_acc"])
with open("ids_train", 'rb') as f:
ids_train = pickle.load(f)
with open("y_train", 'rb') as f:
y_train = pickle.load(f)
with open("ids_test", 'rb') as f:
ids_test = pickle.load(f)
with open("y_test", 'rb') as f:
y_test = pickle.load(f)
print(ids_train)
print("LOAD DATA FROM FILE DONE")
# exit()
train_generator = DataGenerator(ids_train,
y_train,
batch_size=8,
n_classes=len(classes))
valid_generator = DataGenerator(ids_test,
y_test,
batch_size=8,
n_classes=len(classes),
shuffle=False)
print("train_generator:", len(train_generator))
print("valid_generator:", len(valid_generator))
model = Sequential()
model.add(Conv1D(128, kernel_size=5, input_shape=(256, 768)))
# model.add(GlobalMaxPooling1D())
model.add(Conv1D(64, kernel_size=3, activation='relu'))
model.add(GlobalMaxPooling1D())
min_lr=0.0001)
callbacks = [checkpoint, tb_logs, reduce_lr]
training_data_params = {
"dim": (args.patch_height, args.patch_width, args.patch_depth),
"batch_size": args.bz,
"n_in_channels": args.number_input_channels,
"n_out_channels": 1,
"train_test_split": args.train_test_split,
"augment": True,
"shuffle": True,
"seed": args.random_seed
}
training_generator = DataGenerator(True, args.data_path,
**training_data_params)
validation_data_params = {
"dim": (args.patch_height, args.patch_width, args.patch_depth),
"batch_size": 1,
"n_in_channels": args.number_input_channels,
"n_out_channels": 1,
"train_test_split": args.train_test_split,
"augment": False,
"shuffle": False,
"seed": args.random_seed
}
validation_generator = DataGenerator(False, args.data_path,
**validation_data_params)
# Fit the model
def train_model():
## GPU Setting : 30%
os.environ["CUDA_VISIBLE_DEVICES"] = "1"
config = tf.ConfigProto(device_count={'GPU': 1})
config.gpu_options.allow_growth = True
config.gpu_options.per_process_gpu_memory_fraction = 0.4
session = tf.Session(config=config)
set_session(session)
early_stopping = EarlyStopping(monitor='val_loss', patience=10)
## Parameter
epochs = 150
batch_size = 64
cropsize = 200
input_shape = (cropsize, 40, 1)
print('input_shape = ', input_shape)
# Parameters
params = {
'dim': input_shape,
'batch_size': 64,
'n_classes': 921,
'shuffle': True
}
# Datasets
with open('./data/train.txt', 'r') as fp:
train_list = fp.readlines()
with open('./data/val.txt', 'r') as fp:
val_list = fp.readlines()
with open('./data/test.txt', 'r') as fp:
test_list = fp.readlines()
file_list = train_list + val_list + test_list
labels = dict()
for i in range(len(file_list)):
label, filename, _ = file_list[i].replace('\n', '').split('\t')
labels[filename] = int(label)
partition = dict() # IDs
partition['train'] = []
for i in range(len(train_list)):
label, filename, start_idx = train_list[i].replace('\n',
'').split('\t')
partition['train'].append([filename, start_idx])
partition['validation'] = []
for i in range(len(val_list)):
label, filename, start_idx = val_list[i].replace('\n', '').split('\t')
partition['validation'].append([filename, start_idx])
partition['evaluation'] = []
for i in range(len(test_list)):
label, filename, start_idx = test_list[i].replace('\n', '').split('\t')
partition['evaluation'].append([filename, start_idx])
# Generators
training_generator = DataGenerator(partition['train'],
labels,
cropsize,
flag='random',
**params)
validation_generator = DataGenerator(partition['validation'],
labels,
cropsize,
flag='fix',
**params)
evaluation_generator = DataGenerator(partition['evaluation'],
labels,
cropsize,
flag='fix',
**params)
## Load Model
model = build_CRNN_200(input_shape)
adam = optimizers.Adam(lr=0.001)
model.compile(loss=amsoftmax_loss, optimizer=adam, metrics=['accuracy'])
# Train model on dataset
history = model.fit_generator(generator=training_generator,
validation_data=validation_generator,
use_multiprocessing=True,
epochs=epochs,
verbose=1,
callbacks=[early_stopping],
workers=6)
model.summary()
now = datetime.datetime.now()
Today = now.strftime('%Y%m%d')
os.makedirs('best_model', exist_ok=True)
# Save model
model.save('./best_model/model_speaker_2sec_64.h5')
# Evaluation
score = model.evaluate_generator(evaluation_generator)
print('loss, acc : ', score)
try:
# loss graph
fig, loss_ax = plt.subplots()
loss_ax.plot(history.history['loss'], 'y', label='train_loss')
loss_ax.plot(history.history['val_loss'], 'r', label='val_loss')
loss_ax.set_xlabel('epoch')
loss_ax.set_ylabel('loss')
plt.savefig('./best_model/training_curve.png')
# loss graph
fig, acc_ax = plt.subplots()
acc_ax.plot(history.history['acc'], 'b', label='train_acc')
acc_ax.plot(history.history['val_acc'], 'g', label='val_acc')
acc_ax.set_xlabel('epoch')
acc_ax.set_ylabel('acc')
acc_ax.set_ylim([0, 1.1])
fig.legend(loc='upper left')
plt.savefig('./best_model/accuracy_curve.png')
except Exception as e:
print('Failed to save graph')
print(e)
clear_session()
def test(self, error_func_list=None, is_visualize=False):
from demorender import demoAll
total_task = len(self.test_data)
print('total img:', total_task)
model = self.net.model
total_error_list = []
num_output = self.mode[3]
num_input = self.mode[4]
data_generator = DataGenerator(all_image_data=self.test_data,
mode=self.mode[2],
is_aug=False,
is_pre_read=self.is_pre_read)
with torch.no_grad():
model.eval()
for i in range(len(self.test_data)):
data = data_generator.__getitem__(i)
x = data[0]
x = x.to(self.net.device).float()
y = [data[j] for j in range(1, 1 + num_input)]
for j in range(num_input):
y[j] = y[j].to(x.device).float()
y[j] = torch.unsqueeze(y[j], 0)
x = torch.unsqueeze(x, 0)
outputs = model(x, *y)
p = outputs[-1]
x = x.squeeze().cpu().numpy().transpose(1, 2, 0)
p = p.squeeze().cpu().numpy().transpose(1, 2, 0) * 280
b = sio.loadmat(self.test_data[i].bbox_info_path)
gt_y = y[0]
gt_y = gt_y.squeeze().cpu().numpy().transpose(1, 2, 0) * 280
temp_errors = []
for error_func_name in error_func_list:
error_func = getErrorFunction(error_func_name)
error = error_func(gt_y, p, b['Bbox'], b['Kpt'])
temp_errors.append(error)
total_error_list.append(temp_errors)
print(self.test_data[i].init_image_path, end=' ')
for er in temp_errors:
print('%.5f' % er, end=' ')
print('')
if is_visualize:
if temp_errors[0] > 0.00:
tex = np.load(self.test_data[i].texture_path.replace(
'zeroz2', 'full')).astype(np.float32)
init_image = np.load(
self.test_data[i].cropped_image_path).astype(
np.float32) / 255.0
show([p, tex, init_image], mode='uvmap')
init_image = np.load(
self.test_data[i].cropped_image_path).astype(
np.float32) / 255.0
show([gt_y, tex, init_image], mode='uvmap')
demobg = np.load(
self.test_data[i].cropped_image_path).astype(
np.float32)
init_image = demobg / 255.0
img1, img2 = demoAll(p, demobg, is_render=False)
mean_errors = np.mean(total_error_list, axis=0)
for er in mean_errors:
print('%.5f' % er, end=' ')
print('')
for i in range(len(error_func_list)):
print(error_func_list[i], mean_errors[i])
se_idx = np.argsort(np.sum(total_error_list, axis=-1))
se_data_list = np.array(self.test_data)[se_idx]
se_path_list = [a.cropped_image_path for a in se_data_list]
sep = '\n'
fout = open('errororder.txt', 'w', encoding='utf-8')
fout.write(sep.join(se_path_list))
fout.close()
ckpt = ModelCheckpoint(monitor='val_loss',
filepath=ckpt_path,
save_best_only=True,
save_weights_only=True,
verbose=1,
mode='min')
tensorboard = TensorBoard(log_dir=args.outputs,
histogram_freq=0,
write_graph=True,
write_images=True)
callbacks = [lr, ckpt, tensorboard]
train_generator = DataGenerator(path=os.path.join(
args.dataset, 'train'),
batch_size=args.batch_size)
valid_generator = DataGenerator(path=os.path.join(args.dataset, 'val'),
batch_size=args.batch_size)
print('Training on {} samples'.format(len(train_generator)))
print('Validating on {} samples'.format(len(valid_generator)))
model.fit_generator(
generator=train_generator,
initial_epoch=0,
epochs=args.epochs,
verbose=1,
validation_data=valid_generator,
callbacks=callbacks,
from dataloader import DataGenerator
# hyper-parameters
EMBEDDING_DIM = 768
batch_size = 32
epochs = 20
rnn_units = 256
# load data
training_data = np.load('preprocessed_data/training_data.npz',
allow_pickle=True)
x_train = training_data['x']
y_train = training_data['y']
del training_data
# model
model = Sequential()
model.add(Masking(mask_value=0., input_shape=(None, EMBEDDING_DIM)))
model.add(Bidirectional(LSTM(rnn_units, return_sequences=True)))
model.add(Attention(bias=False))
model.add(Dense(2, activation='softmax'))
model.compile(loss='binary_crossentropy', optimizer='rmsprop', metrics=['acc'])
print(model.summary())
# train
train_generator = DataGenerator(x_train, y_train, batch_size=batch_size)
model.fit(train_generator, epochs=epochs)
# save model
model.save('my_model.h5')
model = unet_model.model.load_model(args.saved_model,
custom_objects=unet_model.custom_objects)
print("Loading images and masks from test set")
validation_data_params = {
"dim": (args.patch_height, args.patch_width, args.patch_depth),
"batch_size": 1,
"n_in_channels": args.number_input_channels,
"n_out_channels": 1,
"train_test_split": args.train_test_split,
"augment": False,
"shuffle": False,
"seed": args.random_seed
}
testing_generator = DataGenerator("test", args.data_path,
**validation_data_params)
testing_generator.print_info()
m = model.evaluate_generator(testing_generator,
verbose=1,
max_queue_size=args.num_prefetched_batches,
workers=args.num_data_loaders,
use_multiprocessing=False)
print("\n\nTest metrics")
print("============")
for idx, name in enumerate(unet_model.model.metrics_names):
print("{} = {:.4f}".format(name, m[idx]))
save_directory = "predictions_directory"
try:
batch_size = 128
#
model1_epoch = 40
model2_epoch = 50
learning_rate = [0.000001]
#
for i in learning_rate:
# print("initial discriminative patch : ", end =" ")
model1, model2 = ConvolutionNN(), ConvolutionNN()
train_Instance, train_Instance_label, train_Instance_latent = data_generation_MIL(
"C:\\Users\\yeon\\datasets\\CancerClassify\\Train")
valid_Instance, valid_Instance_label, valid_Instance_latent = data_generation_MIL(
"C:\\Users\\yeon\\datasets\\CancerClassify\\Valid")
train_generator = DataGenerator(1).generate(train_Instance, train_Instance_label)
valid_generator = DataGenerator(1).generate(valid_Instance, valid_Instance_label)
num_bag = len(train_Instance)
val_bag = len(valid_Instance)
model1, model2 = train_step1(model1, model2, model1_epoch, model2_epoch, trn_num_bag=num_bag, val_num_bag=val_bag,
batch_size=batch_size,
learning_rate=i, latent_bag=train_Instance_latent, trn_loader=train_generator,
val_loader=valid_generator, per1=65, per2=65)
del train_Instance
del train_Instance_label
del train_Instance_latent
del valid_Instance
del valid_Instance_label
del valid_Instance_latent
del train_generator
del valid_generator
checkpoint
]
training_data_params = {
"dim": (args.patch_height, args.patch_width, args.patch_depth),
"batch_size": args.bz,
"n_in_channels": args.number_input_channels,
"n_out_channels": 1,
"train_test_split": args.train_test_split,
"validate_test_split": args.validate_test_split,
"augment": True,
"shuffle": True,
"seed": hvd.rank()
}
training_generator = DataGenerator("train", args.data_path,
**training_data_params)
if (hvd.rank() == 0):
training_generator.print_info()
validation_data_params = {
"dim": (args.patch_height, args.patch_width, args.patch_depth),
"batch_size": 1,
"n_in_channels": args.number_input_channels,
"n_out_channels": 1,
"train_test_split": args.train_test_split,
"validate_test_split": args.validate_test_split,
"augment": False,
"shuffle": False,
"seed": args.random_seed
}
validation_generator = DataGenerator("validate", args.data_path,
from dataloader import DataGenerator, Dataloader
from myNet import Nets
import numpy as np
import os
import time
H, W, C = 224, 224, 3
shape = (H, W, C)
n_classes = 5
batch_size = 16
epochs = 10
save_model = './model/aslCNN.h5'
train_data = DataGenerator('./train', n_classes)
valid_data = DataGenerator('./valid', n_classes).valid_generator()
nets = Nets(n_classes, shape)
model = nets.CNN()
def train():
model.summary()
model.fit_generator(train_data.train_generator(batch_size),
epochs=epochs,
validation_data=valid_data,
steps_per_epoch=len(train_data.files) // batch_size)
model.save_weights(save_model)
def test(path):
model.load_weights(save_model)
