Add gradio app and monsterapi v2 client for SD Comparison gradio app.

MonsterAPIClient.py

@@ -0,0 +1,178 @@
+#MonsterAPIClient.py
+
+"""
+Monster API Python client to connect to LLM models on monsterapi
+
+Base URL: https://api.monsterapi.ai/v1/generate/{model}
+
+Available models:
+-----------------
+
+LLMs:
+    1. falcon-7b-instruct
+    2. falcon-40b-instruct
+    3. mpt-30B-instruct
+    4. mpt-7b-instruct
+    5. openllama-13b-base
+    6. llama2-7b-chat
+
+Text to Image:
+    1. stable-diffusion v1.5
+    2. stable-diffusion XL V1.0
+
+"""
+import os
+import time
+import logging
+import requests
+from requests_toolbelt.multipart.encoder import MultipartEncoder
+
+from typing import Optional, Literal, Union, List, Dict
+from pydantic import BaseModel, Field
+
+logging.basicConfig(level=logging.INFO)
+logger = logging.getLogger(__name__)
+
+
+class LLMInputModel1(BaseModel):
+    """
+    Supports Following models: Falcon-40B-instruct, Falcon-7B-instruct, openllama-13b-base, llama2-7b-chat
+
+    prompt	string	Prompt is a textual instruction for the model to produce an output.	Required
+    top_k	integer	Top-k sampling helps improve quality by removing the tail and making it less likely to go off topic.	Optional
+    (Default: 40)
+    top_p	float	Top-p sampling helps generate more diverse and creative text by considering a broader range of tokens.	Optional
+    (Default: 1.0)
+    temp	float	The temperature influences the randomness of the next token predictions.	Optional
+    (Default: 0.98)
+    max_length	integer	The maximum length of the generated text.	Optional
+    (Default: 256)
+    repetition_penalty	float	The model uses this penalty to discourage the repetition of tokens in the output.	Optional
+    (Default: 1.2)
+    beam_size	integer	The beam size for beam search. A larger beam size results in better quality output, but slower generation times.	Optional
+    (Default: 1)    
+    """
+    prompt: str
+    top_k: int = 40
+    top_p: float = Field(0.9, ge=0., le=1.)
+    temp: float = Field(0.98, ge=0., le=1.)
+    max_length: int = 256
+    repetition_penalty: float = 1.2
+    beam_size: int = 1
+
+
+class LLMInputModel2(BaseModel):
+    """
+    Supports Following models: MPT-30B-instruct, MPT-7B-instruct
+
+    prompt:	string	Instruction is a textual command for the model to produce an output.	Required
+    top_k	integer	Top-k sampling helps improve quality by removing the tail and making it less likely to go off topic.	Optional
+    (Default: 40)
+    top_p	float	Top-p sampling helps generate more diverse and creative text by considering a broader range of tokens.	Optional
+    Allowed Range: 0 - 1
+    (Default: 1.0)
+    temp	float	Temperature is a parameter that controls the randomness of the model's output. The higher the temperature, the more random the output.	Optional
+    (Default: 0.98)
+    max_length	integer	Maximum length of the generated output.	Optional
+    (Default: 256)
+    """
+    prompt: str
+    top_k: int = 40
+    top_p: float = Field(0.9, ge=0., le=1.)
+    temp: float = Field(0.98, ge=0., le=1.)
+    max_length: int = 256
+
+class SDInputModel(BaseModel):
+    """
+    Support following models: text2img, text2img-sdxl
+
+    prompt:	string	Your input text prompt	Required
+    negprompt:	string	Negative text prompt	Optional
+    samples:	integer	No. of images to be generated. Allowed range: 1-4	Optional
+    (Default: 1)
+    steps:	integer	Sampling steps per image. Allowed range 30-500	Optional
+    (Default: 30)
+    aspect_ratio: string.  Allowed values: square, landscape, portrait	Optional
+    (Default: square)
+    guidance_scale:	float.	Prompt guidance scale	Optional
+    (Default: 7.5)
+    seed:	integer	Random number used to initialize the image generation.	Optional
+    (Default: random)
+    """
+    prompt: str
+    negprompt: Optional[str] = ""
+    samples: Optional[int] = Field(1, ge=1, le=4)
+    steps: Optional[int] = Field(30, ge=30, le=500)
+    aspect_ratio: Optional[Literal['square', 'landscape', 'portrait']] = 'square'
+    guidance_scale: Optional[float] = 7.5
+    seed: Optional[int] = None
+
+
+MODELS_TO_DATAMODEL = {
+            'falcon-7b-instruct': LLMInputModel1,
+            'falcon-40b-instruct': LLMInputModel1,
+            'mpt-30B-instruct': LLMInputModel2,
+            'mpt-7b-instruct': LLMInputModel2,
+            'openllama-13b-base': LLMInputModel1,
+            'llama2-7b-chat': LLMInputModel1,
+            "sdxl-base": SDInputModel,
+            "txt2img": SDInputModel
+        }
+
+
+class MClient():
+    def __init__(self):
+        self.boundary = '---011000010111000001101001'
+        self.auth_token = os.environ.get('MONSTER_API_KEY')
+        self.headers = {
+            "accept": "application/json",
+            "content-type": f"multipart/form-data; boundary={self.boundary}",
+            'Authorization': 'Bearer ' + self.auth_token}
+        self.base_url = 'https://api.monsterapi.ai/v1'
+        self.models_to_data_model = MODELS_TO_DATAMODEL
+        self.mock = os.environ.get('MOCK_Runner', "False").lower() == "true"
+
+    def get_response(self, model:Literal['falcon-7b-instruct', 'falcon-40b-instruct', 'mpt-30B-instruct', 'mpt-7b-instruct', 'openllama-13b-base', 'llama2-7b-chat'], 
+                     data: dict):
+    
+        if model not in self.models_to_data_model:
+            raise ValueError(f"Invalid model: {model}!")
+
+        dataModel = self.models_to_data_model[model](**data)
+        url = f"{self.base_url}/generate/{model}"
+        data = dataModel.dict()
+        logger.info(f"Calling Monster API with url: {url}, with payload: {data}")
+
+        # convert all values into string
+        for key, value in data.items():
+            data[key] = str(value)
+        multipart_data = MultipartEncoder(fields=data, boundary=self.boundary)
+        response = requests.post(url, headers=self.headers, data=multipart_data)
+        response.raise_for_status()
+        return response.json()
+    
+    def get_status(self, process_id):
+        # /v1/status/{process_id}
+        url = f"{self.base_url}/status/{process_id}"
+        response = requests.get(url, headers=self.headers)
+        response.raise_for_status()
+        return response.json()
+    
+    def wait_and_get_result(self, process_id, timeout=100):
+        start_time = time.time()
+        while True:
+            elapsed_time = time.time() - start_time
+
+            if elapsed_time >= timeout:
+                raise TimeoutError(f"Process {process_id} timed out after {timeout} seconds.")
+
+            status = self.get_status(process_id)
+            if status['status'].lower() == 'completed':
+                return status['result']
+            elif status['status'].lower() == 'failed':
+                raise RuntimeError(f"Process {process_id} failed! {status}")
+            else:
+                if self.mock:
+                    return 100 * "Mock Output!"
+                logger.info(f"Process {process_id} is still running, status is {status['status']}. Waiting ...")
+                time.sleep(0.01)

app.py

@@ -0,0 +1,89 @@
+import random
+import gradio as gr
+import requests
+from concurrent.futures import ThreadPoolExecutor
+from MonsterAPIClient import MClient
+from typing import Tuple
+
+client = MClient()
+
+def generate_model_output(model: str, input_text: str, neg_prompt: str, samples: int, steps: int,
+                          aspect_ratio: str, guidance_scale: float, random_seed: str) -> str:
+    """
+    Generate output from a specific model.
+
+    Parameters:
+        model (str): The name of the model.
+        input_text (str): Your input text prompt.
+        neg_prompt (str): Negative text prompt.
+        samples (int): No. of images to be generated.
+        steps (int): Sampling steps per image.
+        aspect_ratio (str): Aspect ratio of the generated image.
+        guidance_scale (float): Prompt guidance scale.
+        random_seed (str): Random number used to initialize the image generation.
+
+    Returns:
+        str: The generated output text or image URL.
+    """
+    try:
+        response = client.get_response(model, {
+            "prompt": input_text,
+            "negprompt": neg_prompt,
+            "samples": samples,
+            "steps": steps,
+            "aspect_ratio": aspect_ratio,
+            "guidance_scale": guidance_scale,
+            "seed": random_seed,
+        })
+        output = client.wait_and_get_result(response['process_id'])
+        if 'output' in output:
+            return output['output']
+        else:
+            return "No output available."
+    except Exception as e:
+        return f"Error occurred: {str(e)}"
+
+def generate_output(input_text: str, neg_prompt: str, samples: int, steps: int,
+                    aspect_ratio: str, guidance_scale: float, random_seed: str):
+    with ThreadPoolExecutor() as executor:
+        # Schedule the function calls asynchronously
+        future_sdxl_base = executor.submit(generate_model_output, 'sdxl-base', input_text, neg_prompt, samples, steps,
+                                           aspect_ratio, guidance_scale, random_seed)
+        future_txt2img = executor.submit(generate_model_output, 'txt2img', input_text, neg_prompt, samples, steps,
+                                         aspect_ratio, guidance_scale, random_seed)
+        
+        # Get the results from the completed futures
+        sdxl_base_output = future_sdxl_base.result()
+        txt2img_output = future_txt2img.result()
+    
+    return [sdxl_base_output, txt2img_output]
+
+# Function to stitch
+
+
+input_components = [
+    gr.inputs.Textbox(label="Input Prompt"),
+    gr.inputs.Textbox(label="Negative Prompt"),
+    gr.inputs.Slider(label="No. of Images to Generate", minimum=1, maximum=3, default=1),
+    gr.inputs.Slider(label="Sampling Steps per Image", minimum=30, maximum=40, default=30),
+    gr.inputs.Dropdown(label="Aspect Ratio", choices=["square", "landscape", "portrait"], default="square"),
+    gr.inputs.Slider(label="Prompt Guidance Scale", minimum=0.1, maximum=20.0, default=7.5),
+    gr.inputs.Textbox(label="Random Seed", default=random.randint(0, 1000000)),
+]
+
+output_component_sdxl_base = gr.Gallery(label="Stable Diffusion V2.0 Output", type="pil", container = True)
+output_component_txt2img = gr.Gallery(label="Stable Diffusion V1.5 Output", type="pil", container = True)
+
+interface = gr.Interface(
+    fn=generate_output,
+    inputs=input_components,
+    outputs=[output_component_sdxl_base, output_component_txt2img],
+    live=False,
+    capture_session=True,
+    title="Stable Diffusion Evaluation powered by MonsterAPI",
+    description="""This HuggingFace Space has been designed to help you compare the outputs between Stable-Diffusion V1.5 vs V2.0. These models are hosted on [MonsterAPI](https://monsterapi.ai/?utm_source=llm-evaluation&utm_medium=referral) - An AI infrastructure platform built for easily accessing AI models via scalable APIs and [finetuning LLMs](https://docs.monsterapi.ai/fine-tune-a-large-language-model-llm) at very low cost with our no-code implementation. MonsterAPI is powered by our low cost and highly scalable GPU computing platform - [Q Blocks](https://www.qblocks.cloud?utm_source=llm-evaluation&utm_medium=referral). These LLMs are accessible via scalable REST APIs. Checkout our [API documentation](https://documenter.getpostman.com/view/13759598/2s8ZDVZ3Yi) to integrate them in your AI powered applications.""",
+    css="body {background-color: black}"
+)
+
+# Launch the Gradio app
+interface.launch()