def test_case2(self): # 测试使用int初始化 model = Model() if torch.cuda.is_available(): model = _move_model_to_device(model, 0) assert model.param.device == torch.device('cuda:0') assert model.param.device == torch.device('cuda:0'), "The model should be in " with self.assertRaises(Exception): _move_model_to_device(model, 100) with self.assertRaises(Exception): _move_model_to_device(model, -1)
def test_case5(self): if not torch.cuda.is_available(): return # torch.device() device = torch.device('cpu') model = Model() _move_model_to_device(model, device) device = torch.device('cuda') model = _move_model_to_device(model, device) assert model.param.device == torch.device('cuda:0') with self.assertRaises(Exception): _move_model_to_device(model, torch.device('cuda:100'))
def test_case1(self): # 测试str model = Model() model = _move_model_to_device(model, 'cpu') assert model.param.device == torch.device('cpu') # 测试不存在的device报错 with self.assertRaises(Exception): _move_model_to_device(model, 'cpuu') # 测试gpu if torch.cuda.is_available(): model = _move_model_to_device(model, 'cuda') assert model.param.is_cuda model = _move_model_to_device(model, 'cuda:0') assert model.param.device == torch.device('cuda:0') with self.assertRaises(Exception): _move_model_to_device(model, 'cuda:1000') # 测试None model = _move_model_to_device(model, None)
def test_case3(self): # 测试None model = Model() device = _get_model_device(model) model = _move_model_to_device(model, None) assert device == _get_model_device(model), "The device should not change." if torch.cuda.is_available(): model.cuda() device = _get_model_device(model) model = _move_model_to_device(model, None) assert device == _get_model_device(model), "The device should not change." model = nn.DataParallel(model, device_ids=[0]) _move_model_to_device(model, None) with self.assertRaises(Exception): _move_model_to_device(model, 'cpu')
def test_case4(self): # 测试传入list的内容 model = Model() device = ['cpu'] with self.assertRaises(Exception): _move_model_to_device(model, device) if torch.cuda.is_available(): device = [0] _model = _move_model_to_device(model, device) assert not isinstance(_model, nn.DataParallel) device = [torch.device('cuda:0'), torch.device('cuda:0')] with self.assertRaises(Exception): _model = _move_model_to_device(model, device) if torch.cuda.device_count() > 1: device = [0, 1] _model = _move_model_to_device(model, device) assert isinstance(_model, nn.DataParallel) device = ['cuda', 'cuda:1'] with self.assertRaises(Exception): _move_model_to_device(model, device)
test_data.rename_field('Phrase', 'raw_words') test_data.apply(get_words, new_field_name='words') vocab_all.index_dataset(test_data, field_name='words') test_data.set_input('words') ''' EMBED_DIM = 100 model = CNNText((len(vocab_all),EMBED_DIM), num_classes=len(vocab_target), dropout=0.1) ''' device = 0 if torch.cuda.is_available() else 'cpu' embed = BertEmbedding(vocab_all, model_dir_or_name='en', include_cls_sep=True) model = BertForSequenceClassification(embed, len(vocab_target)) ModelLoader.load_pytorch(model, 'save_model/ceshi.pkl') _move_model_to_device(model, device=device) #pred = model_cnn.predict(torch.LongTensor([test_data[10]['words']])) def predict(instance): x_batch = torch.LongTensor([instance['words']]) x_batch = x_batch.to(device=_get_model_device(model)) pred = model.predict(x_batch) pred = vocab_target.to_word(int(pred['pred'])) return pred test_data.apply(predict, new_field_name='target') out_file = open('data/1/sub2021.1.19.csv', 'w') out_file.write('PhraseId,Sentiment\n')
def train(): n_epochs = 10 train_set = data_set_loader._load('../models/all4bert_new_triple.txt') train_set, tmp_set = train_set.split(0.2) val_set, test_set = tmp_set.split(0.5) data_bundle = [train_set, val_set, test_set] for dataset in data_bundle: dataset.apply(addWords, new_field_name="p_words") dataset.apply(addWordPiece, new_field_name="t_words") dataset.apply(processItem, new_field_name="word_pieces") dataset.apply(processNum, new_field_name="word_nums") dataset.apply(addSeqlen, new_field_name="seq_len") dataset.apply(processTarget, new_field_name="target") for dataset in data_bundle: dataset.field_arrays["word_pieces"].is_input = True dataset.field_arrays["seq_len"].is_input = True dataset.field_arrays["word_nums"].is_input = True dataset.field_arrays["target"].is_target = True print("In total " + str(len(data_bundle)) + " datasets:") print("Trainset has " + str(len(train_set)) + " instances.") print("Validateset has " + str(len(val_set)) + " instances.") print("Testset has " + str(len(test_set)) + " instances.") train_set.print_field_meta() # print(train_set) from fastNLP.models.Mybert import BertForSentenceMatching from fastNLP import AccuracyMetric, DataSetIter from fastNLP.core.utils import _pseudo_tqdm as tqdm # 注意这里是表明分的类数 model = BertForSentenceMatching(embed, 3) if torch.cuda.is_available(): model = _move_model_to_device(model, device=0) # print(model) train_batch = DataSetIter(batch_size=16, dataset=train_set, sampler=None) optimizer = torch.optim.Adam(model.parameters(), lr=2e-5) Lossfunc = torch.nn.CrossEntropyLoss() with tqdm(total=n_epochs, postfix='loss:{0:<6.5f}', leave=False, dynamic_ncols=True) as pbar: print_every = 10 for epoch in range(1, n_epochs + 1): pbar.set_description_str( desc="Epoch {}/{}".format(epoch, n_epochs)) avg_loss = 0 step = 0 for batch_x, batch_y in train_batch: step += 1 _move_dict_value_to_device(batch_x, batch_y, device=_get_model_device(model)) optimizer.zero_grad() output = model.forward(batch_x["word_pieces"], batch_x["word_nums"], batch_x["seq_len"]) loss = Lossfunc(output['pred'], batch_y['target']) loss.backward() optimizer.step() avg_loss += loss.item() if step % print_every == 0: avg_loss = float(avg_loss) / print_every print_output = "[epoch: {:>3} step: {:>4}] train loss: {:>4.6}".format( epoch, step, avg_loss) pbar.update(print_every) pbar.set_postfix_str(print_output) avg_loss = 0 metric = AccuracyMetric() val_batch = DataSetIter(batch_size=8, dataset=val_set, sampler=None) for batch_x, batch_y in val_batch: _move_dict_value_to_device(batch_x, batch_y, device=_get_model_device(model)) output = model.predict(batch_x["word_pieces"], batch_x["word_nums"], batch_x["seq_len"]) metric(output, batch_y) eval_result = metric.get_metric() print("ACC on Validate Set:", eval_result) from fastNLP.io import ModelSaver saver = ModelSaver("../models/bert_model_max_triple.pkl") saver.save_pytorch(model, param_only=False) pbar.close() metric = AccuracyMetric() test_batch = DataSetIter(batch_size=8, dataset=test_set, sampler=None) for batch_x, batch_y in test_batch: _move_dict_value_to_device(batch_x, batch_y, device=_get_model_device(model)) output = model.predict(batch_x["word_pieces"], batch_x["word_nums"], batch_x["seq_len"]) metric(output, batch_y) eval_result = metric.get_metric() print("ACC on Test Set:", eval_result) from fastNLP.io import ModelSaver saver = ModelSaver("../models/bert_model_max_triple.pkl") saver.save_pytorch(model, param_only=False)