Update app.py

app.py

@@ -1,91 +1,213 @@
 
-
 import gradio as gr
 from transformers import pipeline
 
-#pipelines init
-qa_pipeline = pipeline("question-answering", model="deepset/roberta-base-squad2")
-
-classification_pipeline = pipeline("zero-shot-classification", model="facebook/bart-large-mnli")
-
-translation_pipeline = pipeline("translation", model="Helsinki-NLP/opus-mt-en-fr")
-
-topic_classification_pipeline = pipeline("text-classification", model="distilbert-base-uncased-finetuned-sst-2-english")  # Fine-tuned model for topic classification
-
-summarization_pipeline = pipeline("summarization", model="facebook/bart-large-cnn")
-
-#functions defining
-
-def answer_question(context, question):
-    return qa_pipeline(question=question, context=context)["answer"]
-
-def classify_text(text, labels):
-    labels = labels.split(",")
-    results = classification_pipeline(text, candidate_labels=labels)
-    return {label: float(f"{prob:.4f}") for label, prob in zip(results["labels"], results["scores"])}
-
-def translate_text(text):
-    return translation_pipeline(text)[0]['translation_text'] if text else "No translation"
-
-def classify_topic(text):
-    results = topic_classification_pipeline(text)
-    return ", ".join([f"{result['label']}: {result['score']:.4f}" for result in results])
-
-def summarize_text(text):
-    result = summarization_pipeline(text, max_length=60)
-    return result[0]['summary_text'] if result else "No summary available"
-
-def multi_model_interaction(text):
-    
-    summary = summarize_text(text)
-    translated_summary = translate_text(summary)
-
-    return {
-        "Summary (English)": summary,
-        "Summary (French)": translated_summary,
-    }
-
-
-#Blocking interface
+# Define the necessary pipelines
+def load_qa_model():
+    return pipeline("question-answering", model="bert-large-uncased-whole-word-masking-finetuned-squad")
+
+def load_classifier_model():
+    return pipeline("zero-shot-classification", model="MoritzLaurer/deberta-v3-base-zeroshot-v1.1-all-33")
+
+def load_translator_model(target_language):
+    try:
+        model_name = f"Helsinki-NLP/opus-mt-en-{target_language}"
+        return pipeline("translation", model=model_name)
+    except Exception as e:
+        print(f"Error loading translation model: {e}")
+        return None
+
+def load_generator_model():
+    try:
+        return pipeline("text-generation", model="EleutherAI/gpt-neo-2.7B", tokenizer="EleutherAI/gpt-neo-2.7B")
+    except Exception as e:
+        print(f"Error loading text generation model: {e}")
+        return None
+
+def load_summarizer_model():
+    try:
+        return pipeline("summarization", model="facebook/bart-large-cnn")
+    except Exception as e:
+        print(f"Error loading summarization model: {e}")
+        return None
+
+# Define the functions for processing
+def process_qa(context, question):
+    qa_model = load_qa_model()
+    try:
+        return qa_model(context=context, question=question)["answer"]
+    except Exception as e:
+        print(f"Error during question answering: {e}")
+        return "Error during question answering"
+
+def process_classifier(text, labels):
+    classifier_model = load_classifier_model()
+    try:
+        return classifier_model(text, labels)["labels"][0]
+    except Exception as e:
+        print(f"Error during classification: {e}")
+        return "Error during classification"
+
+def process_translation(text, target_language):
+    translator_model = load_translator_model(target_language)
+    if translator_model:
+        try:
+            return translator_model(text)[0]["translation_text"]
+        except Exception as e:
+            print(f"Error during translation: {e}")
+            return "Translation error"
+    return "Model loading error"
+
+def process_generation(prompt):
+    generator_model = load_generator_model()
+    if generator_model:
+        if prompt.strip():
+            try:
+                return generator_model(prompt, max_length=50)[0]["generated_text"]
+            except Exception as e:
+                print(f"Error during text generation: {e}")
+                return "Text generation error"
+        else:
+            return "Prompt is empty"
+    return "Model loading error"
+
+def process_summarization(text):
+    summarizer_model = load_summarizer_model()
+    if summarizer_model:
+        if text.strip():
+            try:
+                return summarizer_model(text, max_length=150, min_length=40, do_sample=False)[0]["summary_text"]
+            except Exception as e:
+                print(f"Error during summarization: {e}")
+                return "Summarization error"
+        else:
+            return "Text is empty"
+    return "Model loading error"
+
+# Gradio Interface
 with gr.Blocks() as demo:
-    with gr.Tab("Single Models"):
-        with gr.Column():
-            gr.Markdown("### Question")
-            context = gr.Textbox(label="Context")
-            question = gr.Textbox(label="Question")
-            answer_output = gr.Text(label="Answer")
-            gr.Button("Answer").click(answer_question, inputs=[context, question], outputs=answer_output)
-
-        with gr.Column():
-            gr.Markdown("### Zero-Shot")
-            text_zsc = gr.Textbox(label="Text")
-            labels = gr.Textbox(label="Labels (comma separated)")
-            classification_result = gr.JSON(label="Classification Results")
-            gr.Button("Classify").click(classify_text, inputs=[text_zsc, labels], outputs=classification_result)
-
-        with gr.Column():
-            gr.Markdown("### Translation")
-            text_to_translate = gr.Textbox(label="Text")
-            translated_text = gr.Text(label="Translated Text")
-            gr.Button("Translate").click(translate_text, inputs=[text_to_translate], outputs=translated_text)
-
-        with gr.Column():
-            gr.Markdown("### Summarization")
-            text_to_summarize = gr.Textbox(label="Text")
-            summary = gr.Text(label="Summary")
-            gr.Button("Summarize").click(summarize_text, inputs=[text_to_summarize], outputs=summary)
-
-        with gr.Column():
-            gr.Markdown("### Sentiment Analysis")
-            text_for_sentiment = gr.Textbox(label="Text for Sentiment Analysis")
-            sentiment_result = gr.Text(label="Sentiment")
-            gr.Button("Classify Sentiment").click(classify_topic, inputs=[text_for_sentiment], outputs=sentiment_result)
-
-    with gr.Tab("Multi-Model"):
-        gr.Markdown("### Multi-Model")
-        input_text = gr.Textbox(label="Enter Text for Multi-Model Analysis")
-        multi_output = gr.Text(label="Results")
-        gr.Button("Process").click(multi_model_interaction, inputs=[input_text], outputs=multi_output)
-
-    #Launching demo
-    demo.launch(share=True, debug=True)
+    gr.Markdown("Choose an NLP task and input the required text.")
+
+    with gr.Tab("Single-Models"):
+        gr.Markdown("This tab is for single models demonstration.")
+
+        task_select_single = gr.Dropdown(["Question Answering", "Zero-Shot Classification", "Translation", "Text Generation", "Summarization"], label="Select Task")
+        input_text_single = gr.Textbox(label="Input Text")
+
+        # Additional inputs for specific tasks
+        context_input_single = gr.Textbox(label="Context", visible=False)
+        label_input_single = gr.CheckboxGroup(["positive", "negative", "neutral"], label="Labels", visible=False)
+        target_language_input_single = gr.Dropdown(["nl", "fr", "es", "de"], label="Target Language", visible=False)
+
+        output_text_single = gr.Textbox(label="Output")
+        execute_button_single = gr.Button("Execute")
+
+        def update_inputs(task):
+            if task == "Question Answering":
+                return {
+                    context_input_single: gr.update(visible=True),
+                    label_input_single: gr.update(visible=False),
+                    target_language_input_single: gr.update(visible=False)
+                }
+            elif task == "Zero-Shot Classification":
+                return {
+                    context_input_single: gr.update(visible=False),
+                    label_input_single: gr.update(visible=True),
+                    target_language_input_single: gr.update(visible=False)
+                }
+            elif task == "Translation":
+                return {
+                    context_input_single: gr.update(visible=False),
+                    label_input_single: gr.update(visible=False),
+                    target_language_input_single: gr.update(visible=True)
+                }
+            elif task == "Text Generation":
+                return {
+                    context_input_single: gr.update(visible=False),
+                    label_input_single: gr.update(visible=False),
+                    target_language_input_single: gr.update(visible=False)
+                }
+            elif task == "Summarization":
+                return {
+                    context_input_single: gr.update(visible=False),
+                    label_input_single: gr.update(visible=False),
+                    target_language_input_single: gr.update(visible=False)
+                }
+            else:
+                return {
+                    context_input_single: gr.update(visible=False),
+                    label_input_single: gr.update(visible=False),
+                    target_language_input_single: gr.update(visible=False)
+                }
+
+        task_select_single.change(fn=update_inputs, inputs=task_select_single,
+                                  outputs=[context_input_single, label_input_single, target_language_input_single])
+
+        def execute_task_single(task, input_text, context, labels, target_language):
+            if task == "Question Answering":
+                return process_qa(context=context, question=input_text)
+            elif task == "Zero-Shot Classification":
+                if not labels:
+                    return "Please provide labels for classification."
+                return process_classifier(text=input_text, labels=labels)
+            elif task == "Translation":
+                if not target_language:
+                    return "Please select a target language for translation."
+                return process_translation(text=input_text, target_language=target_language)
+            elif task == "Text Generation":
+                return process_generation(prompt=input_text)
+            elif task == "Summarization":
+                return process_summarization(text=input_text)
+            else:
+                return "Invalid task selected."
+
+        execute_button_single.click(
+            execute_task_single,
+            inputs=[task_select_single, input_text_single, context_input_single, label_input_single, target_language_input_single],
+            outputs=output_text_single
+        )
+
+    with gr.Tab("Multi-Model Task"):
+        gr.Markdown("This tab allows you to execute all tasks sequentially.")
+
+        # Inputs for all tasks
+        input_text_multi = gr.Textbox(label="Input Text")
+        context_input_multi = gr.Textbox(label="Context (for QA)")
+        label_input_multi = gr.CheckboxGroup(["positive", "negative", "neutral"], label="Labels (for Classification)")
+        target_language_input_multi = gr.Dropdown(["nl", "fr", "es", "de"], label="Target Language (for Translation)")
+
+        # Outputs for all tasks
+        output_qa = gr.Textbox(label="QA Output")
+        output_classification = gr.Textbox(label="Classification Output")
+        output_translation = gr.Textbox(label="Translation Output")
+        output_generation = gr.Textbox(label="Text Generation Output")
+        output_summarization = gr.Textbox(label="Summarization Output")
+
+        execute_button_multi = gr.Button("Execute All Tasks")
+
+        def execute_all_tasks(input_text, context, labels, target_language):
+            # Process Question Answering
+            qa_output = process_qa(context=context, question=input_text)
+
+            # Process Classification
+            classification_output = process_classifier(text=input_text, labels=labels)
+
+            # Process Translation
+            translation_output = process_translation(text=input_text, target_language=target_language)
+
+            # Process Text Generation using QA output
+            generation_output = process_generation(prompt=qa_output)
+
+            # Process Summarization using Text Generation output
+            summarization_output = process_summarization(text=generation_output)
+
+            # Return all outputs
+            return qa_output, classification_output, translation_output, generation_output, summarization_output
+
+        execute_button_multi.click(
+            execute_all_tasks,
+            inputs=[input_text_multi, context_input_multi, label_input_multi, target_language_input_multi],
+            outputs=[output_qa, output_classification, output_translation, output_generation, output_summarization]
+        )
+
+demo.launch()