def prepro(ds,
fold,
num_tokens_per_group,
num_paragraphs,
pad=True,
n_samples=None):
fold_funcs = {
'train': lambda: ds.get_train(),
'dev': lambda: ds.get_dev(),
'test': lambda: ds.get_test()
}
qs = fold_funcs[fold]()
if n_samples is not None:
qs = qs[:n_samples]
evidence = ds.evidence
prep = None
extract = ExtractMultiParagraphsPerQuestion(
MergeParagraphs(num_tokens_per_group),
ShallowOpenWebRanker(num_paragraphs),
prep,
intern=True)
answers = {}
batches = {}
for q in tqdm(qs, ncols=80, desc='preprocessing'):
pre = extract.preprocess([q], evidence)
if len(pre.data) == 0:
continue
assert len(pre.data) < 2
assert q.question_id not in answers
assert q.question_id not in batches
mpq = pre.data[0]
pq_batch = [
ParagraphAndQuestion(p.get_context(), q.question, None,
q.question_id, p.doc_id)
for p in mpq.paragraphs
# document paragraph question?
]
if pad:
for i in range(num_paragraphs - len(pq_batch)):
pq_batch.append(
ParagraphAndQuestion([], q.question, None, q.question_id,
None))
answers[q.question_id] = mpq.answer_text
batches[q.question_id] = pq_batch
voc = {w for bs in batches.values() for b in bs for w in b.question}
voc.update({w for bs in batches.values() for b in bs for w in b.context})
return answers, batches, voc
def _get_span_scores(self, question: List[str],
paragraphs: List[ParagraphWithInverse]):
"""
Answer a question using the given paragraphs, returns both the span scores and the
pre-processed paragraphs the span are valid for
"""
if self.model.preprocessor is not None:
prepped = []
for para in paragraphs:
if hasattr(para, "spans"):
spans = para.spans
else:
spans = None
text, _, inv = self.model.preprocessor.encode_paragraph(
[], para.text, para.start == 0,
np.zeros((0, 2), dtype=np.int32), spans)
prepped.append(
WebParagraph([text], para.original_text, inv,
para.paragraph_num, para.start, para.end,
para.source_name, para.source_url))
paragraphs = prepped
qa_pairs = [
ParagraphAndQuestion(c.get_context(), question, None, "")
for c in paragraphs
]
encoded = self.model.encode(qa_pairs, False)
return self.sess.run(self.span_scores, encoded), paragraphs
def get_document_embedding(self, text):
document_tokens, _ = self.tokenize(text)
test_question = ParagraphAndQuestion(document_tokens,
['dummy', 'question'], None,
"cape_question", 'cape_document')
feed = self.model.encode([test_question], False, cached_doc=None)
return self.sess.run(self.model.context_rep, feed_dict=feed)[0]
def read_input_data(model):
data = []
vocab = set()
tokenizer = NltkAndPunctTokenizer()
splitter = Truncate(400) # NOTE: we truncate past 400 tokens
selector = TopTfIdf(NltkPlusStopWords(True), n_to_select=5)
with open(OPTS.input_file) as f:
for i, line in enumerate(f):
try:
document_raw, question_raw = line.strip().split('\t')
except ValueError as e:
print(line.strip())
print('Error at line %d' % i)
raise e
document = re.split("\s*\n\s*", document_raw)
question = tokenizer.tokenize_paragraph_flat(question_raw)
doc_toks = [tokenizer.tokenize_paragraph(p) for p in document]
split_doc = splitter.split(doc_toks)
context = selector.prune(question, split_doc)
if model.preprocessor is not None:
context = [model.preprocessor.encode_text(question, x) for x in context]
else:
context = [flatten_iterable(x.text) for x in context]
vocab.update(question)
for txt in context:
vocab.update(txt)
ex = [ParagraphAndQuestion(x, question, None, "user-question%d"%i)
for i, x in enumerate(context)]
data.append((document_raw, question_raw, context, ex))
return data, vocab
def build_dataset(self, data: FilteredData, corpus) -> Dataset:
flattened = []
for point in data.data:
for para in point.paragraphs:
flattened.append(ParagraphAndQuestion(para.text, point.question,
TokenSpans(point.answer_text, para.answer_spans),
point.question_id))
return ParagraphAndQuestionDataset(flattened, self.batcher)
def build_qa_pair(self, question, question_id, answer_text, group=None) -> ContextAndQuestion:
if answer_text is None:
ans = None
elif group is None:
ans = TokenSpans(answer_text, self.answer_spans)
else:
ans = TokenSpanGroup(answer_text, self.answer_spans, group)
return ParagraphAndQuestion(self.text, question, ans, question_id)
def _get_span_scores(self, question: List[str],
paragraphs: List[WebParagraph]):
paragraphs = self._preprocess(paragraphs)
qa_pairs = [
ParagraphAndQuestion(c.get_context(), question, None, "")
for c in paragraphs
]
encoded = self.model.encode(qa_pairs, False)
return self.sess.run(self.span_scores, encoded), paragraphs
def get_logits(self, question, document_embedding):
question_tokens, _ = self.tokenize(question)
n_words = document_embedding.shape[0]
dummy_document = ['dummy'] * n_words
test_question = ParagraphAndQuestion(dummy_document, question_tokens,
None, "cape_question",
'cape_document')
feed = self.model.encode(
[test_question],
False,
cached_doc=document_embedding[np.newaxis, :, :])
start_logits, end_logits = self.sess.run(
[self.start_logits, self.end_logits], feed_dict=feed)
return start_logits[0][:n_words], end_logits[0][:n_words]
def get_answers_faster(sess,
model,
pred,
batches,
answers,
topk,
batch_size,
verbose=False):
mr_answers = {}
batch_acc = []
location_acc = []
logits_dict = {}
def _run_batch(batch_acc, location_acc):
feed = model.encode(batch_acc, False)
yp, yp2 = sess.run([pred.start_logits, pred.end_logits],
feed_dict=feed)
qqids, js = zip(*location_acc)
for (qqid, j, stl, enl) in zip(qqids, js, yp[:len(location_acc)],
yp2[:len(location_acc)]):
logits_dict[(qqid, j)] = (stl, enl)
for qid, batch in tqdm(batches.items()):
for i, b in enumerate(batch):
batch_acc.append(b)
location_acc.append((qid, i))
if len(batch_acc) == batch_size:
_run_batch(batch_acc, location_acc)
batch_acc, location_acc = [], []
if len(batch_acc) != 0:
bs = len(batch_acc)
for _ in range(batch_size - bs):
batch_acc.append(ParagraphAndQuestion([], [], None, None, None))
_run_batch(batch_acc, location_acc)
qids = batches.keys() if verbose else tqdm(
batches.keys(), ncols=80, desc='Extracting answers')
for qid in qids:
batch = batches[qid]
yp = [logits_dict[qid, j][0] for j in range(len(batch))]
yp2 = [logits_dict[qid, j][1] for j in range(len(batch))]
mr_answers[qid] = _decode_answers(qid, batch, yp, yp2, answers, topk,
verbose)
return mr_answers
def find_answer(documents, raw_question):
raw_question = raw_question.lower()
documents = [d.lower() for d in documents]
global best_spans, conf
documents = [re.split("\s*\n\s*", doc) for doc in documents]
tokenizer = NltkAndPunctTokenizer()
question = tokenizer.tokenize_paragraph_flat(raw_question)
documents = [[tokenizer.tokenize_paragraph(p) for p in doc]
for doc in documents]
splitter = MergeParagraphs(400)
documents = [splitter.split(doc) for doc in documents]
if len(documents) == 1:
selector = TopTfIdf(NltkPlusStopWords(True), n_to_select=5)
context = selector.prune(question, documents[0])
else:
selector = ShallowOpenWebRanker(n_to_select=10)
context = selector.prune(question, flatten_iterable(documents))
context = [flatten_iterable(x.text) for x in context]
data = [
ParagraphAndQuestion(x, question, None, "user-question%d" % i)
for i, x in enumerate(context)
]
encoded = model.encode(data, is_train=False)
with sess.as_default():
spans, confid = sess.run([best_spans, conf], feed_dict=encoded)
best_para = np.argmax(confid)
ans = " ".join(context[best_para][spans[best_para][0]:spans[best_para][1] +
1])
confidence = confid[best_para]
return ans, confidence
def read_input_data(model):
data = []
vocab = set()
tokenizer = NltkAndPunctTokenizer()
with open(OPTS.input_file) as f:
json_data = json.load(f)
for doc in json_data['data']:
for paragraph in doc['paragraphs']:
context = tokenizer.tokenize_with_inverse(paragraph['context'])
if model.preprocessor is not None:
context = model.preprocessor.encode_text(question, context)
context = context.get_context()
vocab.update(context)
for qa in paragraph['qas']:
question = tokenizer.tokenize_sentence(qa['question'])
vocab.update(question)
ex = [ParagraphAndQuestion(context, question, None, qa['id'])]
data.append((paragraph['context'], context, ex))
return data, sorted(list(vocab))
async def answer_question_spans(
self, question: str
) -> Tuple[np.ndarray, np.ndarray, List[WebParagraph]]:
"""
Answer a question using web search, return the top spans and confidence scores for each paragraph
"""
paragraphs = await self.get_question_context(question)
question = self.tokenizer.tokenize_paragraph_flat(question)
paragraphs = self._preprocess(paragraphs)
t0 = time.perf_counter()
qa_pairs = [
ParagraphAndQuestion(c.get_context(), question, None, "")
for c in paragraphs
]
encoded = self.model.encode(qa_pairs, False)
spans, scores = self.sess.run([self.span, self.score], encoded)
self.log.info("Computing answer spans took %.5f seconds" %
(time.perf_counter() - t0))
return spans, scores, paragraphs
def _build_expanded_batches(self, questions):
out = []
for i, q in enumerate(questions):
order = self._order[i]
out.append(ParagraphSelection(q, order[self._on[i]]))
self._on[i] += 1
if self._on[i] == len(order):
self._on[i] = 0
np.random.shuffle(order)
out.sort(key=lambda x: x.n_context_words)
group = 0
for selection_batch in self.batcher.get_epoch(out):
batch = []
for selected in selection_batch:
q = selected.question
if self.merge:
paras = [q.paragraphs[i] for i in selected.selection]
# Sort paragraph my reading order, not rank order
paras.sort(key=lambda x: x.get_order())
answer_spans = []
text = []
for para in paras:
answer_spans.append(len(text) + para.answer_spans)
text += para.text
batch.append(
ParagraphAndQuestion(
text, q.question,
TokenSpans(q.answer_text,
np.concatenate(answer_spans)),
q.question_id))
else:
for i in selected.selection:
para = q.paragraphs[i]
batch.append(
para.build_qa_pair(q.question, q.question_id,
q.answer_text, group))
group += 1
yield batch
def post_query():
document_raw = bottle.request.forms.getunicode('document').strip()
question_raw = bottle.request.forms.getunicode('question').strip()
document = re.split("\s*\n\s*", document_raw)
question = tokenizer.tokenize_paragraph_flat(question_raw)
doc_toks = [tokenizer.tokenize_paragraph(p) for p in document]
split_doc = splitter.split(doc_toks)
context = selector.prune(question, split_doc)
if model.preprocessor is not None:
context = [
model.preprocessor.encode_text(question, x) for x in context
]
else:
context = [flatten_iterable(x.text) for x in context]
vocab = set(question)
for txt in context:
vocab.update(txt)
data = [
ParagraphAndQuestion(x, question, None, "user-question%d" % i)
for i, x in enumerate(context)
]
model.word_embed.update(loader, vocab)
encoded = model.encode(data, is_train=False)
start_logits, end_logits, none_logit = sess.run(
[start_logits_tf, end_logits_tf, none_logit_tf], feed_dict=encoded)
beam, p_na = logits_to_probs(document_raw,
context[0],
start_logits,
end_logits,
none_logit,
beam_size=BEAM_SIZE)
return bottle.template('results',
document=document_raw,
question=question_raw,
beam=beam,
p_na=p_na)
def getAnswer(self):
#parser = argparse.ArgumentParser(description="Run an ELMo model on user input")
#parser.add_argument("model", help="Model directory")
#parser.add_argument("question", help="Question to answer")
#parser.add_argument("documents", help="List of text documents to answer the question with", nargs='+')
#args = parser.parse_args()
#print("Preprocessing...")
# Load the model
model_dir = ModelDir(MODEL_DIR)
model = model_dir.get_model()
if not isinstance(model, ParagraphQuestionModel):
raise ValueError(
"This script is built to work for ParagraphQuestionModel models only"
)
conn = pyodbc.connect(DB_CONN)
cursor = conn.cursor()
#(23211,28690,33214,25638,25837,26454,28693,26137,31428,32087)
query="select cast(filetext as varchar(max)) as filetext, name, type from dbo.UserworkspaceData where objectmasterid= "+\
str(self.ObjectMasterId)+\
" order by id asc"
#query="select cast(filetext as varchar(max)) as filetext from kpl_tmp"
documents = []
document = ""
name = ""
filetype = 0
for doc in cursor.execute(query):
document = document + doc[0]
name = doc[1]
filetype = doc[2]
#open("E:/kpl.txt","w+").write(document)
documents.append(document)
#documents.replace("\n\n","\n")
#r.sub("",documents)
#documents=" ".join(documents.split())
#open("E:\kpl_test.txt","w+").write(document)
#doc="D:\Document QnA\document-qa-master\Data\Drug_Delivery_Surveying_Global_Competitive_Landscape_BMI.txt"
# =============================================================================
# if not isfile(doc):
# raise ValueError(doc + " does not exist")
# with open(doc, "r") as f:
# documents.append(f.read())
# =============================================================================
#print("Loaded %d documents" % len(documents))
#temp=documents[0].split()
# Split documents into lists of paragraphs
#documents=[" ".join(temp[i:(i+400)]) for i in range(1,len(temp),400)]
documents = [re.split("\s*\n\s*", doc) for doc in documents]
# Tokenize the input, the models expects data to be tokenized using `NltkAndPunctTokenizer`
# Note the model expects case-sensitive input
tokenizer = NltkAndPunctTokenizer()
question = tokenizer.tokenize_paragraph_flat(
self.Question) # List of words
# Now list of document->paragraph->sentence->word
documents = [[tokenizer.tokenize_paragraph(p) for p in doc]
for doc in documents]
# Now group the document into paragraphs, this returns `ExtractedParagraph` objects
# that additionally remember the start/end token of the paragraph within the source document
splitter = MergeParagraphs(400)
#splitter = PreserveParagraphs() # Uncomment to use the natural paragraph grouping
documents = [splitter.split(doc) for doc in documents]
#print(str(len(documents))+" kpl") #kpl
# Now select the top paragraphs using a `ParagraphFilter`
if len(documents) == 1:
# Use TF-IDF to select top paragraphs from the document
selector = TopTfIdf(NltkPlusStopWords(True), n_to_select=5)
context = selector.prune(question, documents[0])
else:
# Use a linear classifier to select top paragraphs among all the documents
selector = ShallowOpenWebRanker(n_to_select=10)
context = selector.prune(question, flatten_iterable(documents))
#print("Select %d paragraph" % len(context))
if model.preprocessor is not None:
# Models are allowed to define an additional pre-processing step
# This will turn the `ExtractedParagraph` objects back into simple lists of tokens
context = [
model.preprocessor.encode_text(question, x) for x in context
]
else:
# Otherwise just use flattened text
context = [flatten_iterable(x.text) for x in context]
#x=open("E:\context.txt","a+")
#[x.write(" ".join(cont)) for cont in context]
#x.write("\n.......................................................\n")
#print("Setting up model")
# Tell the model the batch size (can be None) and vocab to expect, This will load the
# needed word vectors and fix the batch size to use when building the graph / encoding the input
voc = set(question)
for txt in context:
voc.update(txt)
model.set_input_spec(self.nlp,
ParagraphAndQuestionSpec(batch_size=len(context)),
voc)
# Now we build the actual tensorflow graph, `best_span` and `conf` are
# tensors holding the predicted span (inclusive) and confidence scores for each
# element in the input batch, confidence scores being the pre-softmax logit for the span
#print("Build tf graph") #kpl
sess = tf.Session(config=tf.ConfigProto(allow_soft_placement=True))
# We need to use sess.as_default when working with the cuNND stuff, since we need an active
# session to figure out the # of parameters needed for each layer. The cpu-compatible models don't need this.
with sess.as_default():
# 8 means to limit the span to size 8 or less
best_spans, conf = model.get_prediction().get_best_span(8)
# Loads the saved weights
model_dir.restore_checkpoint(sess)
# Now the model is ready to run
# The model takes input in the form of `ContextAndQuestion` objects, for example:
data = [
ParagraphAndQuestion(x, question, None, "user-question%d" % i)
for i, x in enumerate(context)
]
#print("Starting run")
# The model is run in two steps, first it "encodes" a batch of paragraph/context pairs
# into numpy arrays, then we use `sess` to run the actual model get the predictions
encoded = model.encode(
data, is_train=True) # batch of `ContextAndQuestion` -> feed_dict
best_spans, conf = sess.run(
[best_spans, conf], feed_dict=encoded) # feed_dict -> predictions
best_para = np.argmax(
conf
) # We get output for each paragraph, select the most-confident one to print
#print("Best Paragraph: " + str(best_para))
#print("Best span: " + str(best_spans[best_para]))
#print("Answer text: " + " ".join(context[best_para][best_spans[best_para][0]:best_spans[best_para][1]+1]))
#print("Confidence: " + str(conf[best_para]))
Answer = " ".join(context[best_para]
[best_spans[best_para][0]:best_spans[best_para][1] +
1])
print("Confidence: " + str(conf[best_para]))
print("Best Paragraph: " + str(best_para))
print("Best span: " + str(best_spans[best_para]))
print("Answer text: " + Answer)
print(" ".join(context[best_para]))
context[best_para][best_spans[best_para][
0]] = r"<em>" + context[best_para][best_spans[best_para][0]]
context[best_para][best_spans[best_para][1]] = context[best_para][
best_spans[best_para][1]] + r"</em>"
start = 0
end = len(context[best_para])
positions = [
x for x, n in enumerate(context[best_para]
[0:best_spans[best_para][0]]) if n == "."
]
if len(positions) >= 2: start = positions[len(positions) - 2] + 1
positions = [
x
for x, n in enumerate(context[best_para][best_spans[best_para][1] +
1:]) if n == "."
]
if len(positions) > 1:
end = best_spans[best_para][1] + 1 + positions[1]
d = dict()
if conf[best_para] > 10:
d["answer"] = Answer
else:
d["answer"] = ""
d["name"] = name
d["filetype"] = filetype
d["paragraph"] = re.sub(r' (?=\W)', '',
" ".join(context[best_para][start:end]))
d["ObjectMasterId"] = self.ObjectMasterId
return d
#if __name__ == "__main__":
# main()
def main():
parser = argparse.ArgumentParser(
description="Run an ELMo model on user input")
parser.add_argument("model", help="Model directory")
parser.add_argument("question", help="Question to answer")
parser.add_argument("context", help="Context to answer the question with")
args = parser.parse_args()
# Tokenize the input, the models expected data to be tokenized using `NltkAndPunctTokenizer`
# Note the model expects case-sensitive input
tokenizer = NltkAndPunctTokenizer()
question = tokenizer.tokenize_paragraph_flat(args.question)
context = tokenizer.tokenize_paragraph_flat(args.context)
print("Loading model")
model_dir = ModelDir(args.model)
model = model_dir.get_model()
if not isinstance(model, ElmoQaModel):
raise ValueError(
"This script is build to work for ElmoQaModel models only")
# Important! This tells the language model not to use the pre-computed word vectors,
# which are only applicable for the SQuAD dev/train sets.
# Instead the language model will use its character-level CNN to compute
# the word vectors dynamically.
model.lm_model.embed_weights_file = None
# Tell the model the batch size and vocab to expect, This will load the needed
# word vectors and fix the batch size when building the graph / encoding the input
print("Setting up model")
voc = set(question)
voc.update(context)
model.set_input_spec(ParagraphAndQuestionSpec(batch_size=1), voc)
# Now we build the actual tensorflow graph, `best_span` and `conf` are
# tensors holding the predicted span (inclusive) and confidence scores for each
# element in the input batch
print("Build tf graph")
sess = tf.Session(config=tf.ConfigProto(allow_soft_placement=True))
with sess.as_default():
# 17 means to limit the span to size 17 or less
best_spans, conf = model.get_prediction().get_best_span(17)
# Now restore the weights, this is a bit fiddly since we need to avoid restoring the
# bilm weights, and instead load them from the pre-computed data
all_vars = tf.global_variables() + tf.get_collection(
tf.GraphKeys.SAVEABLE_OBJECTS)
lm_var_names = {x.name for x in all_vars if x.name.startswith("bilm")}
vars = [x for x in all_vars if x.name not in lm_var_names]
model_dir.restore_checkpoint(sess, vars)
# Run the initializer of the lm weights, which will load them from the lm directory
sess.run(
tf.variables_initializer(
[x for x in all_vars if x.name in lm_var_names]))
# Now the model is ready to run
# The model takes input in the form of `ContextAndQuestion` objects, for example:
data = [ParagraphAndQuestion(context, question, None, "user-question1")]
print("Starting run")
# The model is run in two steps, first it "encodes" the paragraph/context pairs
# into numpy arrays, then to use `sess` to run the actual model get the predictions
encoded = model.encode(
data, is_train=False) # batch of `ContextAndQuestion` -> feed_dict
best_spans, conf = sess.run([best_spans, conf],
feed_dict=encoded) # feed_dict -> predictions
print("Best span: " + str(best_spans[0]))
print("Answer text: " +
" ".join(context[best_spans[0][0]:best_spans[0][1] + 1]))
print("Confidence: " + str(conf[0]))
def get_test_questions():
paragraph = ["Harry", "Potter", "was", "written", "by", "JK"]
question = ["Who", "wrote", "Harry", "Potter", "?"]
return ParagraphAndQuestion(paragraph, question, None, "test_questions")
def main(Data: pd.DataFrame, nlp, model_dir, model):
#parser = argparse.ArgumentParser(description="Run an ELMo model on user input")
#parser.add_argument("model", help="Model directory")
#parser.add_argument("question", help="Question to answer")
#parser.add_argument("documents", help="List of text documents to answer the question with", nargs='+')
#args = parser.parse_args()
#print("Preprocessing...")
# Load the model
#model_dir = ModelDir(MODEL_DIR)
#model = model_dir.get_model()
print(model)
if not isinstance(model, ParagraphQuestionModel):
raise ValueError(
"This script is built to work for ParagraphQuestionModel models only"
)
#print(model)
# Read the documents
documents = []
documents.append(Data.at[0, 'Filetext'])
"""import pyodbc
conn = pyodbc.connect("Driver={ODBC Driver 13 for SQL Server};"
"Server=192.168.100.15;"
"Database=PharmaAce;"
"UID=sa;"
"PWD=admin@123;"
"Trusted_Connection=no;")
cursor=conn.cursor()
#(23211,28690,33214,25638,25837,26454,28693,26137,31428,32087)
for doc in cursor.execute("select cast(filetext as varchar(max)) as filetext from kpl_tmp"):
documents.append(doc[0])
#doc="D:\Document QnA\document-qa-master\Data\Drug_Delivery_Surveying_Global_Competitive_Landscape_BMI.txt"
if not isfile(doc):
raise ValueError(doc + " does not exist")
with open(doc, "r") as f:
documents.append(f.read())
"""
#print("Loaded %d documents" % len(documents))
#temp=documents[0].split()
# Split documents into lists of paragraphs
#documents=[" ".join(temp[i:(i+400)]) for i in range(1,len(temp),400)]
documents = [re.split("\s*\n\s*", doc) for doc in documents]
# Tokenize the input, the models expects data to be tokenized using `NltkAndPunctTokenizer`
# Note the model expects case-sensitive input
tokenizer = NltkAndPunctTokenizer()
question = tokenizer.tokenize_paragraph_flat(
Data.at[0, 'Question']) # List of words
# Now list of document->paragraph->sentence->word
documents = [[tokenizer.tokenize_paragraph(p) for p in doc]
for doc in documents]
# Now group the document into paragraphs, this returns `ExtractedParagraph` objects
# that additionally remember the start/end token of the paragraph within the source document
splitter = MergeParagraphs(400)
#splitter = PreserveParagraphs() # Uncomment to use the natural paragraph grouping
documents = [splitter.split(doc) for doc in documents]
#print(str(len(documents))+" kpl") #kpl
# Now select the top paragraphs using a `ParagraphFilter`
print(len(documents)) #kpl
if len(documents) == 1:
# Use TF-IDF to select top paragraphs from the document
selector = TopTfIdf(NltkPlusStopWords(True), n_to_select=5)
context = selector.prune(question, documents[0])
else:
# Use a linear classifier to select top paragraphs among all the documents
selector = ShallowOpenWebRanker(n_to_select=10)
context = selector.prune(question, flatten_iterable(documents))
#print("Select %d paragraph" % len(context))
if model.preprocessor is not None:
# Models are allowed to define an additional pre-processing step
# This will turn the `ExtractedParagraph` objects back into simple lists of tokens
context = [
model.preprocessor.encode_text(question, x) for x in context
]
else:
# Otherwise just use flattened text
context = [flatten_iterable(x.text) for x in context]
print("Setting up model")
# Tell the model the batch size (can be None) and vocab to expect, This will load the
# needed word vectors and fix the batch size to use when building the graph / encoding the input
voc = set(question)
for txt in context:
voc.update(txt)
model.set_input_spec(nlp,
ParagraphAndQuestionSpec(batch_size=len(context)),
voc)
# Now we build the actual tensorflow graph, `best_span` and `conf` are
# tensors holding the predicted span (inclusive) and confidence scores for each
# element in the input batch, confidence scores being the pre-softmax logit for the span
#print("Build tf graph") #kpl
print("after set input spec")
sess = tf.Session(config=tf.ConfigProto(allow_soft_placement=True))
# We need to use sess.as_default when working with the cuNND stuff, since we need an active
# session to figure out the # of parameters needed for each layer. The cpu-compatible models don't need this.
with sess.as_default():
# 8 means to limit the span to size 8 or less
best_spans, conf = model.get_prediction().get_best_span(8)
# Loads the saved weights
model_dir.restore_checkpoint(sess)
print("after loading weights")
# Now the model is ready to run
# The model takes input in the form of `ContextAndQuestion` objects, for example:
data = [
ParagraphAndQuestion(x, question, None, "user-question%d" % i)
for i, x in enumerate(context)
]
#print("Starting run")
# The model is run in two steps, first it "encodes" a batch of paragraph/context pairs
# into numpy arrays, then we use `sess` to run the actual model get the predictions
encoded = model.encode(
data, is_train=True) # batch of `ContextAndQuestion` -> feed_dict
best_spans, conf = sess.run([best_spans, conf],
feed_dict=encoded) # feed_dict -> predictions
best_para = np.argmax(
conf
) # We get output for each paragraph, select the most-confident one to print
#print("Best Paragraph: " + str(best_para))
#print("Best span: " + str(best_spans[best_para]))
#print("Answer text: " + " ".join(context[best_para][best_spans[best_para][0]:best_spans[best_para][1]+1]))
#print("Confidence: " + str(conf[best_para]))
return " ".join(
context[best_para][best_spans[best_para][0]:best_spans[best_para][1] +
1])
#if __name__ == "__main__":
# main()
def main():
parser = argparse.ArgumentParser(
description="Run an ELMo model on user input")
parser.add_argument("model", help="Model directory")
parser.add_argument("ja_filepath", help="File path to japanese questions")
parser.add_argument("result_file",
help="File path to predicted result json")
args = parser.parse_args()
print(args)
print("Preprocessing...")
paragraphs, questions = read_squad_style_database(args.ja_filepath)
# Load the model
model_dir = ModelDir(args.model)
model = model_dir.get_model()
if not isinstance(model, ParagraphQuestionModel):
raise ValueError(
"This script is built to work for ParagraphQuestionModel models only"
)
paragraphs, questions = read_squad_style_database(args.ja_filepath)
predictions = {}
predictions["conf"] = {}
for qa in questions:
print(qa["id"])
title = qa["title"]
para_idx = qa["para_idx"]
context = paragraphs[title][para_idx]
question = qa["question"]
print(context)
print(question)
if model.preprocessor is not None:
context = [
model.preprocessor.encode_text(question, x) for x in context
]
print("Setting up model")
voc = set(question)
for txt in context:
voc.update(txt)
model.set_input_spec(ParagraphAndQuestionSpec(batch_size=len(context)),
voc)
print("Build tf graph")
sess = tf.Session(config=tf.ConfigProto(allow_soft_placement=True))
with sess.as_default():
best_spans, conf = model.get_prediction().get_best_span(8)
# Loads the saved weights
model_dir.restore_checkpoint(sess)
data = [
ParagraphAndQuestion(x, question, None, "user-question%d" % i)
for i, x in enumerate(context)
]
print("Starting run")
encoded = model.encode(
data, is_train=False) # batch of `ContextAndQuestion` -> feed_dict
best_spans, conf = sess.run(
[best_spans, conf], feed_dict=encoded) # feed_dict -> predictions
print(best_spans)
predictions[qa["id"]] = best_spans
predictions["conf"][qa["id"]] = conf
print(predictions)
result_f = open(args.result_file, "w")
json.dump(predictions, result_f)
exit()
official_evaluator = OfficialEvaluator(args.ja_filepath, args.result_file)
evaluation = official_evaluator.evaluate()
print(evaluation)
def main():
parser = argparse.ArgumentParser(description="Run an ELMo model on user input")
# parser.add_argument("model", type=int, help="Model directory")
parser.add_argument("question", help="Question to answer")
parser.add_argument("documents", help="List of text documents to answer the question with", nargs='+')
args = parser.parse_args()
# Models path
SQUAD_MODEL_DIRECTORY_PATH = 'docqa/models-cpu/squad'
SQUAD_SHARED_NORM_MODEL_DIRECTORY_PATH = 'docqa/models-cpu/squad-shared-norm'
TRIVIAQA_MODEL_DIRECTORY_PATH = 'docqa/models-cpu/triviaqa-unfiltered-shared-norm'
TRIVIAQA_SHARED_NORM_MODEL_DIRECTORY_PATH = 'docqa/models-cpu/triviaqa-web-shared-norm'
models_directory = [
SQUAD_MODEL_DIRECTORY_PATH,
SQUAD_SHARED_NORM_MODEL_DIRECTORY_PATH,
TRIVIAQA_MODEL_DIRECTORY_PATH,
TRIVIAQA_SHARED_NORM_MODEL_DIRECTORY_PATH
]
print("Preprocessing...")
# Load the model
# model_dir = ModelDir(args.model)
model_dir = ModelDir(models_directory[0])
model = model_dir.get_model()
if not isinstance(model, ParagraphQuestionModel):
raise ValueError("This script is built to work for ParagraphQuestionModel models only")
# Read the documents
documents = []
for doc in args.documents:
if not isfile(doc):
raise ValueError(doc + " does not exist")
with open(doc, "r") as f:
documents.append(f.read())
print("Loaded %d documents" % len(documents))
# Split documents into lists of paragraphs
documents = [re.split("\s*\n\s*", doc) for doc in documents]
# Tokenize the input, the models expects data to be tokenized using `NltkAndPunctTokenizer`
# Note the model expects case-sensitive input
tokenizer = NltkAndPunctTokenizer()
question = tokenizer.tokenize_paragraph_flat(args.question) # List of words
# Now list of document->paragraph->sentence->word
documents = [[tokenizer.tokenize_paragraph(p) for p in doc] for doc in documents]
# Now group the document into paragraphs, this returns `ExtractedParagraph` objects
# that additionally remember the start/end token of the paragraph within the source document
splitter = MergeParagraphs(400)
# splitter = PreserveParagraphs() # Uncomment to use the natural paragraph grouping
documents = [splitter.split(doc) for doc in documents]
# Now select the top paragraphs using a `ParagraphFilter`
if len(documents) == 1:
# Use TF-IDF to select top paragraphs from the document
selector = TopTfIdf(NltkPlusStopWords(True), n_to_select=5)
context = selector.prune(question, documents[0])
else:
# Use a linear classifier to select top paragraphs among all the documents
selector = ShallowOpenWebRanker(n_to_select=10)
context = selector.prune(question, flatten_iterable(documents))
print("Select %d paragraph" % len(context))
if model.preprocessor is not None:
# Models are allowed to define an additional pre-processing step
# This will turn the `ExtractedParagraph` objects back into simple lists of tokens
context = [model.preprocessor.encode_text(question, x) for x in context]
else:
# Otherwise just use flattened text
context = [flatten_iterable(x.text) for x in context]
print("Setting up model")
# Tell the model the batch size (can be None) and vocab to expect, This will load the
# needed word vectors and fix the batch size to use when building the graph / encoding the input
voc = set(question)
for txt in context:
voc.update(txt)
model.set_input_spec(ParagraphAndQuestionSpec(batch_size=len(context)), voc)
# Now we build the actual tensorflow graph, `best_span` and `conf` are
# tensors holding the predicted span (inclusive) and confidence scores for each
# element in the input batch, confidence scores being the pre-softmax logit for the span
print("Build tf graph")
sess = tf.Session(config=tf.ConfigProto(allow_soft_placement=True))
# We need to use sess.as_default when working with the cuNND stuff, since we need an active
# session to figure out the # of parameters needed for each layer. The cpu-compatible models don't need this.
with sess.as_default():
# 8 means to limit the span to size 8 or less
best_spans, conf = model.get_prediction().get_best_span(10)
# Loads the saved weights
model_dir.restore_checkpoint(sess)
# Now the model is ready to run
# The model takes input in the form of `ContextAndQuestion` objects, for example:
data = [ParagraphAndQuestion(x, question, None, "user-question%d"%i)
for i, x in enumerate(context)]
print("Starting run")
# The model is run in two steps, first it "encodes" a batch of paragraph/context pairs
# into numpy arrays, then we use `sess` to run the actual model get the predictions
encoded = model.encode(data, is_train=False) # batch of `ContextAndQuestion` -> feed_dict
best_spans, conf = sess.run([best_spans, conf], feed_dict=encoded) # feed_dict -> predictions
best_para = np.argmax(conf) # We get output for each paragraph, select the most-confident one to print
print("Best Paragraph: " + str(best_para))
para_id = int(str(best_para))
# print("Best Paragraph: \n" + (" ".join((paras[para_id].text)[0])))
print("Best Paragraph: \n" + " ".join(context[para_id]))
print("Best span: " + str(best_spans[best_para]))
print("Answer text: " + " ".join(context[best_para][best_spans[best_para][0]:best_spans[best_para][1]+1]))
print("Confidence: " + str(conf[best_para]))
def predict():
json_data = {"success": False, "predictions": []}
print("Preprocessing...")
# Load the model
model_dir = ModelDir(
"/home/antriv/conversation_ai/Transfer_Learning/ALLENAI_DocumentQA/document-qa/pretrained_models/models/triviaqa-unfiltered-shared-norm"
)
model = model_dir.get_model()
if not isinstance(model, ParagraphQuestionModel):
raise ValueError(
"This script is built to work for ParagraphQuestionModel models only"
)
# Load the question
question = (flask.request.data).decode("utf-8")
# Read the documents
documents = []
doclist = ["/home/antriv/data/The-Future-Computed.txt"]
for doc in doclist:
if not isfile(doc):
raise ValueError(doc + " does not exist")
with open(doc, "r") as f:
documents.append(f.read())
print("Loaded %d documents" % len(documents))
# Split documents into lists of paragraphs
documents = [re.split("\s*\n\s*", doc) for doc in documents]
# Tokenize the input, the models expects data to be tokenized using `NltkAndPunctTokenizer`
# Note the model expects case-sensitive input
tokenizer = NltkAndPunctTokenizer()
question = tokenizer.tokenize_paragraph_flat(question) # List of words
# Now list of document->paragraph->sentence->word
documents = [[tokenizer.tokenize_paragraph(p) for p in doc]
for doc in documents]
# Now group the document into paragraphs, this returns `ExtractedParagraph` objects
# that additionally remember the start/end token of the paragraph within the source document
splitter = MergeParagraphs(400)
#splitter = PreserveParagraphs() # Uncomment to use the natural paragraph grouping
documents = [splitter.split(doc) for doc in documents]
# Now select the top paragraphs using a `ParagraphFilter`
if len(documents) == 1:
# Use TF-IDF to select top paragraphs from the document
selector = TopTfIdf(NltkPlusStopWords(True), n_to_select=1000)
context = selector.prune(question, documents[0])
else:
# Use a linear classifier to select top paragraphs among all the documents
selector = ShallowOpenWebRanker(n_to_select=1000)
context = selector.prune(question, flatten_iterable(documents))
print("Select %d paragraph" % len(context))
if model.preprocessor is not None:
# Models are allowed to define an additional pre-processing step
# This will turn the `ExtractedParagraph` objects back into simple lists of tokens
context = [
model.preprocessor.encode_text(question, x) for x in context
]
else:
# Otherwise just use flattened text
context = [flatten_iterable(x.text) for x in context]
print("Setting up model")
# Tell the model the batch size (can be None) and vocab to expect, This will load the
# needed word vectors and fix the batch size to use when building the graph / encoding the input
voc = set(question)
for txt in context:
voc.update(txt)
model.set_input_spec(ParagraphAndQuestionSpec(batch_size=len(context)),
voc)
# Now we build the actual tensorflow graph, `best_span` and `conf` are
# tensors holding the predicted span (inclusive) and confidence scores for each
# element in the input batch, confidence scores being the pre-softmax logit for the span
print("Build tf graph")
sess = tf.Session(config=tf.ConfigProto(allow_soft_placement=True))
# We need to use sess.as_default when working with the cuNND stuff, since we need an active
# session to figure out the # of parameters needed for each layer. The cpu-compatible models don't need this.
with sess.as_default():
# 8 means to limit the span to size 8 or less
best_spans, conf = model.get_prediction().get_best_span(8)
# Loads the saved weights
model_dir.restore_checkpoint(sess)
# Now the model is ready to run
# The model takes input in the form of `ContextAndQuestion` objects, for example:
data = [
ParagraphAndQuestion(x, question, None, "user-question%d" % i)
for i, x in enumerate(context)
]
print("Starting run")
# The model is run in two steps, first it "encodes" a batch of paragraph/context pairs
# into numpy arrays, then we use `sess` to run the actual model get the predictions
encoded = model.encode(
data, is_train=False) # batch of `ContextAndQuestion` -> feed_dict
best_spans, conf = sess.run([best_spans, conf],
feed_dict=encoded) # feed_dict -> predictions
best_para = np.argmax(
conf
) # We get output for each paragraph, select the most-confident one to print
print("Best Paragraph: " + str(best_para))
print("Best span: " + str(best_spans[best_para]))
print("Answer text: " +
" ".join(context[best_para]
[best_spans[best_para][0]:best_spans[best_para][1] + 1]))
print("Confidence: " + str(conf[best_para]))
y_output = " ".join(
context[best_para][best_spans[best_para][0]:best_spans[best_para][1] +
1])
print(y_output)
json_data["predictions"].append(str(y_output))
#indicate that the request was a success
json_data["success"] = True
#return the data dictionary as a JSON response
return flask.jsonify(json_data)
def convert(model_dir, output_dir, best_weights=False):
print("Load model")
md = ModelDir(model_dir)
model = md.get_model()
dim = model.embed_mapper.layers[1].n_units
global_step = tf.get_variable('global_step',
shape=[],
dtype='int32',
initializer=tf.constant_initializer(0),
trainable=False)
print("Setting up cudnn version")
#global_step = tf.get_variable('global_step', shape=[], dtype='int32', trainable=False)
sess = tf.Session()
sess.run(global_step.assign(0))
with sess.as_default():
model.set_input_spec(
ParagraphAndQuestionSpec(1, None, None, 14), {"the"},
ResourceLoader(lambda a, b: {"the": np.zeros(300, np.float32)}))
print("Buiding graph")
pred = model.get_prediction()
test_questions = ParagraphAndQuestion(
["Harry", "Potter", "was", "written", "by", "JK"],
["Who", "wrote", "Harry", "Potter", "?"], None, "test_questions")
print("Load vars")
md.restore_checkpoint(sess)
print("Restore finished")
feed = model.encode([test_questions], False)
cuddn_out = sess.run([pred.start_logits, pred.end_logits], feed_dict=feed)
print("Done, copying files...")
if not exists(output_dir):
mkdir(output_dir)
for file in listdir(model_dir):
if isfile(file) and file != "model.npy":
copyfile(join(model_dir, file), join(output_dir, file))
print("Done, mapping tensors...")
to_save = []
to_init = []
for x in tf.trainable_variables():
if x.name.endswith("/gru_parameters:0"):
key = x.name[:-len("/gru_parameters:0")]
fw_params = x
if "map_embed" in x.name:
c = cudnn_rnn_ops.CudnnGRU(1, dim, 400)
elif "chained-out" in x.name:
c = cudnn_rnn_ops.CudnnGRU(1, dim, dim * 4)
else:
c = cudnn_rnn_ops.CudnnGRU(1, dim, dim * 2)
params_saveable = cudnn_rnn_ops.RNNParamsSaveable(
c, c.params_to_canonical, c.canonical_to_params, [fw_params],
key)
for spec in params_saveable.specs:
if spec.name.endswith("bias_cudnn 0") or \
spec.name.endswith("bias_cudnn 1"):
# ??? What do these even do?
continue
name = spec.name.split("/")
name.remove("cell_0")
if "forward" in name:
ix = name.index("forward")
name.insert(ix + 2, "fw")
else:
ix = name.index("backward")
name.insert(ix + 2, "bw")
del name[ix]
ix = name.index("multi_rnn_cell")
name[ix] = "bidirectional_rnn"
name = "/".join(name)
v = tf.Variable(sess.run(spec.tensor), name=name)
to_init.append(v)
to_save.append(v)
else:
to_save.append(x)
other = [
x for x in tf.get_collection(tf.GraphKeys.GLOBAL_VARIABLES)
if x not in tf.trainable_variables()
]
print(other)
sess.run(tf.initialize_variables(to_init))
saver = tf.train.Saver(to_save + other)
save_dir = join(output_dir, "save")
if not exists(save_dir):
mkdir(save_dir)
saver.save(sess, join(save_dir, "checkpoint"), sess.run(global_step))
sess.close()
tf.reset_default_graph()
print("Updating model...")
model.embed_mapper.layers = [
model.embed_mapper.layers[0],
BiRecurrentMapper(CompatGruCellSpec(dim))
]
model.match_encoder.layers = list(model.match_encoder.layers)
other = model.match_encoder.layers[1].other
other.layers = list(other.layers)
other.layers[1] = BiRecurrentMapper(CompatGruCellSpec(dim))
pred = model.predictor.predictor
pred.first_layer = BiRecurrentMapper(CompatGruCellSpec(dim))
pred.second_layer = BiRecurrentMapper(CompatGruCellSpec(dim))
with open(join(output_dir, "model.pkl"), "wb") as f:
pickle.dump(model, f)
print("Testing...")
with open(join(output_dir, "model.pkl"), "rb") as f:
model = pickle.load(f)
sess = tf.Session()
model.set_input_spec(
ParagraphAndQuestionSpec(1, None, None, 14), {"the"},
ResourceLoader(lambda a, b: {"the": np.zeros(300, np.float32)}))
pred = model.get_prediction()
print("Rebuilding")
saver = tf.train.Saver()
saver.restore(sess, tf.train.latest_checkpoint(save_dir))
feed = model.encode([test_questions], False)
cpu_out = sess.run([pred.start_logits, pred.end_logits], feed_dict=feed)
print("These should be close:")
print([np.allclose(a, b) for a, b in zip(cpu_out, cuddn_out)])
print(cpu_out)
print(cuddn_out)