LT

Q_app_llm_pairs_gen.py

@@ -138,7 +138,7 @@ with gr.Blocks() as app:
 
         solutions_model_selector = gr.Dropdown(
             choices=solutions_model_options,
-            value=solutions_model_options[4],
+            value=solutions_model_options[1],
             label="Select Solution Model"
         )
 

Q_quantum_utils.py

@@ -426,7 +426,7 @@ def generate_dynamic_prompt(selected_domains):
         raise ValueError("No domains selected. Please select at least one domain.")
     # Select a single domain randomly
     selected_domain = random.choice(selected_domains)
-    print("Selected Domain:", selected_domain)
+    
     # Retrieve the description and template
     domain_details = quantum_problem_domains[selected_domain]
     domain_description = domain_details["description"]
@@ -485,30 +485,37 @@ def generate_problem(pair_id, model_name, selected_domains):
         conn.close()
         
         # print(response)
-        return response
+        return response, selected_domain
     except Exception as e:
         print(f"Error generating problem {pair_id}: {e}")
-        return None
+        return None, None
 
-# Generate multiple problems with progress
 def generate_multiple_problems(num_pairs, selected_domains):
     if not selected_domains:
         return "Please select at least one domain type."
-        
+    
     conn = duckdb.connect(database=DB_FILE)
     current_count = conn.execute("SELECT COUNT(*) FROM problems").fetchone()[0]
     conn.close()
 
+    # Prepare a descriptive header for TQDM
+    model_name = selected_model.split("/")[-1]
+    domain_list = ", ".join(selected_domains[:3])  # Include up to 3 domains for brevity
+    
+    tqdm_desc = f"Generating Instructions - Model: {model_name} | Total: {num_pairs}"
+    
     responses = []
-    with tqdm(total=num_pairs, desc="Generating Problems", unit="problem") as pbar:
+    with tqdm(total=num_pairs, desc=tqdm_desc, unit="problem") as pbar:
         for i in range(num_pairs):
-            response = generate_problem(current_count + i + 1, selected_model, selected_domains)
+            response, selected_domain = generate_problem(current_count + i + 1, selected_model, selected_domains)
             if response:
                 responses.append(response)
+            pbar.set_postfix_str(f"Last Domain: {selected_domain}")  # Updates progress bar with last domain
             pbar.update(1)
-            print ("Generated PRB:{}",i)
+            
     return "\n\n".join(responses)
 
+
 def generate_solutions_pqt(solution_model_name):
     df = load_parquet()
     unsolved_problems = df[df["solution"].isna()]
@@ -548,7 +555,6 @@ def generate_solutions_pqt(solution_model_name):
             pbar.update(1)
     return "Solutions generated successfully!"
 
-# Function to generate solutions for unsolved problems
 def generate_solutions(solution_model_name):
     conn = duckdb.connect(database=DB_FILE)
     problems = conn.execute("SELECT uuid, problem FROM problems WHERE solution IS NULL").fetchall()
@@ -556,7 +562,12 @@ def generate_solutions(solution_model_name):
     if not problems:
         return "No unsolved problems found in the database."
 
-    with tqdm(total=len(problems), desc="Generating Solutions", unit="solution") as pbar:
+    # Prepare a descriptive header for TQDM
+    model_name = solution_model_name.split("/")[-1]
+    total_problems = len(problems)
+    tqdm_desc = f"Solution Model: {model_name} | Total Problems: {total_problems}"
+
+    with tqdm(total=total_problems, desc=tqdm_desc, unit="solution") as pbar:
         for problem_id, problem_text in problems:
             try:
                 solution_prompt = RESPONSE_SOLUTION_LLM_USR_PROMPT.format(problem=problem_text)
@@ -581,17 +592,22 @@ def generate_solutions(solution_model_name):
                 ]
                 solution = solution_tokenizer.batch_decode(generated_ids, skip_special_tokens=True)[0]
 
+                # Update the database with the generated solution
                 conn.execute("""
                     UPDATE problems
                     SET solution = ?, solution_model_name = ?
                     WHERE uuid = ?
-                """, (solution, solution_model_name.split("/")[-1], problem_id))
+                """, (solution, model_name, problem_id))
+                
+                # Update progress bar with the last processed problem ID
+                pbar.set_postfix_str(f"Last Problem UUID: {problem_id}")
             except Exception as e:
                 print(f"Error generating solution for problem {problem_id}: {e}")
             pbar.update(1)
     conn.close()
     return "Solutions generated successfully!"
 
+
 # Load problems from DuckDB
 def load_problems_from_duckdb():
     """Load all problems and solutions from the DuckDB database."""