Update app.py

app.py

@@ -1,23 +1,16 @@
 import gradio as gr
-from transformers import AutoModelForCausalLM, AutoTokenizer, pipeline
-from pathlib import Path
 import pandas as pd
+from transformers import pipeline
+from load_models import models_and_tokenizers, models_checkpoints
 import spaces
 
-model_checkpoint = "HuggingFaceTB/SmolLM-1.7B"
-model = AutoModelForCausalLM.from_pretrained(model_checkpoint)
-tokenizer = AutoTokenizer.from_pretrained(model_checkpoint)
+choice = {"ModelA": "", "ModelB": ""}
 
-pipe = pipeline("text-generation", model=model, tokenizer=tokenizer, max_new_tokens=512, repetition_penalty=1.5, temperature=0.5, device="cuda")
-
-
-abs_path = Path(__file__).parent
-
-df = pd.read_csv(str(abs_path / "models.csv"))
-df.to_html("tab.html")
+dff = pd.read_csv("models.csv")
+dff.to_html("tab.html")
 
 def refreshfn() -> gr.HTML:
-    df = pd.read_csv(str(abs_path / "models.csv"))
+    df = pd.read_csv("models.csv")
     df.to_html("tab.html")
     f = open("tab.html")
     content = f.read()
@@ -25,53 +18,75 @@ def refreshfn() -> gr.HTML:
     t = gr.HTML(content)
     return t
 
-def chatfn(text):
-    return text, text
+def rewrite_csv_ordered_by_winning_rate(csv_path):
+    # Read the input CSV
+    df = pd.read_csv(csv_path)
+    
+    # Sort the DataFrame by WINNING_RATE in descending order
+    df_sorted = df.sort_values(by="WINNING_RATE", ascending=False)
+    
+    # Save the sorted DataFrame to a new CSV file
+    df_sorted.to_csv(csv_path, index=False)
+
+@spaces.GPU(duration=200)
+def run_inference(pipeline, prompt):
+    response = pipeline(prompt)
+    bot_message = response[0]["generated_text"]
+    return bot_message
+
+def modelA_button():
+    global choice
+    df = pd.read_csv("models.csv")
+    df.loc[df["MODEL"] == choice["ModelA"], "MATCHES_WON"] += 1
+    df.loc[df["MODEL"] == choice["ModelA"], "WINNING_RATE"] = df.loc[df["MODEL"] == choice["ModelA"], "MATCHES_WON"]/df.loc[df["MODEL"] == choice["ModelA"], "MATCHES_PLAYED"]  
+    df.to_csv("models.csv")
+    rewrite_csv_ordered_by_winning_rate("models.csv")
+
+def modelB_button():
+    global choice
+    df = pd.read_csv("models.csv")
+    df.loc[df["MODEL"] == choice["ModelB"], "MATCHES_WON"] += 1
+    df.loc[df["MODEL"] == choice["ModelB"], "WINNING_RATE"] = df.loc[df["MODEL"] == choice["ModelB"], "MATCHES_WON"]/df.loc[df["MODEL"] == choice["ModelB"], "MATCHES_PLAYED"]  
+    df.to_csv("models.csv")
+    rewrite_csv_ordered_by_winning_rate("models.csv")
+      
+
+def reply(modelA, modelB, prompt):
+    global choice
+    choice["ModelA"] = modelA
+    choice["ModelB"] = modelB
+    df = pd.read_csv("models.csv")
+    df.loc[df["MODEL"] == modelA, "MATCHES_PLAYED"] += 1
+    df.loc[df["MODEL"] == modelB, "MATCHES_PLAYED"] += 1
+    df.to_csv("models.csv", index=False)
+    pipeA = pipeline("text-generation", model=models_and_tokenizers[modelA][0], tokenizer=models_and_tokenizers[modelA][1], max_new_tokens=512, repetition_penalty=1.5, temperature=0.5, device="cuda")
+    pipeB = pipeline("text-generation", model=models_and_tokenizers[modelB][0], tokenizer=models_and_tokenizers[modelB][1], max_new_tokens=512, repetition_penalty=1.5, temperature=0.5, device="cuda")
+    responseA = run_inference(pipeA, prompt)    
+    responseB = run_inference(pipeB, prompt)    
+    return responseA, responseB
 
-with gr.Blocks() as demo:
-    gr.Markdown("""
-    # 🥇 Leaderboard Component
-    """)
-    with gr.Tabs():
-        with gr.Tab("Demo"):
-            f = open("tab.html")
-            content = f.read()
-            f.close()
-            t = gr.HTML(content)
-            btn = gr.Button("Refresh")
-            btn.click(fn=refreshfn, inputs=None, outputs=t)
-        with gr.Tab("Chats"):
-            import random
-            import time
-            with gr.Column():
-                chatbot = gr.Chatbot()
-            with gr.Column():
-                chatbot1 = gr.Chatbot()
-            msg = gr.Textbox()
-            clear = gr.ClearButton([msg, chatbot])
-            @spaces.GPU(duration=200)
-            def respond(message, chat_history):
-                response = pipe(message)
-                bot_message = response[0]["generated_text"]
-                chat_history.append((message, bot_message))
-                return "", chat_history
+modelA_dropdown = gr.Dropdown(models_checkpoints, label="Model A", info="Choose the first model for the battle!")
+modelB_dropdown = gr.Dropdown(models_checkpoints, label="Model B", info="Choose the second model for the battle!")
+prompt_textbox = gr.Textbox(label="Prompt", value="Is pineapple pizza sacrilegious?")
 
-            import concurrent.futures
-            
-            def run_functions_simultaneously():
-                with concurrent.futures.ThreadPoolExecutor() as executor:
-                    # Submit the first function
-                    future1 = executor.submit(msg.submit, respond, [msg, chatbot], [msg, chatbot])
-                    
-                    # Submit the second function
-                    future2 = executor.submit(msg.submit, respond, [msg, chatbot1], [msg, chatbot1])
-                    
-                    # Wait for both futures to complete
-                    concurrent.futures.wait([future1, future2])
+demo0 = gr.Interface(fn=reply, inputs=[modelA_dropdown, modelB_dropdown, prompt_textbox], outputs=[gr.Markdown(label="Model A response"), gr.Markdown(label="Model B response")])
+
+with gr.Blocks() as demo1:
+    iface = demo0
+    btnA = gr.Button("Vote for Model A!") 
+    btnB = gr.Button("Vote for Model B!")
+    btnA.click(modelA_button, inputs=None, outputs=None) 
+    btnB.click(modelB_button, inputs=None, outputs=None) 
+
+with gr.Blocks() as demo2:
+    f = open("tab.html")
+    content = f.read()
+    f.close()
+    t = gr.HTML(content)
+    btn = gr.Button("Refresh")
+    btn.click(fn=refreshfn, inputs=None, outputs=t)
 
-            
-            # Call the function to run the tasks simultaneously
-            run_functions_simultaneously()
+demo = gr.TabbedInterface([demo1, demo2], ["Chat Arena", "Leaderboard"])
 
 if __name__ == "__main__":
-    demo.launch()
+    demo.launch(server_name="0.0.0.0", server_port=7860)