Update app.py

app.py

@@ -1,57 +1,521 @@
-import sys
-import os
 import argparse
+import datetime
+import hashlib
+import json
+import os
+import sys
 import time
-import subprocess
+import warnings
+
+import gradio as gr
 import spaces
-import gradio_web_server as gws
-
-# Execute the pip install command with additional options
-# subprocess.check_call([sys.executable, '-m', 'pip', 'install', 'flash-attn', '--no-build-isolation', '-U'])
-
-
-def start_controller():
-    print("Starting the controller")
-    controller_command = [
-        sys.executable,
-        "-m",
-        "llava.serve.controller",
-        "--host",
-        "0.0.0.0",
-        "--port",
-        "10000",
-    ]
-    print(controller_command)
-    return subprocess.Popen(controller_command)
+import torch
+
+from llava.constants import IMAGE_TOKEN_INDEX
+from llava.constants import LOGDIR
+from llava.conversation import (default_conversation, conv_templates)
+from llava.mm_utils import KeywordsStoppingCriteria, tokenizer_image_token
+from llava.model.builder import load_pretrained_model
+from llava.utils import (build_logger, violates_moderation, moderation_msg)
+from taxonomy import wrap_taxonomy, default_taxonomy
+
+
+def clear_conv(conv):
+    conv.messages = []
+    return conv
+
+
+logger = build_logger("gradio_web_server", "gradio_web_server.log")
+
+headers = {"User-Agent": "LLaVA Client"}
+
+no_change_btn = gr.Button()
+enable_btn = gr.Button(interactive=True)
+disable_btn = gr.Button(interactive=False)
+
+priority = {
+    "LlavaGuard-7B": "aaaaaaa",
+    "LlavaGuard-13B": "aaaaaab",
+    "LlavaGuard-34B": "aaaaaac",
+}
+
 
 @spaces.GPU
-def start_worker(model_path: str, model_name: str, bits=16, device=0):
-    print(f"Starting the model worker for the model {model_path}")
-    # model_name = model_path.strip("/").split("/")[-1]
-    device = f"cuda:{device}" if isinstance(device, int) else device
-    assert bits in [4, 8, 16], "It can be only loaded with 16-bit, 8-bit, and 4-bit."
-    if bits != 16:
-        model_name += f"-{bits}bit"
-    worker_command = [
-        sys.executable,
-        "-m",
-        "llava.serve.model_worker",
-        "--host",
-        "0.0.0.0",
-        "--controller",
-        "http://localhost:10000",
-        "--model-path",
-        model_path,
-        "--model-name",
-        model_name,
-        "--use-flash-attn",
-        '--device',
-        device
-    ]
-    if bits != 16:
-        worker_command += [f"--load-{bits}bit"]
-    print(worker_command)
-    return subprocess.Popen(worker_command, stdout=subprocess.PIPE, stderr=subprocess.PIPE)
+def run_llava(prompt, pil_image):
+    image_size = pil_image.size
+    image_tensor = image_processor.preprocess(pil_image, return_tensors='pt')['pixel_values'].half().cuda()
+    # images_tensor = load_images(images, image_processor)
+    image_tensor = image_tensor.to(model.device, dtype=torch.float16)
+    input_ids = tokenizer_image_token(prompt, tokenizer, IMAGE_TOKEN_INDEX, return_tensors="pt")
+    input_ids = input_ids.unsqueeze(0).cuda()
+    with torch.inference_mode():
+        output_ids = model.generate(
+            input_ids,
+            images=image_tensor,
+            image_sizes=[image_size],
+            do_sample=True,
+            temperature=0.2,
+            top_p=0.95,
+            top_k=50,
+            num_beams=2,
+            max_new_tokens=1024,
+            use_cache=True,
+            stopping_criteria=[KeywordsStoppingCriteria(['}'], tokenizer, input_ids)]
+        )
+    outputs = tokenizer.batch_decode(output_ids, skip_special_tokens=True)
+
+    return outputs[0].strip()
+
+
+def get_conv_log_filename():
+    t = datetime.datetime.now()
+    name = os.path.join(LOGDIR, f"{t.year}-{t.month:02d}-{t.day:02d}-conv.json")
+    return name
+
+
+def get_model_list():
+    # ret = requests.post(args.controller_url + "/refresh_all_workers")
+    # assert ret.status_code == 200
+    # ret = requests.post(args.controller_url + "/list_models")
+    # logger.info(f"get_model_list: {ret.json()}")
+    # models = ret.json()["models"]
+    # models.sort(key=lambda x: priority.get(x, x))
+    # logger.info(f"Models: {models}")
+    models = [
+        'LukasHug/LlavaGuard-7B-hf',
+        'LukasHug/LlavaGuard-13B-hf',
+        'LukasHug/LlavaGuard-34B-hf', ][:1]
+    return models
+
+
+get_window_url_params = """
+function() {
+    const params = new URLSearchParams(window.location.search);
+    url_params = Object.fromEntries(params);
+    console.log(url_params);
+    return url_params;
+    }
+"""
+
+
+def load_demo(url_params, request: gr.Request):
+    logger.info(f"load_demo. ip: {request.client.host}. params: {url_params}")
+
+    dropdown_update = gr.Dropdown(visible=True)
+    if "model" in url_params:
+        model = url_params["model"]
+        if model in models:
+            dropdown_update = gr.Dropdown(value=model, visible=True)
+
+    state = default_conversation.copy()
+    return state, dropdown_update
+
+
+def load_demo_refresh_model_list(request: gr.Request):
+    logger.info(f"load_demo. ip: {request.client.host}")
+    models = get_model_list()
+    state = default_conversation.copy()
+    dropdown_update = gr.Dropdown(
+        choices=models,
+        value=models[0] if len(models) > 0 else ""
+    )
+    return state, dropdown_update
+
+
+def vote_last_response(state, vote_type, model_selector, request: gr.Request):
+    with open(get_conv_log_filename(), "a") as fout:
+        data = {
+            "tstamp": round(time.time(), 4),
+            "type": vote_type,
+            "model": model_selector,
+            "state": state.dict(),
+            "ip": request.client.host,
+        }
+        fout.write(json.dumps(data) + "\n")
+
+
+def upvote_last_response(state, model_selector, request: gr.Request):
+    logger.info(f"upvote. ip: {request.client.host}")
+    vote_last_response(state, "upvote", model_selector, request)
+    return ("",) + (disable_btn,) * 3
+
+
+def downvote_last_response(state, model_selector, request: gr.Request):
+    logger.info(f"downvote. ip: {request.client.host}")
+    vote_last_response(state, "downvote", model_selector, request)
+    return ("",) + (disable_btn,) * 3
+
+
+def flag_last_response(state, model_selector, request: gr.Request):
+    logger.info(f"flag. ip: {request.client.host}")
+    vote_last_response(state, "flag", model_selector, request)
+    return ("",) + (disable_btn,) * 3
+
+
+def regenerate(state, image_process_mode, request: gr.Request):
+    logger.info(f"regenerate. ip: {request.client.host}")
+    state.messages[-1][-1] = None
+    prev_human_msg = state.messages[-2]
+    if type(prev_human_msg[1]) in (tuple, list):
+        prev_human_msg[1] = (*prev_human_msg[1][:2], image_process_mode)
+    state.skip_next = False
+    return (state, state.to_gradio_chatbot(), "", None) + (disable_btn,) * 5
+
+
+def clear_history(request: gr.Request):
+    logger.info(f"clear_history. ip: {request.client.host}")
+    state = default_conversation.copy()
+    return (state, state.to_gradio_chatbot(), "", None) + (disable_btn,) * 5
+
+
+def add_text(state, text, image, image_process_mode, request: gr.Request):
+    logger.info(f"add_text. ip: {request.client.host}. len: {len(text)}")
+    if len(text) <= 0 or image is None:
+        state.skip_next = True
+        return (state, state.to_gradio_chatbot(), "", None) + (no_change_btn,) * 5
+    if args.moderate:
+        flagged = violates_moderation(text)
+        if flagged:
+            state.skip_next = True
+            return (state, state.to_gradio_chatbot(), moderation_msg, None) + (
+                no_change_btn,) * 5
+
+    text = wrap_taxonomy(text)
+    if image is not None:
+        text = text  # Hard cut-off for images
+        if '<image>' not in text:
+            # text = '<Image><image></Image>' + text
+            text = text + '\n<image>'
+        text = (text, image, image_process_mode)
+        state = default_conversation.copy()
+    state = clear_conv(state)
+    state.append_message(state.roles[0], text)
+    state.append_message(state.roles[1], None)
+    state.skip_next = False
+    return (state, state.to_gradio_chatbot(), default_taxonomy, None) + (disable_btn,) * 5
+
+
+def llava_bot(state, model_selector, temperature, top_p, max_new_tokens, request: gr.Request):
+    start_tstamp = time.time()
+    model_name = model_selector
+
+    if state.skip_next:
+        # This generate call is skipped due to invalid inputs
+        yield (state, state.to_gradio_chatbot()) + (no_change_btn,) * 5
+        return
+
+    if len(state.messages) == state.offset + 2:
+        # First round of conversation
+        if "llava" in model_name.lower():
+            if 'llama-2' in model_name.lower():
+                template_name = "llava_llama_2"
+            elif "mistral" in model_name.lower() or "mixtral" in model_name.lower():
+                if 'orca' in model_name.lower():
+                    template_name = "mistral_orca"
+                elif 'hermes' in model_name.lower():
+                    template_name = "chatml_direct"
+                else:
+                    template_name = "mistral_instruct"
+            elif 'llava-v1.6-34b' in model_name.lower():
+                template_name = "chatml_direct"
+            elif "v1" in model_name.lower():
+                if 'mmtag' in model_name.lower():
+                    template_name = "v1_mmtag"
+                elif 'plain' in model_name.lower() and 'finetune' not in model_name.lower():
+                    template_name = "v1_mmtag"
+                else:
+                    template_name = "llava_v1"
+            elif "mpt" in model_name.lower():
+                template_name = "mpt"
+            else:
+                if 'mmtag' in model_name.lower():
+                    template_name = "v0_mmtag"
+                elif 'plain' in model_name.lower() and 'finetune' not in model_name.lower():
+                    template_name = "v0_mmtag"
+                else:
+                    template_name = "llava_v0"
+        elif "mpt" in model_name:
+            template_name = "mpt_text"
+        elif "llama-2" in model_name:
+            template_name = "llama_2"
+        else:
+            template_name = "vicuna_v1"
+        new_state = conv_templates[template_name].copy()
+        new_state.append_message(new_state.roles[0], state.messages[-2][1])
+        new_state.append_message(new_state.roles[1], None)
+        state = new_state
+
+    # Query worker address
+    # controller_url = args.controller_url
+    # ret = requests.post(controller_url + "/get_worker_address",
+    #                     json={"model": model_name})
+    # worker_addr = ret.json()["address"]
+    # logger.info(f"model_name: {model_name}, worker_addr: {worker_addr}")
+
+    # No available worker
+    # if worker_addr == "":
+    #     state.messages[-1][-1] = server_error_msg
+    #     yield (state, state.to_gradio_chatbot(), disable_btn, disable_btn, disable_btn, enable_btn, enable_btn)
+    #     return
+
+    # Construct prompt
+    prompt = state.get_prompt()
+
+    all_images = state.get_images(return_pil=True)
+    all_image_hash = [hashlib.md5(image.tobytes()).hexdigest() for image in all_images]
+    for image, hash in zip(all_images, all_image_hash):
+        t = datetime.datetime.now()
+        filename = os.path.join(LOGDIR, "serve_images", f"{t.year}-{t.month:02d}-{t.day:02d}", f"{hash}.jpg")
+        if not os.path.isfile(filename):
+            os.makedirs(os.path.dirname(filename), exist_ok=True)
+            image.save(filename)
+
+    output = run_llava(prompt, all_images[0])
+
+    state.messages[-1][-1] = output
+
+    # Make requests
+    # pload = {
+    #     "model": model_name,
+    #     "prompt": prompt,
+    #     "temperature": float(temperature),
+    #     "top_p": float(top_p),
+    #     # "num_beams": 2,
+    #     # "top_k": 50,
+    #     "max_new_tokens": min(int(max_new_tokens), 1536),
+    #     "stop": state.sep if state.sep_style in [SeparatorStyle.SINGLE, SeparatorStyle.MPT] else state.sep2,
+    #     "images": f'List of {len(state.get_images())} images: {all_image_hash}',
+    # }
+    # logger.info(f"==== request ====\n{pload}")
+    #
+    # pload['images'] = state.get_images()
+
+    # state.messages[-1][-1] = "▌"
+
+    yield (state, state.to_gradio_chatbot()) + (disable_btn,) * 5
+
+    # try:
+    #     # Stream output
+    #     response = requests.post(worker_addr + "/worker_generate_stream",
+    #                              headers=headers, json=pload, stream=True, timeout=10)
+    #     for chunk in response.iter_lines(decode_unicode=False, delimiter=b"\0"):
+    #         if chunk:
+    #             data = json.loads(chunk.decode())
+    #             if data["error_code"] == 0:
+    #                 output = data["text"][len(prompt):].strip()
+    #                 state.messages[-1][-1] = output + "▌"
+    #                 yield (state, state.to_gradio_chatbot()) + (disable_btn,) * 5
+    #             else:
+    #                 output = data["text"] + f" (error_code: {data['error_code']})"
+    #                 state.messages[-1][-1] = output
+    #                 yield (state, state.to_gradio_chatbot()) + (
+    #                     disable_btn, disable_btn, disable_btn, enable_btn, enable_btn)
+    #                 return
+    #             time.sleep(0.03)
+    # except requests.exceptions.RequestException as e:
+    #     state.messages[-1][-1] = server_error_msg
+    #     yield (state, state.to_gradio_chatbot()) + (disable_btn, disable_btn, disable_btn, enable_btn, enable_btn)
+    #     return
+    #
+    # state.messages[-1][-1] = state.messages[-1][-1][:-1]
+    # yield (state, state.to_gradio_chatbot()) + (enable_btn,) * 5
+
+    finish_tstamp = time.time()
+    logger.info(f"{output}")
+
+    with open(get_conv_log_filename(), "a") as fout:
+        data = {
+            "tstamp": round(finish_tstamp, 4),
+            "type": "chat",
+            "model": model_name,
+            "start": round(start_tstamp, 4),
+            "finish": round(finish_tstamp, 4),
+            "state": state.dict(),
+            "images": all_image_hash,
+            "ip": request.client.host,
+        }
+        fout.write(json.dumps(data) + "\n")
+
+
+title_markdown = ("""
+# LLAVAGUARD: VLM-based Safeguard for Vision Dataset Curation and Safety Assessment
+[[Project Page](https://ml-research.github.io/human-centered-genai/projects/llavaguard/index.html)]
+[[Code](https://github.com/ml-research/LlavaGuard)]
+[[Model](https://huggingface.co/collections/AIML-TUDA/llavaguard-665b42e89803408ee8ec1086)]
+[[Dataset](https://huggingface.co/datasets/aiml-tuda/llavaguard)]
+[[LavaGuard](https://arxiv.org/abs/2406.05113)]
+""")
+
+tos_markdown = ("""
+### Terms of use
+By using this service, users are required to agree to the following terms:
+The service is a research preview intended for non-commercial use only. It only provides limited safety measures and may generate offensive content. It must not be used for any illegal, harmful, violent, racist, or sexual purposes. The service may collect user dialogue data for future research.
+Please click the "Flag" button if you get any inappropriate answer! We will collect those to keep improving our moderator.
+For an optimal experience, please use desktop computers for this demo, as mobile devices may compromise its quality.
+""")
+
+learn_more_markdown = ("""
+### License
+The service is a research preview intended for non-commercial use only, subject to the model [License](https://github.com/facebookresearch/llama/blob/main/MODEL_CARD.md) of LLaMA, [Terms of Use](https://openai.com/policies/terms-of-use) of the data generated by OpenAI, and [Privacy Practices](https://chrome.google.com/webstore/detail/sharegpt-share-your-chatg/daiacboceoaocpibfodeljbdfacokfjb) of ShareGPT. Please contact us if you find any potential violation.
+""")
+
+block_css = """
+
+#buttons button {
+    min-width: min(120px,100%);
+}
+
+"""
+
+taxonomies = ["Default", "Modified w/ O1 non-violating", "Default message 3"]
+
+
+def build_demo(embed_mode, cur_dir=None, concurrency_count=10):
+    with gr.Accordion("Safety Risk Taxonomy", open=False) as accordion:
+        textbox = gr.Textbox(
+            label="Safety Risk Taxonomy",
+            show_label=True,
+            placeholder="Enter your safety policy here",
+            container=True,
+            value=default_taxonomy,
+            lines=50)
+    with gr.Blocks(title="LlavaGuard", theme=gr.themes.Default(), css=block_css) as demo:
+        state = gr.State()
+
+        if not embed_mode:
+            gr.Markdown(title_markdown)
+
+        with gr.Row():
+            with gr.Column(scale=3):
+                with gr.Row(elem_id="model_selector_row"):
+                    model_selector = gr.Dropdown(
+                        choices=models,
+                        value=models[0] if len(models) > 0 else "",
+                        interactive=True,
+                        show_label=False,
+                        container=False)
+
+                imagebox = gr.Image(type="pil", label="Image", container=False)
+                image_process_mode = gr.Radio(
+                    ["Crop", "Resize", "Pad", "Default"],
+                    value="Default",
+                    label="Preprocess for non-square image", visible=False)
+
+                if cur_dir is None:
+                    cur_dir = os.path.dirname(os.path.abspath(__file__))
+                gr.Examples(examples=[
+                    [f"{cur_dir}/examples/image{i}.png"] for i in range(1, 6)
+                ], inputs=imagebox)
+
+                with gr.Accordion("Parameters", open=False) as parameter_row:
+                    temperature = gr.Slider(minimum=0.0, maximum=1.0, value=0.2, step=0.1, interactive=True,
+                                            label="Temperature", )
+                    top_p = gr.Slider(minimum=0.0, maximum=1.0, value=0.95, step=0.1, interactive=True, label="Top P", )
+                    max_output_tokens = gr.Slider(minimum=0, maximum=1024, value=512, step=64, interactive=True,
+                                                  label="Max output tokens", )
+
+            with gr.Column(scale=8):
+                chatbot = gr.Chatbot(
+                    elem_id="chatbot",
+                    label="LLavaGuard Safety Assessment",
+                    height=650,
+                    layout="panel",
+                )
+                with gr.Row():
+                    with gr.Column(scale=8):
+                        textbox.render()
+                    with gr.Column(scale=1, min_width=50):
+                        submit_btn = gr.Button(value="Send", variant="primary")
+                with gr.Row(elem_id="buttons") as button_row:
+                    upvote_btn = gr.Button(value="👍  Upvote", interactive=False)
+                    downvote_btn = gr.Button(value="👎  Downvote", interactive=False)
+                    flag_btn = gr.Button(value="⚠️  Flag", interactive=False)
+                    # stop_btn = gr.Button(value="⏹️  Stop Generation", interactive=False)
+                    regenerate_btn = gr.Button(value="🔄  Regenerate", interactive=False)
+                    clear_btn = gr.Button(value="🗑️  Clear", interactive=False)
+
+        if not embed_mode:
+            gr.Markdown(tos_markdown)
+            gr.Markdown(learn_more_markdown)
+        url_params = gr.JSON(visible=False)
+
+        # Register listeners
+        btn_list = [upvote_btn, downvote_btn, flag_btn, regenerate_btn, clear_btn]
+        upvote_btn.click(
+            upvote_last_response,
+            [state, model_selector],
+            [textbox, upvote_btn, downvote_btn, flag_btn]
+        )
+        downvote_btn.click(
+            downvote_last_response,
+            [state, model_selector],
+            [textbox, upvote_btn, downvote_btn, flag_btn]
+        )
+        flag_btn.click(
+            flag_last_response,
+            [state, model_selector],
+            [textbox, upvote_btn, downvote_btn, flag_btn]
+        )
+
+        regenerate_btn.click(
+            regenerate,
+            [state, image_process_mode],
+            [state, chatbot, textbox, imagebox] + btn_list
+        ).then(
+            llava_bot,
+            [state, model_selector, temperature, top_p, max_output_tokens],
+            [state, chatbot] + btn_list,
+            concurrency_limit=concurrency_count
+        )
+
+        clear_btn.click(
+            clear_history,
+            None,
+            [state, chatbot, textbox, imagebox] + btn_list,
+            queue=False
+        )
+
+        textbox.submit(
+            add_text,
+            [state, textbox, imagebox, image_process_mode],
+            [state, chatbot, textbox, imagebox] + btn_list,
+            queue=False
+        ).then(
+            llava_bot,
+            [state, model_selector, temperature, top_p, max_output_tokens],
+            [state, chatbot] + btn_list,
+            concurrency_limit=concurrency_count
+        )
+
+        submit_btn.click(
+            add_text,
+            [state, textbox, imagebox, image_process_mode],
+            [state, chatbot, textbox, imagebox] + btn_list
+        ).then(
+            llava_bot,
+            [state, model_selector, temperature, top_p, max_output_tokens],
+            [state, chatbot] + btn_list,
+            concurrency_limit=concurrency_count
+        )
+
+        if args.model_list_mode == "once":
+            demo.load(
+                load_demo,
+                [url_params],
+                [state, model_selector],
+                js=get_window_url_params
+            )
+        elif args.model_list_mode == "reload":
+            demo.load(
+                load_demo_refresh_model_list,
+                None,
+                [state, model_selector],
+                queue=False
+            )
+        else:
+            raise ValueError(f"Unknown model list mode: {args.model_list_mode}")
+
+    return demo
 
 
 if __name__ == "__main__":
@@ -64,10 +528,10 @@ if __name__ == "__main__":
     parser.add_argument("--share", action="store_true")
     parser.add_argument("--moderate", action="store_true")
     parser.add_argument("--embed", action="store_true")
-    gws.args = parser.parse_args()
-    gws.models = []
+    args = parser.parse_args()
+    models = []
 
-    gws.title_markdown += """
+    title_markdown += """
 
 ONLY WORKS WITH GPU!
 
@@ -77,9 +541,9 @@ Set the environment variable `model` to change the model:
 ['AIML-TUDA/LlavaGuard-34B'](https://huggingface.co/AIML-TUDA/LlavaGuard-34B),
 """
     # set_up_env_and_token(read=True)
-    print(f"args: {gws.args}")
+    print(f"args: {args}")
     # set the huggingface login token
-    controller_proc = start_controller()
+    # controller_proc = start_controller()
     concurrency_count = int(os.getenv("concurrency_count", 5))
     api_key = os.getenv("token")
     if api_key:
@@ -89,40 +553,42 @@ Set the environment variable `model` to change the model:
         if '/workspace' not in sys.path:
             sys.path.append('/workspace')
         from llavaguard.hf_utils import set_up_env_and_token
-        set_up_env_and_token(read=True, write=False)
+
+        api_key = set_up_env_and_token(read=True, write=False)
 
     models = [
         'LukasHug/LlavaGuard-7B-hf',
         'LukasHug/LlavaGuard-13B-hf',
-        'LukasHug/LlavaGuard-34B-hf',]
+        'LukasHug/LlavaGuard-34B-hf', ]
     bits = int(os.getenv("bits", 16))
     model = os.getenv("model", models[0])
     available_devices = os.getenv("CUDA_VISIBLE_DEVICES", "0")
     model_path, model_name = model, model.split("/")[1]
+    # model_path = '/common-repos/LlavaGuard/models/LlavaGuard-v1.1-7b-full/smid_and_crawled_v2_with_augmented_policies/json-v12/llava'
+
 
-    worker_proc = start_worker(model_path, model_name, bits=bits)
+    print(f"Loading model {model_path}")
+    tokenizer, model, image_processor, context_len = load_pretrained_model(model_path, None, model_name, token=api_key)
 
+    model.config.tokenizer_model_max_length = 2048 * 2
 
     # Wait for worker and controller to start
-    time.sleep(50)
+    # time.sleep(10)
 
     exit_status = 0
     try:
-        demo = gws.build_demo(embed_mode=False, cur_dir='./', concurrency_count=concurrency_count)
+        demo = build_demo(embed_mode=False, cur_dir='./', concurrency_count=concurrency_count)
         demo.queue(
             status_update_rate=10,
             api_open=False
         ).launch(
-            server_name=gws.args.host,
-            server_port=gws.args.port,
-            share=gws.args.share
+            server_name=args.host,
+            server_port=args.port,
+            share=args.share
         )
 
     except Exception as e:
         print(e)
         exit_status = 1
     finally:
-        worker_proc.kill()
-        controller_proc.kill()
-
-        sys.exit(exit_status)
+        sys.exit(exit_status)