app.py

from transformers import AutoModelForQuestionAnswering, AutoModelForSeq2SeqLM, AutoTokenizer, PegasusForConditionalGeneration, PegasusTokenizer, pipeline
import gradio as grad
import ast

# mdl_name = "deepset/roberta-base-squad2"
# my_pipeline = pipeline('question-answering', model=mdl_name, tokenizer=mdl_name)

# model_translate_name = 'danhsf/m2m100_418M-finetuned-kde4-en-to-pt_BR'
# model_translate = AutoModelForSeq2SeqLM.from_pretrained(model_translate_name)
# model_translate_token = AutoTokenizer.from_pretrained(model_translate_name)
# translate_pipeline = pipeline('translation', model=model_translate_name)

def answer_question(question,context):
    text= "{"+"'question': '"+question+"','context': '"+context+"'}"
    di=ast.literal_eval(text)
    response = my_pipeline(di)
    print('response', response)
    return response
#grad.Interface(answer_question, inputs=["text","text"], outputs="text").launch()


def translate(text):
    inputs = model_translate_token(text, return_tensor='pt')
    translate_output = model_translate.generate(**inputs)
    response = model_translate_token(translate_output[0], skip_special_tokens=True)
    #response = translate_pipeline(text)
    return response
# grad.Interface(translate, inputs=['text',], outputs='text').launch()


# mdl_name = "google/pegasus-xsum"
# pegasus_tkn = PegasusTokenizer.from_pretrained(mdl_name)
# mdl = PegasusForConditionalGeneration.from_pretrained(mdl_name)

def summarize(text):
    tokens = pegasus_tkn(text, truncation=True, padding="longest", return_tensors="pt")
    txt_summary = mdl.generate(**tokens, num_return_sequences=5, max_length=200, temperature=1.5,num_beams=10)
    response = pegasus_tkn.batch_decode(txt_summary, skip_special_tokens=True)
    return response
    
# txt=grad.Textbox(lines=10, label="English", placeholder="English Text here")
# out=grad.Textbox(lines=10, label="Summary")
# grad.Interface(summarize, inputs=txt, outputs=out).launch()

# ZeroShotClassification using pipeline
# from transformers import pipeline
# import gradio as grad
# zero_shot_classifier = pipeline("zero-shot-classification")
def classify(text,labels):
    classifer_labels = labels.split(",")
    #["software", "politics", "love", "movies", "emergency", "advertisment","sports"]
    response = zero_shot_classifier(text,classifer_labels)
    return response
# txt=grad.Textbox(lines=1, label="English", placeholder="text to be classified")
# labels=grad.Textbox(lines=1, label="Labels", placeholder="comma separated labels")
# out=grad.Textbox(lines=1, label="Classification")
# grad.Interface(classify, inputs=[txt,labels], outputs=out).launch()

# Text classification using BartForSequenceClassification
# from transformers import BartForSequenceClassification, BartTokenizer
# import gradio as grad
# bart_tkn = BartTokenizer.from_pretrained('facebook/bart-large-mnli')
# mdl = BartForSequenceClassification.from_pretrained('facebook/bart-large-mnli')
def classify(text,label):
    tkn_ids = bart_tkn.encode(text, label, return_tensors='pt')
    tkn_lgts = mdl(tkn_ids)[0]
    entail_contra_tkn_lgts = tkn_lgts[:,[0,2]]
    probab = entail_contra_tkn_lgts.softmax(dim=1)
    response =  probab[:,1].item() * 100
    return response
# txt=grad.Textbox(lines=1, label="English", placeholder="text to be classified")
# labels=grad.Textbox(lines=1, label="Label", placeholder="Input a Label")
# out=grad.Textbox(lines=1, label="Probablity of label being true is")
# grad.Interface(classify, inputs=[txt,labels], outputs=out).launch()

# GPT2
# from transformers import GPT2LMHeadModel,GPT2Tokenizer
# import gradio as grad
# mdl = GPT2LMHeadModel.from_pretrained('gpt2')
# gpt2_tkn=GPT2Tokenizer.from_pretrained('gpt2')
def generate(starting_text):
    tkn_ids = gpt2_tkn.encode(starting_text, return_tensors = 'pt')
    gpt2_tensors = mdl.generate(tkn_ids,max_length=100,no_repeat_ngram_size=True,num_beams=3,do_sample=True)
    response=""
    #response = gpt2_tensors
    for i, x in enumerate(gpt2_tensors):
       response=response+f"{i}: {gpt2_tkn.decode(x, skip_special_tokens=True)}"
    return response
# txt=grad.Textbox(lines=1, label="English", placeholder="English Text here")
# out=grad.Textbox(lines=1, label="Generated Text")
# grad.Interface(generate, inputs=txt, outputs=out).launch()

#DistlGPT2
# from transformers import pipeline, set_seed
# import gradio as grad
# gpt2_pipe = pipeline('text-generation', model='distilgpt2')
# set_seed(42)
def generateDistlGPT2(starting_text):
    response= gpt2_pipe(starting_text, max_length=20, num_return_sequences=5)
    return response
# txt=grad.Textbox(lines=1, label="English", placeholder="English Text here")
# out=grad.Textbox(lines=1, label="Generated Text")
# grad.Interface(generateDistlGPT2, inputs=txt, outputs=out).launch()

#Text Generation
#Question Generation
# from transformers import AutoModelWithLMHead, AutoTokenizer
# import gradio as grad
# text2text_tkn = AutoTokenizer.from_pretrained("mrm8488/t5-base-finetuned-question-generation-ap")
# mdl = AutoModelWithLMHead.from_pretrained("mrm8488/t5-base-finetuned-question-generation-ap")
def text2text(context,answer):
    input_text = "answer: %s  context: %s </s>" % (answer, context)
    features = text2text_tkn ([input_text], return_tensors='pt')
    output = mdl.generate(input_ids=features['input_ids'],
               attention_mask=features['attention_mask'],
               max_length=64)
    response=text2text_tkn.decode(output[0])
    return response
# context=grad.Textbox(lines=10, label="English", placeholder="Context")
# ans=grad.Textbox(lines=1, label="Answer")
# out=grad.Textbox(lines=1, label="Genereated Question")
# grad.Interface(text2text, inputs=[context,ans], outputs=out).launch()

#T5 summaryzer
# from transformers import AutoTokenizer, AutoModelWithLMHead
# import gradio as grad
# text2text_tkn = AutoTokenizer.from_pretrained("deep-learning-analytics/wikihow-t5-small")
# mdl = AutoModelWithLMHead.from_pretrained("deep-learning-analytics/wikihow-t5-small")
def text2text_summary(para):
    initial_txt = para.strip().replace("\n","")
    tkn_text = text2text_tkn.encode(initial_txt, return_tensors="pt")
    tkn_ids = mdl.generate(
            tkn_text,
            max_length=250,
            num_beams=5,
            repetition_penalty=2.5,
            early_stopping=True
        )
    response = text2text_tkn.decode(tkn_ids[0], skip_special_tokens=True)
    return response
# para=grad.Textbox(lines=10, label="Paragraph", placeholder="Copy paragraph")
# out=grad.Textbox(lines=1, label="Summary")
# grad.Interface(text2text_summary, inputs=para, outputs=out).launch()

# T5 Translate
from transformers import T5ForConditionalGeneration, T5Tokenizer
import gradio as grad
text2text_tkn= T5Tokenizer.from_pretrained("t5-small")
mdl = T5ForConditionalGeneration.from_pretrained("t5-small")
def text2text_translation(text):
     inp = "translate English to Portuguese:: "+text
     enc = text2text_tkn(inp, return_tensors="pt")
     tokens = mdl.generate(**enc)
     response=text2text_tkn.batch_decode(tokens)
     return response
para=grad.Textbox(lines=1, label="English Text", placeholder="Text in English")
out=grad.Textbox(lines=1, label="Portuguese Translation")
grad.Interface(text2text_translation, inputs=para, outputs=out).launch()