Create app.py

app.py

@@ -0,0 +1,256 @@
+import gradio as gr
+from transformers import AutoModelForCausalLM, AutoTokenizer, pipeline
+from diffusers import StableDiffusionPipeline
+import torch
+import os
+import logging
+
+# Set up logging
+logging.basicConfig(level=logging.INFO)
+logger = logging.getLogger(__name__)
+
+# Read the Hugging Face access token from the environment variable
+read_token = os.getenv('AccToken')
+if not read_token:
+    raise ValueError("Hugging Face access token not found. Please set the AccToken environment variable.")
+from huggingface_hub import login
+login(read_token)
+
+# Set device to GPU if available
+device = torch.device("cuda" if torch.cuda.is_available() else "cpu")
+logger.info(f"Device set to use {device}")
+
+# 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",
+}
+
+# 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 = {}
+
+# Initialize pipelines for Text-to-Image
+text_to_image_pipelines = {}
+
+# Initialize pipelines for Text-to-Speech
+text_to_speech_pipelines = {}
+
+# Initialize pipelines for other tasks
+visual_qa_pipeline = pipeline("visual-question-answering", model="dandelin/vilt-b32-finetuned-vqa", device=device)
+document_qa_pipeline = pipeline("question-answering", model="deepset/roberta-base-squad2", device=device)
+image_classification_pipeline = pipeline("image-classification", model="facebook/deit-base-distilled-patch16-224", device=device)
+object_detection_pipeline = pipeline("object-detection", model="facebook/detr-resnet-50", device=device)
+video_classification_pipeline = pipeline("video-classification", model="facebook/timesformer-base-finetuned-k400", device=device)
+summarization_pipeline = pipeline("summarization", model="facebook/bart-large-cnn", device=device)
+
+# Load speaker embeddings for text-to-audio
+def load_speaker_embeddings(model_name):
+    if model_name == "microsoft/speecht5_tts":
+        logger.info("Loading speaker embeddings for SpeechT5")
+        from datasets import load_dataset
+        dataset = load_dataset("Matthijs/cmu-arctic-xvectors", split="validation")
+        speaker_embeddings = torch.tensor(dataset[7306]["xvector"]).unsqueeze(0).to(device)  # Example speaker
+        return speaker_embeddings
+    return None
+
+# Use a different model for text-to-audio if stabilityai/stable-audio-open-1.0 is not supported
+try:
+    text_to_audio_pipeline = pipeline("text-to-audio", model="stabilityai/stable-audio-open-1.0", device=device)
+except ValueError as e:
+    logger.error(f"Error loading stabilityai/stable-audio-open-1.0: {e}")
+    logger.info("Falling back to a different text-to-audio model.")
+    text_to_audio_pipeline = pipeline("text-to-audio", model="microsoft/speecht5_tts", device=device)
+    speaker_embeddings = load_speaker_embeddings("microsoft/speecht5_tts")
+
+audio_classification_pipeline = pipeline("audio-classification", model="facebook/wav2vec2-base", device=device)
+
+def load_conversational_model(model_name):
+    if model_name not in conversational_models_loaded:
+        logger.info(f"Loading conversational model: {model_name}")
+        tokenizer = AutoTokenizer.from_pretrained(conversational_models[model_name], use_auth_token=read_token)
+        model = AutoModelForCausalLM.from_pretrained(conversational_models[model_name], use_auth_token=read_token).to(device)
+        conversational_tokenizers[model_name] = tokenizer
+        conversational_models_loaded[model_name] = model
+    return conversational_tokenizers[model_name], conversational_models_loaded[model_name]
+
+def chat(model_name, user_input, history=[]):
+    tokenizer, model = load_conversational_model(model_name)
+    
+    # Encode the input
+    input_ids = tokenizer.encode(user_input + tokenizer.eos_token, return_tensors="pt").to(device)
+    
+    # Generate a response
+    with torch.no_grad():
+        output = model.generate(input_ids, max_length=150, pad_token_id=tokenizer.eos_token_id)
+    
+    response = tokenizer.decode(output[0], skip_special_tokens=True)
+    
+    # Clean up the response to remove the user input part
+    response = response[len(user_input):].strip()
+    
+    # Append to chat history
+    history.append((user_input, response))
+    
+    return history, history
+
+def generate_image(model_name, prompt):
+    if model_name not in text_to_image_pipelines:
+        logger.info(f"Loading text-to-image model: {model_name}")
+        text_to_image_pipelines[model_name] = StableDiffusionPipeline.from_pretrained(
+            text_to_image_models[model_name], use_auth_token=read_token, torch_dtype=torch.float16, device_map="auto"
+        )
+    pipeline = text_to_image_pipelines[model_name]
+    image = pipeline(prompt).images[0]
+    return image
+
+def generate_speech(model_name, text):
+    if model_name not in text_to_speech_pipelines:
+        logger.info(f"Loading text-to-speech model: {model_name}")
+        text_to_speech_pipelines[model_name] = pipeline(
+            "text-to-speech", model=text_to_speech_models[model_name], use_auth_token=read_token, device=device
+        )
+    pipeline = text_to_speech_pipelines[model_name]
+    audio = pipeline(text, speaker_embeddings=speaker_embeddings)
+    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 summarize_text(text):
+    result = summarization_pipeline(text)
+    return result[0]["summary_text"]
+
+def text_to_audio(text):
+    global speaker_embeddings
+    result = text_to_audio_pipeline(text, speaker_embeddings=speaker_embeddings)
+    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("## 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("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)
+    
+    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)
+
+    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 Gradio interface
+demo.launch()