Update main.py

main.py

@@ -18,37 +18,35 @@ def generate_players(instruction, n):
     )
     return [c.message.content.strip() for c in response.choices]
 
-def run_tournament(instruction_input, criteria_input, n_gen,
-                   num_top_picks, pool_size, max_workers):
+def run_tournament(instruction_input, criteria_input, n_gen, num_top_picks, pool_size, max_workers):
     instruction = instruction_input.strip()
-    criteria_list = [c.strip() for c in criteria_input.split(",") if c.strip()] or [
-        "Factuality", "Instruction Following", "Precision"
-    ]
+    criteria_list = [c.strip() for c in criteria_input.split(",") if c.strip()] or ["Factuality", "Instruction Following", "Precision"]
     n_gen = int(n_gen)
     num_top_picks = int(num_top_picks)
     pool_size = int(pool_size)
     max_workers = int(max_workers)
-
+    process_log = []
+    def log(msg):
+        process_log.append(msg)
+        yield "\n".join(process_log), ""
+    yield from log("Generating players …")
+    all_players = generate_players(instruction, n_gen)
+    yield from log(f"{len(all_players)} players generated")
     def criteria_block():
         return "\n".join(f"{i + 1}) {c}" for i, c in enumerate(criteria_list))
-
     def prompt_score(player):
         prompt = f"""Evaluate the output below on the following criteria:
 {criteria_block()}
 
-Return JSON exactly like: {{"score": [{', '.join(['1-10'] * len(criteria_list))}]}}.
+Return JSON exactly like: {{\"score\": [{', '.join(['1-10'] * len(criteria_list))}]}}.
 
 Instruction:
 {instruction}
 
 Output:
 {player}"""
-        response = completion(
-            model="gpt-4o-mini",
-            messages=[{"role": "system", "content": prompt}]
-        )
+        response = completion(model="gpt-4o-mini", messages=[{"role": "system", "content": prompt}])
         return response.choices[0].message.content.strip()
-
     def score(player):
         try:
             data = json.loads(prompt_score(player))
@@ -56,12 +54,16 @@ Output:
             data = eval(prompt_score(player))
         lst = data.get("score", data.get("scores", []))
         return sum(lst) / len(lst) if lst else 0.0
-
+    yield from log("Scoring players …")
+    with ThreadPoolExecutor(max_workers=max_workers) as ex:
+        scores = {p: s for p, s in zip(all_players, list(tqdm(ex.map(score, all_players), total=len(all_players))))}
+    top_players = sorted(all_players, key=scores.get, reverse=True)[:pool_size]
+    yield from log(f"Filtered to {len(top_players)} players with best scores")
     def prompt_play(a, b):
         prompt = f"""Compare the two players below using:
 {criteria_block()}
 
-Return ONLY JSON {{"winner": "A"}} or {{"winner": "B"}}.
+Return ONLY JSON {{\"winner\": \"A\"}} or {{\"winner\": \"B\"}}.
 
 Instruction:
 {instruction}
@@ -69,26 +71,14 @@ Instruction:
 Players:
 <A>{a}</A>
 <B>{b}</B>"""
-        response = completion(
-            model="gpt-4o-mini",
-            messages=[{"role": "system", "content": prompt}]
-        )
+        response = completion(model="gpt-4o-mini", messages=[{"role": "system", "content": prompt}])
         return response.choices[0].message.content.strip()
-
     def play(a, b):
         try:
             winner_label = json.loads(prompt_play(a, b))["winner"]
         except json.JSONDecodeError:
             winner_label = eval(prompt_play(a, b)).get("winner", "A")
         return a if winner_label == "A" else b
-
-    def precompute_scores(players, executor):
-        futures = {executor.submit(score, p): p for p in players}
-        scores = {}
-        for fut in tqdm(as_completed(futures), total=len(futures)):
-            scores[futures[fut]] = fut.result()
-        return scores
-
     def tournament_round(pairs, executor):
         futures = {executor.submit(play, a, b): (a, b) for a, b in pairs}
         results = []
@@ -98,7 +88,6 @@ Players:
             loser = b if winner == a else a
             results.append((winner, loser))
         return results
-
     def tournament(players, executor):
         lost_to = {}
         current = players[:]
@@ -110,36 +99,26 @@ Players:
             if len(players) % 2 == 1:
                 current.append(players[-1])
         return current[0], lost_to
-
     def get_candidates(champion, lost_to):
         return [p for p, o in lost_to.items() if o == champion] + [champion]
-
     def playoff(candidates, executor):
         wins = {p: 0 for p in candidates}
-        pairs = [(candidates[i], candidates[j])
-                 for i in range(len(candidates))
-                 for j in range(i + 1, len(candidates))]
+        pairs = [(candidates[i], candidates[j]) for i in range(len(candidates)) for j in range(i + 1, len(candidates))]
         futures = {executor.submit(play, a, b): (a, b) for a, b in pairs}
         for fut in tqdm(as_completed(futures), total=len(futures)):
             wins[fut.result()] += 1
         return sorted(candidates, key=lambda p: wins[p], reverse=True)
-
     def get_top(players, executor):
         champion, lost_to = tournament(players, executor)
         runner_up = lost_to.get(champion)
         finalists = [champion] + ([runner_up] if runner_up else [])
-        semifinalists = [p for p, o in lost_to.items()
-                         if o in finalists and p not in finalists]
-        candidates = set(finalists + semifinalists +
-                         get_candidates(champion, lost_to))
+        semifinalists = [p for p, o in lost_to.items() if o in finalists and p not in finalists]
+        candidates = set(finalists + semifinalists + get_candidates(champion, lost_to))
         return playoff(list(candidates), executor)[:num_top_picks]
-
-    all_players = generate_players(instruction, n_gen)
+    yield from log("Running tournament …")
     with ThreadPoolExecutor(max_workers=max_workers) as ex:
-        scores = precompute_scores(all_players, ex)
-        top_players = sorted(all_players, key=scores.get, reverse=True)[:pool_size]
         top_k = get_top(top_players, ex)
-    return ", ".join(top_k)
+    yield "\n".join(process_log + ["Done"]), ", ".join(top_k)
 
 demo = gr.Interface(
     fn=run_tournament,
@@ -151,7 +130,10 @@ demo = gr.Interface(
         gr.Number(value=POOL_SIZE_DEFAULT, label="Filter Size"),
         gr.Number(value=MAX_WORKERS_DEFAULT, label="Max Workers")
     ],
-    outputs=gr.Textbox(label="Top picks")
+    outputs=[
+        gr.Textbox(lines=10, label="Process"),
+        gr.Textbox(label="Top picks")
+    ]
 )
 
 if __name__ == "__main__":