def test_named_entity_recognition():
# Creating train_df and eval_df for demonstration
train_data = [
[0, "Simple", "B-MISC"],
[0, "Transformers", "I-MISC"],
[0, "started", "O"],
[1, "with", "O"],
[0, "text", "O"],
[0, "classification", "B-MISC"],
[1, "Simple", "B-MISC"],
[1, "Transformers", "I-MISC"],
[1, "can", "O"],
[1, "now", "O"],
[1, "perform", "O"],
[1, "NER", "B-MISC"],
]
train_df = pd.DataFrame(train_data,
columns=["sentence_id", "words", "labels"])
eval_data = [
[0, "Simple", "B-MISC"],
[0, "Transformers", "I-MISC"],
[0, "was", "O"],
[1, "built", "O"],
[1, "for", "O"],
[0, "text", "O"],
[0, "classification", "B-MISC"],
[1, "Simple", "B-MISC"],
[1, "Transformers", "I-MISC"],
[1, "then", "O"],
[1, "expanded", "O"],
[1, "to", "O"],
[1, "perform", "O"],
[1, "NER", "B-MISC"],
]
eval_df = pd.DataFrame(eval_data,
columns=["sentence_id", "words", "labels"])
# Create a NERModel
model = NERModel(
"bert",
"bert-base-cased",
args={
"no_save": True,
"overwrite_output_dir": True,
"reprocess_input_data": False
},
use_cuda=False,
)
# Train the model
model.train_model(train_df)
# Evaluate the model
result, model_outputs, predictions = model.eval_model(eval_df)
# Predictions on arbitary text strings
predictions, raw_outputs = model.predict(["Some arbitary sentence"])
class BioAnalysis:
def __init__(self,
train_file="./data/train.tsv",
dev_file="./data/dev.tsv",
test_file="./data/test.tsv"):
self.train_data = file_opener(train_file)
self.dev_data = file_opener(dev_file)
self.test_data = file_opener(test_file)
self.test_data.pop(192)
self.crf = sklearn_crfsuite.CRF(algorithm='lbfgs',
c1=0.09684573395986483,
c2=0.0800864058815976,
max_iterations=100,
all_possible_transitions=True)
self.dev_predicted = None
self.test_predicted = None
self.dev_labels = None
self.test_labels = None
self.labels = [
'B-Abiotic_Entity', 'B-Aggregate_Biotic_Abiotic_Entity',
'B-Biotic_Entity', 'B-Eventuality', 'B-Location', 'B-Quality',
'B-Time', 'B-Unit', 'B-Value', 'I-Abiotic_Entity',
'I-Aggregate_Biotic_Abiotic_Entity', 'I-Biotic_Entity',
'I-Eventuality', 'I-Location', 'I-Quality', 'I-Time', 'I-Unit',
'I-Value', 'O'
]
self.roberta_nel_model = None
self.roberta_nel_dev_eval = None
self.roberta_nel_test_eval = None
self.roberta_nel_dev_links = None
self.roberta_nel_test_links = None
self.roberta_nel_train_data, _ = get_roberta_nel_data(self.train_data)
self.roberta_nel_dev_data, self.roberta_nel_dev_spans = get_roberta_nel_data(
self.dev_data)
self.roberta_nel_test_data, self.roberta_nel_test_spans = get_roberta_nel_data(
self.test_data)
self.roberta_ner_model = None
self.roberta_ner_dev_eval = None
self.roberta_ner_test_eval = None
self.roberta_ner_train_data = get_roberta_ner_data(self.train_data)
self.roberta_ner_dev_data = get_roberta_ner_data(self.dev_data)
self.roberta_ner_test_data = get_roberta_ner_data(self.test_data)
def crf_fit(self):
self.crf.fit(*get_features_labels(self.train_data))
def crf_predict(self):
dev_feat, self.dev_labels = get_features_labels(self.dev_data)
test_feat, self.test_labels = get_features_labels(self.test_data)
self.dev_predicted = self.crf.predict(dev_feat)
self.test_predicted = self.crf.predict(test_feat)
def crf_evaluate(self, verbose=False, labels=False):
if labels:
lab = labels
else:
lab = self.crf.classes_
lab.remove("O")
with warnings.catch_warnings():
warnings.simplefilter("ignore")
print("Dev Results\n===========")
dev_args = (self.dev_labels, self.dev_predicted)
kwargs = {"average": "weighted", "labels": lab}
if verbose:
print("Precision:",
metrics.flat_precision_score(*dev_args, **kwargs))
print("Recall:",
metrics.flat_recall_score(*dev_args, **kwargs))
print("F1:", metrics.flat_f1_score(*dev_args, **kwargs))
test_args = (self.test_labels, self.test_predicted)
print("\nTest Results\n============")
if verbose:
print("Precision:",
metrics.flat_precision_score(*test_args, **kwargs))
print("Recall:",
metrics.flat_recall_score(*test_args, **kwargs))
print("F1:", metrics.flat_f1_score(*test_args, **kwargs))
def roberta_nel_train(self):
train_df = pd.DataFrame(self.roberta_nel_train_data)
self.roberta_nel_model = ClassificationModel(
"roberta",
"roberta-base",
args={
"num_train_epochs": 3,
"overwrite_output_dir": True,
"output_dir": "nel_outputs/"
})
self.roberta_nel_model.train_model(train_df)
def roberta_nel_eval(self):
dev_df = pd.DataFrame(self.roberta_nel_dev_data)
test_df = pd.DataFrame(self.roberta_nel_test_data)
self.roberta_nel_dev_eval = self.roberta_nel_model.eval_model(
dev_df, acc=f1_score)
self.roberta_nel_test_eval = self.roberta_nel_model.eval_model(
test_df, acc=f1_score)
print("Dev NEL Results\n===========")
print("F1:", self.roberta_nel_dev_eval[0]["acc"])
print("\nTest NEL Results\n============")
print("F1:", self.roberta_nel_test_eval[0]["acc"])
def roberta_nel_load_model(self):
self.roberta_nel_model = ClassificationModel(
"roberta", "nel_outputs/", args={"num_train_epochs": 3})
def roberta_ner_train(self):
train_df = pd.DataFrame(self.roberta_ner_train_data,
columns=['sentence_id', 'words', 'labels'])
self.roberta_ner_model = NERModel("roberta",
"roberta-base",
labels=self.labels,
args={
"num_train_epochs": 3,
"overwrite_output_dir": True,
"output_dir": "ner_outputs/"
})
self.roberta_ner_model.train_model(train_df)
def roberta_ner_eval(self):
dev_df = pd.DataFrame(self.roberta_ner_dev_data,
columns=['sentence_id', 'words', 'labels'])
test_df = pd.DataFrame(self.roberta_ner_test_data,
columns=['sentence_id', 'words', 'labels'])
self.roberta_ner_dev_eval = self.roberta_ner_model.eval_model(
dev_df, "./ner_outputs/")
self.roberta_ner_test_eval = self.roberta_ner_model.eval_model(
test_df, "./ner_outputs/")
print("Dev NER Results\n===========")
print("Precision:", self.roberta_ner_dev_eval[0]["precision"])
print("Recall:", self.roberta_ner_dev_eval[0]["recall"])
print("F1:", self.roberta_ner_dev_eval[0]["f1_score"])
print("\nTest NER Results\n============")
print("Precision:", self.roberta_ner_test_eval[0]["precision"])
print("Recall:", self.roberta_ner_test_eval[0]["recall"])
print("F1:", self.roberta_ner_test_eval[0]["f1_score"])
def roberta_ner_load_model(self):
self.roberta_ner_model = NERModel("roberta",
"ner_outputs/",
labels=self.labels,
args={"num_train_epochs": 3})
def roberta_ner_nel_pipeline(self):
try:
self.roberta_ner_load_model()
except OSError:
self.roberta_ner_train()
self.roberta_ner_eval()
roberta_dev_phrases = deepcopy(self.dev_data)
for ii in range(len(roberta_dev_phrases)):
for jj in range(len(roberta_dev_phrases[ii])):
roberta_dev_phrases[ii][jj] = list(roberta_dev_phrases[ii][jj])
roberta_dev_phrases[ii][jj][2] = self.roberta_ner_dev_eval[2][
ii][jj]
roberta_dev_phrases, roberta_dev_spans = get_roberta_nel_data(
roberta_dev_phrases)
roberta_test_phrases = deepcopy(self.test_data)
for ii in range(len(roberta_test_phrases)):
for jj in range(len(roberta_test_phrases[ii])):
roberta_test_phrases[ii][jj] = list(
roberta_test_phrases[ii][jj])
roberta_test_phrases[ii][jj][2] = self.roberta_ner_test_eval[
2][ii][jj]
roberta_test_phrases, roberta_test_spans = get_roberta_nel_data(
roberta_test_phrases)
try:
self.roberta_nel_load_model()
except OSError:
self.roberta_nel_train()
roberta_dev_prediction = self.roberta_nel_model.predict(
[x[0] for x in roberta_dev_phrases])[0]
roberta_test_prediction = self.roberta_nel_model.predict(
[x[0] for x in roberta_test_phrases])[0]
roberta_dev_actual = [x[1] for x in self.roberta_nel_dev_data]
roberta_test_actual = [x[1] for x in self.roberta_nel_test_data]
dev_prediction = transform_nel_results(roberta_dev_prediction,
roberta_dev_spans)
dev_actual = transform_nel_results(roberta_dev_actual,
self.roberta_nel_dev_spans)
dev_actual, dev_prediction = resolve_diff(dev_actual, dev_prediction)
test_prediction = transform_nel_results(roberta_test_prediction,
roberta_test_spans)
test_actual = transform_nel_results(roberta_test_actual,
self.roberta_nel_test_spans)
test_actual, test_prediction = resolve_diff(test_actual,
test_prediction)
print("Dev NEL Combined Results\n===========")
print("F1:", f1_score(dev_actual, dev_prediction))
print("Test NEL Combined Results\n===========")
print("F1:", f1_score(test_actual, test_prediction))
dev_output = list(
zip([x[0] for x in roberta_dev_phrases], roberta_dev_prediction))
self.roberta_nel_dev_links = get_links(dev_output)
test_output = list(
zip([x[0] for x in roberta_test_phrases], roberta_test_prediction))
self.roberta_nel_test_links = get_links(test_output)
'classification_report': True
}
model = NERModel("electra",
"discriminator_trained/discriminator_model",
args=train_args,
labels=labels,
use_cuda=True,
crf=True)
# Train the model
model.train_model(train_file, eval_data=eval_file)
# Evaluate the model
test_file = 'data_set/test.ner.small.txt'
result, model_outputs, predictions = model.eval_model(train_file)
print(result)
# from transformers import ElectraTokenizer, ElectraForPreTraining
# model_name = r'D:\git_learn\simpletransformers\examples\language_model\discriminator_trained\discriminator_model'
# model = ElectraForPreTraining.from_pretrained(model_name)
# tokenizer = ElectraTokenizer.from_pretrained(model_name)
# sentence = '发烧头[MASK]3天'
# sentence = '患者自发病来，神志清楚，精神好'
# input_ids = torch.tensor(tokenizer.encode(sentence, add_special_tokens=True)).unsqueeze(0)
# output = model(input_ids, return_dict=True)
# # print(list(zip(list(output.logits.detach().numpy()), tokenizer.tokenize(sentence))))
# logits = list(output.logits.detach().numpy())
# print(len(logits))
# print(logits)
[0, "text", "O"],
[0, "classification", "B-MISC"],
[1, "Simple", "B-MISC"],
[1, "Transformers", "I-MISC"],
[1, "then", "O"],
[1, "expanded", "O"],
[1, "to", "O"],
[1, "perform", "O"],
[1, "NER", "B-MISC"],
]
eval_df = pd.DataFrame(eval_data, columns=["sentence_id", "words", "labels"])
# Create a NERModel
model = NERModel("bert",
"bert-base-cased",
args={
"overwrite_output_dir": True,
"reprocess_input_data": True
})
# Train the model
model.train_model(train_df)
# Evaluate the model
result, model_outputs, predictions = model.eval_model(eval_df)
# Predictions on arbitary text strings
predictions, raw_outputs = model.predict(["Some arbitary sentence"])
print(predictions)
label
args=NERArgs()
args.num_train_epochs=1
args.learning_rate=1e-4
args.overwrite_output_dir=True
args.train_batch_size=32
args.eval_batch_size=32
model=NERModel('bert', 'bert-base-cased', labels=label, args=args)
model.train_model(train_data, eval_data=test_data, acc=accuracy_score)
result, model_outputs, preds_list=model.eval_model(test_data)
result
prediction, model_output=model.predict(["This is Nishi"])
prediction
!pip install bert-extractive-summarizer
!pip install wikipedia
import wikipedia
wiki = wikipedia.page('Amsterdam')
article=wiki.content
class NerModel:
def __init__(self, modelname="", dataset=None, use_saved_model=False):
self.dataset = dataset
#labels_list = ["O", "B-ACT", "I-ACT", "B-OBJ", "I-OBJ", "B-VAL", "I-VAL", "B-VAR", "I-VAR"]
#labels_list = dataset.get_labels_list()
labels_list = dataset['labels_list']
output_dir = "outputs_{}".format(modelname)
# Create a NERModel
model_args = {
'output_dir': output_dir,
'overwrite_output_dir': True,
'reprocess_input_data': True,
'save_eval_checkpoints': False,
'save_steps': -1,
'save_model_every_epoch': False,
'train_batch_size': 10, # 10
'num_train_epochs': 10, # 5
'max_seq_length': 256,
'gradient_accumulation_steps': 8,
'labels_list': labels_list
}
if use_saved_model:
self.model = NERModel("bert", output_dir, use_cuda=False, args=model_args)
else:
self.model = NERModel("bert", "bert-base-cased", use_cuda=False, args=model_args)
# args={"overwrite_output_dir": True, "reprocess_input_data": True}
def train(self):
# # Train the model
if self.dataset:
self.model.train_model(self.dataset['train'])
else:
raise Exception("dataset is None")
def eval(self):
# # Evaluate the model
if self.dataset:
result, model_outputs, predictions = self.model.eval_model(self.dataset['val'])
print("Evaluation result:", result)
else:
raise Exception("dataset is None")
def simple_test(self):
# Predictions on arbitary text strings
sentences = ["Some arbitary sentence", "Simple Transformers sentence"]
predictions, raw_outputs = self.model.predict(sentences)
print(predictions)
# More detailed preditctions
for n, (preds, outs) in enumerate(zip(predictions, raw_outputs)):
print("\n___________________________")
print("Sentence: ", sentences[n])
for pred, out in zip(preds, outs):
key = list(pred.keys())[0]
new_out = out[key]
preds = list(softmax(np.mean(new_out, axis=0)))
print(key, pred[key], preds[np.argmax(preds)], preds)
def predict(self, sentences):
predictions, raw_outputs = self.model.predict(sentences)
return predictions
# Download CoNLL-2003 dataset from the git repo down below.
# https://github.com/synalp/NER/tree/master/corpus/CoNLL-2003
from simpletransformers.ner import NERModel
# BERT UNCASED
model = NERModel('bert', 'bert-base-uncased', args={'overwrite_output_dir':True})
model.train_model('CoNLL-2003/eng.train')
results, model_outputs, predictions = model.eval_model('CoNLL-2003/eng.testb')
print(results)
# BERT CASED
model = NERModel('bert', 'bert-base-cased', args={'overwrite_output_dir':True})
model.train_model('CoNLL-2003/eng.train')
results, model_outputs, predictions = model.eval_model('CoNLL-2003/eng.testb')
print(results)
# ALBERT
model = NERModel('albert', 'albert-base-v2', args={'overwrite_output_dir':True})
model.train_model('CoNLL-2003/eng.train')
results, model_outputs, predictions = model.eval_model('CoNLL-2003/eng.testb')
print(results)
class NerModel:
def __init__(self,
modelname="",
dataset=None,
use_saved_model=False,
input_dir=None,
output_dir=None):
#pretrained_model_name = "lm_outputs_test/from_scratch/best_model"
self.tokenizer = BertTokenizer.from_pretrained('bert-base-uncased')
self.dataset = dataset
#labels_list = ["O", "B-ACT", "I-ACT", "B-OBJ", "I-OBJ", "B-VAL", "I-VAL", "B-VAR", "I-VAR"]
#labels_list = dataset.get_labels_list()
labels_list = dataset['labels_list']
#labels_list = ['O', 'B-ACT', 'I-ACT', 'B-OBJ', 'I-OBJ', 'B-CNT', 'I-CNT',
# 'B-OPE', 'I-OPE', 'B-ORD', 'B-PRE', 'I-PRE', 'B-TYP',
# 'B-VAL', 'I-VAL', 'B-ATT', 'I-ATT', 'B-VAR', 'I-VAR']
#output_dir = "outputs_{}".format(modelname)
os.system("{} -rf".format(output_dir))
use_cuda = torch.cuda.is_available()
# Create a NERModel
model_args = {
'labels_list': labels_list,
'output_dir': output_dir,
'overwrite_output_dir': True,
'reprocess_input_data': True,
'save_eval_checkpoints': False,
'save_steps': -1,
'save_model_every_epoch': False,
#'no_save' : True,
#'no_cache': True,
'evaluate_during_training': True,
'num_train_epochs': 15, # 5
'train_batch_size': 10, # 10 (<=10 for bert, <=5 for longformer)
'eval_batch_size': 10,
'max_seq_length': 128, # default 128
'gradient_accumulation_steps': 8,
'learning_rate':
0.0001, # default 4e-5; a good value is 0.0001 for albert
#'max_position_embeddings': 64,
}
#self.model = NERModel("bert", pretrained_model_name, use_cuda=False, args=model_args)
#self.model = NERModel("bert", "bert-base-uncased", use_cuda=False, args=model_args)
#self.model = NERModel("longformer", "allenai/longformer-base-4096", use_cuda=False, args=model_args)
#self.model = NERModel("longformer", pretrained_model_name, use_cuda=False, args=model_args)
#self.model = NERModel("xlmroberta", "xlm-roberta-base", use_cuda=False, args=model_args)
#self.model = NERModel("albert", "albert-base-v2", use_cuda=False, args=model_args)
#self.model = NERModel("electra", 'google/electra-small-generator', use_cuda=False, args=model_args)
#self.model = NERModel("layoutlm", 'microsoft/layoutlm-base-uncased', use_cuda=False, args=model_args)
#self.model = NERModel("distilbert", "distilbert-base-cased-distilled-squad", use_cuda=False, args=model_args)
#model_type, english_model_name = "longformer", "allenai/longformer-base-4096"
#model_type, english_model_name = "mpnet", "microsoft/mpnet-base"
#model_type, english_model_name = "electra", "google/electra-small-discriminator"
#model_type, english_model_name = "squeezebert", "squeezebert/squeezebert-uncased"
#model_type, english_model_name = "albert", "albert-base-v2"
#model_type, english_model_name = "xlmroberta", "xlm-roberta-base"
model_type, english_model_name = "roberta", "distilroberta-base"
#model_type, english_model_name = "bert", "bert-base-uncased"
#model_type, english_model_name = "distilbert", "distilbert-base-uncased"
if input_dir:
# Use a previously trained model (on NER or LM tasks)
self.model = NERModel(model_type,
input_dir,
use_cuda=use_cuda,
args=model_args)
else:
# Use a pre-trained (English) model
self.model = NERModel(model_type,
english_model_name,
use_cuda=use_cuda,
args=model_args) # force_download=True
"""
if use_saved_model:
if path:
# Use a model located in a given folder
self.model = NERModel("longformer", path, use_cuda=False, args=model_args)
else:
# Use a previously trained model (on NER or LM tasks)
self.model = NERModel("longformer", output_dir, use_cuda=False, args=model_args)
else:
# Use a pre-trained (English) model
self.model = NERModel("longformer", "allenai/longformer-base-4096", use_cuda=False, args=model_args)
"""
"""
if use_saved_model:
self.model = NERModel("bert", output_dir, use_cuda=False, args=model_args)
else:
self.model = NERModel("bert", pretrained_model_name, use_cuda=False, args=model_args)
# args={"overwrite_output_dir": True, "reprocess_input_data": True}
"""
self.model_info = {
'model_type': model_type,
'english_model_name': english_model_name,
'input_dir': input_dir
}
def train(self):
# # Train the model
if self.dataset:
global_step, training_details = self.model.train_model(
self.dataset['train'], eval_data=self.dataset['val'])
else:
raise Exception("dataset is None")
print("global_step:", global_step)
print("training_details:", training_details)
#training_details: {'global_step': [4], 'precision': [0.6987951807228916], 'recall': [0.402777777777777
#8], 'f1_score': [0.5110132158590308], 'train_loss': [0.41127926111221313], 'eval_loss': [0.63655577600
#00229]}
# it contains f1_score only for the validation dataset
return training_details
def eval(self):
# # Evaluate the model
if self.dataset:
res_train, model_outputs, predictions = self.model.eval_model(
self.dataset['train'])
res_val, model_outputs, predictions = self.model.eval_model(
self.dataset['val'])
print("Evaluation")
#print("On train data:", result)
#{'eval_loss': 0.8920, 'precision': 0.0833, 'recall': 0.027, 'f1_score': 0.0416}
print("train loss: {:.3f}; prec/recall/f1: {:.3f}/{:.3f}/{:.3f}".
format(res_train['eval_loss'], res_train['precision'],
res_train['recall'], res_train['f1_score']))
#print("On validation data:", result)
print("valid loss: {:.3f}; prec/recall/f1: {:.3f}/{:.3f}/{:.3f}".
format(res_val['eval_loss'], res_val['precision'],
res_val['recall'], res_val['f1_score']))
print(
"Summary. Loss (train/val): {:.3f}/{:.3f}, F1: {:.3f}/{:.3f}".
format(res_train['eval_loss'], res_val['eval_loss'],
res_train['f1_score'], res_val['f1_score']))
else:
raise Exception("dataset is None")
print("model_info:", self.model_info)
return res_val
def test(self):
sentence_id = self.dataset['test']['sentence_id']
words = self.dataset['test']['words']
labels = self.dataset['test']['labels']
prev_id = 0
s_words = []
s_labels = []
samples = []
for i in range(len(sentence_id)):
s_id = sentence_id[i]
word = words[i]
label = labels[i]
if s_id != prev_id:
sentence = " ".join(s_words)
#print("sentence id={}: {}".format(prev_id, sentence))
samples.append({
'text': sentence,
'tokens': s_words,
'labels': s_labels
})
#print("s_labels: {}".format(s_labels))
s_words = []
s_labels = []
prev_id = s_id
s_words.append(words[i])
s_labels.append(labels[i])
#print("i={}, word={}, label={}".format(s_id, word, label))
sentence = " ".join(s_words)
#print("sentence id={}: {}".format(prev_id, sentence))
samples.append({
'text': sentence,
'tokens': s_words,
'labels': s_labels
})
texts = [sample['text'] for sample in samples]
predictions, raw_outputs = self.model.predict(texts)
#print(predictions)
acc_list = []
success_list = []
# More detailed preditctions
for i, (preds, raw_outs) in enumerate(zip(predictions, raw_outputs)):
print()
print("text: ", texts[i])
#print("\npreds: ", preds)
pred_labels = [list(t.values())[0] for t in preds]
print("pred_labels: ", pred_labels)
true_labels = samples[i]['labels']
print("true_labels: ", true_labels)
#print("raw_outs: ", raw_outs)
if len(true_labels) != len(pred_labels):
raise Exception("len(true_labels) != len(pred_labels)")
comp = [
true_labels[i] == pred_labels[i]
for i in range(len(pred_labels))
]
acc1sentence = np.mean(comp)
print("acc={:.3f}".format(acc1sentence))
acc_list.append(acc1sentence)
success = 1 if acc1sentence == 1.0 else 0
success_list.append(success)
avg_acc = np.mean(acc_list)
avg_success = np.mean(success_list)
return {'avg_acc': avg_acc, 'avg_success': avg_success}
#for pred, out in zip(preds, outs):
#print("pred:", pred)
#print("out:", out)
#key = list(pred.keys())[0]
#new_out = out[key]
#preds = list(softmax(np.mean(new_out, axis=0)))
#print(key, pred[key], preds[np.argmax(preds)], preds)
def simple_test(self):
# Predictions on arbitary text strings
sentences = ["Some arbitary sentence", "Simple Transformers sentence"]
predictions, raw_outputs = self.model.predict(sentences)
print(predictions)
# More detailed preditctions
for n, (preds, outs) in enumerate(zip(predictions, raw_outputs)):
print("\n___________________________")
print("Sentence: ", sentences[n])
for pred, out in zip(preds, outs):
key = list(pred.keys())[0]
new_out = out[key]
preds = list(softmax(np.mean(new_out, axis=0)))
print(key, pred[key], preds[np.argmax(preds)], preds)
def predict(self, sentences):
predictions, raw_outputs = self.model.predict(sentences)
#tokenized_sentences = [self.tokenizer.tokenize(sentence) for sentence in sentences]
#predictions, raw_outputs = self.model.predict(tokenized_sentences, split_on_space=False)
return predictions
def raw_predict(self, sentences):
predictions, raw_outputs = self.model.predict(sentences)
#print("raw_outputs:", raw_outputs)
#print(self.model.args.labels_list)
labels_list = self.model.args.labels_list
confidences = [
calc_confidence(raw_output, labels_list)
for raw_output in raw_outputs
]
#print("confidence:", confidence)
return {
'predictions': predictions,
'raw_outputs': raw_outputs,
'confidences': confidences
}
"""
"wandb_project": None,
"wandb_kwargs": {},
"use_early_stopping": True,
"early_stopping_patience": 3,
"early_stopping_delta": 0,
"early_stopping_metric": "eval_loss",
"early_stopping_metric_minimize": True,
"manual_seed": None,
"encoding": None,
"config": {},
}
with open('tag-set.txt', 'r') as f:
ents_dict = set(ast.literal_eval(f.read()))
print(ents_dict)
# Create a NERModel
model = NERModel('bert',
'bert-base-cased',
args=args,
use_cuda=False,
labels=ents_dict)
model.train_model('sample_data/train.txt',
eval_data='sample_data/test.txt')
results, model_outputs, predictions = model.eval_model(
'sample_data/test.txt')
print(results)