def main(): parser = argparse.ArgumentParser() # Required parameters parser.add_argument("--do_train", default=True, action='store_true') parser.add_argument('--do_eval', default=False, action='store_true') parser.add_argument("--do_predict", default=False, action='store_true') parser.add_argument('--markup', default='bieos', type=str, choices=['bios', 'bio', 'bieos']) # 标签类型 parser.add_argument("--arch", default='bilstm_crf', type=str) parser.add_argument('--learning_rate', default=0.001, type=float) parser.add_argument('--seed', default=1234, type=int) parser.add_argument('--gpu', default='', type=str) parser.add_argument('--epochs', default=100, type=int) parser.add_argument('--batch_size', default=32, type=int) parser.add_argument('--embedding_size', default=128, type=int) parser.add_argument('--hidden_size', default=384, type=int) parser.add_argument("--grad_norm", default=5.0, type=float, help="Max gradient norm.") parser.add_argument("--task_name", type=str, default='ner') args = parser.parse_args() args.data_dir = config.data_dir if not config.output_dir.exists(): args.output_dir.mkdir() args.output_dir = config.output_dir / '{}'.format(args.arch) if not args.output_dir.exists(): args.output_dir.mkdir() init_logger(log_file=str(args.output_dir / '{}-{}.log'.format(args.arch, args.task_name))) seed_everything(args.seed) if args.gpu != '': args.device = torch.device(f"cuda:{args.gpu}") else: args.device = torch.device("cpu") args.id2label = {i: label for i, label in enumerate(config.label2id)} args.label2id = config.label2id processor = CluenerProcessor(data_dir=config.data_dir) processor.get_vocab() model = BERT_NERModel(device=args.device, label2id=args.label2id, need_birnn=True) # model = NERModel(vocab_size=len(processor.vocab), embedding_size=args.embedding_size, # hidden_size=args.hidden_size, device=args.device, label2id=args.label2id) model.to(args.device) if args.do_train: train(args, model, processor) if args.do_eval: model_path = args.output_dir / 'best-model.bin' model = load_model(model, model_path=str(model_path)) evaluate(args, model, processor) if args.do_predict: predict(args, model, processor)
def main(): parser = argparse.ArgumentParser() parser.add_argument("--do_train", default=False, action='store_true') parser.add_argument("--do_eval", default=False, action='store_true') parser.add_argument('--do_predict', default=False, action='store_true') #bios,s是single单字 parser.add_argument('--markup', default='bios', type=str, choices=['bio', 'bios']) parser.add_argument("--arch", default='bert', type=str) parser.add_argument('--seed', default=1234, type=int) parser.add_argument('--gpu', default='0', type=str) parser.add_argument('--epochs', default=20, type=int) parser.add_argument('--batch_size', default=16, type=int) parser.add_argument("--task_name", type=str, default='ner') parser.add_argument("--max_seq_len", type=int, default=64) parser.add_argument("--aug_num", default=4, type=int) args = parser.parse_args() args.vocab_file = config.vocab_file args.data_dir = config.data_dir args.tf_checkpoint = config.tf_checkpoint args.init_checkpoint = config.init_checkpoint args.bert_config_file = config.bert_config_file if not config.output_dir.exists(): args.output_dir.mkdir() args.output_dir = config.output_dir / '{}'.format(args.arch) if not args.output_dir.exists(): args.output_dir.mkdir() init_logger(log_file=str(args.output_dir / '{}-{}.log'.format(args.arch, args.task_name))) seed_everything(args.seed) #设置gpu os.environ["CUDA_VISIBLE_DEVICES"] = args.gpu args.id2label = {i: label for i, label in enumerate(config.label2id)} args.label2id = config.label2id processor = CluenerProcessor(data_dir=config.data_dir, vocab_file=config.vocab_file, label2id=config.label2id, max_seq_len=args.max_seq_len) processor.get_label_embedding(args.label2id, config.pretrain_label_embedding_file, config.label_embedding_file) args.label_embedding = processor.label_embedding if args.do_train: train(args, NERModel, processor) if args.do_predict: predict(args, processor)
def main(): parser = argparse.ArgumentParser() parser.add_argument("--do_train", default=False, action='store_true') parser.add_argument("--do_eval", default=False, action='store_true') parser.add_argument('--do_predict', default=False, action='store_true') parser.add_argument('--markup', default='bmeso', type=str) parser.add_argument("--arch", default='transformer', type=str) parser.add_argument('--learning_rate', default=0.001, type=float) parser.add_argument('--seed', default=1234, type=int) parser.add_argument('--gpu', default='0', type=str) parser.add_argument('--epochs', default=100, type=int) parser.add_argument('--batch_size', default=16, type=int) # parser.add_argument('--hidden_size', default=512, type=int) parser.add_argument("--grad_norm", default=5.0, type=float, help="Max gradient norm.") args = parser.parse_args() args.data_dir = config.data_dir args.output_dir = config.output_dir / Path( '{}'.format(str(config.dataset) + '-on-lstm')) if not args.output_dir.exists(): args.output_dir.mkdir() init_logger(log_file=str(args.output_dir / '{}.log'.format(args.arch))) seed_everything(args.seed) # 设置gpu os.environ["CUDA_VISIBLE_DEVICES"] = args.gpu if os.path.exists(config.save_data_name): print('Loading processed data') with open(config.save_data_name, 'rb') as fp: data = pickle.load(fp) else: data = Data() data_initialization(data, config.gaz_file, config.train_path, config.dev_path, config.test_path) data.generate_instance_with_gaz(config.train_path, 'train') data.generate_instance_with_gaz(config.dev_path, 'dev') data.generate_instance_with_gaz(config.test_path, 'test') data.build_word_pretrain_emb(config.char_emb) data.build_biword_pretrain_emb(config.bichar_emb) data.build_gaz_pretrain_emb(config.gaz_file) print('Dumping data') with open(config.save_data_name, 'wb') as f: pickle.dump(data, f) if args.do_train: train(args, data, NERModel) if args.do_predict: predict(args, data, NERModel, 'test')
def main(): parser = argparse.ArgumentParser() parser.add_argument("--do_train", default=False, action='store_true') parser.add_argument("--do_eval", default=False, action='store_true') parser.add_argument('--do_predict', default=False, action='store_true') #bios,s是single单字 parser.add_argument('--markup', default='bios', type=str, choices=['bio', 'bios']) parser.add_argument("--arch", default='bilstm_crf', type=str) parser.add_argument('--learning_rate', default=0.001, type=float) parser.add_argument('--seed', default=1234, type=int) parser.add_argument('--gpu', default='0', type=str) parser.add_argument('--epochs', default=80, type=int) parser.add_argument('--batch_size', default=32, type=int) parser.add_argument('--embedding_size', default=128, type=int) parser.add_argument('--hidden_size', default=384, type=int) parser.add_argument("--grad_norm", default=5.0, type=float, help="Max gradient norm.") parser.add_argument("--task_name", type=str, default='ner') args = parser.parse_args() args.data_dir = config.data_dir if not config.output_dir.exists(): args.output_dir.mkdir() args.output_dir = config.output_dir / '{}'.format(args.arch) if not args.output_dir.exists(): args.output_dir.mkdir() init_logger(log_file=str(args.output_dir / '{}-{}.log'.format(args.arch, args.task_name))) seed_everything(args.seed) #设置gpu os.environ["CUDA_VISIBLE_DEVICES"] = args.gpu args.id2label = {i: label for i, label in enumerate(config.label2id)} args.label2id = config.label2id processor = CluenerProcessor(data_dir=config.data_dir) processor.get_vocab() if args.do_train: train(args, NERModel, processor) if args.do_predict: predict(args, NERModel, processor)
import numpy as np import torch import torch.nn as nn from config import CFG import common as com com.seed_everything(seed=42) def train_fn(train_loader, model, optimizer, epoch, scheduler, device): losses = AverageMeter() model.train() for step, (cont_x, cate_x, y) in enumerate(train_loader): cont_x, cate_x, y = cont_x.to(device), cate_x.to(device), y.to(device) batch_size = cont_x.size(0) pred = model(cont_x, cate_x) loss = nn.BCEWithLogitsLoss()(pred, y) losses.update(loss.item(), batch_size) if CFG.gradient_accumulation_steps > 1: loss = loss / CFG.gradient_accumulation_steps loss.backward() grad_norm = torch.nn.utils.clip_grad_norm_(model.parameters(),
def main(): argparser = argparse.ArgumentParser() argparser.add_argument("samples_filename", type=str, help="Slices to reconstruct") argparser.add_argument("equations_filename", type=str, help="File to read the equations") argparser.add_argument("mesh_filename", type=str, help="Reconstruction to save") argparser.add_argument("--scaling-todo", "-st", type=float, default=1, help="What scaling would you like to do") argparser.add_argument("--num-epochs", "-e", type=int, default=1, help="Number of training epochs") argparser.add_argument("--num-batches", "-b", type=int, default=72500, help="Number of training batches") argparser.add_argument("--resolution", "-r", type=int, default=300, help="Resolution to evaluate on network") argparser.add_argument("--seed", "-s", type=int, default=-1) args = argparser.parse_args() if args.seed > 0: seed = args.seed common.seed_everything(seed) else: seed = np.random.randint(0, 2**32 - 1) common.seed_everything(seed) print("Using seed %d" % seed) torch.cuda.empty_cache() device = torch.device("cuda" if torch.cuda.is_available() else "cpu") # # We load the training data Samples, Ocupancy, num_samples, Samples_per_slice = common.load_samples( args.samples_filename) Samples = Samples * args.scaling_todo print(np.amin(Samples), np.amax(Samples)) x_test = torch.from_numpy(Samples.astype(np.float32)).to(device) y_test = torch.from_numpy(Ocupancy.astype(np.float32)).to(device) train_data = common.CustomDataset(x_test, y_test) #Separate into bartches batches_size equal to the number of points in each slice n_samples x n_samples train_loader = DataLoader(dataset=train_data, batch_size=args.num_batches, shuffle=True) phi = common.MLP(3, 1).to(device) criterion = torch.nn.BCEWithLogitsLoss() optimizer = torch.optim.Adam(phi.parameters(), lr=0.01) epoch = args.num_epochs fit_start_time = time.time() for epoch in range(epoch): batch = 0 for x_batch, y_batch in train_loader: optimizer.zero_grad() x_train = x_batch y_train = y_batch y_pred = phi(x_batch) loss = criterion(y_pred.squeeze(), y_batch.squeeze()) print('Batch {}: train loss: {}'.format( batch, loss.item())) # Backward pass loss.backward() optimizer.step() # Optimizes only phi parameters batch += 1 print('Epoch {}: train loss: {}'.format(epoch, loss.item())) fit_end_time = time.time() print("Total time = %f" % (fit_end_time - fit_start_time)) min = -5 max = 5 complexnum = 1j #Sample 3D space X, Y, Z = np.mgrid[min:max:args.resolution * complexnum, min:max:args.resolution * complexnum, min:max:args.resolution * complexnum] with torch.no_grad(): xyz = torch.from_numpy( np.vstack([X.ravel(), Y.ravel(), Z.ravel()]).transpose().astype(np.float32)).to(device) eval_data = common.LabelData(xyz) labels = np.asarray([]) #Separate into bartches batches_size equal to the number of points in each slice n_samples x n_samples eval_loader = DataLoader(dataset=eval_data, batch_size=args.num_batches, shuffle=False) for eval_batch in eval_loader: phi.eval() label = torch.sigmoid(phi(eval_batch).to(device)) label = label.detach().cpu().numpy().astype(np.float32) labels = np.append(labels, label) I = labels.reshape((np.cbrt(labels.shape[0]).astype(np.int32), np.cbrt(labels.shape[0]).astype(np.int32), np.cbrt(labels.shape[0]).astype(np.int32))) verts, faces, normals = measure.marching_cubes_lewiner( I, spacing=(X[1, 0, 0] - X[0, 0, 0], Y[0, 1, 0] - Y[0, 0, 0], Z[0, 0, 1] - Z[0, 0, 0]))[:3] verts = verts - max visualize.vizualize_all_contours(verts, faces, args.scaling_todo, args.equations_filename) common.write_objfile(args.mesh_filename, verts, faces)
def main(): parser = argparse.ArgumentParser() parser.add_argument('--task_name', default='NER', type=str) parser.add_argument('--data_dir', default='./datasets/cluener', type=str) parser.add_argument('--model_type', default='bert', type=str) parser.add_argument('--display', default='./display', type=str) parser.add_argument('--pretrain_model_path', default='./pretrained_model/bert-base-uncased/', type=str, required=False) parser.add_argument('--output_dir', default='./output/', type=str) parser.add_argument('--markup', default='bios', type=str, choices=['bios', 'bio']) parser.add_argument('--loss_type', default='ghmc', choices=['lsr', 'focal', 'ce', 'ghmc']) parser.add_argument('--max_seq_length', default=128, type=int) parser.add_argument("--do_lower_case", default=True) parser.add_argument('--do_train', default=True) parser.add_argument('--do_eval', default=True) parser.add_argument('--do_predict', default=False) parser.add_argument('--per_gpu_train_batch_size', default=128, type=int) parser.add_argument('--gradient_accumulation_steps', type=int, default=1) parser.add_argument('--learning_rate', default=5e-5, type=float) parser.add_argument("--weight_decay", default=0.0, type=float) parser.add_argument('--adam_epsilon', default=1e-8, type=float) parser.add_argument('--max_grad_norm', default=1.0, type=float) parser.add_argument('--num_train_epochs', default=8.0, type=float) parser.add_argument('--warmup_steps', default=0, type=int) parser.add_argument('--logging_steps', type=int, default=50) parser.add_argument('--save_steps', type=int, default=50) parser.add_argument('--no_cuda', default=False) parser.add_argument('--overwrite_output_dir', default=True) parser.add_argument('--seed', type=int, default=42) parser.add_argument('--fp16', default=True) parser.add_argument('--fp16_opt_level', type=str, default="O1") parser.add_argument('--local_rank', type=int, default=-1) parser.add_argument("--eval_count", type=int, default=0) args = parser.parse_args() if not os.path.exists(args.display): os.mkdir(args.display) if not os.path.exists(args.output_dir): os.mkdir(args.output_dir) args.output_dir = args.output_dir + f'{args.model_type}' if os.path.exists(args.output_dir) and os.listdir( args.output_dir ) and args.do_train and not args.overwrite_output_dir: raise ValueError( "Output directory ({}) already exists and is not empty. Use --overwrite_output_dir to overcome." .format(args.output_dir)) if args.local_rank == -1 or args.no_cuda: device = torch.device("cuda" if torch.cuda.is_available() and not args.no_cuda else "cpu") args.n_gpu = torch.cuda.device_count() else: torch.cuda.set_device(args.local_rank) device = torch.device('cuda', args.local_rank) args.n_gpu = 1 args.device = device seed_everything(args.seed) process = DataProcess() label_list = process.get_labels() args.id2label = {i: label for i, label in enumerate(label_list)} args.label2id = {label: i for i, label in enumerate(label_list)} num_labels = len(label_list) if args.local_rank not in [-1, 0]: torch.distributed.barrier() config_class, model_class, tokenizer_class = BertConfig, BertSpanForNer, CNerTokenizer config = config_class.from_pretrained(args.pretrain_model_path, num_labels=num_labels, loss_type=args.loss_type, soft_label=True) tokenizer = tokenizer_class.from_pretrained( args.pretrain_model_path, do_lower_case=args.do_lower_case) model = model_class.from_pretrained(args.pretrain_model_path, config=config) model.to(args.device) writer = SummaryWriter(log_dir=args.display + '/' + time.strftime('%m_%d_%H.%M', time.localtime()) + '_' + str(args.loss_type)) if args.do_train: train_dataset = load_examples(args, tokenizer, data_type='train') global_step, train_loss = train(args, train_dataset, model, tokenizer, writer) model_to_save = (model.module if hasattr(model, "module") else model) model_to_save.save_pretrained(args.output_dir) tokenizer.save_vocabulary(args.output_dir) torch.save(args, os.path.join(args.output_dir, "training_args.bin")) results = {} if args.do_eval and args.local_rank in [-1, 0]: tokenizer = tokenizer_class.from_pretrained( args.output_dir, do_lower_case=args.do_lower_case) checkpoints = [args.output_dir] for checkpoint in checkpoints: global_step = checkpoint.split( "-")[-1] if len(checkpoints) > 1 else "" prefix = checkpoint.split( '/')[-1] if checkpoint.find('checkpoint') != -1 else "" model = model_class.from_pretrained(checkpoint) model.to(args.device) result = evaluate(args, model, tokenizer, writer) if global_step: result = { "{}_{}".format(global_step, k): v for k, v in result.items() } results.update(result) output_eval_file = os.path.join(args.output_dir, "eval_results.txt") with open(output_eval_file, "w") as writer: for key in sorted(results.keys()): writer.write("{} = {}\n".format(key, str(results[key])))