Add: data during 2024-2025; weather report; re-embedding

id_info.json

@@ -1,5 +1,5 @@
 {
-    "weather_2014-18": {
+    "weather_large": {
         "sensor_downtime": {}
     }
 

weather_2019-23.parquet → raw_data/weather_2019-22.parquet

@@ -1,3 +1,3 @@
 version https://git-lfs.github.com/spec/v1
-oid sha256:c2c1917d5a5db6c5009ad4c22b29245bd423a8b9c1102f0e5ea37f78eb8d7f9c
-size 8155570
+oid sha256:8e6f42740a21cd6c6415b1a279db4f6a53f4f367235450e41e0d0292b4d3f663
+size 8903879

embeddings.pkl → raw_data/weather_2023-25.parquet

@@ -1,3 +1,3 @@
 version https://git-lfs.github.com/spec/v1
-oid sha256:0baba5a83e687c4f24763a4f71ac03c6ab379ac6d040ef365c67e707a70775d7
-size 78848178
+oid sha256:8da4d39f5892c4074bfec126116d1292b3cbfc58d16871fff93049cb6ecb3c98
+size 5924749

scripts/embed.py

@@ -0,0 +1,215 @@
+#!/usr/bin/env python3
+
+import json
+import glob
+import joblib
+import os
+import torch
+import numpy as np  # Required for array operations
+from transformers import AutoModel
+
+# Set proxy (replace with your proxy address and port)
+# os.environ['HTTP_PROXY'] = 'http://localhost:1080'
+# os.environ['HTTPS_PROXY'] = 'http://localhost:1080'
+
+# --- Configuration ---
+# Assuming your data directory structure is as follows:
+# ./data/
+# ├── san-francisco/
+# │   ├── fast_general_..._forecast_2017.json
+# │   └── ...
+# ├── san-diego/
+# │   ├── fast_general_..._forecast_2017.json
+# │   └── ...
+# └── id_info_imputed.json
+
+DATA_DIR = "./weather/weather_report"  # Your main data directory
+EMBEDDING_MODEL = "jinaai/jina-embeddings-v3"
+TRUNCATE_DIM = 256
+BATCH_SIZE = 1500 # Adjust based on your hardware
+
+# --- New Configuration: Define the cities ---
+BOROUGHS = ['formal_report']
+BASE_BOROUGH = 'formal_report' # We will use this city's files as the baseline for finding corresponding files
+
+def initialize_model():
+    """
+    Initializes and loads the embedding model, prioritizing GPU usage.
+    """
+    print("Initializing embedding model...")
+    device = "cuda:0" if torch.cuda.is_available() else "cpu"
+    print(f"Using device: {device}")
+    
+    model = AutoModel.from_pretrained(
+        EMBEDDING_MODEL, 
+        trust_remote_code=True
+    ).to(device)
+    
+    print("Model loaded successfully.")
+    return model
+
+def process_dynamic_data_for_borough(model, borough):
+    """
+    Processes all dynamic forecast JSON files for a specific city,
+    generating and saving their embeddings.
+    """
+    print(f"\n--- Starting processing for city: {borough} ---")
+    borough_path = os.path.join(DATA_DIR, borough)
+    json_files = glob.glob(os.path.join(borough_path, "wm_messages_??.json"))
+    
+    if not json_files:
+        print(f"No dynamic forecast JSON files found for {borough}. Skipping.")
+        return
+
+    for file_path in json_files:
+        print(f"\nProcessing file: {file_path}")
+        with open(file_path, "r") as f:
+            data = json.load(f)
+        
+        timestamps = list(data.keys())
+        if not timestamps:
+            print(f"File {file_path} is empty. Skipping.")
+            continue
+        print(f"Loaded {len(data)} records from {file_path}")
+            
+        emb_dict = {}
+        num_batches = (len(timestamps) + BATCH_SIZE - 1) // BATCH_SIZE
+        for i in range(0, len(timestamps), BATCH_SIZE):
+            batch_timestamps = timestamps[i:i + BATCH_SIZE]
+            print(f"  Processing batch {i // BATCH_SIZE + 1}/{num_batches}")
+            
+            batch_texts, len_list = [], [0]
+            for ts in batch_timestamps:
+                # Preprocess text uniformly, adding city information
+                texts = [f'{borough.replace("-", " ").title()}: {text}' for text in data[ts].values()]
+                batch_texts.extend(texts)
+                len_list.append(len(batch_texts))
+
+            embeddings = model.encode(batch_texts, truncate_dim=TRUNCATE_DIM)
+            
+            for j, ts in enumerate(batch_timestamps):
+                start_idx, end_idx = len_list[j], len_list[j+1]
+                emb_dict[ts] = embeddings[start_idx:end_idx, :]
+        
+        output_file_name = os.path.basename(file_path).replace("forecast", "embeddings").replace(".json", ".pkl")
+        output_path = os.path.join(borough_path, output_file_name)
+
+        with open(output_path, "wb") as f:
+            joblib.dump(emb_dict, f)
+        print(f"Saved city-specific embeddings to {output_path}")
+
+def merge_borough_embeddings():
+    """
+    Merges the embedding files from all specified cities.
+    """
+    print("\n--- Starting merging of city embeddings ---")
+    base_path = os.path.join(DATA_DIR, 'weather', BASE_BOROUGH)
+    base_embedding_files = glob.glob(os.path.join(base_path, "fast_general_*_embeddings_*.pkl"))
+
+    if not base_embedding_files:
+        print("No base embedding files found to merge. Skipping.")
+        return
+        
+    for base_file in base_embedding_files:
+        print(f"\nMerging based on: {base_file}")
+        
+        # Load the corresponding files for all cities
+        data_files = {}
+        try:
+            for borough in BOROUGHS:
+                target_file = base_file.replace(BASE_BOROUGH, borough)
+                with open(target_file, "rb") as f:
+                    data_files[borough] = joblib.load(f)
+        except FileNotFoundError as e:
+            print(f"Could not find a corresponding file for {e.filename}. Skipping this year.")
+            continue
+            
+        merged_embeddings = {}
+        # Iterate through the timestamps of the base file
+        for timestamp in data_files[BASE_BOROUGH].keys():
+            embeddings_to_merge = []
+            # Ensure each city has data for this timestamp
+            if all(timestamp in data_files[b] for b in BOROUGHS):
+                for borough in BOROUGHS:
+                    embeddings_to_merge.append(data_files[borough][timestamp])
+                
+                # Concatenate the embeddings using numpy
+                merged_embeddings[timestamp] = np.concatenate(embeddings_to_merge, axis=0)
+        
+        output_filename = os.path.basename(base_file)
+        final_output_path = os.path.join(DATA_DIR, 'weather', output_filename)
+        joblib.dump(merged_embeddings, final_output_path)
+        print(f"Saved final merged embeddings to {final_output_path}")
+
+def process_static_data(model):
+    """
+    Processes the static info JSON file to generate and save embeddings.
+    """
+    print("\n--- Starting processing of static info data ---")
+    static_info_path = os.path.join(DATA_DIR, "expanded_impute_data", "id_info_imputed.json")
+    
+    if not os.path.exists(static_info_path):
+        print(f"Static info source file not found at {static_info_path}. Skipping.")
+        return
+
+    with open(static_info_path, "r") as f:
+        id_info = json.load(f)
+
+    # 1. Create a dictionary for the text information
+    static_info_text = {}
+    static_info_text['general_info'] = 'This dataset contains Average Speed of a Vehicle Traveled Between End Points data in km/h collected from various locations in New York City by sensors. The sampling rate is every 5 minutes. When no car is detected in the period, the speed is set to 0.'
+    static_info_text['downtime_prompt'] = "The sensor is down for unknown reasons, readings set to 0. "
+    static_info_text['channel_info'] = {
+        ch: f"Sensor {ch} is located at {info['borough']}, with segment of {info['link']}." 
+        for ch, info in id_info.items()
+    }
+    # Save the text version
+    text_output_path = os.path.join(DATA_DIR, 'weather', "static_info.json")
+    with open(text_output_path, 'w') as f:
+        json.dump(static_info_text, f, indent=2)
+    print(f"Saved static info text to {text_output_path}")
+
+    # 2. Collect all texts for embedding
+    channels = list(static_info_text['channel_info'].keys())
+    texts_to_embed = (
+        [static_info_text['general_info'], static_info_text['downtime_prompt']] + 
+        [static_info_text['channel_info'][ch] for ch in channels]
+    )
+    
+    print(f"Embedding {len(texts_to_embed)} static text entries...")
+    embeddings = model.encode(texts_to_embed, truncate_dim=TRUNCATE_DIM)
+    
+    # 3. Create a new dictionary to store the embeddings
+    static_info_embeddings = {}
+    static_info_embeddings['general_info'] = embeddings[0:1, :]
+    static_info_embeddings['downtime_prompt'] = embeddings[1:2, :]
+    static_info_embeddings['channel_info'] = {
+        ch: embeddings[i+2:i+3, :] 
+        for i, ch in enumerate(channels)
+    }
+        
+    # 4. Save the dictionary containing the embeddings
+    output_path = os.path.join(DATA_DIR, 'weather', "static_info_embeddings.pkl")
+    joblib.dump(static_info_embeddings, output_path)
+    print(f"Saved static info embeddings to {output_path}")
+
+def main():
+    """
+    Main execution function
+    """
+    model = initialize_model()
+    
+    # 1. Generate embeddings for each city individually
+    for borough in BOROUGHS:
+        process_dynamic_data_for_borough(model, borough)
+        
+    # 2. Merge the embeddings from all cities
+    merge_borough_embeddings()
+    
+    # 3. Process the static information
+    process_static_data(model)
+    
+    print("\nAll processing complete.")
+
+if __name__ == "__main__":
+    main()

scripts/embed_static.py

@@ -0,0 +1,101 @@
+import json
+import joblib
+import torch
+import os
+from transformers import AutoModel
+
+# Set proxy (replace with your proxy address and port)
+os.environ['HTTP_PROXY'] = 'http://localhost:1080'
+os.environ['HTTPS_PROXY'] = 'http://localhost:1080'
+
+def create_static_embeddings(
+    input_path="./data/Jena_Atmospheric_Physics/static_info.json",
+    output_path="./data/Jena_Atmospheric_Physics/static_info_embeddings.pkl",
+):
+    """
+    Loads static information from a JSON file, generates embeddings for the text fields,
+    and saves the result as a pickle file.
+
+    Args:
+        input_path (str): Path to the input static_info.json file.
+        output_path (str): Path to save the output .pkl file with embeddings.
+    """
+    # --- 1. Sanity Checks ---
+    if not os.path.exists(input_path):
+        print(f"Error: Input file not found at '{input_path}'")
+        # Create a dummy file for demonstration if it doesn't exist
+        print("Creating a dummy 'static_info.json' for demonstration purposes.")
+        dummy_data = {
+            "general_info": "This dataset contains the solar power generation data of 16 solar panels in Calgary, Alberta, Canada. The data is collected hourly. ",
+            "downtime_prompt": "The system is shutdown, thus no power generation.",
+            "channel_info": {
+                "CFH_HQ": "The solar panel is located at Calgary Fire Hall Headquarters.",
+                "WMSC": "The solar panel is located at Whitehorn Multi-Service Centre.",
+                "SLC": "The solar panel is located at Southland Leisure Centre."
+            }
+        }
+        os.makedirs(os.path.dirname(input_path), exist_ok=True)
+        with open(input_path, 'w') as f:
+            json.dump(dummy_data, f, indent=2)
+        print(f"Dummy file created at '{input_path}'. Please run the script again.")
+        return
+
+    # --- 2. Initialize Model ---
+    print("Initializing embedding model...")
+    # Set up device (use GPU if available)
+    device = "cuda:0" if torch.cuda.is_available() else "cpu"
+    print(f"Using device: {device}")
+    
+    # Load the pre-trained model
+    model = AutoModel.from_pretrained(
+        "jinaai/jina-embeddings-v3", 
+        trust_remote_code=True
+    ).to(device=device)
+
+    # --- 3. Load and Prepare Data ---
+    print(f"Loading data from '{input_path}'...")
+    with open(input_path, "r") as f:
+        static_info = json.load(f)
+
+    # Extract all text pieces to be embedded into a single list
+    channels = list(static_info['channel_info'].keys())
+    texts_to_embed = (
+        [static_info['general_info'], static_info['downtime_prompt']] 
+        + [static_info['channel_info'][key] for key in channels]
+    )
+    
+    print(f"Found {len(texts_to_embed)} text snippets to embed.")
+
+    # --- 4. Generate Embeddings ---
+    print("Generating embeddings...")
+    embeddings = model.encode(
+        texts_to_embed,
+        truncate_dim=256  # Truncate to 256 dimensions as in the notebook
+    )
+    print(f"Embeddings generated with shape: {embeddings.shape}")
+
+    # --- 5. Replace Text with Embeddings in the Dictionary ---
+    print("Replacing text data with embeddings...")
+    # The original static_info dictionary is modified in place
+    static_info['general_info'] = embeddings[0:1, :]
+    static_info['downtime_prompt'] = embeddings[1:2, :]
+    
+    for i, key in enumerate(channels):
+        # The slice [i+2:i+3, :] keeps the result as a 2D array (1, 256)
+        static_info['channel_info'][key] = embeddings[i+2:i+3, :]
+
+    # --- 6. Save the Result ---
+    # Ensure the output directory exists
+    output_dir = os.path.dirname(output_path)
+    if output_dir:
+        os.makedirs(output_dir, exist_ok=True)
+        
+    print(f"Saving embeddings to '{output_path}'...")
+    with open(output_path, "wb") as f:
+        joblib.dump(static_info, f)
+
+    print("Process completed successfully!")
+
+
+if __name__ == "__main__":
+    create_static_embeddings()

static_info.json

@@ -0,0 +1,27 @@
+{
+    "general_info": "This dataset contains comprehensive weather and climate measurements recorded in Jena, Germany, spanning multiple years.",
+    "downtime_prompt": "No reading at this time for unknown reason, set 0 as default, ignore.",
+    "channel_info": {
+        "p (mbar)": "Atmospheric pressure measured in millibars. It indicates the weight of the air above the point of measurement.",
+        "T (degC)": "Temperature at the point of observation, measured in degrees Celsius.",
+        "Tpot (K)": "Potential temperature, given in Kelvin. This is the temperature that a parcel of air would have if it were brought adiabatically to a standard reference pressure, often used to compare temperatures at different pressures in a thermodynamically consistent way.",
+        "Tdew (degC)": "Dew point temperature in degrees Celsius. It's the temperature to which air must be cooled, at constant pressure and water vapor content, for saturation to occur. A lower dew point means dryer air.",
+        "rh (%)": "Relative humidity, expressed as a percentage. It measures the amount of moisture in the air relative to the maximum amount of moisture the air can hold at that temperature.",
+        "VPmax (mbar)": "Maximum vapor pressure, in millibars. It represents the maximum amount of moisture that the air can hold at a given temperature.",
+        "VPact (mbar)": "Actual vapor pressure, in millibars. It's the current amount of water vapor present in the air.",
+        "VPdef (mbar)": "Vapor pressure deficit, in millibars. The difference between the maximum vapor pressure and the actual vapor pressure; it indicates how much more moisture the air can hold before saturation.",
+        "sh (g/kg)": "Specific humidity, the mass of water vapor in a given mass of air, including the water vapor. It's measured in grams of water vapor per kilogram of air.",
+        "H2OC (mmol/mol)": "Water vapor concentration, expressed in millimoles of water per mole of air. It's another way to quantify the amount of moisture in the air.",
+        "rho (g/m³)": "Air density, measured in grams per cubic meter. It indicates the mass of air in a given volume and varies with temperature, pressure, and moisture content.",
+        "wv (m/s)": "Wind velocity, the speed of the wind measured in meters per second.",
+        "max. wv (m/s)": "Maximum wind velocity observed in the given time period, measured in meters per second.",
+        "wd (deg)": "Wind direction, in degrees from true north. This indicates the direction from which the wind is coming.",
+        "rain (mm)": "Rainfall amount, measured in millimeters. It indicates how much rain has fallen during the observation period.",
+        "raining (s)": "Duration of rainfall, measured in seconds. It specifies how long it has rained during the observation period.",
+        "SWDR (W/m²)": "Shortwave Downward Radiation, the amount of solar radiation reaching the ground, measured in watts per square meter.",
+        "PAR (μmol/m²/s)": "Photosynthetically Active Radiation, the amount of light available for photosynthesis, measured in micromoles of photons per square meter per second.",
+        "max. PAR (μmol/m²/s)": "Maximum Photosynthetically Active Radiation observed in the given time period, indicating the peak light availability for photosynthesis.",
+        "Tlog (degC)": "Likely a logged temperature measurement in degrees Celsius. It could be a specific type of temperature measurement or recording method used in the dataset.",
+        "CO2 (ppm)": "Carbon dioxide concentration in the air, measured in parts per million. It's a key greenhouse gas and indicator of air quality."
+    }
+}

time_series/id_info.json

@@ -0,0 +1,6 @@
+{
+    "weather_large": {
+        "sensor_downtime": {}
+    }
+
+}

weather_large.parquet → time_series/weather_large.parquet

@@ -1,3 +1,3 @@
 version https://git-lfs.github.com/spec/v1
-oid sha256:c709908bebb7e853059c25f9aa336999fbc991e3122312c048460b7e00e9dabe
-size 16863314
+oid sha256:7b31c944dc04ffda92aaaba76473eb1d6db3e6055c6f4d070ce76c27014a1e3e
+size 23421608

static_info_embeddings_new.pkl → weather/report_embedding/formal_report/static_info_embeddings.pkl

@@ -1,3 +1,3 @@
 version https://git-lfs.github.com/spec/v1
-oid sha256:bae20678402088d2b279d59f9270b02f862fa7a25d30215423c8211fd16e6a88
-size 38867
+oid sha256:84dbe5a639b337a2db7de4d5a743f8dead59f587658763a124e216d4f3aabb7e
+size 25331

weather/report_embedding/formal_report/wm_messages_v1.pkl

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

weather/report_embedding/formal_report/wm_messages_v2.pkl

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

weather/report_embedding/formal_report/wm_messages_v3.pkl

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