def main():
"""Start of training program.
"""
np.random.seed(1)
tf.set_random_seed(2)
args = get_cmd_args()
if args.input_shape[2]!=1:
raise Exception("Currenly tested for only gray scale images. input_shape should be [height,width,1]")
start_training(args)
def run_config(exp_args):
config_file = exp_args[0]
config_dir = exp_args[1]
save_dir = exp_args[2]
exp_name = exp_args[3]
device = exp_args[4]
args = exp_args[5]
master = exp_args[6]
# Load JSON config file
with open(os.path.join(config_dir, config_file), 'r') as f:
config = json.load(f)
trial_id = config_file[:-5] # remove .json at the end
print('########## Trial {}:{} ##########'.format(exp_name, trial_id))
# Create save folder
save_path = os.path.join(save_dir, trial_id)
if not os.path.exists(save_path):
os.makedirs(save_path)
os.makedirs(os.path.join(save_path,
'checkpoints')) # for model checkpoints
os.makedirs(
os.path.join(save_path, 'results')
) # for saving various results afterwards (e.g. plots, samples, etc.)
# Start training
summary, log, data_config, model_config, train_config = start_training(
save_path=save_path,
data_config=config['data_config'],
model_config=config['model_config'],
train_config=config['train_config'],
device=device)
# Save config file (for reproducability)
config['data_config'] = data_config
config['model_config'] = model_config
config['train_config'] = train_config
with open(os.path.join(save_dir, 'configs', config_file), 'w') as f:
json.dump(config, f, indent=4)
# Save summary file
with open(os.path.join(save_path, 'summary.json'), 'w') as f:
json.dump(summary, f, indent=4)
# Save log file
with open(os.path.join(save_path, 'log.json'), 'w') as f:
json.dump(log, f, indent=4)
# Save entry in master file
summary['log_path'] = os.path.join(args.save_dir, exp_name, trial_id,
'log.json')
tmp = master['summaries'].copy()
tmp[trial_id] = summary
master['summaries'] = tmp
# Save master file
with open(os.path.join(save_dir, 'master.json'), 'w') as f:
json.dump(master._getvalue(), f, indent=4)
def train_model(working_dir, pre_training_phase):
# PRE TRAINING
# commit a5030dd7a1b53cd11d5ab7832fa2d43f2093a464
# Merge: a11d13e b30e64e
# Author: Philippe Remy <*****@*****.**>
# Date: Fri Apr 10 10:37:59 2020 +0900
# LibriSpeech train-clean-data360 (600, 100). 0.985 on test set (enough for pre-training).
# TRIPLET TRAINING
# [...]
# Epoch 175/1000
# 2000/2000 [==============================] - 919s 459ms/step - loss: 0.0077 - val_loss: 0.0058
# Epoch 176/1000
# 2000/2000 [==============================] - 917s 458ms/step - loss: 0.0075 - val_loss: 0.0059
# Epoch 177/1000
# 2000/2000 [==============================] - 927s 464ms/step - loss: 0.0075 - val_loss: 0.0059
# Epoch 178/1000
# 2000/2000 [==============================] - 948s 474ms/step - loss: 0.0073 - val_loss: 0.0058
start_training(working_dir, pre_training_phase)
def train_model(event, context):
try:
tables = ('som_ambiente', 'efeito_sonoro', 'musica_ambiente')
success = start_training(tables)
if success:
insert_status('SUCCESS', '')
return build_response_with_success('Success')
insert_status('ERROR', '')
return build_response_with_error(500, 'error on send file to S3')
except Exception as e:
message = f'Internal error:\n{e}'
insert_status('ERROR', message)
logging.info(message)
return build_response_with_error(500, message)
def run(self):
model_id = self.job['model']
categories = self.job['categories']
filename, architecture = get_model(model_id)
cat_dict, categories_id = request_categories(categories)
path = prepare_dataset(categories_id, filename)
model, gen = compile_model(architecture, categories_id)
train_generator, test_generator, image_files, class_indices = create_gens(
path, gen)
train_accuracy, train_loss, val_accuracy, val_loss = start_training(
model, train_generator, test_generator, image_files, filename)
create_labels(cat_dict, filename, class_indices)
api.update_job(
self.job['id'], {
'done': 1,
'train_accuracy': train_accuracy,
'train_loss': train_loss,
'val_accuracy': val_accuracy,
'val_loss': val_loss
})
def main(args):
ensures_dir(args.working_dir)
if args.preprocess:
if args.audio_dir is None:
return Audio(cache_dir=args.working_dir, audio_dir=args.audio_dir, sample_rate=args.sample_rate)
if args.build_keras_inputs:
counts_per_speaker = [int(b) for b in args.counts_per_speaker.split(',')]
kc = KerasFormatConverter(args.working_dir)
kc.generate(max_length=NUM_FRAMES, counts_per_speaker=counts_per_speaker)
kc.persist_to_disk()
if args.train_embedding:
if args.pre_training_phase:
start_training(args.working_dir, pre_training_phase=args.pre_training_phase, epochs=args.epochs_pretrain)
start_training(args.working_dir, pre_training_phase=False, epochs=args.epochs_triplet)
if args.train_classifier:
start_training(args.working_dir, pre_training_phase=False, classify=True, epochs=args.epochs_classifier)
# Create save folder
save_path = os.path.join(save_dir, trial_id)
if not os.path.exists(save_path):
os.makedirs(save_path)
os.makedirs(os.path.join(save_path,
'checkpoints')) # for model checkpoints
os.makedirs(
os.path.join(save_path, 'results')
) # for saving various results afterwards (e.g. plots, samples, etc.)
# Start training
summary, log, data_config, model_config, train_config = start_training(
save_path=save_path,
data_config=config['data_config'],
model_config=config['model_config'],
train_config=config['train_config'],
device=device,
test_code=args.test_code)
# Save config file (for reproducability)
config['data_config'] = data_config
config['model_config'] = model_config
config['train_config'] = train_config
with open(os.path.join(save_dir, 'configs', config_file), 'w') as f:
json.dump(config, f, indent=4)
# Save summary file
with open(os.path.join(save_path, 'summary.json'), 'w') as f:
json.dump(summary, f, indent=4)
def train_model(working_dir):
start_training(working_dir)
def main(arguments):
x_data = dict()
y_data = dict()
tensors = dict()
color_data = dict()
flags = dict()
flags['num_epochs'] = arguments.me
flags['batch_size'] = arguments.batchsize
flags['hold_prob'] = arguments.holdprobabilty
flags['numberofimages'] = arguments.numberOfimages
flags['cd'] = arguments.choosedevice
flags['dataset_folder'] = arguments.foldername
flags['model'] = arguments.model
flags['learn_rate'] = 1e-4
flags['vgg16_weights'] = 'model_weights/vgg16_weights.npz'
flags['inception_v3_weights'] = 'model_weights/inception_v3.ckpt'
flags['chatbot_tensor'] = []
device_name = ['/CPU:0', '/GPU:0']
if device_name[flags['cd']] == '/CPU:0':
print('Using CPU')
else:
print('Using GPU')
# extracting images names and get mean per color
images_names, labels = get_images_names(number_of_images=flags['numberofimages'],
orig_data=flags['dataset_folder'])
color_data['r_mean'], color_data['g_mean'], color_data['b_mean'] = clr_mean(images_names)
# split data to test and train_dev
x_train_dev, x_data['x_test'], y_train_dev, y_data['y_test'] = train_test_split(images_names,
labels,
test_size=0.1,
random_state=17)
assert len(set(y_data['y_test'])) == len(set(y_train_dev))
# split train_dev to train and dev
x_data['x_train'], x_data['x_dev'], y_data['y_train'], y_data['y_dev'] = train_test_split(x_train_dev,
y_train_dev,
test_size=0.1,
random_state=17)
assert len(set(y_data['y_dev'])) == len(set(y_data['y_train'])) == len(set(y_data['y_test']))
# one hot encode the labels
flags['num_classes'] = len(set(y_data['y_test']))
# print(np.array(y_train).shape, np.array(y_dev).shape, np.array(y_test).shape)
y_data['y_train'] = np_utils.to_categorical(y_data['y_train'], flags['num_classes'])
y_data['y_dev'] = np_utils.to_categorical(y_data['y_dev'], flags['num_classes'])
y_data['y_test'] = np_utils.to_categorical(y_data['y_test'], flags['num_classes'])
flags['folder'] = '{:d} classes results batchsize {:d} holdprob {:.2f}/'.format(flags['num_classes'],
flags['batch_size'],
flags['hold_prob'])
# create folders to save results and model
if not os.path.exists(flags['folder']):
os.makedirs(flags['folder'])
if not os.path.exists(flags['folder'] + 'model/'):
os.makedirs(flags['folder'] + 'model/')
'''
initialize model
'''
# better allocate memory during training in GPU
config = tf.ConfigProto()
config.gpu_options.allocator_type = 'BFC'
# create input and label tensors placeholder
with tf.device(device_name[flags['cd']]):
tensors['hold_prob'] = tf.placeholder_with_default(1.0, shape=(), name='hold_prob')
if flags['model'] == 'vgg16':
tensors['input_layer'] = tf.placeholder(tf.float32, [None, 224, 224, 3], 'input_layer')
else:
tensors['input_layer'] = tf.placeholder(tf.float32, [None, 299, 299, 3], 'input_layer')
tensors['labels_tensor'] = tf.placeholder(tf.float32, [None, flags['num_classes']])
if flags['chatbot_tensor']:
tensors['chatbot_tensor'] = tf.placeholder(tf.float32, [None, 10], 'chatbot_tensor')
else:
tensors['chatbot_tensor'] = []
# start tensorflow session
with tf.Session(config=config) as sess:
# create the vgg16 model
tic = time.clock()
if flags['model'] == 'vgg16':
model = Vgg16(tensors['input_layer'], tensors['chatbot_tensor'], flags['vgg16_weights'], sess,
hold_prob=tensors['hold_prob'],
num_classes=flags['num_classes'])
else:
model = InceptionV3(tensors['input_layer'], flags['inception_v3_weights'], sess,
flags['hold_prob'],
num_classes=flags['num_classes'])
toc = time.clock()
print('loading model time: ', toc-tic)
writer = tf.summary.FileWriter('tensorboard')
writer.add_graph(sess.graph)
print('start tensorboard')
# train, dev, and test
start_training(x_data=x_data, y_data=y_data, flags=flags, color_data=color_data, session=sess,
tensors=tensors, last_fc=model.last_layer)
#view the created formatted text file
with open(path_to_savefile, 'rb') as file:
lines = file.readlines()
normalized_pairs = [[
process.normalize_string(s) for s in line.decode('utf8').split('\t')
] for line in lines]
voc = Vocabulary()
filtered_pairs = process.filter_pairs(pairs)
print('Total number of conversations in the dataset:', len(pairs))
print('Filtered conversations:', len(filtered_pairs))
for each_pair in filtered_pairs:
voc.add_sentence(each_pair[0])
voc.add_sentence(each_pair[1])
print('Total words added to vocabulary:', voc.num_of_words - 3)
#remove words from vocab which occur less than 3 times in all chats
#remove the pairs which contain
trimmed_pairs = voc.trim_rare_words(filtered_pairs)
print(
f'Total number of pairs: {len(filtered_pairs)},\nNumber of pairs after rare word removal: {len(trimmed_pairs)}'
)
#path to save trained model
save_model = SAVE_MODEL
start_training(voc, trimmed_pairs, save_model, load_model_path)
help="Dropout applied on the input encodings to the paraphrase module",
type=float,
default=0.2)
parser.add_argument(
"--decoder_lstm_dropout",
help=
"Dropout applied on the outputs within the LSTM stacks for paraphrase module",
type=float,
default=0.2)
parser.add_argument(
"--decoder_output_dropout",
help="Dropout applied on the encodings going to the classifier head",
type=float,
default=0.2)
parser.add_argument(
"--decoder_concat_features",
help=
"Whether to concatenate semantic, style and lstm output features in the output layer or to apply a reduction layer.",
action="store_true")
parser.add_argument(
"--decoder_lstm_additional_input",
help=
"Whether to add a combination of semantics, style and last slot embeddings to the input of the decoder LSTM or not.",
action="store_true")
args = parser.parse_args()
print(args)
start_training(args, unsupervised_args_to_params,
UnsupervisedParaphraseTrain)
def run_train():
"""WARNING: Time consuming operation. Takes around 6 hours"""
start_training()
no_face_image = utils.eliminate_face(face_bounds, found_face,
segmented_image)
del segmented_image
del image
# Hand extraction
hand = utils.get_my_hand(no_face_image)
del no_face_image
# Feature extraction
feature_vector = utils.extract_features(hand)
# Convert 'features' from list to str.
feature_str = ''
for feature_val in feature_vector:
feature_str += str(feature_val) + ','
# Write to file
data.write(feature_str + '%s\n' % label)
except:
continue
print(' ' * 60, end='\r')
print(' ' * 60 + '\rDone!')
start_training_model = input('Start training? [y/N]: ')
if start_training_model == 'y' or start_training_model == 'Y':
from train import start_training
start_training(data_file=data_file_name)
