code stringlengths 17 6.64M |
|---|
def parse_args():
parser = argparse.ArgumentParser(description='Preprocess REDS datasets', epilog='You can first download REDS datasets using the script from:https://gist.github.com/SeungjunNah/b10d369b92840cb8dd2118dd4f41d643')
parser.add_argument('--root-path', type=str, help='root path for REDS')
parse... |
def make_lmdb(mode, data_path, lmdb_path, train_list, batch=5000, compress_level=1):
"Create lmdb for the Vimeo90K dataset.\n\n Contents of lmdb. The file structure is:\n example.lmdb\n ├── data.mdb\n ├── lock.mdb\n ├── meta_info.txt\n\n The data.mdb and lock.mdb are standard lmdb files and you ... |
def generate_anno_file(train_list, file_name='meta_info_Vimeo90K_GT.txt'):
"Generate anno file for Vimeo90K datasets from the official train list.\n\n Args:\n train_list (str): Train list path for Vimeo90K datasets.\n file_name (str): Saved file name. Default: 'meta_info_Vimeo90K_GT.txt'.\n "
... |
def parse_args():
modify_args()
parser = argparse.ArgumentParser(description='Preprocess Vimeo90K datasets', epilog='You can download the Vimeo90K dataset from：http://toflow.csail.mit.edu/')
parser.add_argument('train_list', help='official training list path for Vimeo90K')
parser.add_argument('--gt-pa... |
class TensorRTRestorerGenerator(nn.Module):
'Inner class for tensorrt restorer model inference\n\n Args:\n trt_file (str): The path to the tensorrt file.\n device_id (int): Which device to place the model.\n '
def __init__(self, trt_file: str, device_id: int):
super().__init__()
... |
class TensorRTRestorer(nn.Module):
'A warper class for tensorrt restorer\n\n Args:\n base_model (Any): The base model build from config.\n trt_file (str): The path to the tensorrt file.\n device_id (int): Which device to place the model.\n '
def __init__(self, base_model: Any, trt_... |
class TensorRTEditing(nn.Module):
'A class for testing tensorrt deployment\n\n Args:\n trt_file (str): The path to the tensorrt file.\n cfg (Any): The configuration of the testing, decided by the config file.\n device_id (int): Which device to place the model.\n '
def _... |
def parse_args():
parser = argparse.ArgumentParser(description='mmediting tester')
parser.add_argument('config', help='test config file path')
parser.add_argument('model', help='input model file')
parser.add_argument('backend', help='backend of the model.', choices=['onnxruntime', 'tensorrt'])
par... |
def main():
args = parse_args()
cfg = Config.fromfile(args.config)
if (args.cfg_options is not None):
cfg.merge_from_dict(args.cfg_options)
distributed = False
dataset = build_dataset(cfg.data.test)
loader_cfg = {**dict(((k, cfg.data[k]) for k in ['workers_per_gpu'] if (k in cfg.data))... |
def mmedit2torchserve(config_file: str, checkpoint_file: str, output_folder: str, model_name: str, model_version: str='1.0', force: bool=False):
"Converts MMEditing model (config + checkpoint) to TorchServe `.mar`.\n Args:\n config_file:\n In MMEditing config format.\n The contents... |
def parse_args():
parser = ArgumentParser(description='Convert MMEditing models to TorchServe `.mar` format.')
parser.add_argument('config', type=str, help='config file path')
parser.add_argument('checkpoint', type=str, help='checkpoint file path')
parser.add_argument('--output-folder', type=str, requ... |
class MMEditHandler(BaseHandler):
def initialize(self, context):
print('MMEditHandler.initialize is called')
properties = context.system_properties
self.map_location = ('cuda' if torch.cuda.is_available() else 'cpu')
self.device = torch.device((((self.map_location + ':') + str(pro... |
def parse_args():
parser = ArgumentParser()
parser.add_argument('model_name', help='The model name in the server')
parser.add_argument('--inference-addr', default='127.0.0.1:8080', help='Address and port of the inference server')
parser.add_argument('--img-path', type=str, help='The input LQ image.')
... |
def save_results(content, save_path, ori_shape):
ori_len = np.prod(ori_shape)
scale = int(np.sqrt((len(content) / ori_len)))
target_size = [int((size * scale)) for size in ori_shape[:2][::(- 1)]]
img = Image.frombytes('RGB', target_size, content, 'raw', 'BGR', 0, 0)
img.save(save_path)
|
def main(args):
url = ((('http://' + args.inference_addr) + '/predictions/') + args.model_name)
ori_shape = cv2.imread(args.img_path).shape
with open(args.img_path, 'rb') as image:
response = requests.post(url, image)
save_results(response.content, args.save_path, ori_shape)
|
def evaluate_one(args):
'Function to evaluate one sample of data.\n\n Args:\n args (tuple): Information needed to evaluate one sample of data.\n\n Returns:\n dict: The evaluation results including sad, mse, gradient error and\n connectivity error.\n '
(pred_alpha_path, alpha_... |
def evaluate(pred_root, gt_root, trimap_root, verbose, nproc):
'Evaluate test results of Adobe composition-1k dataset.\n\n There are 50 different ground truth foregrounds and alpha mattes pairs,\n each of the foreground will be composited with 20 different backgrounds,\n producing 1000 images for testing... |
def parse_args():
modify_args()
parser = argparse.ArgumentParser(description='evaluate composition-1k prediction result')
parser.add_argument('pred_root', help='Path to the predicted alpha matte folder')
parser.add_argument('gt_root', help='Path to the ground truth alpha matte folder')
parser.add_... |
def main():
args = parse_args()
if (not osp.exists(args.pred_root)):
raise FileNotFoundError(f'pred_root {args.pred_root} not found')
if (not osp.exists(args.gt_root)):
raise FileNotFoundError(f'gt_root {args.gt_root} not found')
evaluate(args.pred_root, args.gt_root, args.trimap_root,... |
def parse_args():
parser = argparse.ArgumentParser(description='Train a editor')
parser.add_argument('config', help='train config file path')
parser.add_argument('--shape', type=int, nargs='+', default=[250, 250], help='input image size')
args = parser.parse_args()
return args
|
def main():
args = parse_args()
if (len(args.shape) == 1):
input_shape = (3, args.shape[0], args.shape[0])
elif (len(args.shape) == 2):
input_shape = ((3,) + tuple(args.shape))
elif (len(args.shape) in [3, 4]):
input_shape = tuple(args.shape)
else:
raise ValueError(... |
def parse_args():
parser = argparse.ArgumentParser(description='Process a checkpoint to be published')
parser.add_argument('in_file', help='input checkpoint filename')
parser.add_argument('out_file', help='output checkpoint filename')
args = parser.parse_args()
return args
|
def process_checkpoint(in_file, out_file):
checkpoint = torch.load(in_file, map_location='cpu')
if ('optimizer' in checkpoint):
del checkpoint['optimizer']
if (version.parse(torch.__version__) >= version.parse('1.6')):
torch.save(checkpoint, out_file, _use_new_zipfile_serialization=False)
... |
def main():
args = parse_args()
process_checkpoint(args.in_file, args.out_file)
|
def parse_args():
parser = argparse.ArgumentParser(description='mmediting tester')
parser.add_argument('config', help='test config file path')
parser.add_argument('checkpoint', help='checkpoint file')
parser.add_argument('--seed', type=int, default=None, help='random seed')
parser.add_argument('--... |
def main():
args = parse_args()
cfg = mmcv.Config.fromfile(args.config)
setup_multi_processes(cfg)
if cfg.get('cudnn_benchmark', False):
torch.backends.cudnn.benchmark = True
cfg.model.pretrained = None
if (args.launcher == 'none'):
distributed = False
else:
distrib... |
def parse_args():
parser = argparse.ArgumentParser(description='Train an editor')
parser.add_argument('config', help='train config file path')
parser.add_argument('--work-dir', help='the dir to save logs and models')
parser.add_argument('--resume-from', help='the checkpoint file to resume from')
p... |
def main():
args = parse_args()
cfg = Config.fromfile(args.config)
setup_multi_processes(cfg)
if cfg.get('cudnn_benchmark', False):
torch.backends.cudnn.benchmark = True
if (args.work_dir is not None):
cfg.work_dir = args.work_dir
if (args.resume_from is not None):
cfg.... |
def cal_psnr(original, compressed):
mse = np.mean(((original - compressed) ** 2))
if (mse == 0):
return np.inf
psnr = (10 * log10((max_pixel_square / mse)))
return psnr
|
def main():
parser = argparse.ArgumentParser()
parser.add_argument('-gt-dir', default='../mmediting/data/ldv_v2/test_gt')
parser.add_argument('-enh-dir', default='../mmediting/data/ldv_v2/test_lq')
parser.add_argument('-ignored-frms', type=json.loads, default='{"002":[0]}', help='{"002":[0,]} will lea... |
def return_y_from_bgr(img_bgr):
img = mmcv.bgr2ycbcr(img_bgr, y_only=True)
return img
|
def cal_psnr(original, compressed):
mse = np.mean(((original - compressed) ** 2))
if (mse == 0):
return np.inf
psnr = (10 * log10((max_pixel_square / mse)))
return psnr
|
def main():
parser = argparse.ArgumentParser()
parser.add_argument('-gt-dir', default='../mmediting/data/mfqe_v2/test_gt')
parser.add_argument('-enh-dir', default='../mmediting/data/mfqe_v2/test_lq')
parser.add_argument('-save-dir', default='log')
parser.add_argument('-ignored-frms', type=json.loa... |
def return_y_from_bgr(img_bgr):
img = mmcv.bgr2ycbcr(img_bgr, y_only=True)
return img
|
def cal_psnr(original, compressed):
mse = np.mean(((original - compressed) ** 2))
if (mse == 0):
return np.inf
psnr = (10 * log10((max_pixel_square / mse)))
return psnr
|
def main():
parser = argparse.ArgumentParser()
parser.add_argument('-gt-dir', default='../mmediting/data/mfqe_v2/test_gt')
parser.add_argument('-enh-dir', default='../mmediting/data/mfqe_v2/test_lq')
parser.add_argument('-save-dir', default='log')
parser.add_argument('-ignored-frms', type=json.loa... |
class DataLoader(object):
def __init__(self, path, sep='\t', seq_sep=',', label='label', rank_file=RANK_FILE, group_1_file=GROUP_1_FILE, group_2_file=GROUP_2_FILE):
self.rank_df = None
self.path = path
self.sep = sep
self.seq_sep = seq_sep
self.label = label
self.r... |
class UGF(object):
def __init__(self, data_loader, k, eval_metric_list, fairness_metric='f1', epsilon=0.05, logger=None, model_name='', group_name=''):
"\n Train fairness model\n :param data_loader: Dataloader object\n :param k: k for top-K number of items to be selected from the ent... |
def mean_reciprocal_rank(rs):
"Score is reciprocal of the rank of the first relevant item\n First element is 'rank 1'. Relevance is binary (nonzero is relevant).\n Example from http://en.wikipedia.org/wiki/Mean_reciprocal_rank\n >>> rs = [[0, 0, 1], [0, 1, 0], [1, 0, 0]]\n >>> mean_reciprocal_rank(rs... |
def r_precision(r):
'Score is precision after all relevant documents have been retrieved\n Relevance is binary (nonzero is relevant).\n >>> r = [0, 0, 1]\n >>> r_precision(r)\n 0.33333333333333331\n >>> r = [0, 1, 0]\n >>> r_precision(r)\n 0.5\n >>> r = [1, 0, 0]\n >>> r_precision(r)\n ... |
def precision_at_k(r, k):
'Score is precision @ k\n Relevance is binary (nonzero is relevant).\n >>> r = [0, 0, 1]\n >>> precision_at_k(r, 1)\n 0.0\n >>> precision_at_k(r, 2)\n 0.0\n >>> precision_at_k(r, 3)\n 0.33333333333333331\n >>> precision_at_k(r, 4)\n Traceback (most recent ca... |
def average_precision(r):
'Score is average precision (area under PR curve)\n Relevance is binary (nonzero is relevant).\n >>> r = [1, 1, 0, 1, 0, 1, 0, 0, 0, 1]\n >>> delta_r = 1. / sum(r)\n >>> sum([sum(r[:x + 1]) / (x + 1.) * delta_r for x, y in enumerate(r) if y])\n 0.7833333333333333\n >>> ... |
def mean_average_precision(rs):
'Score is mean average precision\n Relevance is binary (nonzero is relevant).\n >>> rs = [[1, 1, 0, 1, 0, 1, 0, 0, 0, 1]]\n >>> mean_average_precision(rs)\n 0.78333333333333333\n >>> rs = [[1, 1, 0, 1, 0, 1, 0, 0, 0, 1], [0]]\n >>> mean_average_precision(rs)\n ... |
def dcg_at_k(r, k, method=0):
'Score is discounted cumulative gain (dcg)\n Relevance is positive real values. Can use binary\n as the previous methods.\n Example from\n http://www.stanford.edu/class/cs276/handouts/EvaluationNew-handout-6-per.pdf\n >>> r = [3, 2, 3, 0, 0, 1, 2, 2, 3, 0]\n >>> dc... |
def ndcg_at_k(r, k, method=0):
'Score is normalized discounted cumulative gain (ndcg)\n Relevance is positive real values. Can use binary\n as the previous methods.\n Example from\n http://www.stanford.edu/class/cs276/handouts/EvaluationNew-handout-6-per.pdf\n >>> r = [3, 2, 3, 0, 0, 1, 2, 2, 3, 0... |
def create_logger(name='result_logger', path='results.log'):
logger = logging.getLogger(name)
logger.setLevel(logging.INFO)
file_handler = logging.FileHandler(path)
formatter = logging.Formatter('%(message)s')
file_handler.setFormatter(formatter)
logger.addHandler(file_handler)
return logg... |
def evaluation_methods(df, metrics):
'\n Generate evaluation scores\n :param df:\n :param metrics:\n :return:\n '
evaluations = []
data_df = df.copy(deep=True)
data_df['q*s'] = (data_df['q'] * data_df['score'])
for metric in metrics:
k = int(metric.split('@')[(- 1)])
... |
def get_args():
parser = argparse.ArgumentParser()
parser.add_argument('-m', '--batch-size', help='The size of the mini batches', default=8, required=False, type=int)
parser.add_argument('--language', help='The language to use', required=True, type=str)
parser.add_argument('--ud-path', help='The path ... |
def get_ud_file_base(ud_path, language):
return os.path.join(ud_path, UD_LIST[language])
|
def get_data_file_base(output_path, language):
output_path = os.path.join(output_path, language)
util.mkdir(output_path)
return os.path.join(output_path, '%s--%s.pickle.bz2')
|
def load_bert(bert_name):
bert_tokenizer = BertTokenizer.from_pretrained(bert_name)
bert_model = BertModel.from_pretrained(bert_name).to(device=constants.device)
bert_model.eval()
return (bert_tokenizer, bert_model)
|
def tokenize_ud(file_name, bert_tokenizer):
all_ud_tokens = []
all_bert_tokens = []
all_bert2target_map = []
all_tree_matrices = []
all_ud_data = []
with open(file_name, 'r', encoding='utf-8') as file:
for token_list in parse_incr(file):
ud_tokens = []
ud_data =... |
def embed_bert(all_bert_tokens, batch_size, model, bert_tokenizer):
all_bert_embeddings = []
batch_num = 0
for batch_start in range(0, len(all_bert_tokens), batch_size):
batch_num += 1
if ((batch_num % 10) == 0):
logging.info('Processing batch {} to embeddings'.format(batch_num... |
def process_bert_token(token):
if token.startswith('##'):
return token[2:]
return token
|
def check_bert_word(word, bert_tokens, target_tokens):
word_bert = ''.join([process_bert_token(token) for token in bert_tokens])
if (word_bert == word):
return True
logging.warning("Failed to embed '{}' from BERT tokens {} in sentence {}".format(word, '+'.join(bert_tokens), '+'.join(target_tokens)... |
def combine_bert(all_target_token, all_bert2target_map, all_bert_tokens, all_bert_embeddings):
output_embeddings = []
output_words = []
sentence_num = 0
for sentence in range(len(all_target_token)):
sentence_num += 1
if ((sentence_num % 10000) == 0):
logging.info('Re-mergin... |
def load_fasttext(language):
lang = constants.LANGUAGE_CODES[language]
ft_path = 'data/fasttext'
ft_fname = os.path.join(ft_path, ('cc.%s.300.bin' % lang))
if (not os.path.exists(ft_fname)):
logging.info('Downloading fasttext model')
temp_fname = fasttext.util.download_model(lang, if_e... |
def get_fasttext(fasttext_model, words):
embeddings = [[fasttext_model[word] for word in sentence] for sentence in words]
return embeddings
|
def process_file(bert_model, bert_tokenizer, fasttext_model, batch_size, language, ud_file, output_file):
logging.info('Processing file {}'.format(ud_file))
logging.info('PHASE ONE: reading file and tokenizing')
(all_target_tokens, all_bert_tokens, all_bert2target_map, all_ud) = tokenize_ud(ud_file, bert_... |
def process(language, ud_path, batch_size, bert_name, output_path):
logging.info('Loading pre-trained BERT network')
(bert_tokenizer, bert_model) = load_bert(bert_name)
fasttext_model = load_fasttext(language)
logging.info(('Precessing language %s' % language))
ud_file_base = get_ud_file_base(ud_p... |
def main():
logging.basicConfig(format='%(asctime)s : %(levelname)s : %(processName)s : %(message)s', level=logging.INFO)
args = get_args()
batch_size = args.batch_size
language = args.language
ud_path = args.ud_path
output_path = args.output_path
bert_name = 'bert-base-multilingual-cased'... |
def generate_batch(batch):
x = torch.cat([item[0].unsqueeze(0) for item in batch], dim=0)
y = torch.cat([item[1].unsqueeze(0) for item in batch], dim=0)
(x, y) = (x.to(device=constants.device), y.to(device=constants.device))
return (x, y)
|
def get_data_cls(task):
if (task == 'pos_tag'):
return PosTagDataset
if (task == 'dep_label'):
return DepLabelDataset
|
def get_data_loader(dataset_cls, data_path, language, representations, pca_size, mode, batch_size, shuffle, pca=None, classes=None, words=None):
trainset = dataset_cls(data_path, language, representations, pca_size, mode, pca=pca, classes=classes, words=words)
trainloader = DataLoader(trainset, batch_size=bat... |
def get_data_loaders(data_path, task, language, representations, pca_size, batch_size):
dataset_cls = get_data_cls(task)
(trainloader, pca, classes, words) = get_data_loader(dataset_cls, data_path, language, representations, pca_size, 'train', batch_size=batch_size, shuffle=True)
(devloader, _, classes, w... |
class DepLabelDataset(PosTagDataset):
def load_data_index(self):
data_ud = util.read_data((self.input_name_base % (self.mode, 'ud')))
(x_raw, y_raw) = ([], [])
for (sentence_ud, words) in data_ud:
for (i, token) in enumerate(sentence_ud):
head = token['head']
... |
class PosTagDataset(Dataset):
def __init__(self, data_path, language, representation, embedding_size, mode, pca=None, classes=None, words=None):
self.data_path = data_path
self.language = language
self.mode = mode
self.representation = representation
self.embedding_size = ... |
class BaseModel(nn.Module, ABC):
name = 'base'
def __init__(self):
super().__init__()
self.best_state_dict = None
def set_best(self):
self.best_state_dict = copy.deepcopy(self.state_dict())
def recover_best(self):
self.load_state_dict(self.best_state_dict)
def s... |
class TransparentDataParallel(nn.DataParallel):
def set_best(self, *args, **kwargs):
return self.module.set_best(*args, **kwargs)
def recover_best(self, *args, **kwargs):
return self.module.recover_best(*args, **kwargs)
def save(self, *args, **kwargs):
return self.module.save(*a... |
class MLP(BaseModel):
name = 'mlp'
def __init__(self, task, embedding_size=768, n_classes=3, hidden_size=5, nlayers=1, dropout=0.1, representation=None, n_words=None):
super().__init__()
self.dropout_p = dropout
self.embedding_size = embedding_size
self.hidden_size = hidden_si... |
def args2list(args):
return ['--data-path', str(args.data_path), '--task', str(args.task), '--language', str(args.language), '--batch-size', str(args.batch_size), '--representation', str(args.representation), '--eval-batches', str(args.eval_batches), '--wait-epochs', str(args.wait_epochs), '--checkpoint-path', st... |
def get_hyperparameters(search):
hyperparameters = {'--hidden-size': search[0], '--nlayers': search[1], '--dropout': search[2], '--pca-size': search[3]}
return dict2list(hyperparameters)
|
def get_hyperparameters_search(n_runs, representation):
bert_pca_size = list([768])
fast_pca_size = list([300])
onehot_pca_size = list({int((2 ** x)) for x in np.arange(5.6, 8.2, 0.01)})
hidden_size = list({int((2 ** x)) for x in np.arange(2, 9, 0.01)})
nlayers = [1, 2, 3]
dropout = list(np.ar... |
def dict2list(data):
list2d = [[k, str(x)] for (k, x) in data.items()]
return list(itertools.chain.from_iterable(list2d))
|
def write_done(done_fname):
with open(done_fname, 'w') as f:
f.write('done training\n')
|
def append_result(fname, values):
with open(fname, 'a+') as f:
f.write((','.join(values) + '\n'))
|
def get_results(out, err):
loss_pattern = '^Final loss. Train: (\\d.\\d+) Dev: (\\d.\\d+) Test: (\\d.\\d+)$'
acc_pattern = '^Final acc. Train: (\\d.\\d+) Dev: (\\d.\\d+) Test: (\\d.\\d+)$'
output = out.decode().split('\n')
try:
m = re.match(loss_pattern, output[(- 3)])
(train_loss, dev... |
def main():
args = get_args()
n_runs = 50
ouput_path = os.path.join(args.checkpoint_path, args.task, args.language, args.representation)
results_fname = os.path.join(ouput_path, 'all_results.txt')
done_fname = os.path.join(ouput_path, 'finished.txt')
curr_iter = (util.file_len(results_fname) -... |
def get_model_name(args):
fpath = ('nl_%d-es_%d-hs_%d-d_%.4f' % (args.nlayers, args.pca_size, args.hidden_size, args.dropout))
return fpath
|
def get_args():
parser = argparse.ArgumentParser()
parser.add_argument('--data-path', type=str, required=True)
parser.add_argument('--language', type=str, required=True)
parser.add_argument('--task', type=str, required=True)
parser.add_argument('--batch-size', type=int, default=64)
parser.add_... |
def get_model(n_classes, n_words, args):
mlp = MLP(args.task, embedding_size=args.pca_size, n_classes=n_classes, hidden_size=args.hidden_size, nlayers=args.nlayers, dropout=args.dropout, representation=args.representation, n_words=n_words)
if (torch.cuda.device_count() > 1):
mlp = TransparentDataParal... |
def _evaluate(evalloader, model):
criterion = nn.CrossEntropyLoss().to(device=constants.device)
(dev_loss, dev_acc) = (0, 0)
for (x, y) in evalloader:
(loss, acc) = model.eval_batch(x, y)
dev_loss += loss
dev_acc += acc
n_instances = len(evalloader.dataset)
return {'loss': ... |
def evaluate(evalloader, model):
model.eval()
with torch.no_grad():
result = _evaluate(evalloader, model)
model.train()
return result
|
def train_epoch(trainloader, devloader, model, optimizer, criterion, train_info):
for (x, y) in trainloader:
loss = model.train_batch(x, y, optimizer, criterion)
train_info.new_batch(loss)
if train_info.eval:
dev_results = evaluate(devloader, model)
if train_info.is... |
def train(trainloader, devloader, model, eval_batches, wait_iterations):
optimizer = optim.Adam(model.parameters())
criterion = nn.CrossEntropyLoss().to(device=constants.device)
with tqdm(total=wait_iterations) as pbar:
train_info = TrainInfo(pbar, wait_iterations, eval_batches)
while (not... |
def eval_all(model, trainloader, devloader, testloader):
train_results = evaluate(trainloader, model)
dev_results = evaluate(devloader, model)
test_results = evaluate(testloader, model)
print(('Final loss. Train: %.4f Dev: %.4f Test: %.4f' % (train_results['loss'], dev_results['loss'], test_results['l... |
def save_results(model, train_results, dev_results, test_results, results_fname):
results = [['n_classes', 'embedding_size', 'hidden_size', 'nlayers', 'dropout_p', 'train_loss', 'dev_loss', 'test_loss', 'train_acc', 'dev_acc', 'test_acc']]
results += [[model.n_classes, model.embedding_size, model.hidden_size,... |
def save_checkpoints(model, train_results, dev_results, test_results, save_path):
util.mkdir(save_path)
model.save(save_path)
results_fname = (save_path + '/results.csv')
save_results(model, train_results, dev_results, test_results, results_fname)
|
def main():
args = get_args()
(trainloader, devloader, testloader, n_classes, n_words) = get_data_loaders(args.data_path, args.task, args.language, args.representation, args.pca_size, args.batch_size)
print(('Language: %s Train size: %d Dev size: %d Test size: %d' % (args.language, len(trainloader.dataset... |
class TrainInfo():
batch_id = 0
running_loss = []
best_loss = float('inf')
best_batch = 0
def __init__(self, pbar, wait_iterations, eval_batches):
self.pbar = pbar
self.wait_iterations = wait_iterations
self.eval_batches = eval_batches
@property
def finish(self):
... |
def config(seed):
random.seed(seed)
np.random.seed(seed)
torch.manual_seed(seed)
|
def write_csv(filename, results):
with io.open(filename, 'w', encoding='utf8') as f:
writer = csv.writer(f, delimiter=',')
writer.writerows(results)
|
def write_data(filename, data):
with open(filename, 'wb') as f:
pickle.dump(data, f)
|
def read_data(filename):
with open(filename, 'rb') as f:
data = pickle.load(f)
return data
|
def rmdir_if_exists(fdir):
if os.path.exists(fdir):
shutil.rmtree(fdir)
|
def file_len(fname):
if (not os.path.isfile(fname)):
return 0
with open(fname, 'r') as f:
for (i, l) in enumerate(f):
pass
return (i + 1)
|
def mkdir(folder):
pathlib.Path(folder).mkdir(parents=True, exist_ok=True)
|
@dataclass
class MelConfig():
n_mels: int = 128
sample_rate: int = 24000
win_length: int = 1024
hop_length: int = 256
|
@dataclass
class DiffusionConfig():
in_channels: int = 128
residual_layers: int = 30
residual_channels: int = 128
dilation_cycle_length: int = 10
num_diffusion_steps: int = 50
sample_rate: int = 24000
win_length: int = 1024
hop_length: int = 256
|
@dataclass
class GANConfig():
in_channels: int = 128
upsample_in_channels: int = 1536
upsample_strides: List[int] = field(default_factory=(lambda : [4, 4, 2, 2, 2, 2]))
resblock_kernel_sizes: List[int] = field(default_factory=(lambda : [3, 7, 11]))
resblock_dilations: List[List[int]] = field(defau... |
Subsets and Splits
No community queries yet
The top public SQL queries from the community will appear here once available.