Update app.py

app.py

@@ -2,56 +2,35 @@ import gradio as gr
 from transformers import BertForQuestionAnswering
 from transformers import BertTokenizerFast
 import torch
-from nltk.tokenize import word_tokenize
-import timm
 
 device = torch.device('cuda' if torch.cuda.is_available() else 'cpu')
 tokenizer = BertTokenizerFast.from_pretrained('bert-base-uncased')
-#model = BertForQuestionAnswering.from_pretrained("bert-base-uncased")
 model = BertForQuestionAnswering.from_pretrained("CountingMstar/ai-tutor-bert-model").to(device)
 
 def get_prediction(context, question):
-  inputs = tokenizer.encode_plus(question, context, return_tensors='pt').to(device)
-  outputs = model(**inputs)
-  
-  answer_start = torch.argmax(outputs[0])  
-  answer_end = torch.argmax(outputs[1]) + 1 
-  
-  answer = tokenizer.convert_tokens_to_string(tokenizer.convert_ids_to_tokens(inputs['input_ids'][0][answer_start:answer_end]))
-  
-  return answer
-  
-def question_answer(context, question):
-  prediction = get_prediction(context,question)
-  return prediction
+    inputs = tokenizer.encode_plus(question, context, return_tensors='pt').to(device)
+    outputs = model(**inputs)
+    
+    answer_start = torch.argmax(outputs.start_logits)
+    answer_end = torch.argmax(outputs.end_logits) + 1
+    
+    answer = tokenizer.convert_tokens_to_string(tokenizer.convert_ids_to_tokens(inputs['input_ids'][0][answer_start:answer_end]))
+    
+    return answer
 
-def split(text):
-    context, question = '', ''
-    act = False
-    tmp = ''
-    for t in text:
-        tmp += t
-        if len(tmp) == 4:
-            tmp = tmp[1:]
-            if tmp == '///':
-                act = True
+def question_answer(context, question):
+    prediction = get_prediction(context, question)
+    return prediction
 
-        if act == True:
-            question += t
+examples_text = [["A large language model (LLM) is a type of language model notable for its ability to achieve general-purpose language understanding and generation. LLMs acquire these abilities by using  massive amounts of data to learn billions of parameters during training and consuming large computational resources during their training and operation.[1] LLMs are artificial neural networks (mainly transformers[2]) and are (pre-)trained using self-supervised learning and semi-supervised learning.","What is large language model?"],
+                   ["Feature engineering or feature extraction or feature discovery is the process of extracting features (characteristics, properties, attributes) from raw data. Due to deep learning networks, such as convolutional neural networks, that are able to learn features by themselves, domain-specific-based feature engineering has become obsolete for vision and speech processing. Other examples of features in physics include the construction of dimensionless numbers such as Reynolds number in fluid dynamics; then Nusselt number in heat transfer; Archimedes number in sedimentation; construction of first approximations of the solution such as analytical strength of materials solutions in mechanics, etc.", "What is Feature engineering?"],
+                   ["It calculates soft weights for each word, more precisely for its embedding, in the context window. It can do it either in parallel (such as in transformers) or sequentially (such as recurrent neural networks). Soft weights can change during each runtime, in contrast to hard weights, which are (pre-)trained and fine-tuned and remain frozen afterwards. Attention was developed to address the weaknesses of recurrent neural networks, where words in a sentence are slowly processed one at a time. Machine learning-based attention is a mechanism mimicking cognitive attention. Recurrent neural networks favor more recent words at the end of a sentence while earlier words fade away in volatile neural activations. Attention gives all words equal access to any part of a sentence in a faster parallel scheme and no longer suffers the wait time of serial processing. Earlier uses attached this mechanism to a serial recurrent neural network's language translation system (below), but later uses in Transformers large language models removed the recurrent neural network and relied heavily on the faster parallel attention scheme.", "What is Attention mechanism?"]]
 
-        if act == False:
-            context += t
-        
-    return context[:-2], question[1:]
-    
-def greet(texts):
-    context, question = split(texts)
-    answer = question_answer(context, question)
-    return answer
-# def greet(text):
-#     context, question = split(text)
-#     # answer = question_answer(context, question)
-#     return context
+iface = gr.Interface(
+    fn=question_answer,
+    inputs=[gr.Textbox("Context"), gr.Textbox("Question")],
+    outputs=gr.Textbox("Answer"),
+    examples=examples_text
+)
 
-iface = gr.Interface(fn=greet, inputs="text", outputs="text")
-iface.launch()
+iface.launch()