Update app.py

app.py

@@ -1,26 +1,69 @@
 import gradio as gr
-from transformers import AutoModelForCausalLM, AutoTokenizer
+from transformers import AutoModelForCausalLM, AutoTokenizer, pipeline
+from diffusers import StableDiffusionPipeline
 import torch
+import requests
+from PIL import Image
+import io
 
-# Define a dictionary of model names and their corresponding Hugging Face model IDs
-models = {
-    "GPT-Neo-125M": "EleutherAI/gpt-neo-125M",
-    "GPT-J-6B": "EleutherAI/gpt-j-6B",
-    "GPT-NeoX-20B": "EleutherAI/gpt-neox-20b",
-    "GPT-3.5-Turbo": "gpt2",  # Placeholder for illustrative purposes
+# Define a dictionary of conversational models
+conversational_models = {
+    "Qwen": "Qwen/QwQ-32B",
+    "DeepSeek R1": "deepseek-ai/DeepSeek-R1",
+    "Perplexity (R1 Post-trained)": "perplexity-ai/r1-1776",
+    "Llama-Instruct by Meta": "meta-llama/Llama-3.2-3B-Instruct",
+    "Mistral": "mistralai/Mistral-7B-v0.1",
+    "Gemma": "google/gemma-2-2b-it",
 }
 
-# Initialize tokenizers and models
-tokenizers = {}
-models_loaded = {}
+# Define a dictionary of Text-to-Image models
+text_to_image_models = {
+    "Stable Diffusion 3.5 Large": "stabilityai/stable-diffusion-3.5-large",
+    "Stable Diffusion 1.4": "CompVis/stable-diffusion-v1-4",
+    "Flux Dev": "black-forest-labs/FLUX.1-dev",
+}
+
+# Define a dictionary of Text-to-Speech models
+text_to_speech_models = {
+    "Spark TTS": "SparkAudio/Spark-TTS-0.5B",
+}
+
+# Initialize tokenizers and models for conversational AI
+conversational_tokenizers = {}
+conversational_models_loaded = {}
+
+for model_name, model_id in conversational_models.items():
+    conversational_tokenizers[model_name] = AutoTokenizer.from_pretrained(model_id)
+    conversational_models_loaded[model_name] = AutoModelForCausalLM.from_pretrained(model_id)
+
+# Initialize pipelines for Text-to-Image
+text_to_image_pipelines = {}
+
+for model_name, model_id in text_to_image_models.items():
+    text_to_image_pipelines[model_name] = StableDiffusionPipeline.from_pretrained(model_id)
+
+# Initialize pipelines for Text-to-Speech
+text_to_speech_pipelines = {}
+
+for model_name, model_id in text_to_speech_models.items():
+    text_to_speech_pipelines[model_name] = pipeline("text-to-speech", model=model_id)
 
-for model_name, model_id in models.items():
-    tokenizers[model_name] = AutoTokenizer.from_pretrained(model_id)
-    models_loaded[model_name] = AutoModelForCausalLM.from_pretrained(model_id)
+# Initialize pipelines for other tasks
+visual_qa_pipeline = pipeline("visual-question-answering", model="dandelin/vilt-b32-finetuned-vqa")
+document_qa_pipeline = pipeline("question-answering", model="deepset/roberta-base-squad2")
+image_classification_pipeline = pipeline("image-classification", model="facebook/detr-resnet-50")
+object_detection_pipeline = pipeline("object-detection", model="facebook/detr-resnet-50")
+video_classification_pipeline = pipeline("video-classification", model="facebook/x3d-l")
+text_to_3d_pipeline = pipeline("text-to-3d", model="CompVis/td2s")
+keypoint_detection_pipeline = pipeline("keypoint-detection", model="facebook/detr-resnet-50")
+translation_pipeline = pipeline("translation_en_to_fr", model="Helsinki-NLP/opus-mt-en-fr")
+summarization_pipeline = pipeline("summarization", model="facebook/bart-large-cnn")
+text_to_audio_pipeline = pipeline("text-to-speech", model="julien-c/ljspeech_tts_train_tacotron2_raw_phn_tacotron_g2p_en_no_space")
+audio_classification_pipeline = pipeline("audio-classification", model="facebook/wav2vec2-base")
 
 def chat(model_name, user_input, history=[]):
-    tokenizer = tokenizers[model_name]
-    model = models_loaded[model_name]
+    tokenizer = conversational_tokenizers[model_name]
+    model = conversational_models_loaded[model_name]
     
     # Encode the input
     input_ids = tokenizer.encode(user_input + tokenizer.eos_token, return_tensors="pt")
@@ -39,17 +82,167 @@ def chat(model_name, user_input, history=[]):
     
     return history, history
 
+def generate_image(model_name, prompt):
+    pipeline = text_to_image_pipelines[model_name]
+    image = pipeline(prompt).images[0]
+    return image
+
+def generate_speech(model_name, text):
+    pipeline = text_to_speech_pipelines[model_name]
+    audio = pipeline(text)
+    return audio["audio"]
+
+def visual_qa(image, question):
+    result = visual_qa_pipeline(image, question)
+    return result["answer"]
+
+def document_qa(document, question):
+    result = document_qa_pipeline(question=question, context=document)
+    return result["answer"]
+
+def image_classification(image):
+    result = image_classification_pipeline(image)
+    return result
+
+def object_detection(image):
+    result = object_detection_pipeline(image)
+    return result
+
+def video_classification(video):
+    result = video_classification_pipeline(video)
+    return result
+
+def text_to_3d(text):
+    result = text_to_3d_pipeline(text)
+    return result["image"]
+
+def keypoint_detection(image):
+    result = keypoint_detection_pipeline(image)
+    return result
+
+def translate_text(text):
+    result = translation_pipeline(text)
+    return result[0]["translation_text"]
+
+def summarize_text(text):
+    result = summarization_pipeline(text)
+    return result[0]["summary_text"]
+
+def text_to_audio(text):
+    result = text_to_audio_pipeline(text)
+    return result["audio"]
+
+def audio_classification(audio):
+    result = audio_classification_pipeline(audio)
+    return result
+
 # Define the Gradio interface
 with gr.Blocks() as demo:
-    gr.Markdown("## Chat with Different Models")
+    gr.Markdown("## Versatile AI Chatbot and Text-to-X Tasks")
+    
+    with gr.Tab("Conversational AI"):
+        conversational_model_choice = gr.Dropdown(list(conversational_models.keys()), label="Choose a Conversational Model")
+        conversational_chatbot = gr.Chatbot(label="Chat")
+        conversational_message = gr.Textbox(label="Message")
+        conversational_submit = gr.Button("Submit")
+        
+        conversational_submit.click(chat, inputs=[conversational_model_choice, conversational_message, conversational_chatbot], outputs=[conversational_chatbot, conversational_chatbot])
+        conversational_message.submit(chat, inputs=[conversational_model_choice, conversational_message, conversational_chatbot], outputs=[conversational_chatbot, conversational_chatbot])
+    
+    with gr.Tab("Text-to-Image"):
+        text_to_image_model_choice = gr.Dropdown(list(text_to_image_models.keys()), label="Choose a Text-to-Image Model")
+        text_to_image_prompt = gr.Textbox(label="Prompt")
+        text_to_image_generate = gr.Button("Generate Image")
+        text_to_image_output = gr.Image(label="Generated Image")
+        
+        text_to_image_generate.click(generate_image, inputs=[text_to_image_model_choice, text_to_image_prompt], outputs=text_to_image_output)
+    
+    with gr.Tab("Text-to-Speech"):
+        text_to_speech_model_choice = gr.Dropdown(list(text_to_speech_models.keys()), label="Choose a Text-to-Speech Model")
+        text_to_speech_text = gr.Textbox(label="Text")
+        text_to_speech_generate = gr.Button("Generate Speech")
+        text_to_speech_output = gr.Audio(label="Generated Speech")
+        
+        text_to_speech_generate.click(generate_speech, inputs=[text_to_speech_model_choice, text_to_speech_text], outputs=text_to_speech_output)
+    
+    with gr.Tab("Visual Question Answering"):
+        visual_qa_image = gr.Image(label="Upload Image")
+        visual_qa_question = gr.Textbox(label="Question")
+        visual_qa_generate = gr.Button("Answer")
+        visual_qa_output = gr.Textbox(label="Answer")
+        
+        visual_qa_generate.click(visual_qa, inputs=[visual_qa_image, visual_qa_question], outputs=visual_qa_output)
+    
+    with gr.Tab("Document Question Answering"):
+        document_qa_document = gr.Textbox(label="Document Text")
+        document_qa_question = gr.Textbox(label="Question")
+        document_qa_generate = gr.Button("Answer")
+        document_qa_output = gr.Textbox(label="Answer")
+        
+        document_qa_generate.click(document_qa, inputs=[document_qa_document, document_qa_question], outputs=document_qa_output)
+    
+    with gr.Tab("Image Classification"):
+        image_classification_image = gr.Image(label="Upload Image")
+        image_classification_generate = gr.Button("Classify")
+        image_classification_output = gr.Textbox(label="Classification Result")
+        
+        image_classification_generate.click(image_classification, inputs=image_classification_image, outputs=image_classification_output)
+    
+    with gr.Tab("Object Detection"):
+        object_detection_image = gr.Image(label="Upload Image")
+        object_detection_generate = gr.Button("Detect")
+        object_detection_output = gr.Image(label="Detection Result")
+        
+        object_detection_generate.click(object_detection, inputs=object_detection_image, outputs=object_detection_output)
+    
+    with gr.Tab("Video Classification"):
+        video_classification_video = gr.Video(label="Upload Video")
+        video_classification_generate = gr.Button("Classify")
+        video_classification_output = gr.Textbox(label="Classification Result")
+        
+        video_classification_generate.click(video_classification, inputs=video_classification_video, outputs=video_classification_output)
+    
+    with gr.Tab("Text-to-3D"):
+        text_to_3d_text = gr.Textbox(label="Text")
+        text_to_3d_generate = gr.Button("Generate 3D")
+        text_to_3d_output = gr.Image(label="3D Model")
+        
+        text_to_3d_generate.click(text_to_3d, inputs=text_to_3d_text, outputs=text_to_3d_output)
+    
+    with gr.Tab("Keypoint Detection"):
+        keypoint_detection_image = gr.Image(label="Upload Image")
+        keypoint_detection_generate = gr.Button("Detect Keypoints")
+        keypoint_detection_output = gr.Image(label="Keypoint Detection Result")
+        
+        keypoint_detection_generate.click(keypoint_detection, inputs=keypoint_detection_image, outputs=keypoint_detection_output)
+    
+    with gr.Tab("Translation"):
+        translate_text_text = gr.Textbox(label="Text")
+        translate_text_generate = gr.Button("Translate")
+        translate_text_output = gr.Textbox(label="Translated Text")
+        
+        translate_text_generate.click(translate_text, inputs=translate_text_text, outputs=translate_text_output)
+    
+    with gr.Tab("Summarization"):
+        summarize_text_text = gr.Textbox(label="Text")
+        summarize_text_generate = gr.Button("Summarize")
+        summarize_text_output = gr.Textbox(label="Summary")
+        
+        summarize_text_generate.click(summarize_text, inputs=summarize_text_text, outputs=summarize_text_output)
     
-    model_choice = gr.Dropdown(list(models.keys()), label="Choose a Model")
-    chatbot = gr.Chatbot(label="Chat")
-    message = gr.Textbox(label="Message")
-    submit = gr.Button("Submit")
+    with gr.Tab("Text-to-Audio"):
+        text_to_audio_text = gr.Textbox(label="Text")
+        text_to_audio_generate = gr.Button("Generate Audio")
+        text_to_audio_output = gr.Audio(label="Generated Audio")
+        
+        text_to_audio_generate.click(text_to_audio, inputs=text_to_audio_text, outputs=text_to_audio_output)
     
-    submit.click(chat, inputs=[model_choice, message, chatbot], outputs=[chatbot, chatbot])
-    message.submit(chat, inputs=[model_choice, message, chatbot], outputs=[chatbot, chatbot])
+    with gr.Tab("Audio Classification"):
+        audio_classification_audio = gr.Audio(label="Upload Audio")
+        audio_classification_generate = gr.Button("Classify")
+        audio_classification_output = gr.Textbox(label="Classification Result")
+        
+        audio_classification_generate.click(audio_classification, inputs=audio_classification_audio, outputs=audio_classification_output)
 
 # Launch the demo
 demo.launch()