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])))
