Upload 3 files

add-column-names.py

@@ -0,0 +1,34 @@
+import os
+import pandas as pd
+
+# Define the directory path containing the CSV files
+csv_directory = '/media/joe/512-3/csv'
+
+# Define the column names to be added
+column_names = ['score', 'text', 'url']
+
+# Function to add headers to CSV files
+def add_headers_to_csv(file_path):
+    try:
+        # Load the CSV file without headers
+        df = pd.read_csv(file_path, header=None)
+
+        # Add column names
+        df.columns = column_names
+
+        # Save the updated CSV file with headers
+        df.to_csv(file_path, index=False)
+
+        print(f"Headers added to '{file_path}'")
+
+    except Exception as e:
+        print(f"Error processing '{file_path}': {e}")
+
+# Loop through all the CSV files in the specified directory
+for file_name in os.listdir(csv_directory):
+    if file_name.endswith('.csv'):
+        file_path = os.path.join(csv_directory, file_name)
+        add_headers_to_csv(file_path)
+
+print("All CSV files processed.")
+

organize_by_folder.py

@@ -0,0 +1,39 @@
+import os
+import shutil
+
+# Define the years and the base directory
+years = ["2013", "2014", "2015", "2016", "2017", "2018", "2019", "2020", "2021", "2022", "2023", "2024"]
+base_dir = '/media/joe/512-3/csv'  # Adjust this to your actual base directory
+
+# Step 1: Create directories for each year
+for year in years:
+    folder_path = os.path.join(base_dir, f"CC-MAIN-{year}")
+    if not os.path.exists(folder_path):
+        os.makedirs(folder_path)
+        print(f"Created folder: {folder_path}")
+
+# Step 2: Move files to their respective folders and rename them
+for year in years:
+    year_folder = os.path.join(base_dir, f"CC-MAIN-{year}")
+    # Find all files that match the pattern for this year
+    year_files = [f for f in os.listdir(base_dir) if f.startswith(f"forti-sampled_dataset_CC-MAIN-{year}")]
+    
+    total_files = len(year_files)
+    if total_files == 0:
+        print(f"No files found for the year {year}")
+        continue
+    
+    # Sort and rename the files
+    for index, file_name in enumerate(sorted(year_files)):
+        new_file_name = f"train-{str(index+1).zfill(5)}-of-{str(total_files).zfill(4)}.csv"
+        
+        old_file_path = os.path.join(base_dir, file_name)
+        new_file_path = os.path.join(year_folder, new_file_name)
+        
+        # Attempt to move and rename the file
+        try:
+            shutil.move(old_file_path, new_file_path)
+            print(f"Moved and renamed: {old_file_path} to {new_file_path}")
+        except Exception as e:
+            print(f"Error moving file {old_file_path}: {e}")
+

par-4-forti-four.py

@@ -0,0 +1,235 @@
+import csv
+from datasets import load_dataset
+import os
+import time
+import signal
+import requests
+from multiprocessing import Pool, Manager
+from functools import partial
+
+# Define parameters
+score_threshold = 4
+error_log_file = "error_log.txt"
+
+# List of dataset folders to process
+dataset_folders = [
+    "CC-MAIN-2013-20", "CC-MAIN-2013-48", "CC-MAIN-2014-10", "CC-MAIN-2014-15",
+    "CC-MAIN-2014-23", "CC-MAIN-2014-35", "CC-MAIN-2014-41", "CC-MAIN-2014-42",
+    "CC-MAIN-2014-49", "CC-MAIN-2014-52", "CC-MAIN-2015-06", "CC-MAIN-2015-11",
+    "CC-MAIN-2015-14", "CC-MAIN-2015-18", "CC-MAIN-2015-22", "CC-MAIN-2015-27",
+    "CC-MAIN-2015-32", "CC-MAIN-2015-35", "CC-MAIN-2015-40", "CC-MAIN-2015-48",
+    "CC-MAIN-2016-07", "CC-MAIN-2016-18", "CC-MAIN-2016-22", "CC-MAIN-2016-26",
+    "CC-MAIN-2016-30", "CC-MAIN-2016-36", "CC-MAIN-2016-40", "CC-MAIN-2016-44",
+    "CC-MAIN-2016-50", "CC-MAIN-2017-04", "CC-MAIN-2017-09", "CC-MAIN-2017-13",
+    "CC-MAIN-2017-17", "CC-MAIN-2017-22", "CC-MAIN-2017-26", "CC-MAIN-2017-30",
+    "CC-MAIN-2017-34", "CC-MAIN-2017-39", "CC-MAIN-2017-43", "CC-MAIN-2017-47",
+    "CC-MAIN-2017-51", "CC-MAIN-2018-05", "CC-MAIN-2018-09", "CC-MAIN-2018-13",
+    "CC-MAIN-2018-17", "CC-MAIN-2018-22", "CC-MAIN-2018-26", "CC-MAIN-2018-30",
+    "CC-MAIN-2018-34", "CC-MAIN-2018-39", "CC-MAIN-2018-43", "CC-MAIN-2018-47",
+    "CC-MAIN-2018-51", "CC-MAIN-2019-04", "CC-MAIN-2019-09", "CC-MAIN-2019-13",
+    "CC-MAIN-2019-18", "CC-MAIN-2019-22", "CC-MAIN-2019-26", "CC-MAIN-2019-30",
+    "CC-MAIN-2019-35", "CC-MAIN-2019-39", "CC-MAIN-2019-43", "CC-MAIN-2019-47",
+    "CC-MAIN-2019-51", "CC-MAIN-2020-05", "CC-MAIN-2020-10", "CC-MAIN-2020-16",
+    "CC-MAIN-2020-24", "CC-MAIN-2020-29", "CC-MAIN-2020-34", "CC-MAIN-2020-40",
+    "CC-MAIN-2020-45", "CC-MAIN-2020-50", "CC-MAIN-2021-04", "CC-MAIN-2021-10",
+    "CC-MAIN-2021-17", "CC-MAIN-2021-21", "CC-MAIN-2021-25", "CC-MAIN-2021-31",
+    "CC-MAIN-2021-39", "CC-MAIN-2021-43", "CC-MAIN-2021-49", "CC-MAIN-2022-05",
+    "CC-MAIN-2022-21", "CC-MAIN-2022-27", "CC-MAIN-2022-33", "CC-MAIN-2022-40",
+    "CC-MAIN-2022-49", "CC-MAIN-2023-06", "CC-MAIN-2023-14", "CC-MAIN-2023-23",
+    "CC-MAIN-2023-40", "CC-MAIN-2023-50", "CC-MAIN-2024-10"
+]
+
+# Global variable for interruption
+interrupt_flag = Manager().Value('i', False)
+
+# Function to log errors
+def log_error(error_message):
+    with open(error_log_file, "a") as error_log:
+        error_log.write(f"{error_message}\n")
+
+# Retry mechanism to handle connection errors when loading the dataset
+def retry_request(load_dataset_function, max_retries=5, wait_time=5):
+    retries = 0
+    while retries < max_retries:
+        try:
+            dataset = load_dataset_function()
+            return dataset
+        except requests.exceptions.ConnectionError as e:
+            log_error(f"Connection error: {e}. Retrying in {wait_time} seconds...")
+            retries += 1
+            time.sleep(wait_time)
+        except Exception as e:
+            log_error(f"Unexpected error: {e}. Retrying in {wait_time} seconds...")
+            retries += 1
+            time.sleep(wait_time)
+    log_error("Max retries exceeded.")
+    return None
+
+# Function to save the text column to a file with start and stop tokens
+def save_text_column(entry, output_text_file):
+    try:
+        text = entry["text"]
+        with open(output_text_file, "a", encoding='utf-8') as f:
+            f.write(f"<s>\n{text}</s>\n")
+    except KeyError as e:
+        log_error(f"Missing 'text' field: {e}")
+
+# Function to save score, text, and URL to a CSV file, with error handling
+def save_to_csv(entry, output_csv_file, write_header=False):
+    try:
+        with open(output_csv_file, mode='a', newline='', encoding='utf-8') as file:
+            writer = csv.writer(file)
+            if write_header:
+                writer.writerow(["score", "text", "url"])  # CSV headers
+            score = entry["score"]
+            text = entry["text"]
+            url = entry.get("url", "N/A")  # Ensure 'url' is included
+            writer.writerow([score, text, url])
+    except KeyError as e:
+        log_error(f"Missing field in entry: {e}")
+
+# Graceful exit handling
+def signal_handler(sig, frame):
+    global interrupt_flag
+    print("Interrupt received, saving progress and exiting...")
+    interrupt_flag.value = True  # Set the flag to stop processing
+    exit(0)
+
+signal.signal(signal.SIGINT, signal_handler)
+
+# Function to process a single folder
+def process_folder(folder, score_threshold):
+    global interrupt_flag
+
+    # Define per-folder log file
+    log_file = f"processing_log_{folder}.txt"
+
+    # Function to log progress to a file
+    def log_progress(last_id):
+        with open(log_file, "w") as log:
+            log.write(f"{last_id}")
+
+    # Function to resume from a specific point by reading the log file
+    def resume_progress():
+        if os.path.exists(log_file):
+            with open(log_file, "r") as log:
+                last_id = log.read().strip()
+                if last_id == 'None' or last_id == '':
+                    last_id = None
+                return last_id
+        return None
+
+    print(f"Processing dataset folder: {folder}")
+
+    # Define per-folder output files
+    output_text_file = f"forti-sampled_text_dataset_{folder}.txt"
+    output_csv_file = f"forti-sampled_dataset_{folder}.csv"
+
+    # Load dataset with retry mechanism
+    dataset = retry_request(lambda: load_dataset(
+        "airtrain-ai/fineweb-edu-fortified",
+        folder,
+        split="train",
+        streaming=True
+    ))
+    if not dataset:
+        log_error(f"Failed to load dataset {folder}. Skipping.")
+        return
+
+    # Retrieve last processed ID for resuming
+    last_processed_id = resume_progress()
+
+    # Initialize variables
+    found_last_id = last_processed_id is None
+    processed_entries = 0  # Reset processed_entries for the new folder
+
+    # Process entries
+    while True:
+        try:
+            for entry in dataset:
+                if interrupt_flag.value:
+                    break  # Exit loop if interrupt flag is set
+
+                # Skip entries until we reach the last processed ID
+                entry_id = entry.get('id')
+                if not found_last_id:
+                    if entry_id == last_processed_id:
+                        found_last_id = True
+                    continue
+
+                # Update last_processed_id
+                last_processed_id = entry_id
+
+                # Check if entry meets the score threshold
+                if entry.get('score', 0) >= score_threshold:
+                    # Save entry to text file and CSV
+                    # Write headers if files are new
+                    if processed_entries == 0:
+                        write_header = True
+                    else:
+                        write_header = False
+                    save_to_csv(entry, output_csv_file, write_header=write_header)
+                    save_text_column(entry, output_text_file)
+
+                processed_entries += 1
+
+                if processed_entries % 100 == 0:
+                    log_progress(last_processed_id)
+                    print(f"Processed {processed_entries} entries from {folder}...")  # Terminal output
+
+            break  # Exit while loop when dataset iteration is complete
+
+        except requests.exceptions.ConnectionError as e:
+            # Handle connection error during iteration
+            log_error(f"Connection error during iteration in {folder}: {e}")
+            print(f"Connection error during iteration in {folder}: {e}. Retrying in 5 seconds...")
+            time.sleep(5)
+            # Re-initialize dataset streaming from the point after last_processed_id
+            dataset = retry_request(lambda: load_dataset(
+                "airtrain-ai/fineweb-edu-fortified",
+                folder,
+                split="train",
+                streaming=True
+            ))
+            if not dataset:
+                log_error(f"Failed to reload dataset {folder} after connection error. Skipping.")
+                break
+            # Reset found_last_id to False to skip entries up to last_processed_id
+            found_last_id = False
+
+        except Exception as e:
+            log_error(f"Error during processing in {folder}: {e}")
+            print(f"Error during processing in {folder}: {e}. Skipping entry.")
+            continue
+
+    # After processing all entries in the folder, log progress
+    log_progress(last_processed_id)
+    print(f"Completed processing folder: {folder}")
+
+    if interrupt_flag.value:
+        print(f"Processing interrupted in folder: {folder}")
+
+# Main process function to process multiple folders in parallel
+def process_all_folders_parallel(dataset_folders, score_threshold):
+    global interrupt_flag
+
+    # Use a multiprocessing Pool to process folders in parallel
+    with Pool(processes=os.cpu_count()) as pool:
+        try:
+            # Partial function to fix the score_threshold parameter
+            func = partial(process_folder, score_threshold=score_threshold)
+            pool.map(func, dataset_folders)
+        except KeyboardInterrupt:
+            print("KeyboardInterrupt received, terminating pool...")
+            pool.terminate()
+            pool.join()
+            print("Pool terminated.")
+            interrupt_flag.value = True
+
+    print("Processing complete.")
+
+# Start processing all folders in parallel
+process_all_folders_parallel(dataset_folders, score_threshold)
+
+print("Filtered datasets saved to individual files per folder.")
+