Datasets:

wxcai
/

California_ISO

import os
import glob
import json
import joblib
import torch
from transformers import AutoModel
from tqdm import tqdm

os.environ['HTTP_PROXY'] = 'http://localhost:1080'
os.environ['HTTPS_PROXY'] = 'http://localhost:1080'

# --- Configuration Section ---
# Model settings
MODEL_NAME = "jinaai/jina-embeddings-v3"
TRUST_REMOTE_CODE = True
TRUNCATE_DIM = 256

# Data processing settings
DATA_ROOT_DIR = "./data/California_ISO/weather"
FILE_PATTERN = os.path.join(DATA_ROOT_DIR, "*", "fast_general_*.json")
BATCH_SIZE = 5000  # Number of texts processed in single batch (adjust based on GPU memory)

def load_embedding_model(model_name, device):
    """
    Load text embedding model and move to specified device.
    """
    print(f"Loading model '{model_name}' to device '{device}'...")
    try:
        model = AutoModel.from_pretrained(
            model_name, 
            trust_remote_code=TRUST_REMOTE_CODE
        ).to(device)
        model.eval()  # Set to evaluation mode
        print("Model loaded successfully.")
        return model
    except Exception as e:
        print(f"Error: Failed to load model. {e}")
        print("Please ensure 'transformers' and 'torch' libraries are installed, and internet connection is working.")
        exit(1)

def process_and_embed_files(model, file_list, batch_size, truncate_dim):
    """
    Process list of files: generate embeddings for texts in each file and save results.
    """
    if not file_list:
        print("No matching files found. Please check FILE_PATTERN and DATA_ROOT_DIR settings.")
        return

    print(f"\nFound {len(file_list)} files. Starting processing...")
    
    # Progress bar for file processing
    for file_path in tqdm(file_list, desc="Overall progress"):
        try:
            with open(file_path, "r") as f:
                data = json.load(f)
        except (json.JSONDecodeError, FileNotFoundError) as e:
            print(f"\nWarning: Skipping unreadable file {file_path}: {e}")
            continue

        timestamps = list(data.keys())
        if not timestamps:
            print(f"\nWarning: Skipping empty file {file_path}")
            continue
            
        # Extract company/source name from file path for context
        context_prefix = os.path.basename(os.path.dirname(file_path))
        print(context_prefix)

        emb_dict = {}
        # Batch processing for timestamps within a file
        for i in tqdm(range(0, len(timestamps), batch_size), desc=f"Processing {os.path.basename(file_path)}", leave=False):
            batch_timestamps = timestamps[i : i + batch_size]
            
            # Aggregate all texts in current batch
            all_texts_in_batch = []
            # len_list tracks text boundaries for later embedding separation
            len_list = [0] 
            for timestamp in batch_timestamps:
                if isinstance(data.get(timestamp), dict):
                    daily_texts = list(data[timestamp].values())
                    all_texts_in_batch.extend(daily_texts)
                    len_list.append(len(all_texts_in_batch))

            if not all_texts_in_batch:
                continue

            # Add contextual prefix to each text
            prefixed_texts = [f'{context_prefix}: {text}' for text in all_texts_in_batch]

            # Generate embeddings with model
            with torch.no_grad():
                embeddings = model.encode(
                    prefixed_texts,
                    truncate_dim=truncate_dim
                )
            
            # Split aggregated embeddings back to timestamp-specific chunks
            for j, timestamp in enumerate(batch_timestamps):
                start_index = len_list[j]
                end_index = len_list[j + 1]
                emb_dict[timestamp] = embeddings[start_index:end_index, :]

        # Save generated embeddings
        output_dir = os.path.dirname(file_path)
        base_name = os.path.basename(file_path)
        output_filename = base_name.replace("forecast", "embeddings").replace(".json", ".pkl")
        output_path = os.path.join(output_dir, output_filename)

        with open(output_path, "wb") as f:
            joblib.dump(emb_dict, f)

def main():
    """
    Main execution function
    """
    # 1. Configure processing device
    device = "cuda" if torch.cuda.is_available() else "cpu"
    print(f"Using compute device: {device}")

    # 2. Load embedding model
    model = load_embedding_model(MODEL_NAME, device)

    # 3. Find all matching files
    print(f"Searching for files matching '{FILE_PATTERN}'...")
    files_to_process = sorted(glob.glob(FILE_PATTERN))

    # 4. Execute embedding pipeline
    process_and_embed_files(model, files_to_process, BATCH_SIZE, TRUNCATE_DIM)

    print("\nAll files processed successfully!")

if __name__ == "__main__":
    main()

	import os
	import glob
	import json
	import joblib
	import torch
	from transformers import AutoModel
	from tqdm import tqdm

	os.environ['HTTP_PROXY'] = 'http://localhost:1080'
	os.environ['HTTPS_PROXY'] = 'http://localhost:1080'

	# --- Configuration Section ---
	# Model settings
	MODEL_NAME = "jinaai/jina-embeddings-v3"
	TRUST_REMOTE_CODE = True
	TRUNCATE_DIM = 256

	# Data processing settings
	DATA_ROOT_DIR = "./data/California_ISO/weather"
	FILE_PATTERN = os.path.join(DATA_ROOT_DIR, "", "fast_general_.json")
	BATCH_SIZE = 5000 # Number of texts processed in single batch (adjust based on GPU memory)

	def load_embedding_model(model_name, device):
	"""
	Load text embedding model and move to specified device.
	"""
	print(f"Loading model '{model_name}' to device '{device}'...")
	try:
	model = AutoModel.from_pretrained(
	model_name,
	trust_remote_code=TRUST_REMOTE_CODE
	).to(device)
	model.eval() # Set to evaluation mode
	print("Model loaded successfully.")
	return model
	except Exception as e:
	print(f"Error: Failed to load model. {e}")
	print("Please ensure 'transformers' and 'torch' libraries are installed, and internet connection is working.")
	exit(1)

	def process_and_embed_files(model, file_list, batch_size, truncate_dim):
	"""
	Process list of files: generate embeddings for texts in each file and save results.
	"""
	if not file_list:
	print("No matching files found. Please check FILE_PATTERN and DATA_ROOT_DIR settings.")
	return

	print(f"\nFound {len(file_list)} files. Starting processing...")

	# Progress bar for file processing
	for file_path in tqdm(file_list, desc="Overall progress"):
	try:
	with open(file_path, "r") as f:
	data = json.load(f)
	except (json.JSONDecodeError, FileNotFoundError) as e:
	print(f"\nWarning: Skipping unreadable file {file_path}: {e}")
	continue

	timestamps = list(data.keys())
	if not timestamps:
	print(f"\nWarning: Skipping empty file {file_path}")
	continue

	# Extract company/source name from file path for context
	context_prefix = os.path.basename(os.path.dirname(file_path))
	print(context_prefix)

	emb_dict = {}
	# Batch processing for timestamps within a file
	for i in tqdm(range(0, len(timestamps), batch_size), desc=f"Processing {os.path.basename(file_path)}", leave=False):
	batch_timestamps = timestamps[i : i + batch_size]

	# Aggregate all texts in current batch
	all_texts_in_batch = []
	# len_list tracks text boundaries for later embedding separation
	len_list = [0]
	for timestamp in batch_timestamps:
	if isinstance(data.get(timestamp), dict):
	daily_texts = list(data[timestamp].values())
	all_texts_in_batch.extend(daily_texts)
	len_list.append(len(all_texts_in_batch))

	if not all_texts_in_batch:
	continue

	# Add contextual prefix to each text
	prefixed_texts = [f'{context_prefix}: {text}' for text in all_texts_in_batch]

	# Generate embeddings with model
	with torch.no_grad():
	embeddings = model.encode(
	prefixed_texts,
	truncate_dim=truncate_dim
	)

	# Split aggregated embeddings back to timestamp-specific chunks
	for j, timestamp in enumerate(batch_timestamps):
	start_index = len_list[j]
	end_index = len_list[j + 1]
	emb_dict[timestamp] = embeddings[start_index:end_index, :]

	# Save generated embeddings
	output_dir = os.path.dirname(file_path)
	base_name = os.path.basename(file_path)
	output_filename = base_name.replace("forecast", "embeddings").replace(".json", ".pkl")
	output_path = os.path.join(output_dir, output_filename)

	with open(output_path, "wb") as f:
	joblib.dump(emb_dict, f)

	def main():
	"""
	Main execution function
	"""
	# 1. Configure processing device
	device = "cuda" if torch.cuda.is_available() else "cpu"
	print(f"Using compute device: {device}")

	# 2. Load embedding model
	model = load_embedding_model(MODEL_NAME, device)

	# 3. Find all matching files
	print(f"Searching for files matching '{FILE_PATTERN}'...")
	files_to_process = sorted(glob.glob(FILE_PATTERN))

	# 4. Execute embedding pipeline
	process_and_embed_files(model, files_to_process, BATCH_SIZE, TRUNCATE_DIM)

	print("\nAll files processed successfully!")

	if __name__ == "__main__":
	main()