Upload 2 files

.gitattributes

@@ -56,3 +56,4 @@ saved_model/**/* filter=lfs diff=lfs merge=lfs -text
 # Video files - compressed
 *.mp4 filter=lfs diff=lfs merge=lfs -text
 *.webm filter=lfs diff=lfs merge=lfs -text
+finance_train_204181.csv filter=lfs diff=lfs merge=lfs -text

finance_train_204181.csv

@@ -0,0 +1,3 @@
+version https://git-lfs.github.com/spec/v1
+oid sha256:b5f039d1d5b0423de2c7c85c38b5ba2192665941e75f192e1156fdfc6c75cc51
+size 6506281583

find-fin-fine.py

@@ -0,0 +1,137 @@
+import pandas as pd
+import re
+from concurrent.futures import ProcessPoolExecutor
+from tqdm import tqdm
+import os
+import glob
+
+# Expanded financial keywords (formatted for regex word boundaries)
+financial_keywords = [
+    r"\bfinance\b", r"\bfinancial\b", r"\beconomy\b", r"\beconomic\b", r"\bmarket\b", r"\bstock\b", r"\bbond\b",
+    r"\bshare\b", r"\basset\b", r"\bportfolio\b", r"\binvestment\b", r"\binvestor\b", r"\btrading\b", r"\bbroker\b",
+    r"\bcommodity\b", r"\bcurrency\b", r"\bforeign exchange\b", r"\bforex\b", r"\bderivative\b", r"\boption\b",
+    r"\bfutures\b", r"\bhedging\b", r"\brisk\b", r"\bdividend\b", r"\binterest\b", r"\bliquidity\b", r"\bcredit\b",
+    r"\bdebt\b", r"\bcapital\b", r"\bfund\b", r"\bventure\b", r"\bvaluation\b", r"\bmerger\b", r"\bacquisition\b",
+    r"\bIPO\b", r"\binitial public offering\b", r"\bprivate equity\b", r"\bhedge fund\b", r"\bmutual fund\b",
+    r"\bETF\b", r"\bexchange-traded fund\b", r"\bfinancial statement\b", r"\bbalance sheet\b", r"\bincome statement\b",
+    r"\bcash flow\b", r"\brevenue\b", r"\bprofit\b", r"\bloss\b", r"\bexpense\b", r"\bbudget\b", r"\bforecast\b",
+    r"\banalysis\b", r"\bearnings\b", r"\bEBITDA\b", r"\bEPS\b", r"\bP/E ratio\b", r"\bprice to earnings\b",
+    r"\bROI\b", r"\breturn on investment\b", r"\bROE\b", r"\breturn on equity\b", r"\bdiversification\b",
+    r"\bNASDAQ\b", r"\bNYSE\b", r"\bS&P 500\b", r"\bDow Jones\b", r"\bFTSE\b", r"\bNikkei\b", r"\bcommodities\b",
+    r"\bgold\b", r"\bsilver\b", r"\boil\b", r"\bGDP\b", r"\bgross domestic product\b", r"\binflation\b",
+    r"\bunemployment\b", r"\binterest rate\b", r"\bfederal reserve\b", r"\bcentral bank\b", r"\bmonetary policy\b",
+    r"\bquantitative easing\b", r"\bfiscal policy\b", r"\btax\b", r"\btreasury\b", r"\bbudget deficit\b",
+    r"\bnational debt\b", r"\bcredit rating\b", r"\bstandard & poor's\b", r"\bmoody's\b", r"\bfitch\b",
+    r"\bsovereign wealth fund\b", r"\binternational monetary fund\b", r"\bIMF\b", r"\bworld bank\b",
+    r"\bbasel III\b", r"\bdodd-frank\b", r"\bfinancial regulation\b", r"\binsurance\b", r"\breal estate\b",
+    r"\bmortgage\b", r"\bloan\b", r"\bbank\b", r"\bbanking\b", r"\bfintech\b", r"\bblockchain\b", r"\bcryptocurrency\b",
+    r"\bbitcoin\b", r"\bethereum\b", r"\bsmart contract\b", r"\bdigital currency\b", r"\bdecentralized finance\b",
+    # Add more general financial terms as needed
+]
+
+# Combine financial keywords into a single regex pattern using non-capturing groups
+financial_regex = r'(?:' + r'|'.join(financial_keywords) + r')'
+
+# Function to process a chunk of the dataset
+def process_chunk(chunk):
+    # Use vectorized string operations for efficiency
+    # Count the number of matches in each column
+    score_counts = chunk['score'].astype(str).str.count(financial_regex, flags=re.IGNORECASE)
+    url_counts = chunk['url'].astype(str).str.count(financial_regex, flags=re.IGNORECASE)
+    text_counts = chunk['text'].astype(str).str.count(financial_regex, flags=re.IGNORECASE)
+    
+    # Handle NaN values by filling them with zero
+    score_counts = score_counts.fillna(0)
+    url_counts = url_counts.fillna(0)
+    text_counts = text_counts.fillna(0)
+    
+    # Sum the counts to get the financial score
+    match_counts = score_counts + url_counts + text_counts
+    match_counts = match_counts.astype(int)
+    
+    # Set a threshold for the minimum financial score
+    threshold = 14  # Adjust this value as needed
+    
+    # Filter rows that meet the threshold
+    filtered_chunk = chunk[match_counts >= threshold].copy()
+    filtered_chunk['financial_score'] = match_counts[match_counts >= threshold]
+    
+    # Replace the original 'score' with 'financial_score'
+    filtered_chunk['score'] = filtered_chunk['financial_score']
+    filtered_chunk = filtered_chunk.drop(columns=['financial_score'])
+    
+    return filtered_chunk
+
+# Function to process a single CSV file
+def process_file(input_file, output_file):
+    # Read the CSV file in chunks
+    chunk_size = 10000  # Adjust this value based on your memory constraints
+    reader = pd.read_csv(input_file, chunksize=chunk_size)
+    
+    # Prepare the output file
+    first_chunk = True
+    
+    # Number of worker processes
+    num_workers = 8  # Adjust based on your CPU cores
+    
+    # Batch size for chunks to process in parallel
+    batch_size = num_workers * 4  # Adjust based on memory constraints
+    
+    chunk_list = []
+    with ProcessPoolExecutor(max_workers=num_workers) as executor:
+        futures = []
+        for chunk in tqdm(reader, desc=f'Reading chunks from {os.path.basename(input_file)}'):
+            chunk_list.append(chunk)
+            if len(chunk_list) == batch_size:
+                # Process batch of chunks in parallel
+                futures = [executor.submit(process_chunk, c) for c in chunk_list]
+                for future in tqdm(futures, desc='Processing batch', leave=False):
+                    filtered_chunk = future.result()
+                    if not filtered_chunk.empty:
+                        if first_chunk:
+                            filtered_chunk.to_csv(output_file, mode='w', index=False)
+                            first_chunk = False
+                        else:
+                            filtered_chunk.to_csv(output_file, mode='a', index=False, header=False)
+                chunk_list = []
+        # Process any remaining chunks
+        if chunk_list:
+            futures = [executor.submit(process_chunk, c) for c in chunk_list]
+            for future in tqdm(futures, desc='Processing last batch', leave=False):
+                filtered_chunk = future.result()
+                if not filtered_chunk.empty:
+                    if first_chunk:
+                        filtered_chunk.to_csv(output_file, mode='w', index=False)
+                        first_chunk = False
+                    else:
+                        filtered_chunk.to_csv(output_file, mode='a', index=False, header=False)
+    print(f'Finished processing {input_file}')
+
+# List of directories to process
+data_dir = '/media/joe/512-3/csv'
+years = [f'CC-MAIN-{year}' for year in range(2013, 2025)]  # Adjust years as needed
+directories = [os.path.join(data_dir, year) for year in years]
+
+# Process each CSV file in each directory
+for dir_path in directories:
+    if not os.path.isdir(dir_path):
+        print(f'Directory not found: {dir_path}')
+        continue
+    csv_files = glob.glob(os.path.join(dir_path, '*.csv'))
+    print(f'Found {len(csv_files)} CSV files in {dir_path}')
+    for input_file in csv_files:
+        # Construct output file name
+        # Example: If input_file is '/path/CC-MAIN-2013/train-00001-of-00001.csv'
+        # Output file will be 'fin_CC-MAIN-2013_train-00001-of-00001.csv'
+        base_name = os.path.basename(input_file)
+        output_file = os.path.join(
+            dir_path, 'fin_' + base_name
+        )
+        
+        # Check if output file already exists to avoid reprocessing
+        if os.path.exists(output_file):
+            print(f'Output file already exists. Skipping: {output_file}')
+            continue
+        
+        process_file(input_file, output_file)
+