def manipulate(TAG_NAME,BATCH_SIZE,FILEPATH,LABEL,NUM_CLASSES,MODEL,LAYERS,EPOCHS):
print("Parameters: Timestamp:{} Batch size:{} Model:{} Epochs:{}".format(TAG_NAME,BATCH_SIZE,MODEL,EPOCHS))
data = pd.read_csv(FILEPATH)
rows = np.asarray(data.iloc[:, :])
print("Shuffling brands.")
np.random.shuffle(rows)
print("Shuffle finished.")
layers_list = LAYERS
train_data = rows[:int(0.8*(len(rows)))]
val_data = rows[int(0.8*(len(rows))):]
train_generator = DataGenerator(datas=train_data,batch_size=BATCH_SIZE,label=LABEL,num_classes=NUM_CLASSES)
val_generator = DataGenerator(datas=val_data,batch_size=BATCH_SIZE,label=LABEL,num_classes=NUM_CLASSES)
model = config.model(MODEL).create_model_with_layers(layers_list,NUM_CLASSES)
steps_per_epoch = math.ceil(len(data) / BATCH_SIZE)
checkpoint = ModelCheckpoint("saved_models/{}_best_model.hdf5".format(TAG_NAME), monitor='val_loss', verbose=1, save_best_only=True, save_weights_only=False, mode='auto', period=1)
callback_lists = [checkpoint]
history = model.fit_generator(train_generator,
steps_per_epoch=steps_per_epoch,epochs=EPOCHS,validation_data=val_generator,callbacks=callback_lists)
model.save("model_{}.h5".format(TAG_NAME))
post_process(history,TAG_NAME)
def __init__(self, pre_path=''):
self.all_data = ABSAData()
self.train_iter = self.all_data.train_iter
self.val_iter = self.all_data.val_iter
self.test_iter = self.all_data.test_iter
self.text_vocab = self.all_data.text_vocab
self.aspect_vocab = self.all_data.aspect_vocab
self.label_vocab = self.all_data.label_vocab
self.device_dict = {
-1: 'cpu',
0: 'cuda:0',
1: 'cuda:1',
2: 'cuda:2',
}
self.model = config.model().to(self.device_dict[config.device])
if config.pretrain:
self.load_model(config.pretrain_path)
self.criterion = config.criterion()
# TODO: Set momentum for optimizer, momentum=0.9
self.optimizer = config.optimizer(filter(lambda p: p.requires_grad,
self.model.parameters()),
lr=config.learning_rate,
lr_decay=config.lr_decay,
weight_decay=0.001)
if config.if_log:
self.writer = SummaryWriter(log_dir=config.log_dir)
# Create pretrained model folder
if not config.pretrain:
if pre_path != '':
self.pre_dir = pre_path
def model():
body = b_class
planet = p_class
initialcondition = ic_class
aerodynamics = a_class
engine = e_class
m = cnf.model(body, planet, initialcondition, aerodynamics, engine)
return m
def vqa():
st = time.time()
img = utl.get_img_tensor(cfg.img_path)
img_features = cfg.vgg16_extractor(img)
img_features = tf.reshape(img_features, (1, -1, 512))
out, att = cfg.model(cfg.question_seq, trg=None, image_info=img_features)
cfg.answer = utl.convert_text(cfg.tokenizer_ans, out[0]).replace(' ', '')
cfg.att = att
end = time.time()
return end - st
def run_past_model(weights_path, model=None):
X_test = load_data(test_only=True)
# recreate the model
if model is None:
m = config.model()
else:
m = model()
m.load_weights(weights_path)
test_model(X_test, m, weights_path)
def set_up_models(self, embeddings):
print("..Seting up the models")
classifier_params = config.lstm_classifier_params if config.model is LSTMClassifier else config.hierarchical_lstm_classifier_params
vocabulary, n_embeddings, embedding_layer = embeddings
for i in range(0, self.size):
model = config.model(embedding_layer, n_embeddings,
**classifier_params).cpu()
model_restore_callback = BestModelRestore(
monitor=config.restore_monitor,
mode=config.restore_mode,
verbose=True)
early_stopping_callback = EarlyStopping(
monitor=config.early_stop_monitor,
min_delta=config.early_stop_min_delta,
patience=config.early_stop_patience,
mode=config.early_stop_mode,
verbose=True)
grad_clip_callback = ClipNorm(model.parameters(),
config.max_grad_norm)
lr_callback_2 = MultiStepLR(milestones=[3])
model_pt = Model(model,
config.optimizer,
self.loss_fn,
metrics=['acc', microF1]).cpu()
self.constituents.append(model)
self.constituents_pt.append(model_pt)
self.constituents_callbacks.append(
(model_restore_callback, early_stopping_callback,
grad_clip_callback, lr_callback_2))
if self.type == "stack":
self.stack_model = StackedClassifier(self.size, config.classes)
model_restore_callback = BestModelRestore(
monitor=config.restore_monitor,
mode=config.restore_mode,
verbose=True)
early_stopping_callback = EarlyStopping(
monitor=config.early_stop_monitor,
min_delta=config.early_stop_min_delta,
patience=config.early_stop_patience,
mode=config.early_stop_mode,
verbose=True)
grad_clip_callback = ClipNorm(self.stack_model.parameters(),
config.max_grad_norm)
self.stack_model_pt = Model(
self.stack_model,
config.optimizer,
torch.nn.NLLLoss(torch.Tensor(config.label_weights).cuda()),
metrics=['acc', microF1]).cpu()
self.stack_callbacks = [
model_restore_callback, early_stopping_callback,
grad_clip_callback
]
def train(data, scene, mdl_path, vgg_weights_path):
### hyper-params
lr = config.lr
val_split = config.val_split
max_epoch = config.max_epoch
batch_size = config.batch_size
###
img_shape = np.shape(data[0][0]) #(height, width, channel)
model = config.model(lr, img_shape, scene, vgg_weights_path)
model = model.initModel('SBI')
# make sure that training input shape equals to model output
input_shape = (img_shape[0], img_shape[1])
output_shape = (model.output._keras_shape[1], model.output._keras_shape[2])
assert input_shape == output_shape, 'Given input shape:' + str(
input_shape) + ', but your model outputs shape:' + str(output_shape)
early = keras.callbacks.EarlyStopping(monitor='val_loss',
min_delta=1e-4,
patience=10,
verbose=0,
mode='auto')
mc = keras.callbacks.ModelCheckpoint('weights{epoch:08d}.h5',
save_weights_only=False,
period=1)
redu = keras.callbacks.ReduceLROnPlateau(monitor='val_loss',
factor=0.1,
patience=5,
verbose=0,
mode='auto')
model.fit(data[0],
data[1],
validation_split=val_split,
epochs=max_epoch,
batch_size=batch_size,
callbacks=[redu, early, mc],
verbose=1,
class_weight=data[2],
shuffle=True)
#model.summary()
model.save(mdl_path)
del model, data, early, redu
def set_up_model(vectors, **kwargs):
print("..Setting up the model")
classifier_params = config.lstm_classifier_params if config.model is lstm_classifier.LSTMClassifier else config.hierarchical_lstm_classifier_params
model = config.model(vectors[2], vectors[1], **classifier_params).cuda()
model_restore_callback = BestModelRestore(monitor=config.restore_monitor,
mode=config.restore_mode,
verbose=True)
early_stopping_callback = EarlyStopping(
monitor=config.early_stop_monitor,
min_delta=config.early_stop_min_delta,
patience=config.early_stop_patience,
mode=config.early_stop_mode,
verbose=True)
grad_clip_callback = ClipNorm(model.parameters(), config.max_grad_norm)
# lr_callback_1 = ReduceLROnPlateau(mode="max", patience=1, monitor="val_microF1", threshold=0.002, min_lr=1e-6, verbose=True, threshold_mode='abs')
lr_callback_2 = MultiStepLR(milestones=[2])
loss_fn = torch.nn.CrossEntropyLoss(
torch.Tensor(config.label_weights).cuda())
pt_fw = Model(model, config.optimizer, loss_fn, metrics=['acc', microF1])
return pt_fw, [
model_restore_callback, early_stopping_callback, grad_clip_callback
], model
def train(X_train, y_train, X_val, y_val, weights_path=None):
"""
Trains our CNN
"""
# create base model
# model = ResNet50()
model = config.model()
# restart from middle
if weights_path:
model.load_weights(weights_path)
# optimizers: adam, rmsprop, sgd, etc.
model.compile(optimizer=config.optimizer,
loss='categorical_crossentropy',
metrics=['accuracy', 'top_k_categorical_accuracy'])
# callbacks for training
cb_early_stop = EarlyStopping(monitor="val_loss", patience=config.patience)
cb_checkpoint = ModelCheckpoint("weights.{epoch:02d}-{val_loss:.2f}.hdf5")
cb_csv = CSVLogger("training.log")
# preprocessed data niceness
inputs_train, inputs_val = preprocess_data(X_train, y_train, X_val, y_val)
print("# Data loaded. Beginning training.")
history = model.fit_generator(
inputs_train,
epochs=config.epochs,
steps_per_epoch=X_train.shape[0] / config.batch_size,
validation_steps=X_val.shape[0] / config.batch_size,
verbose=1,
validation_data=inputs_val,
callbacks=[cb_early_stop, cb_checkpoint, cb_csv])
return model, history
dataset_sizes = {x: len(image_datasets[x]) for x in ['train', 'test']}
class_names = image_datasets['train'].classes
trainloader = dataloaders['train']
testloader = dataloaders['test']
# compute class weights
class_weights = compute_class_weights(image_datasets['train'].imgs,
len(image_datasets['train'].classes))
class_weights = torch.FloatTensor(class_weights).to(device)
print("Found {} training images".format(len(image_datasets['train'])))
print("Found {} evaluating images".format(len(image_datasets['test'])))
print("Classes: {}".format(class_names))
# model
net = model(args)
net = net.to(device)
# print(net)
# net parameters
# count_parameters(net)
summary(net, (3, args.img_size, args.img_size))
if device == 'cuda':
net = torch.nn.DataParallel(net)
cudnn.benchmark = True
if args.resume:
# load checkpoint.
print('Resuming from checkpoint {}'.format(args.checkpoint))
assert os.path.isfile(
args.checkpoint), 'Error: no checkpoint directory found!'
if __name__ == '__main__':
import argparse
parser = argparse.ArgumentParser()
parser.add_argument('--gpu', '-g', type=str, default='0')
parser.add_argument('--bsize', '-b', type=int, default=32)
parser.add_argument('--model', '-m', type=str, default='VGG16')
parser.add_argument('--epochs','-e', type=int, default=5)
args = parser.parse_args()
print("Parameters: ",args)
BATCH_SIZE = args.bsize
os.environ["CUDA_VISIBLE_DEVICES"] = args.gpu
chosed_model = config.model(args.model)
EPOCHS = args.epochs
data = pd.read_csv("Reinforced_mixed_benefits.csv")
rows = np.asarray(data.iloc[:, :])
print("Start shuffling.")
np.random.shuffle(rows)
print("Shuffling finished.")
train_data = rows[:int(0.8*(len(rows)))]
val_data = rows[int(0.8*(len(rows))):]
pd.DataFrame(val_data).to_csv("test_data.csv",header=0,index=False)
train_generator = DataGenerator(datas=train_data,batch_size=BATCH_SIZE)
val_generator = DataGenerator(datas=val_data,batch_size=BATCH_SIZE)
def main():
model_name = config.model()
Model = import_model.import_model(model_name)
# DATABASE
DATABASE = config.data_name()
DATABASE_PATH = config.data_root() + "/" + DATABASE
# RESULTS
result_folder = config.result_root() + '/' + DATABASE + '/' + Model.name()
if not os.path.isdir(result_folder):
os.makedirs(result_folder)
# Parameters
parameters = config.parameters(result_folder)
if os.path.isfile(DATABASE_PATH + '/binary_piano'):
parameters["binarize_piano"] = True
else:
parameters["binarize_piano"] = False
if os.path.isfile(DATABASE_PATH + '/binary_orch'):
parameters["binarize_orch"] = True
else:
parameters["binarize_orch"] = False
parameters["model_name"] = model_name
# Load the database metadata and add them to the script parameters to keep a record of the data processing pipeline
parameters.update(pkl.load(open(DATABASE_PATH + '/metadata.pkl', 'rb')))
############################################################
# Logging
############################################################
# log file
log_file_path = 'log'
# set up logging to file - see previous section for more details
logging.basicConfig(level=logging.INFO,
format='%(asctime)s %(levelname)-8s %(message)s',
datefmt='%m-%d %H:%M',
filename=log_file_path,
filemode='w')
# define a Handler which writes INFO messages or higher to the sys.stderr
console = logging.StreamHandler()
console.setLevel(logging.INFO)
# set a format which is simpler for console use
formatter = logging.Formatter('%(levelname)-8s %(message)s')
# tell the handler to use this format
console.setFormatter(formatter)
# add the handler to the root logger
logging.getLogger('').addHandler(console)
# Now, we can log to the root logger, or any other logger. First the root...
logging.info('#' * 60)
logging.info('#' * 60)
logging.info('#' * 60)
logging.info('* L * O * P *')
logging.info('** Model : ' + Model.name())
for k, v in parameters.items():
logging.info('** ' + k + ' : ' + str(v))
logging.info('#' * 60)
logging.info('#' * 60)
############################################################
# Hyper parameter space
############################################################
# Two cases :
# 1/ Random search
model_parameters_space = Model.get_hp_space()
# 2/ Defined configurations
configs = config.import_configs()
############################################################
# Grid search loop
############################################################
# Organisation :
# Each config is a folder with a random ID (integer)
# In eahc of this folder there is :
# - a config.pkl file with the hyper-parameter space
# - a result.txt file with the result
# The result.csv file containing id;result is created from the directory, rebuilt from time to time
if DEFINED_CONFIG:
for config_id, model_parameters in configs.items():
config_folder = parameters['result_folder'] + '/' + config_id
if os.path.isdir(config_folder):
shutil.rmtree(config_folder)
os.mkdir(config_folder)
config_loop(Model, config_folder, model_parameters, parameters,
DATABASE_PATH)
else:
# Already tested configs
list_config_folders = glob.glob(result_folder + '/*')
number_hp_config = max(
0, parameters["max_hyperparam_configs"] - len(list_config_folders))
for hp_config in range(number_hp_config):
# Give a random ID and create folder
ID_SET = False
while not ID_SET:
ID_config = str(random.randint(0, 2**25))
config_folder = parameters['result_folder'] + '/' + ID_config
if config_folder not in list_config_folders:
ID_SET = True
os.mkdir(config_folder)
# Sample model parameters from hyperparam space
model_parameters = hyperopt.pyll.stochastic.sample(
model_parameters_space)
config_loop(Model, config_folder, model_parameters, parameters,
DATABASE_PATH)
# Update folder list
list_config_folders.append(config_folder)
return
def main():
# check cuda available
assert torch.cuda.is_available() == True
# when the input dimension doesnot change, add this flag to speed up
cudnn.benchmark = True
num_classes = config.num_classes[config.problem_type]
# input are RGB images in size 3 * h * w
# output are binary
model = config.model(3, num_classes)
# data parallel
model = nn.DataParallel(model, device_ids=config.device_ids).cuda()
# loss function
if num_classes == 2:
loss = LossBinary(jaccard_weight=config.jaccard_weight)
valid_metric = validation_binary
else:
loss = LossMulti(num_classes=num_classes,
jaccard_weight=config.jaccard_weight)
valid_metric = validation_multi
# train/valid filenmaes
train_filenames, valid_filenames = trainval_split(config.fold)
print('num of train / validation files = {} / {}'.format(
len(train_filenames), len(valid_filenames)))
# trainset transform
train_transform = Compose([
Resize(height=config.train_height, width=config.train_width, p=1),
Normalize(p=1)
],
p=1)
# validset transform
valid_transform = Compose([
Resize(height=config.train_height, width=config.train_width, p=1),
Normalize(p=1)
],
p=1)
# train dataloader
train_loader = DataLoader(dataset=RobotSegDataset(
train_filenames, transform=train_transform),
shuffle=True,
num_workers=config.num_workers,
batch_size=config.batch_size,
pin_memory=True)
# valid dataloader
valid_loader = DataLoader(
dataset=RobotSegDataset(valid_filenames, transform=valid_transform),
shuffle=True,
num_workers=config.num_workers,
batch_size=len(
config.device_ids), # in valid time use one img for each dataset
pin_memory=True)
train(model=model,
loss_func=loss,
train_loader=train_loader,
valid_loader=valid_loader,
valid_metric=valid_metric,
fold=config.fold,
num_classes=num_classes)
