Update app.py

Zero-shot text classification

app.py

@@ -99,20 +99,51 @@
 #------------------------------------------------------------------------------------------
 # 6. Same model with some tuning with some parameters: num_return_sequences=5, max_length=200, temperature=1.5, num_beams=10
 
-from transformers import PegasusForConditionalGeneration, PegasusTokenizer
+# from transformers import PegasusForConditionalGeneration, PegasusTokenizer
+# import gradio as grad
+
+# 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")
+#     translated_txt = mdl.generate(**tokens, num_return_sequences=5, max_length=200, temperature=1.5, num_beams=10)
+#     response = pegasus_tkn.batch_decode(translated_txt, 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()
+
+#-----------------------------------------------------------------------------------
+# 7. Zero-Shot Learning: 
+# Zero-shot learning, as the name implies, is to use a pretrained model , trained on a certain set of data, 
+# on a different set of data, which it has not seen during training. This would mean, as an example, to take 
+# some model from huggingface that is trained on a certain dataset and use it for inference on examples it has never seen before.
+
+# The transformers are where the zero-shot classification implementations are most frequently found by us. 
+# There are more than 60 transformer models that function based on the zero-shot classification that are found in the huggingface library.
+
+# When we discuss zero-shot text classification , there is one additional thing that springs to mind. 
+# In the same vein as zero-shot classification is few-shot classification, which is very similar to zero-shot classification. 
+# However, in contrast with zero-shot classification, few-shot classification makes use of very few labeled samples during the training process. 
+# The implementation of the few-shot classification methods can be found in OpenAI, where the GPT3 classifier is a well-known example of a few-shot classifier.
+
+from transformers import pipeline
 import gradio as grad
 
-mdl_name = "google/pegasus-xsum"
-pegasus_tkn = PegasusTokenizer.from_pretrained(mdl_name)
-mdl = PegasusForConditionalGeneration.from_pretrained(mdl_name)
+zero_shot_classifier = pipeline("zero-shot-classification")
 
-def summarize(text):
-    tokens = pegasus_tkn(text, truncation=True, padding="longest", return_tensors="pt")
-    translated_txt = mdl.generate(**tokens, num_return_sequences=5, max_length=200, temperature=1.5, num_beams=10)
-    response = pegasus_tkn.batch_decode(translated_txt, skip_special_tokens=True)
-    return response
+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=10, label="English", placeholder="English Text here")
-out = grad.Textbox(lines=10, label="Summary")
+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(summarize, inputs=txt, outputs=out).launch()
+grad.Interface(classify, inputs=[txt,labels], outputs=out).launch()