Upload 3 files

output.py

@@ -1,10 +1,8 @@
 import sqlite3
 import random
 import json
-import hashlib
-from pybloom_live import ScalableBloomFilter
-
 from tqdm import tqdm
+from multiprocessing import Pool, Value, Lock
 
 DATABASE_FILE = "discobase3-29-2021-9-32-09-PM.db"  # Replace with your database file
 
@@ -117,37 +115,59 @@ def format_conversation_output(conversation):
 
     return output.strip()
 
-def main():
-    """Main function to generate and output conversation paths."""
-    conn = sqlite3.connect(DATABASE_FILE)
+def worker_process(args):
+    """Worker function for parallel processing"""
+    db_file, starting_dialogues = args
+    conn = sqlite3.connect(db_file)
     cursor = conn.cursor()
-
-    conversations = []
-    num_paths_to_generate = 1000
-    paths_generated = 0
     
-    # Track seen conversation patterns
-    seen_windows = set()
-    min_window_size = 5  # Minimum consecutive dialogues to consider for duplication
+    # Generate a single path
+    start_convo_id, start_dialogue_id = random.choice(starting_dialogues)
+    path = generate_conversation_path(cursor, start_convo_id, start_dialogue_id)
     
-    # Either pick a random starting point:
-    starting_dialogues = get_starting_dialogues(cursor)
+    conn.close()
+    return path
+
+def main():
+    """Main function using multiprocessing"""
+    starting_dialogues = get_starting_dialogues(sqlite3.connect(DATABASE_FILE).cursor())
     if not starting_dialogues:
         print("Error: No starting dialogues found in the database.")
-        conn.close()
         return
 
-    with tqdm(total=num_paths_to_generate, desc="Generating paths") as pbar:
-        while paths_generated < num_paths_to_generate:
-            start_convo_id, start_dialogue_id = random.choice(starting_dialogues)
-            path = generate_conversation_path(cursor, start_convo_id, start_dialogue_id)
-
-            # Skip paths that are too short
-            if len(path) < 5:
+    conversations = []
+    seen_windows = set()
+    min_window_size = 5
+    num_paths_to_generate = 5000
+    
+    # Create worker arguments (same for all workers)
+    worker_args = (DATABASE_FILE, starting_dialogues)
+    
+    # Create process pool
+    counter = Value('i', 0)
+    lock = Lock()
+    
+    def update_progress(_):
+        with lock:
+            counter.value += 1
+            if counter.value % 10 == 0:
+                print(f"\rGenerated {counter.value}/{num_paths_to_generate} paths", end="")
+    
+    with Pool(processes=8) as pool:  # Adjust number of processes based on CPU cores
+        results = []
+        # Submit initial batch of tasks
+        for _ in range(num_paths_to_generate * 2):  # Generate extra to account for rejected paths
+            results.append(pool.apply_async(worker_process, (worker_args,), callback=update_progress))
+        
+        # Collect valid results
+        while len(conversations) < num_paths_to_generate and results:
+            result = results.pop(0).get()
+            if len(result) < 5:
                 continue
-
-            # Create semantic key for conversation
-            path_text = " ".join(entry["dialogue"].strip().lower() for entry in path if not entry["dialogue"].startswith("["))
+                
+            # Duplicate checking (now in main process)
+            path_text = " ".join(entry["dialogue"].strip().lower() 
+                            for entry in result if not entry["dialogue"].startswith("["))
             
             def is_duplicate(new_text):
                 """Check if new conversation contains or is contained within existing conversations"""
@@ -178,23 +198,17 @@ def main():
                     seen_windows.add(" ".join(path_dialogues[i:i+min_window_size]))
                 return False
 
-            # Check for duplicates
-            try:
-                if (not is_duplicate(path_text) and 
-                    not is_added(path) and 
-                    any(entry["dialogue"][0] != "[" for entry in path)):
-                    conversations.append(path)
-                    paths_generated += 1
-                    pbar.update(1)
-            except Exception as e:
-                print(f"Error: {e}")
-                continue
+            if (not is_duplicate(path_text) and 
+                not is_added(result) and 
+                any(entry["dialogue"][0] != "[" for entry in result)):
+                conversations.append(result)
+        
+        pool.close()
+        pool.join()
 
     output = {"conversations": conversations}
     with open("output.json", "w") as f:
         json.dump(output, f, indent=4)
 
-    conn.close()
-
 if __name__ == "__main__":
     main()