def test(args):
set_seed(args.seed)
train_loader, val_loader, test_loader = get_data_loaders(args)
model = get_model(args)
criterion = get_criterion(args)
logger = create_logger('%s/logfile.log' % args.savedir, args)
logger.info(model)
model.cuda()
start_epoch, global_step, n_no_improve, best_metric = 0, 0, 0, -np.inf
if os.path.exists(os.path.join(args.savedir, "checkpoint.pt")):
checkpoint = torch.load(os.path.join(args.savedir, "checkpoint.pt"))
start_epoch = checkpoint["epoch"]
n_no_improve = checkpoint["n_no_improve"]
best_metric = checkpoint["best_metric"]
model.load_state_dict(checkpoint["state_dict"])
# Test best model
load_checkpoint(model, os.path.join(args.savedir, "model_best.pt"))
model.eval()
test_metrics = model_eval(
np.inf, test_loader, model, args, criterion, store_preds=True
)
log_metrics(f"Test - test", test_metrics, args, logger)
def get_train_params(params):
trainer_params = params.copy(
) # create separate trainer_params as can't pickle model if checkpoint_callback is passed to hparams in model
model_dir = Path(
f"../results/linear_probing/resnet_50/layer_{hparams['layer_name']}")
model_dir.mkdir(parents=True, exist_ok=True)
checkpoint_callback = ModelCheckpoint(filepath=model_dir,
save_top_k=10,
verbose=True,
monitor='val_loss',
mode='min')
trainer_params['checkpoint_callback'] = checkpoint_callback
if not params['disable_logger']:
experiment_name = 'finetuning_resnet_' + str(params['layer_name'])
trainer_params['logger'] = create_logger(experiment_name)
if params['debug']:
trainer_params.update({
'limit_train_batches': 0.01,
'limit_val_batches': 0.02,
'limit_test_batches': 0.03
})
trainer_params = argparse.Namespace(**trainer_params)
return trainer_params
def main():
args = parse_args()
configs = Config.fromfile(args.config)
if args.work_dir is not None:
configs.work_dir = args.work_dir
assert osp.exists(args.model), "Model {} not exists".format(args.model)
logger = create_logger()
logger.info(configs.text)
dataset_config = configs.data
test_dataset = eval('datasets.{}.build_dataset'.format(
dataset_config.test.type))(dataset_config, is_training=False)
test_loader = DataLoader(test_dataset,
batch_size=dataset_config.batch,
shuffle=True,
num_workers=dataset_config.num_workers)
model = eval('models.{}.build_model'.format(configs.model.name))(configs)
model = torch.nn.DataParallel(model, device_ids=configs.gpu_group).cuda()
model.load_state_dict(torch.load(args.model))
# Test model
valid_model(configs, model, test_loader)
def __init__(self):
self.database = EsDatabase()
self.alphavantage = Alphavantage()
self.tickers = config.TICKERS
self.interval = config.INTERVAL
self.logger = create_logger('Feeder')
pass
def get_train_params(params):
trainer_params = params.copy(
) # create separate trainer_params as can't pickle model if checkpoint_callback is passed to hparams in model
experiment_type = 'segmentation' if params['segmentation'] else 'detection'
model_dir = Path(f"../results/models/{params['model_name']}")
model_dir = model_dir / experiment_type / trainer_params['experiment_name']
model_dir.mkdir(parents=True, exist_ok=True)
checkpoint_callback = ModelCheckpoint(
# filepath=f'{model_save_path}_best_model.pth',
filepath=model_dir,
save_top_k=10,
verbose=True,
monitor='val_loss',
mode='min')
trainer_params['checkpoint_callback'] = checkpoint_callback
if not params['disable_logger']:
experiment_name = 'finetuning_' + params[
'model_name'] + '_' + experiment_type
trainer_params['logger'] = create_logger(experiment_name)
if params['debug']:
trainer_params.update({
'limit_train_batches': 0.01,
'limit_val_batches': 0.02,
'limit_test_batches': 0.03
})
trainer_params = argparse.Namespace(**trainer_params)
return trainer_params
def __init__(self):
self.database = EsDatabase()
self.algorithms = [
SVRAlgorithm(),
RandAlgorithm(),
]
self.tickers = config.TICKERS
self.logger = create_logger('Predictor')
def _custom_tf_logger(args):
# Set custom logger
log_dir = Path(args.model_dir) / "logs"
if not log_dir.exists():
log_dir.mkdir(parents=True, exist_ok=True)
log_file = log_dir / "{}_{}".format(args.mode, args.tag)
logging._logger = create_logger(log_file=log_file, with_time=True,
clear_exist_handlers=True, name="tensorflow")
def main(options):
logs_dir = options.logs_dir
require_empty(logs_dir, recreate=options.overwrite)
logging_filename = os.path.join(logs_dir, "train.log")
# train on multiple gpu
if len(options.gpu) == 0:
device = torch.device('cpu')
prefetch_data = False
elif len(options.gpu) == 1:
device = torch.device('cuda:{}'.format(options.gpu[0]))
prefetch_data = True
else:
os.environ["CUDA_DEVICE_ORDER"] = "PCI_BUS_ID"
os.environ["CUDA_VISIBLE_DEVICES"] = ','.join(options.gpu)
device = torch.device('cuda:{}'.format(options.gpu[0]))
prefetch_data = True
parallel = True
logger = create_logger(logging_filename, options.verbose)
logger.info("Called with parameters: {}".format(options.__dict__))
#***************#
if options.net == 'path':
# val_data = PathDataset(options.val_dir, options.im_w, options.im_h)
val_data = SingleDataset(options.val_dir, options.im_w, options.im_h)
else:
val_data = OverlapDataset(options.val_dir, options.im_w, options.im_h)
val_loader = DataLoader(val_data,
batch_size=options.val_batch_size,
shuffle=True,
num_workers=4)
#***************#
logger.info('Total number of val samples: ~{}'.format(
len(val_loader) * options.val_batch_size))
#***************#
if options.net == 'path':
model = PathNet(options.repeat_num,
options.conv_hidden_num,
input_channel=2).to(device)
else:
model = PathNet(options.repeat_num,
options.conv_hidden_num,
last_activation='sigmoid',
input_channel=1).to(device)
cp_dict = {
"model": model
# 'optimizer': optimizer
}
#***************#
logger.info_trainable_params(model)
if options.init_model_filename:
load_model(options.init_model_filename, cp_dict)
#***************#
metrics = [[iou, "iou"]]
val_loss = validate(val_loader, model, logger, metrics, logs_dir)
def create_user(self, user_exist = False):
user_name = 'test' if user_exist else input("请输入您的用户名：")
user_path = os.path.join(ROOT_DIR, 'logs', user_name)
log_path = os.path.join(user_path, 'log')
if not os.path.exists(user_path):
os.mkdir(user_path)
os.mkdir(log_path)
self.record_savedir = os.path.join(ROOT_DIR, user_path, 'dialogs.txt')
log_name = time.strftime("%Y-%m-%d-%H-%M-%S", time.localtime())
self.log_savedir = log_path +'/' + log_name + '.log'
self.logger = create_logger(self.log_savedir, FLAGS.print)
return user_name
def main():
"""Fill the application described by the command line arguments.
Example commands:
'python3 run.py -hd -d' to run in debug mode with headless mode disabled
'python3 run.py -m 2' to run in graph generation mode
"""
LOGGER = create_logger('LOGGER')
args = parse_args()
is_debug = args.debug
is_headless = not (args.headless)
mode = args.mode
if mode == 1:
LOGGER.info('Running Leetcode scraping task...')
genProblemsJSON(LOGGER, is_headless, is_debug)
elif mode == 2:
LOGGER.info('Running Graph generating task...')
genGraphJSON()
LOGGER.info('Done')
return 0
def initialization():
"""
Initializing arguments, logger, tensorboard recorder and json files.
"""
import argparse
from torch.utils.tensorboard import SummaryWriter
from utils import file_operator as f_op
from utils import logger as log_util
from utils import seed
from utils.config import Config
import environ
# create config object from arguments
args = environ.to_config(Config)
# create logger
logger_ = log_util.create_logger("main", "./files/output/logs", args.save_key, args.log_level)
log_util.logger_ = logger_
# show specified arguments
logger_.info("*** ARGUMENTS ***")
logger_.info(args)
# create TensorBoard writer
board_root_dir = f"./files/output/board/{args.save_key}"
f_op.create_folder(board_root_dir)
log_util.writer_ = SummaryWriter(board_root_dir)
# load model config
logger_.info("** LOAD MODEL CONFIG **")
config = f_op.load_json("./files/input/models/configs", args.model_config_key)
logger_.info(config)
# set flg of using seeds
if args.is_seed:
seed.feed_seed = True
return args, config
def initialization():
"""
Initializing arguments, logger, tensorboard recorder and json files.
"""
from torch.utils.tensorboard import SummaryWriter
from utils import file_operator as f_op
from utils import logger as log_util
import environ
from config.config_grad_cam import ConfigGradCAM
# create config object from arguments
args = environ.to_config(ConfigGradCAM)
# create logger
logger_ = log_util.create_logger("main", "./files/output/logs",
args.save_key, args.log_level)
log_util.logger_ = logger_
# show specified arguments
logger_.info("*** ARGUMENTS ***")
logger_.info(args)
return args
# %%
if config.dataset not in dataset2path:
raise ValueError("dataset {} is not registered.".format(
config.dataset))
else:
train_path = dataset2path[config.dataset]["train"]
test_path = dataset2path[config.dataset]["test"]
label_path = dataset2path[config.dataset]["test_label"]
# %%
device = torch.device("cuda:1")
train_logger, file_logger, meta_logger = create_logger(
dataset=args.dataset,
h_dim=config.h_dim,
rolling_size=config.rolling_size,
train_logger_name='donut_train_logger',
file_logger_name='donut_file_logger',
meta_logger_name='donut_meta_logger',
model_name='DONUT',
pid=args.pid)
# logging setting
file_logger.info('============================')
for key, value in vars(args).items():
file_logger.info(key + ' = {}'.format(value))
file_logger.info('============================')
meta_logger.info('============================')
for key, value in vars(args).items():
meta_logger.info(key + ' = {}'.format(value))
meta_logger.info('============================')
import tensorflow as tf
import numpy as np
import time
from utils.logger import create_logger
logger = create_logger(__name__)
def kinetic_energy(v):
return 0.5 * tf.reduce_sum(tf.multiply(v, v), axis=1)
def hamiltonian(p, v, f):
"""
Return the value of the Hamiltonian
:param p: position variable
:param v: velocity variable
:param f: energy function
:return: hamiltonian
"""
return f(p) + kinetic_energy(v)
def metropolis_hastings_accept(energy_prev, energy_next):
"""
Run Metropolis-Hastings algorithm for 1 step
:param energy_prev:
:param energy_next:
:return: Tensor of boolean values, indicating accept or reject
"""
energy_diff = energy_prev - energy_next
config.export_config(
'./config/{}/Config_LOF_hdim_{}_rollingsize_{}_pid={}.json'.
format(config.dataset, config.n_neighbors, 1, config.pid))
# %%
if config.dataset not in dataset2path:
raise ValueError("dataset {} is not registered.".format(
config.dataset))
else:
train_path = dataset2path[config.dataset]["train"]
test_path = dataset2path[config.dataset]["test"]
label_path = dataset2path[config.dataset]["test_label"]
train_logger, file_logger, meta_logger = create_logger(
dataset=args.dataset,
train_logger_name='lof_train_logger',
file_logger_name='lof_file_logger',
meta_logger_name='lof_meta_logger',
model_name='LOF',
pid=args.pid)
# logging setting
file_logger.info('============================')
for key, value in vars(args).items():
file_logger.info(key + ' = {}'.format(value))
file_logger.info('============================')
meta_logger.info('============================')
for key, value in vars(args).items():
meta_logger.info(key + ' = {}'.format(value))
meta_logger.info('============================')
server_run=args.server_run, robustness=args.robustness, pid=args.pid, save_results=args.save_results)
if args.save_config:
if not os.path.exists('./config/{}/'.format(config.dataset)):
os.makedirs('./config/{}/'.format(config.dataset))
config.export_config('./config/{}/Config_OCSVM_pid={}.json'.format(config.dataset, config.pid))
# %%
if config.dataset not in dataset2path:
raise ValueError("dataset {} is not registered.".format(config.dataset))
else:
train_path = dataset2path[config.dataset]["train"]
test_path = dataset2path[config.dataset]["test"]
label_path = dataset2path[config.dataset]["test_label"]
# %%
train_logger, file_logger, meta_logger = create_logger(dataset=args.dataset,
train_logger_name='ocsvm_train_logger',
file_logger_name='ocsvm_file_logger',
meta_logger_name='ocsvm_meta_logger',
model_name='OCSVM',
pid=args.pid)
# logging setting
file_logger.info('============================')
for key, value in vars(args).items():
file_logger.info(key + ' = {}'.format(value))
file_logger.info('============================')
meta_logger.info('============================')
for key, value in vars(args).items():
meta_logger.info(key + ' = {}'.format(value))
meta_logger.info('============================')
s_TN = []
raise ValueError("dataset {} is not registered.".format(
config.dataset))
else:
train_path = dataset2path[config.dataset]["train"]
test_path = dataset2path[config.dataset]["test"]
label_path = dataset2path[config.dataset]["test_label"]
# %%
gpu_id = args.gpu_id
device = torch.device("cuda:{}".format(gpu_id))
# device = torch.device("cpu")
# device = torch.device(get_free_device())
train_logger, file_logger, meta_logger = create_logger(
dataset=args.dataset,
train_logger_name='rn_train_logger',
file_logger_name='rn_file_logger',
meta_logger_name='rn_meta_logger',
model_name='RN',
pid=args.pid)
# logging setting
file_logger.info('============================')
for key, value in vars(args).items():
file_logger.info(key + ' = {}'.format(value))
file_logger.info('============================')
meta_logger.info('============================')
for key, value in vars(args).items():
meta_logger.info(key + ' = {}'.format(value))
meta_logger.info('============================')
data_aug = True
test_image = None
supervision = 1
iter_mean_grad = 10
max_training_iters = 45000
save_step = 5000
display_step = 10
# learning rate setting
ini_learning_rate = 1e-6
end_learning_rate = 2.5 * 1e-7
batch_size = 1
# log some important info
logger = create_logger(logs_path)
logger.info('The random seed is {}'.format(seed))
logger.info(
'The pascal base training iteration is {}'.format(pascal_base_iterations))
logger.info(
'The max objectness training iteration is {}'.format(max_training_iters))
logger.info('The supervision mode is {}'.format(supervision))
logger.info('Data augmentation is {}'.format(data_aug))
# Define Dataset
train_file = 'datasets/davis2016_trainset.txt'
# # small dataset txt file for fast debugging
# train_file = 'datasets/test_algorithm_davis2016_trainset.txt'
dataset = Dataset(train_file,
None,
def train(args):
set_seed(args.seed)
args.savedir = os.path.join(args.savedir, args.name)
os.makedirs(args.savedir, exist_ok=True)
train_loader, val_loader, test_loader = get_data_loaders(args)
model = get_model(args)
criterion = get_criterion(args)
optimizer = get_optimizer(model, args)
scheduler = get_scheduler(optimizer, args)
logger = create_logger('%s/logfile.log' % args.savedir, args)
logger.info(model)
model.cuda()
torch.save(args, os.path.join(args.savedir, 'args.pt'))
start_epoch, global_step, n_no_improve, best_metric = 0, 0, 0, -np.inf
if os.path.exists(os.path.join(args.savedir, "checkpoint.pt")):
checkpoint = torch.load(os.path.join(args.savedir, "checkpoint.pt"))
start_epoch = checkpoint["epoch"]
n_no_improve = checkpoint["n_no_improve"]
best_metric = checkpoint["best_metric"]
model.load_state_dict(checkpoint["state_dict"])
optimizer.load_state_dict(checkpoint["optimizer"])
scheduler.load_state_dict(checkpoint["scheduler"])
logger.info("Training..")
for i_epoch in range(start_epoch, args.max_epochs):
train_losses = []
model.train()
optimizer.zero_grad()
for batch in tqdm(train_loader, total=len(train_loader)):
loss, _, _ = model_forward(i_epoch, model, args, criterion, batch)
train_losses.append(loss.item())
loss.backward()
optimizer.step()
optimizer.zero_grad()
model.eval()
metrics = model_eval(i_epoch, val_loader, model, args, criterion)
logger.info("Train Loss: {:.4f}".format(np.mean(train_losses)))
log_metrics("Val", metrics, args, logger)
tuning_metric = (metrics["acc"])
scheduler.step(tuning_metric)
is_improvement = tuning_metric > best_metric
if is_improvement:
best_metric = tuning_metric
n_no_improve = 0
else:
n_no_improve += 1
save_checkpoint(
{
"epoch": i_epoch + 1,
"state_dict": model.state_dict(),
"optimizer": optimizer.state_dict(),
"scheduler": scheduler.state_dict(),
"n_no_improve": n_no_improve,
"best_metric": best_metric,
},
is_improvement,
args.savedir,
)
if n_no_improve >= args.patience:
logger.info("No improvement. Breaking out of loop.")
break
# Test best model
load_checkpoint(model, os.path.join(args.savedir, "model_best.pt"))
model.eval()
test_metrics = model_eval(np.inf,
test_loader,
model,
args,
criterion,
store_preds=True)
log_metrics(f"Test - test", test_metrics, args, logger)
def global_logger(name, propagate=False):
logger = create_logger(file_=False,
console=False,
propagate=propagate,
name=name)
return logger
def main(options):
torch.autograd.set_detect_anomaly(False)
logs_dir = options.logs_dir
require_empty(logs_dir, recreate=options.overwrite)
logging_filename = os.path.join(logs_dir, "train.log")
save_model_filename = os.path.join(logs_dir, "model")
require_empty(save_model_filename, recreate=options.overwrite)
tboard_dir = os.path.join(logs_dir, "tboard")
# train on multiple gpu
if len(options.gpu) == 0:
device = torch.device('cpu')
prefetch_data = False
elif len(options.gpu) == 1:
device = torch.device('cuda:{}'.format(options.gpu[0]))
prefetch_data = True
else:
os.environ["CUDA_DEVICE_ORDER"] = "PCI_BUS_ID"
os.environ["CUDA_VISIBLE_DEVICES"] = ','.join(options.gpu)
device = torch.device('cuda:{}'.format(options.gpu[0]))
prefetch_data = True
parallel = True
logger = create_logger(logging_filename, options.verbose)
writer = SummaryWriter(log_dir=tboard_dir)
logger.info("Called with parameters: {}".format(options.__dict__))
#***************#
if options.net == 'path':
print(options.augment_gamma)
train_data = PathDataset(options.train_dir, options.im_w, options.im_h, random_w=options.augment_stroke_width, random_gamma=options.augment_gamma)
val_data = PathDataset(options.val_dir, options.im_w, options.im_h)
else:
train_data = OverlapDataset(options.train_dir, options.im_w, options.im_h, random_w=options.augment_stroke_width)
val_data = OverlapDataset(options.val_dir, options.im_w, options.im_h)
train_loader = DataLoader(train_data, batch_size=options.train_batch_size, shuffle=True, num_workers=4)
val_loader = DataLoader(val_data, batch_size=options.val_batch_size, shuffle=True, num_workers=4)
#***************#
logger.info('Total number of train samples: ~{}'.format(len(train_loader) * options.train_batch_size))
logger.info('Total number of val samples: ~{}'.format(len(val_loader) * options.val_batch_size))
#***************#
if options.net == 'path':
model = PathNet(options.repeat_num, options.conv_hidden_num, input_channel=2).to(device)
# model = PathNet(options.repeat_num, options.conv_hidden_num, last_activation='sigmoid', input_channel=2).to(device)
else:
model = PathNet(options.repeat_num, options.conv_hidden_num, last_activation='sigmoid', input_channel=1).to(device)
optimizer = torch.optim.Adam(model.parameters(), lr=options.lr, weight_decay=options.weight_decay, betas=[0.5, 0.999])
# lr_scheduler = torch.optim.lr_scheduler.StepLR(optimizer, 150, gamma=0.1)
lr_scheduler = torch.optim.lr_scheduler.MultiStepLR(optimizer, milestones=[150,180], gamma=0.1)
cp_dict = {"model": model
# 'optimizer': optimizer
}
#***************#
logger.info_trainable_params(model)
if options.init_model_filename:
load_model(options.init_model_filename, cp_dict)
#***************#
if options.loss == 'l1':
criterion = nn.L1Loss(reduction='mean')
elif options.loss == 'bce':
criterion = nn.BCELoss(reduction='mean')
else:
criterion = nn.MSELoss(reduction='mean')
#***************#
best_val_loss = 100000000
best_val_iou = 0.0
metrics = [[criterion, options.loss], [iou, "iou"]]
for epoch_i in range(options.epochs):
logger.info('Training batch {}'.format(epoch_i))
epoch_loss = 0
start_time = time()
model.train()
for j, data in enumerate(train_loader):
model.zero_grad()
img, trg, _ = data
img = img.to(device)
trg = trg.to(device)
# global discriminator
pred = model(img)
# pred = torch.clamp(pred, 0, 1)
loss = criterion(pred, trg)
loss.backward()
epoch_loss += loss.item()
torch.nn.utils.clip_grad_norm_(model.parameters(), options.clip)
optimizer.step()
lr_scheduler.step()
logger.info(
'loss : {loss_G:.4f}'.format(loss_G=epoch_loss/len(train_loader)))
writer.add_scalar("train_loss", epoch_loss / len(train_loader), global_step=epoch_i)
logger.info('Time {}'.format(time() - start_time))
img_grid = _make_gird(img, pred, trg)
writer.add_image('train_output', img_grid, global_step=epoch_i)
val_iou, val_loss = validate(val_loader, model, logger, epoch_i, metrics, writer)
logger.info(
'val loss : {loss_G:.4f}'.format(loss_G=val_loss))
logger.info(
'val iou : {loss_G:.4f}'.format(loss_G=val_iou))
if val_loss < best_val_loss:
best_val_loss = val_loss
save_model(os.path.join(save_model_filename, 'best_loss.pth'), cp_dict)
if val_iou > best_val_iou:
best_val_iou = val_iou
save_model(os.path.join(save_model_filename, 'best_iou.pth'), cp_dict)
if (epoch_i % options.batches_before_save) == 0:
save_model(os.path.join(save_model_filename, f'epoch_{epoch_i}.pth'), cp_dict)
config.rolling_size, config.pid))
# %%
if config.dataset not in dataset2path:
raise ValueError("dataset {} is not registered.".format(config.dataset))
else:
train_path = dataset2path[config.dataset]["train"]
test_path = dataset2path[config.dataset]["test"]
label_path = dataset2path[config.dataset]["test_label"]
# %%
#device = torch.device(get_free_device())
device = torch.device("cuda:1")
train_logger, file_logger, meta_logger = create_logger(dataset=args.dataset,
h_dim=args.h_dim,
rolling_size=args.rolling_size,
train_logger_name='lstmndt_train_logger',
file_logger_name='lstmndt_file_logger',
meta_logger_name='lstmndt_meta_logger',
model_name='LSTMNDT',
pid=args.pid)
# logging setting
file_logger.info('============================')
for key, value in vars(args).items():
file_logger.info(key + ' = {}'.format(value))
file_logger.info('============================')
meta_logger.info('============================')
for key, value in vars(args).items():
meta_logger.info(key + ' = {}'.format(value))
meta_logger.info('============================')
return args
if __name__ == '__main__':
args = parse_args()
if args.cfg_file:
update_cfg(args.cfg_file)
logdir = osp.join(cfg.SRC_DIR, cfg.LOG_DIR)
if not osp.exists(logdir):
os.makedirs(logdir)
logfile = osp.join(
logdir, "test_%s_%s_iter_%d" % (cfg.TAG, cfg.PREFIX, cfg.TEST.ITER))
logger = create_logger(log_file=logfile,
withtime=True,
propagate=False,
name=cfg.LOGGER)
if cfg.TEST.SAVE_MODEL:
cfg.TRAIN.BS = cfg.TEST.BS_2D
logger.info("Configuration: ")
for handler in logger.handlers:
pprint(cfg, handler.stream)
model_path = osp.join(cfg.SRC_DIR, cfg.OUTPUT_DIR, cfg.TAG)
if args.best.lower() not in ["false", "0"]:
model_file = osp.join(model_path, "{:s}_best.ckpt".format(cfg.PREFIX))
else:
model_file = osp.join(
model_path, "{:s}_iter_{:d}.ckpt".format(cfg.PREFIX,
from utils import logger
from cassandra.cluster import Cluster
import pandas as pd
log = logger.create_logger(__name__)
CNT_QUERY_CLIENTS = "SELECT prodID, consID, topic , count(*) as cnt " \
"FROM CNT WHERE prodid = %s AND consid = %s"\
"GROUP BY id, prodID, consID, topic ALLOW FILTERING"
CASS_CONTACT_POINTS = ["127.0.0.1"]
CASS_KEYSPACE = "brokertracker"
def connect():
try:
cluster = Cluster(CASS_CONTACT_POINTS)
session = cluster.connect(CASS_KEYSPACE)
log.info("Connected to Cassandra.")
return session
except:
log.error("Error connecting to Cassandra.")
def getJoinCntDF(session, query, params):
l = []
rows = session.execute(query=query,
parameters=(params[0], params[1]),
trace=True)
print(rows.get_query_trace())
def reset_options(options, args, phase='train'):
if hasattr(args, "batch_size") and args.batch_size:
options.train.batch_size = options.test.batch_size = args.batch_size
if hasattr(args, "version") and args.version:
options.version = args.version
if hasattr(args, "num_epochs") and args.num_epochs:
options.train.num_epochs = args.num_epochs
if hasattr(args, "checkpoint") and args.checkpoint:
options.checkpoint = args.checkpoint
if hasattr(args, "folder") and args.folder:
options.dataset.predict.folder = args.folder
if hasattr(args, "gpus") and args.gpus:
options.num_gpus = args.gpus
if hasattr(args, "shuffle") and args.shuffle:
options.train.shuffle = options.test.shuffle = True
if hasattr(args, "name") and args.name:
options.name = args.name
cwd = os.getcwd()
if options.version is None:
prefix = ""
if args.options:
prefix = slugify(args.options) + "_"
options.version = prefix + datetime.now().strftime(
'%m%d%H%M%S') # ignore %Y
options.log_dir = os.path.join(cwd, options.experiments_dir,
options.log_dir, options.name)
print('=> creating {}'.format(options.log_dir))
os.makedirs(options.log_dir, exist_ok=True)
options.checkpoint_dir = os.path.join(cwd, options.experiments_dir,
options.checkpoint_dir, options.name,
options.version)
if phase != 'predict':
print('=> creating {}'.format(options.checkpoint_dir))
os.makedirs(options.checkpoint_dir, exist_ok=True)
options.summary_dir = os.path.join(cwd, options.experiments_dir,
options.summary_dir, options.name,
options.version)
if phase != 'predict':
print('=> creating {}'.format(options.summary_dir))
os.makedirs(options.summary_dir, exist_ok=True)
if phase == 'predict':
print('=> do not create summary writer for predict')
writer = None
else:
print('=> creating summary writer')
writer = SummaryWriter(options.summary_dir)
options.predict_dir = os.path.join(cwd, options.experiments_dir,
options.predict_dir, options.name,
options.version)
if phase == 'predict':
print('=> creating {}'.format(options.predict_dir))
os.makedirs(options.predict_dir, exist_ok=True)
logger = create_logger(options, phase=phase)
options_text = pprint.pformat(vars(options))
logger.info(options_text)
return logger, writer
def __init__(self,
network,
energy_fn,
discriminator,
noise_sampler,
b,
m,
eta=1.0,
scale=10.0):
self.energy_fn = energy_fn
self.logger = create_logger(__name__)
self.train_op = TrainingOperator(network)
self.infer_op = InferenceOperator(network, energy_fn)
self.b = tf.to_int32(tf.reshape(tf.multinomial(tf.ones([1, b]), 1),
[])) + 1
self.m = tf.to_int32(tf.reshape(tf.multinomial(tf.ones([1, m]), 1),
[])) + 1
self.network = network
self.x_dim, self.v_dim = network.x_dim, network.v_dim
self.z = tf.placeholder(tf.float32, [None, self.x_dim])
self.x = tf.placeholder(tf.float32, [None, self.x_dim])
self.xl = tf.placeholder(tf.float32, [None, self.x_dim])
self.steps = tf.placeholder(tf.int32, [])
bx, bz = tf.shape(self.x)[0], tf.shape(self.z)[0]
# Obtain values from inference ops
# `infer_op` contains Metropolis step
v = tf.random_normal(tf.stack([bz, self.v_dim]))
self.z_, self.v_ = self.infer_op((self.z, v), self.steps)
# Reshape for pairwise discriminator
x = tf.reshape(self.x, [-1, 2 * self.x_dim])
xl = tf.reshape(self.xl, [-1, 2 * self.x_dim])
# Obtain values from train ops
v1 = tf.random_normal(tf.stack([bz, self.v_dim]))
x1_, v1_ = self.train_op((self.z, v1), self.b)
x1_ = x1_[-1]
x1_sg = tf.stop_gradient(x1_)
v2 = tf.random_normal(tf.stack([bx, self.v_dim]))
x2_, v2_ = self.train_op((self.x, v2), self.m)
x2_ = x2_[-1]
v3 = tf.random_normal(tf.stack([bx, self.v_dim]))
x3_, v3_ = self.train_op((x1_sg, v3), self.m)
x3_ = x3_[-1]
# The pairwise discriminator has two components:
# (x, x2) from x -> x2
# (x1, x3) from z -> x1 -> x3
#
# The optimal case is achieved when x1, x2, x3
# are all from the data distribution
x_ = tf.concat([tf.concat([x2_, self.x], 1),
tf.concat([x3_, x1_], 1)], 0)
# Concat all v values for log-likelihood training
v1_ = v1_[-1]
v2_ = v2_[-1]
v3_ = v3_[-1]
v_ = tf.concat([v1_, v2_, v3_], 0)
v_ = tf.reshape(v_, [-1, self.v_dim])
d = discriminator(x, reuse=False)
d_ = discriminator(x_)
# generator loss
# TODO: MMD loss (http://szhao.me/2017/06/10/a-tutorial-on-mmd-variational-autoencoders.html)
# it is easy to implement, but maybe we should wait after this codebase is settled.
self.v_loss = tf.reduce_mean(0.5 * tf.multiply(v_, v_))
self.g_loss = tf.reduce_mean(d_) + self.v_loss * eta
# discriminator loss
self.d_loss = tf.reduce_mean(d) - tf.reduce_mean(d_)
epsilon = tf.random_uniform([], 0.0, 1.0)
x_hat = xl * epsilon + x_ * (1 - epsilon)
d_hat = discriminator(x_hat)
ddx = tf.gradients(d_hat, x_hat)[0]
ddx = tf.norm(ddx, axis=1)
ddx = tf.reduce_mean(tf.square(ddx - 1.0) * scale)
self.d_loss = self.d_loss + ddx
# I don't have a good solution to the tf variable scope mess.
# So I basically force the NiceLayer to contain the 'generator' scope.
# See `nice/__init__.py`.
g_vars = [
var for var in tf.global_variables() if 'generator' in var.name
]
d_vars = [
var for var in tf.global_variables()
if discriminator.name in var.name
]
self.d_train = tf.train.AdamOptimizer(learning_rate=5e-4, beta1=0.5, beta2=0.9)\
.minimize(self.d_loss, var_list=d_vars)
self.g_train = tf.train.AdamOptimizer(learning_rate=5e-4, beta1=0.5, beta2=0.9)\
.minimize(self.g_loss, var_list=g_vars)
self.init_op = tf.group(tf.global_variables_initializer(),
tf.local_variables_initializer())
gpu_options = tf.GPUOptions(allow_growth=True)
self.sess = tf.Session(config=tf.ConfigProto(
inter_op_parallelism_threads=1,
intra_op_parallelism_threads=1,
gpu_options=gpu_options,
))
self.sess.run(self.init_op)
self.ns = noise_sampler
self.ds = None
self.path = 'logs/' + energy_fn.name
try:
os.makedirs(self.path)
except OSError:
pass
def __init__(self):
self.database = EsDatabase()
self.tickers = config.TICKERS
self.logger = create_logger('Evaluater')
pass
def train():
set_device()
output_dir = pathlib.Path(cfg.LOG_DIR)
output_dir.mkdir(exist_ok=True, parents=True)
logger = create_logger(name=__name__,
output_dir=output_dir,
filename='log.txt')
# 数据集加载
train_dataset = get_dataset(cfg.DATASET.TRAIN_DATA, cfg, is_training=True)
val_dataset = get_dataset(cfg.DATASET.VAL_DATA, cfg)
for batch, (images, labels) in enumerate(train_dataset):
for i in range(cfg.TRAIN.BATCH_SIZE):
img = np.array(images[i, :, :, :] * 255).astype(np.int64)
label = np.array(labels[i, :, :, 0]).astype(np.int64)
vis_segmentation(img, label, label_names=cfg.DATASET.LABELS)
# 模型搭建和损失函数配置
model = create_model(cfg, name=cfg.MODEL_NAME, backbone=cfg.BACKBONE_NAME)
model = add_regularization(model, tf.keras.regularizers.l2(cfg.LOSS.WEIGHT_DECAY))
model.summary()
loss = get_loss(cfg, cfg.LOSS.TYPE)
# 优化器和学习率配置
lr = tf.Variable(cfg.SCHEDULER.LR_INIT)
learning_rate = learning_rate_config(cfg)
# warmup策略
def lr_with_warmup(global_steps):
lr_ = tf.cond(tf.less(global_steps, cfg.SCHEDULER.WARMUP_STEPS),
lambda: cfg.SCHEDULER.LR_INIT * tf.cast((global_steps + 1) / cfg.SCHEDULER.WARMUP_STEPS, tf.float32),
lambda: tf.maximum(learning_rate(global_steps - cfg.SCHEDULER.WARMUP_STEPS), cfg.SCHEDULER.LR_LOWER_BOUND))
return lr_
optimizer = config_optimizer(cfg, learning_rate=lr)
# 模型保存与恢复
manager, ckpt = ckpt_manager(cfg, model, logger, optimizer)
# 训练与验证静态图
@tf.function
def train_one_batch(x, y):
with tf.GradientTape() as tape:
# 1、计算模型输出和损失
pred_o = model(x, training=True)
# pred_o, l2, l3, l4, l5 = model(x, training=True)
regularization_loss_out = tf.reduce_sum(model.losses)
# seg_loss_out = loss(y, pred_o) + 0.1 * (loss(y, l2) + loss(y, l3) + loss(y, l4) + loss(y, l5))
seg_loss_out = loss(y, pred_o)
total_loss_out = seg_loss_out + regularization_loss_out
# 计算梯度以及更新梯度, 固定用法
grads = tape.gradient(total_loss_out, model.trainable_variables)
optimizer.apply_gradients(zip(grads, model.trainable_variables))
return total_loss_out, seg_loss_out, pred_o
@tf.function
def val_one_batch(x, y):
# pred_o, _, _, _, _ = model(x, training=False)
pred_o = model(x, training=False)
return pred_o
# region # 记录器和评价指标
summary_writer = tf.summary.create_file_writer(cfg.LOG_DIR)
# tf.summary.trace_on(profiler=True) # 开启Trace（可选）
# 评价指标
val_metric = SegmentationMetric(cfg.DATASET.N_CLASSES)
train_metric = SegmentationMetric(cfg.DATASET.N_CLASSES)
val_metric.reset()
train_metric.reset()
# endregion
# region # 迭代优化
for _ in range(int(ckpt.step), cfg.TRAIN.EPOCHS):
# region # 训练集
ckpt.step.assign_add(1)
lr.assign(lr_with_warmup(optimizer.iterations)) # 必须使用assign才能改变optimizer的lr的值，否则，是个固定值
for batch, (images_batch, labels_batch) in tqdm(enumerate(train_dataset)):
total_loss, seg_loss, train_pred = train_one_batch(images_batch, labels_batch)
# 计算训练集精度
if int(ckpt.step) % cfg.TRAIN.SNAP_SHOT == 1:
train_out = np.argmax(train_pred, axis=-1)
for i in range(labels_batch.shape[0]):
train_label = np.array(labels_batch[i, :, :, 0]).astype(np.int64)
train_metric.addBatch(train_label, train_out[i, :, :])
# if epoch > 200:
with summary_writer.as_default(): # 指定记录器
tf.summary.scalar("train/total_losses", total_loss, step=optimizer.iterations) # 将当前损失函数的值写入记录器
tf.summary.scalar("train/segmentation_loss_loss", seg_loss, step=optimizer.iterations)
tf.summary.scalar("train/learning_rate", lr, step=optimizer.iterations)
# endregion
# region # 验证集
if int(ckpt.step) % cfg.TRAIN.SNAP_SHOT == 1:
# ----------------------------------------------验证集验证--------------------------------------------------------
for batch, (images_batch, labels_batch) in tqdm(enumerate(val_dataset)):
out = val_one_batch(images_batch, labels_batch)
out = np.squeeze(np.argmax(out, axis=-1))
labels_batch = np.array(labels_batch[0, :, :, 0]).astype(np.int64)
val_metric.addBatch(labels_batch, out)
with summary_writer.as_default():
tf.summary.scalar("val_metric/mPA", val_metric.meanPixelAccuracy(), step=int(ckpt.step))
tf.summary.scalar("val_metric/dice", val_metric.dice(), step=int(ckpt.step))
tf.summary.scalar("val_metric/IoU1", val_metric.IoU(1), step=int(ckpt.step))
tf.summary.scalar("val_metric/mIoU", val_metric.mIoU(), step=int(ckpt.step))
tf.summary.scalar("train_metric/mPA", train_metric.meanPixelAccuracy(), step=int(ckpt.step))
tf.summary.scalar("train_metric/mIoU", train_metric.mIoU(), step=int(ckpt.step))
tf.summary.scalar("train_metric/dice", train_metric.dice(), step=int(ckpt.step))
tf.summary.scalar("train_metric/IoU1", train_metric.IoU(1), step=int(ckpt.step))
# VAL_PA = val_metric.meanPixelAccuracy()
logger.info('__EPOCH_{}__: TRAIN_mIoU: {:.5f}, TRAIN_mPA: {:.5f}, TRAIN_dice: {:.5f}; '
'VAL_mIoU: {:.5f}, VAL_mPA: {:.5f}, VAL_dice: {:.5f}'
.format(int(ckpt.step), train_metric.mIoU(), train_metric.meanPixelAccuracy(), train_metric.dice(),
val_metric.mIoU(), val_metric.meanPixelAccuracy(), val_metric.dice()))
train_metric.reset()
val_metric.reset()
# endregion
# region # 模型保存
# 使用CheckpointManager保存模型参数到文件并自定义编号
manager.save(checkpoint_number=int(ckpt.step))
parser.add_argument('--max_sen_num',
type=int,
default=7,
help='The maximum number of sentences in the finding')
parser.add_argument(
'--single_punc',
type=bool,
default=True,
help=
'Take punctuation as a single word: If true, generate sentences such as: Hello , world .'
)
args = parser.parse_args()
print(args)
# Record the training process and values
logger = create_logger(args.log_path)
logger.info('=' * 55)
logger.info(args)
logger.info('=' * 55)
# The time of training the same model to get average results
num_run = 3
best_bleu_lst = []
best_meteor_lst = []
best_rouge_lst = []
best_cider_lst = []
for n_run in range(num_run):
b_bleu, b_meteor, b_rouge, b_cider = train_net(n_run, logger, args)
best_bleu_lst.append(b_bleu)
best_meteor_lst.append(b_meteor)
best_rouge_lst.append(b_rouge)
best_cider_lst.append(b_cider)
from violance_v2 import ViolenceDetection
from utils.config import Config
from utils.logger import create_logger
import sys
import logging
logger = create_logger("violence")
logger.setLevel(logging.DEBUG)
cfg = Config.fromfile(sys.argv[1])
cfg.mode = "test"
v = ViolenceDetection(cfg)
v.test()