Upload 15 files

3dcnn-model.h5

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

Trj_GRU.h5

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

Trj_GRU.weights.h5

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

app.py

@@ -0,0 +1,344 @@
+import streamlit as st
+import numpy as np
+from PIL import Image
+import cv2
+from scipy.ndimage import gaussian_filter
+
+# ------------------ TC CENTERING UTILS ------------------
+
+def find_tc_center(ir_image, smoothing_sigma=3):
+    smoothed_image = gaussian_filter(ir_image, sigma=smoothing_sigma)
+    min_coords = np.unravel_index(np.argmin(smoothed_image), smoothed_image.shape)
+    return min_coords[::-1]  # Return as (x, y)
+
+def extract_local_region(ir_image, center, region_size=95):
+    h, w = ir_image.shape
+    half_size = region_size // 2
+    x_min = max(center[0] - half_size, 0)
+    x_max = min(center[0] + half_size, w)
+    y_min = max(center[1] - half_size, 0)
+    y_max = min(center[1] + half_size, h)
+    region = np.full((region_size, region_size), np.nan)
+    extracted = ir_image[y_min:y_max, x_min:x_max]
+    region[:extracted.shape[0], :extracted.shape[1]] = extracted
+    return region
+
+def generate_hovmoller(X_data):
+    hovmoller_list = []
+    for ir_images in X_data:  # ir_images: shape (8, 95, 95)
+        time_steps = ir_images.shape[0]
+        hovmoller_data = np.zeros((time_steps, 95, 95))
+        for t in range(time_steps):
+            tc_center = find_tc_center(ir_images[t])
+            hovmoller_data[t] = extract_local_region(ir_images[t], tc_center, 95)
+        hovmoller_list.append(hovmoller_data)
+    return np.array(hovmoller_list)
+
+def reshape_vmax(vmax_values, chunk_size=8):
+    trimmed_size = (len(vmax_values) // chunk_size) * chunk_size
+    vmax_values_trimmed = vmax_values[:trimmed_size]
+    return vmax_values_trimmed.reshape(-1, chunk_size)
+def create_3d_vmax(vmax_2d_array):
+    # Initialize a 3D array of shape (N, 8, 8) filled with zeros
+    vmax_3d_array = np.zeros((vmax_2d_array.shape[0], 8, 8))
+
+    # Fill the diagonal for each row in the 3D array
+    for i in range(vmax_2d_array.shape[0]):
+        np.fill_diagonal(vmax_3d_array[i], vmax_2d_array[i])
+
+    # Reshape to (N*10, 8, 8, 1) and remove the last element
+    vmax_3d_array = vmax_3d_array.reshape(-1, 8, 8, 1)
+     # Trim last element
+
+    return vmax_3d_array
+
+def process_lat_values(data):
+    lat_values = data # Convert to NumPy array
+
+    # Trim the array to make its length divisible by 8
+    trimmed_size = (len(lat_values) // 8) * 8
+    lat_values_trimmed = lat_values[:trimmed_size]
+    lat_values_trimmed=np.array(lat_values_trimmed)  # Convert to NumPy array
+    # Reshape into a 2D array (rows of 8 values each) and remove the last row
+    lat_2d_array = lat_values_trimmed.reshape(-1, 8)
+
+    return lat_2d_array
+
+def process_lon_values(data):
+    lon_values =data  # Convert to NumPy array
+    lon_values = np.array(lon_values)  # Convert to NumPy array
+    # Trim the array to make its length divisible by 8
+    trimmed_size = (len(lon_values) // 8) * 8
+    lon_values_trimmed = lon_values[:trimmed_size]
+
+    # Reshape into a 2D array (rows of 8 values each) and remove the last row
+    lon_2d_array = lon_values_trimmed.reshape(-1, 8)
+
+    return lon_2d_array
+
+import numpy as np
+
+def calculate_intensity_difference(vmax_2d_array):
+    """Calculates intensity difference for each row in Vmax 2D array."""
+    int_diff = []
+    
+    for i in vmax_2d_array:
+        k = abs(i[0] - i[-1])  # Absolute difference between first & last element
+        i = np.append(i, k)  # Append difference as the 9th element
+        int_diff.append(i)
+    
+    return np.array(int_diff)
+
+import numpy as np
+
+# Function to process and reshape image data
+def process_images(images, batch_size=8, img_size=(95, 95, 1)):
+    num_images = images.shape[0]
+    
+    # Trim the dataset to make it divisible by batch_size
+    trimmed_size = (num_images // batch_size) * batch_size
+    images_trimmed = images[:trimmed_size]
+
+    # Reshape into (x, batch_size, img_size[0], img_size[1], img_size[2])
+    images_reshaped = images_trimmed.reshape(-1, batch_size, *img_size)
+
+    return images_reshaped
+
+import numpy as np
+
+def process_cc_mask(cc_data):
+    """Processes CC mask images by trimming and reshaping into (x, 8, 95, 95, 1)."""
+    num_images = cc_data.shape[0]
+    batch_size = 8
+    trimmed_size = (num_images // batch_size) * batch_size  # Ensure divisibility by 8
+
+    images_trimmed = cc_data[:trimmed_size]  # Trim excess images
+    cc_images = images_trimmed.reshape(-1, batch_size, 95, 95, 1)  # Reshape
+
+    return cc_images
+def extract_convective_cores(ir_data):
+    """
+    Extract Convective Cores (CCs) from IR imagery based on the criteria in the paper.
+    Args:
+        ir_data: IR imagery of shape (height, width).
+    Returns:
+        cc_mask: Binary mask of CCs (1 for CC, 0 otherwise) of shape (height, width).
+    """
+    height, width,c = ir_data.shape
+    cc_mask = np.zeros_like(ir_data, dtype=np.float32)  # Initialize CC mask
+
+    # Define the neighborhood (8-connected)
+    neighbors = [(-1, -1), (-1, 0), (-1, 1),
+                 (0, -1),   (0,0)  ,     (0, 1),
+                 (1, -1),  (1, 0), (1, 1)]
+
+    for i in range(1, height - 1):  # Avoid boundary pixels
+        for j in range(1, width - 1):
+            bt_ij = ir_data[i, j]
+
+            # Condition 1: BT < 253K
+            if (bt_ij >= 253).any():
+                continue
+
+            # Condition 2: BT <= BT_n for all neighbors
+            is_local_min = True
+            for di, dj in neighbors:
+                if ir_data[i + di, j + dj] < bt_ij:
+                    is_local_min = False
+                    break
+            if not is_local_min:
+                continue
+
+            # Condition 3: Gradient condition
+            numerator1 = (ir_data[i - 1, j] + ir_data[i + 1, j] - 2 * bt_ij) / 3.1
+            numerator2 = (ir_data[i, j - 1] + ir_data[i, j + 1] - 2 * bt_ij) / 8.0
+            lhs = numerator1 + numerator2
+            rhs = (4 / 5.8) * np.exp(0.0826 * (bt_ij - 217))
+
+            if lhs > rhs:
+                cc_mask[i, j] = 1  # Mark as CC
+
+    return cc_mask
+
+def compute_convective_core_masks(ir_data):
+    """Extracts convective core masks for each IR image."""
+    cc_mask = []
+    
+    for i in ir_data:
+        c = extract_convective_cores(i)  # Assuming this function is defined
+        c = np.array(c)
+        cc_mask.append(c)
+    
+    return np.array(cc_mask)
+
+
+# ------------------ Streamlit UI ------------------
+st.set_page_config(page_title="TCIR Daily Input", layout="wide")
+
+st.title("Tropical Cyclone Input Uploader (8 sets/day)")
+
+ir_images = st.file_uploader("Upload 8 IR images", type=["jpg", "jpeg", "png"], accept_multiple_files=True)
+pmw_images = st.file_uploader("Upload 8 PMW images", type=["jpg", "jpeg", "png"], accept_multiple_files=True)
+
+if len(ir_images) != 8 or len(pmw_images) != 8:
+    st.warning("Please upload exactly 8 IR and 8 PMW images.")
+else:
+    st.success("Uploaded 8 IR and 8 PMW images successfully.")
+
+st.header("Input Latitude, Longitude, Vmax")
+lat_values, lon_values, vmax_values = [], [], []
+
+col1, col2, col3 = st.columns(3)
+with col1:
+    for i in range(8):
+        lat_values.append(st.number_input(f"Latitude {i+1}", key=f"lat{i}"))
+with col2:
+    for i in range(8):
+        lon_values.append(st.number_input(f"Longitude {i+1}", key=f"lon{i}"))
+with col3:
+    for i in range(8):
+        vmax_values.append(st.number_input(f"Vmax {i+1}", key=f"vmax{i}"))
+st.header("Select Prediction Model")
+model_choice = st.selectbox(
+    "Choose a model for prediction",
+    ("ConvGRU", "ConvLSTM", "Traj-GRU","3DCNN","spatiotemporalLSTM","Unet_LSTM"),
+    index=0
+)
+# ------------------ Process Button ------------------
+if st.button("Submit for Processing"):
+
+    if len(ir_images) == 8 and len(pmw_images) == 8:
+        # st.success("Starting preprocessing...")
+        if model_choice == "Unet_LSTM":
+            from unetlstm import predict_unetlstm
+            model_predict_fn = predict_unetlstm
+        elif model_choice == "ConvGRU":
+            from gru_model import predict
+            model_predict_fn = predict
+        elif model_choice == "ConvLSTM":
+            from convlstm import predict_lstm
+            model_predict_fn = predict_lstm
+        elif model_choice == "3DCNN":
+            from cnn3d import predict_3dcnn
+            model_predict_fn = predict_3dcnn
+        elif model_choice == "Traj-GRU":
+            from trjgru import predict_trajgru
+            model_predict_fn = predict_trajgru
+        elif model_choice == "spatiotemporalLSTM":
+            from spaio_temp import predict_stlstm
+            model_predict_fn = predict_stlstm
+        # from gru_model import predict
+        # from convlstm import predict_lstm
+        # from cnn3d import predict_3dcnn
+        # from trjgru import predict_trajgru
+        # from spaio_temp import predict_stlstm
+        # from unetlstm import predict_unetlstm
+        ir_arrays = []
+        pmw_arrays = []
+        train_vmax_2d = reshape_vmax(np.array(vmax_values))
+        # st.write("Vmax 2D shape:", train_vmax_2d.shape)
+        train_vmax_3d= create_3d_vmax(train_vmax_2d)
+        # st.write("Vmax 3D shape:", train_vmax_3d.shape)
+        lat_processed = process_lat_values(lat_values)
+        lon_processed = process_lon_values(lon_values)
+        # st.write("Lat 2D shape:", lat_processed.shape)
+        # st.write("Lon 2D shape:", lon_processed.shape)
+        v_max_diff = calculate_intensity_difference(train_vmax_2d)
+        # st.write("Vmax Intensity Difference shape:", v_max_diff.shape)
+        for ir in ir_images:
+            img = Image.open(ir).convert("L")
+            arr = np.array(img).astype(np.float32)
+            bt_arr = (arr / 255.0) * (310 - 190) + 190
+            resized = cv2.resize(bt_arr, (95, 95), interpolation=cv2.INTER_CUBIC)
+            ir_arrays.append(resized)
+
+        for pmw in pmw_images:
+            img = Image.open(pmw).convert("L")
+            arr = np.array(img).astype(np.float32) / 255.0
+            resized = cv2.resize(arr, (95, 95), interpolation=cv2.INTER_CUBIC)
+            pmw_arrays.append(resized)
+        ir=np.array(ir_arrays)
+        pmw=np.array(pmw_arrays)
+        # Stack into (8, 95, 95)
+        ir_seq = process_images(ir)
+        pmw_seq = process_images(pmw)
+
+        # st.write(f"IR sequence shape: {ir_seq.shape}")
+        # st.write(f"PMW sequence shape: {pmw_seq.shape}")
+
+        # For demonstration: create batches
+        X_train_new = ir_seq.reshape((1, 8, 95, 95)) # Shape: (1, 8, 95, 95)
+        # X_test_new = X_valid = X_train_new.copy()     # Dummy copies for now
+        # st.write(f"X_train_new shape: {X_train_new.shape}")
+        cc_mask= compute_convective_core_masks(X_train_new)
+        # st.write("CC Mask Shape:", cc_mask.shape)
+        hov_m_train = generate_hovmoller(X_train_new)
+        # hov_m_test = generate_hovmoller(X_test_new)
+        # hov_m_valid = generate_hovmoller(X_valid)
+        hov_m_train[np.isnan(hov_m_train)] = 0 
+        hov_m_train = hov_m_train.transpose(0, 2, 3, 1) 
+        # st.success("Hovmöller diagrams generated ✅")
+        # st.write("Hovmöller Train Shape:", hov_m_train.shape)
+        # st.write("Hovmöller Test Shape:", hov_m_test.shape)
+        # st.write("Hovmöller Valid Shape:", hov_m_valid.shape)
+        
+        # Visualize first sample
+        # st.subheader("Hovmöller Sample (Train Set)")
+        # for t in range(8):
+        #     st.image(hov_m_train[0, t], caption=f"Time Step {t+1}", clamp=True, width=150)
+        # st.write(hov_m_train[0,0])
+        cc_mask[np.isnan(cc_mask)] = 0
+        cc_mask=cc_mask.reshape(1, 8, 95, 95, 1)
+        i_images=cc_mask+ir_seq
+        reduced_images = np.concatenate([i_images,pmw_seq ], axis=-1)
+        reduced_images[np.isnan(reduced_images)] = 0
+        # st.write("Reduced Images Shape:", reduced_images.shape)
+        # y=np.isnan(reduced_images).sum()
+        # st.write("Reduced Images NaN Count:", y)
+        # model_predict_fn = {
+        #     "ConvGRU": predict,
+        #     "ConvLSTM": predict_lstm,
+        #     "3DCNN":predict_3dcnn,
+        #     "Traj-GRU": predict_trajgru,
+        #     "spatiotemporalLSTM": predict_stlstm,
+        #     "Unet_LSTM": predict_unetlstm,
+        # }[model_choice]
+        if model_choice == "Unet_LSTM":
+            import tensorflow as tf
+
+            def tf_gradient_magnitude(images):
+                # Sobel kernels
+                sobel_x = tf.constant([[1, 0, -1], [2, 0, -2], [1, 0, -1]], dtype=tf.float32)
+                sobel_y = tf.constant([[1, 2, 1], [0, 0, 0], [-1, -2, -1]], dtype=tf.float32)
+                sobel_x = tf.reshape(sobel_x, [3, 3, 1, 1])
+                sobel_y = tf.reshape(sobel_y, [3, 3, 1, 1])
+
+                images = tf.convert_to_tensor(images, dtype=tf.float32)
+                images = tf.expand_dims(images, -1)
+
+                gx = tf.nn.conv2d(images, sobel_x, strides=1, padding='SAME')
+                gy = tf.nn.conv2d(images, sobel_y, strides=1, padding='SAME')
+                grad_mag = tf.sqrt(tf.square(gx) + tf.square(gy) + 1e-6)
+
+                return tf.squeeze(grad_mag, -1).numpy()
+            def GM_maps_prep(ir):
+                GM_maps=[]
+                for i in ir:
+                    GM_map = tf_gradient_magnitude(i)
+                    GM_maps.append(GM_map)
+                GM_maps=np.array(GM_maps)
+                return GM_maps
+            ir_seq=ir_seq.reshape(8, 95, 95, 1)
+            GM_maps = GM_maps_prep(ir_seq)
+            print(GM_maps.shape)
+            GM_maps=GM_maps.reshape(1, 8, 95, 95, 1)
+            i_images=cc_mask+ir_seq+GM_maps
+            reduced_images = np.concatenate([i_images,pmw_seq ], axis=-1)
+            reduced_images[np.isnan(reduced_images)] = 0
+            print(reduced_images.shape)
+            y = model_predict_fn(reduced_images, hov_m_train, train_vmax_3d, lat_processed, lon_processed, v_max_diff)
+        else:
+            y = model_predict_fn(reduced_images, hov_m_train, train_vmax_3d, lat_processed, lon_processed, v_max_diff)
+        st.write("Predicted Vmax:", y)
+    else:
+        st.error("Make sure you uploaded exactly 8 IR and 8 PMW images.")

cnn3d.py

@@ -0,0 +1,230 @@
+import tensorflow as tf
+from tensorflow.keras import layers, models # type: ignore
+import numpy as np
+
+# Define the ConvGRU2DLayer (same as before)
+
+
+def build_3d_conv_model(input_shape=(8, 95, 95, 2), batch_size=16):
+    """
+    Builds a 3D ConvLSTM model with Conv3D layers and MaxPooling3D layers.
+    
+    Parameters:
+    - input_shape: Shape of the input tensor (time_steps, height, width, channels).
+    - batch_size: Batch size for the model.
+    
+    Returns:
+    - model: The compiled Keras model.
+    """
+    # Input tensor
+    input_tensor = layers.Input(shape=input_shape)
+    
+    # First ConvLSTM2D block with Conv3D
+    # x = layers.ConvLSTM2D(filters=32, kernel_size=(3, 3), padding='same', return_sequences=True)(input_tensor)
+    x = layers.Conv3D(filters=32, kernel_size=(3, 3, 3), padding='same', activation='relu')(input_tensor)
+    x = layers.MaxPooling3D(pool_size=(2, 2, 2), strides=(4, 3, 3), padding='same')(x)
+    
+    # Second ConvLSTM2D block with Conv3D
+    # x = layers.ConvLSTM2D(filters=64, kernel_size=(3, 3), padding='same', return_sequences=True)(x)
+    x = layers.Conv3D(filters=64, kernel_size=(3, 3, 3), padding='same', activation='relu')(x)
+    x = layers.MaxPooling3D(pool_size=(2, 2, 2), strides=(4, 3, 3), padding='same')(x)
+    
+    # Third ConvLSTM2D block with Conv3D
+    # x = layers.ConvLSTM2D(filters=128, kernel_size=(3, 3), padding='same', return_sequences=True)(x)
+    x = layers.Conv3D(filters=128, kernel_size=(3, 3, 3), padding='same', activation='relu')(x)
+    x = layers.MaxPooling3D(pool_size=(2, 2, 2), strides=(2, 2, 2), padding='same')(x)
+    
+    # Flatten the output before passing to the fully connected layers
+    x = layers.Flatten()(x)
+    
+    # Create the final model
+    model = models.Model(inputs=input_tensor, outputs=x)
+    
+    return model
+
+def radial_structure_subnet(input_shape):
+    """
+    Creates the subnet for extracting TC radial structure features using a five-branch CNN design with 2D convolutions.
+
+    Parameters:
+    - input_shape: tuple, shape of the input data (e.g., (95, 95, 3))
+
+    Returns:
+    - model: tf.keras.Model, the radial structure subnet model
+    """
+    
+    input_tensor = layers.Input(shape=input_shape)
+
+    # Divide input data into four quadrants (NW, NE, SW, SE)
+    # Assuming the input shape is (batch_size, height, width, channels)
+    
+    # Quadrant extraction - using slicing to separate quadrants
+    nw_quadrant = input_tensor[:, :input_shape[0]//2, :input_shape[1]//2, :]
+    ne_quadrant = input_tensor[:, :input_shape[0]//2, input_shape[1]//2:, :]
+    sw_quadrant = input_tensor[:, input_shape[0]//2:, :input_shape[1]//2, :]
+    se_quadrant = input_tensor[:, input_shape[0]//2:, input_shape[1]//2:, :]
+
+
+    target_height = max(input_shape[0]//2, input_shape[0] - input_shape[0]//2)  # 48
+    target_width = max(input_shape[1]//2, input_shape[1] - input_shape[1]//2)  # 48
+    
+    # Padding the quadrants to match the target size (48, 48)
+    nw_quadrant = layers.ZeroPadding2D(padding=((0, target_height - nw_quadrant.shape[1]), 
+                                                (0, target_width - nw_quadrant.shape[2])))(nw_quadrant)
+    ne_quadrant = layers.ZeroPadding2D(padding=((0, target_height - ne_quadrant.shape[1]), 
+                                                (0, target_width - ne_quadrant.shape[2])))(ne_quadrant)
+    sw_quadrant = layers.ZeroPadding2D(padding=((0, target_height - sw_quadrant.shape[1]), 
+                                                (0, target_width - sw_quadrant.shape[2])))(sw_quadrant)
+    se_quadrant = layers.ZeroPadding2D(padding=((0, target_height - se_quadrant.shape[1]), 
+                                                (0, target_width - se_quadrant.shape[2])))(se_quadrant)
+
+    print(nw_quadrant.shape)
+    print(ne_quadrant.shape)
+    print(sw_quadrant.shape)
+    print(se_quadrant.shape)
+    # Main branch (processing the entire structure)
+    main_branch = layers.Conv2D(filters=8, kernel_size=(3, 3), padding='same', activation='relu')(input_tensor)
+    y=layers.MaxPool2D()(main_branch)
+
+    y = layers.ZeroPadding2D(padding=((0, target_height - y.shape[1]), 
+                                   (0, target_width - y.shape[2])))(y)
+    # Side branches (processing the individual quadrants)
+    nw_branch = layers.Conv2D(filters=8, kernel_size=(3, 3), padding='same', activation='relu')(nw_quadrant)
+    ne_branch = layers.Conv2D(filters=8, kernel_size=(3, 3), padding='same', activation='relu')(ne_quadrant)
+    sw_branch = layers.Conv2D(filters=8, kernel_size=(3, 3), padding='same', activation='relu')(sw_quadrant)
+    se_branch = layers.Conv2D(filters=8, kernel_size=(3, 3), padding='same', activation='relu')(se_quadrant)
+    
+    # Apply padding to the side branches to match the dimensions of the main branch
+    # nw_branch = layers.UpSampling2D(size=(2, 2), interpolation='nearest')(nw_branch)
+    # ne_branch = layers.UpSampling2D(size=(2, 2), interpolation='nearest')(ne_branch)
+    # sw_branch = layers.UpSampling2D(size=(2, 2), interpolation='nearest')(sw_branch)
+    # se_branch = layers.UpSampling2D(size=(2, 2), interpolation='nearest')(se_branch)
+    
+    # Fusion operations (concatenate the outputs from the main branch and side branches)
+    fusion = layers.concatenate([y, nw_branch, ne_branch, sw_branch, se_branch], axis=-1)
+    
+    # Additional convolution layer to combine the fused features
+    x = layers.Conv2D(filters=16, kernel_size=(3, 3), padding='same', activation='relu')(fusion)
+    x=layers.MaxPool2D(pool_size=(2, 2))(x)
+    # Final dense layer for further processing
+    nw_branch = layers.Conv2D(filters=16, kernel_size=(3, 3), padding='same', activation='relu')(nw_branch)
+    
+    ne_branch = layers.Conv2D(filters=16, kernel_size=(3, 3), padding='same', activation='relu')(ne_branch)
+    sw_branch = layers.Conv2D(filters=16, kernel_size=(3, 3), padding='same', activation='relu')(sw_branch)
+    se_branch = layers.Conv2D(filters=16, kernel_size=(3, 3), padding='same', activation='relu')(se_branch)
+    nw_branch = layers.MaxPool2D(pool_size=(2, 2))(nw_branch)
+    ne_branch = layers.MaxPool2D(pool_size=(2, 2))(ne_branch)
+    sw_branch = layers.MaxPool2D(pool_size=(2, 2))(sw_branch)
+    se_branch = layers.MaxPool2D(pool_size=(2, 2))(se_branch)
+
+    fusion = layers.concatenate([x, nw_branch, ne_branch, sw_branch, se_branch], axis=-1)
+    x = layers.Conv2D(filters=32, kernel_size=(3, 3), padding='same', activation='relu')(fusion)
+    x=layers.MaxPool2D(pool_size=(2, 2))(x)
+    
+    nw_branch = layers.Conv2D(filters=32, kernel_size=(3, 3), padding='same', activation='relu')(nw_branch)
+    
+    ne_branch = layers.Conv2D(filters=32, kernel_size=(3, 3), padding='same', activation='relu')(ne_branch)
+    sw_branch = layers.Conv2D(filters=32, kernel_size=(3, 3), padding='same', activation='relu')(sw_branch)
+    se_branch = layers.Conv2D(filters=32, kernel_size=(3, 3), padding='same', activation='relu')(se_branch)
+    nw_branch = layers.MaxPool2D(pool_size=(2, 2))(nw_branch)
+    ne_branch = layers.MaxPool2D(pool_size=(2, 2))(ne_branch)
+    sw_branch = layers.MaxPool2D(pool_size=(2, 2))(sw_branch)
+    se_branch = layers.MaxPool2D(pool_size=(2, 2))(se_branch)
+
+    fusion = layers.concatenate([x, nw_branch, ne_branch, sw_branch, se_branch], axis=-1)
+    x = layers.Conv2D(filters=32, kernel_size=(3, 3),  activation='relu')(fusion)
+    x=layers.Conv2D(filters=32, kernel_size=(3, 3), activation=None)(x)
+    # Create and return the model
+    x=layers.Flatten()(x)
+    model = models.Model(inputs=input_tensor, outputs=x)
+    return model
+
+# Define input shape (batch_size, height, width, channels)
+# input_shape = (95, 95, 8)  # Example input shape (95x95 spatial resolution, 3 channels)
+
+# # Build the model
+# model = radial_structure_subnet(input_shape)
+
+# # Model summary
+# model.summary()
+
+def build_cnn_model(input_shape=(8, 8, 1)):
+    # Define the input layer
+    input_tensor = layers.Input(shape=input_shape)
+    
+    # Convolutional layer
+    x = layers.Conv2D(64, (3, 3), padding='same')(input_tensor)
+    x = layers.BatchNormalization()(x)
+    x = layers.ReLU()(x)
+    
+    # Flatten layer
+    x = layers.Flatten()(x)
+    
+    # Create the model
+    model = models.Model(inputs=input_tensor, outputs=x)
+    
+    return model
+
+from tensorflow.keras import layers, models, Input # type: ignore
+
+def build_combined_model():
+    # Define input shapes
+    input_shape_3d = (8, 95, 95, 2)
+    input_shape_radial = (95, 95, 8)
+    input_shape_cnn = (8, 8, 1)
+    
+    input_shape_latitude = (8,)
+    input_shape_longitude = (8,)
+    input_shape_other = (9,)
+
+    # Build individual models
+    model_3d = build_3d_conv_model(input_shape=input_shape_3d)
+    model_radial = radial_structure_subnet(input_shape=input_shape_radial)
+    model_cnn = build_cnn_model(input_shape=input_shape_cnn)
+
+    # Define new inputs
+    input_latitude = Input(shape=input_shape_latitude ,name="latitude_input")
+    input_longitude = Input(shape=input_shape_longitude, name="longitude_input")
+    input_other = Input(shape=input_shape_other, name="other_input")
+
+    # Flatten the additional inputs
+    flat_latitude = layers.Dense(32,activation='relu')(input_latitude)
+    flat_longitude = layers.Dense(32,activation='relu')(input_longitude)
+    flat_other = layers.Dense(64,activation='relu')(input_other)
+
+    # Combine all outputs
+    combined = layers.concatenate([
+        model_3d.output, 
+        model_radial.output, 
+        model_cnn.output,
+        flat_latitude, 
+        flat_longitude, 
+        flat_other
+    ])
+
+    # Add dense layers for final processing
+    x = layers.Dense(128, activation='relu')(combined)  
+    x = layers.Dense(1, activation=None)(x)
+
+    # Create the final model
+    final_model = models.Model(
+        inputs=[model_3d.input, model_radial.input, model_cnn.input,
+                input_latitude, input_longitude, input_other ],
+        outputs=x
+    )
+
+    return final_model
+
+import h5py
+with h5py.File(r"E:\1MAIN PROJECT\tf_env\3dcnn-model.h5", 'r') as f:
+    print(f.attrs.get('keras_version'))
+    print(f.attrs.get('backend'))
+    print("Model layers:", list(f['model_weights'].keys()))
+
+model = build_combined_model()  # Your original model building function
+model.load_weights(r"E:\1MAIN PROJECT\tf_env\3dcnn-model.h5")
+
+
+def predict_3dcnn(reduced_images_test,hov_m_test,test_vmax_3d,lat_test,lon_test,int_diff_test):
+    y=model.predict([reduced_images_test,hov_m_test,test_vmax_3d,lat_test,lon_test,int_diff_test ])
+    return y

convgru-model.h5

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

convlstm.py

@@ -0,0 +1,229 @@
+import tensorflow as tf
+from tensorflow.keras import layers, models # type: ignore
+import numpy as np
+
+# Define the ConvGRU2DLayer (same as before)
+
+def build_3d_conv_lstm_model(input_shape=(8, 95, 95, 2), batch_size=16):
+    """
+    Builds a 3D ConvLSTM model with Conv3D layers and MaxPooling3D layers.
+    
+    Parameters:
+    - input_shape: Shape of the input tensor (time_steps, height, width, channels).
+    - batch_size: Batch size for the model.
+    
+    Returns:
+    - model: The compiled Keras model.
+    """
+    # Input tensor
+    input_tensor = layers.Input(shape=input_shape)
+    
+    # First ConvLSTM2D block with Conv3D
+    x = layers.ConvLSTM2D(filters=32, kernel_size=(3, 3), padding='same', return_sequences=True)(input_tensor)
+    x = layers.Conv3D(filters=32, kernel_size=(3, 3, 3), padding='same', activation='relu')(x)
+    x = layers.MaxPooling3D(pool_size=(2, 2, 2), strides=(4, 3, 3), padding='same')(x)
+    
+    # Second ConvLSTM2D block with Conv3D
+    x = layers.ConvLSTM2D(filters=64, kernel_size=(3, 3), padding='same', return_sequences=True)(x)
+    x = layers.Conv3D(filters=64, kernel_size=(3, 3, 3), padding='same', activation='relu')(x)
+    x = layers.MaxPooling3D(pool_size=(2, 2, 2), strides=(4, 3, 3), padding='same')(x)
+    
+    # Third ConvLSTM2D block with Conv3D
+    x = layers.ConvLSTM2D(filters=128, kernel_size=(3, 3), padding='same', return_sequences=True)(x)
+    x = layers.Conv3D(filters=128, kernel_size=(3, 3, 3), padding='same', activation='relu')(x)
+    x = layers.MaxPooling3D(pool_size=(2, 2, 2), strides=(2, 2, 2), padding='same')(x)
+    
+    # Flatten the output before passing to the fully connected layers
+    x = layers.Flatten()(x)
+    
+    # Create the final model
+    model = models.Model(inputs=input_tensor, outputs=x)
+    
+    return model
+
+def radial_structure_subnet(input_shape):
+    """
+    Creates the subnet for extracting TC radial structure features using a five-branch CNN design with 2D convolutions.
+
+    Parameters:
+    - input_shape: tuple, shape of the input data (e.g., (95, 95, 3))
+
+    Returns:
+    - model: tf.keras.Model, the radial structure subnet model
+    """
+    
+    input_tensor = layers.Input(shape=input_shape)
+
+    # Divide input data into four quadrants (NW, NE, SW, SE)
+    # Assuming the input shape is (batch_size, height, width, channels)
+    
+    # Quadrant extraction - using slicing to separate quadrants
+    nw_quadrant = input_tensor[:, :input_shape[0]//2, :input_shape[1]//2, :]
+    ne_quadrant = input_tensor[:, :input_shape[0]//2, input_shape[1]//2:, :]
+    sw_quadrant = input_tensor[:, input_shape[0]//2:, :input_shape[1]//2, :]
+    se_quadrant = input_tensor[:, input_shape[0]//2:, input_shape[1]//2:, :]
+
+
+    target_height = max(input_shape[0]//2, input_shape[0] - input_shape[0]//2)  # 48
+    target_width = max(input_shape[1]//2, input_shape[1] - input_shape[1]//2)  # 48
+    
+    # Padding the quadrants to match the target size (48, 48)
+    nw_quadrant = layers.ZeroPadding2D(padding=((0, target_height - nw_quadrant.shape[1]), 
+                                                (0, target_width - nw_quadrant.shape[2])))(nw_quadrant)
+    ne_quadrant = layers.ZeroPadding2D(padding=((0, target_height - ne_quadrant.shape[1]), 
+                                                (0, target_width - ne_quadrant.shape[2])))(ne_quadrant)
+    sw_quadrant = layers.ZeroPadding2D(padding=((0, target_height - sw_quadrant.shape[1]), 
+                                                (0, target_width - sw_quadrant.shape[2])))(sw_quadrant)
+    se_quadrant = layers.ZeroPadding2D(padding=((0, target_height - se_quadrant.shape[1]), 
+                                                (0, target_width - se_quadrant.shape[2])))(se_quadrant)
+
+    print(nw_quadrant.shape)
+    print(ne_quadrant.shape)
+    print(sw_quadrant.shape)
+    print(se_quadrant.shape)
+    # Main branch (processing the entire structure)
+    main_branch = layers.Conv2D(filters=8, kernel_size=(3, 3), padding='same', activation='relu')(input_tensor)
+    y=layers.MaxPool2D()(main_branch)
+
+    y = layers.ZeroPadding2D(padding=((0, target_height - y.shape[1]), 
+                                   (0, target_width - y.shape[2])))(y)
+    # Side branches (processing the individual quadrants)
+    nw_branch = layers.Conv2D(filters=8, kernel_size=(3, 3), padding='same', activation='relu')(nw_quadrant)
+    ne_branch = layers.Conv2D(filters=8, kernel_size=(3, 3), padding='same', activation='relu')(ne_quadrant)
+    sw_branch = layers.Conv2D(filters=8, kernel_size=(3, 3), padding='same', activation='relu')(sw_quadrant)
+    se_branch = layers.Conv2D(filters=8, kernel_size=(3, 3), padding='same', activation='relu')(se_quadrant)
+    
+    # Apply padding to the side branches to match the dimensions of the main branch
+    # nw_branch = layers.UpSampling2D(size=(2, 2), interpolation='nearest')(nw_branch)
+    # ne_branch = layers.UpSampling2D(size=(2, 2), interpolation='nearest')(ne_branch)
+    # sw_branch = layers.UpSampling2D(size=(2, 2), interpolation='nearest')(sw_branch)
+    # se_branch = layers.UpSampling2D(size=(2, 2), interpolation='nearest')(se_branch)
+    
+    # Fusion operations (concatenate the outputs from the main branch and side branches)
+    fusion = layers.concatenate([y, nw_branch, ne_branch, sw_branch, se_branch], axis=-1)
+    
+    # Additional convolution layer to combine the fused features
+    x = layers.Conv2D(filters=16, kernel_size=(3, 3), padding='same', activation='relu')(fusion)
+    x=layers.MaxPool2D(pool_size=(2, 2))(x)
+    # Final dense layer for further processing
+    nw_branch = layers.Conv2D(filters=16, kernel_size=(3, 3), padding='same', activation='relu')(nw_branch)
+    
+    ne_branch = layers.Conv2D(filters=16, kernel_size=(3, 3), padding='same', activation='relu')(ne_branch)
+    sw_branch = layers.Conv2D(filters=16, kernel_size=(3, 3), padding='same', activation='relu')(sw_branch)
+    se_branch = layers.Conv2D(filters=16, kernel_size=(3, 3), padding='same', activation='relu')(se_branch)
+    nw_branch = layers.MaxPool2D(pool_size=(2, 2))(nw_branch)
+    ne_branch = layers.MaxPool2D(pool_size=(2, 2))(ne_branch)
+    sw_branch = layers.MaxPool2D(pool_size=(2, 2))(sw_branch)
+    se_branch = layers.MaxPool2D(pool_size=(2, 2))(se_branch)
+
+    fusion = layers.concatenate([x, nw_branch, ne_branch, sw_branch, se_branch], axis=-1)
+    x = layers.Conv2D(filters=32, kernel_size=(3, 3), padding='same', activation='relu')(fusion)
+    x=layers.MaxPool2D(pool_size=(2, 2))(x)
+    
+    nw_branch = layers.Conv2D(filters=32, kernel_size=(3, 3), padding='same', activation='relu')(nw_branch)
+    
+    ne_branch = layers.Conv2D(filters=32, kernel_size=(3, 3), padding='same', activation='relu')(ne_branch)
+    sw_branch = layers.Conv2D(filters=32, kernel_size=(3, 3), padding='same', activation='relu')(sw_branch)
+    se_branch = layers.Conv2D(filters=32, kernel_size=(3, 3), padding='same', activation='relu')(se_branch)
+    nw_branch = layers.MaxPool2D(pool_size=(2, 2))(nw_branch)
+    ne_branch = layers.MaxPool2D(pool_size=(2, 2))(ne_branch)
+    sw_branch = layers.MaxPool2D(pool_size=(2, 2))(sw_branch)
+    se_branch = layers.MaxPool2D(pool_size=(2, 2))(se_branch)
+
+    fusion = layers.concatenate([x, nw_branch, ne_branch, sw_branch, se_branch], axis=-1)
+    x = layers.Conv2D(filters=32, kernel_size=(3, 3),  activation='relu')(fusion)
+    x=layers.Conv2D(filters=32, kernel_size=(3, 3), activation=None)(x)
+    # Create and return the model
+    x=layers.Flatten()(x)
+    model = models.Model(inputs=input_tensor, outputs=x)
+    return model
+
+# Define input shape (batch_size, height, width, channels)
+# input_shape = (95, 95, 8)  # Example input shape (95x95 spatial resolution, 3 channels)
+
+# # Build the model
+# model = radial_structure_subnet(input_shape)
+
+# # Model summary
+# model.summary()
+
+def build_cnn_model(input_shape=(8, 8, 1)):
+    # Define the input layer
+    input_tensor = layers.Input(shape=input_shape)
+    
+    # Convolutional layer
+    x = layers.Conv2D(64, (3, 3), padding='same')(input_tensor)
+    x = layers.BatchNormalization()(x)
+    x = layers.ReLU()(x)
+    
+    # Flatten layer
+    x = layers.Flatten()(x)
+    
+    # Create the model
+    model = models.Model(inputs=input_tensor, outputs=x)
+    
+    return model
+
+from tensorflow.keras import layers, models, Input # type: ignore
+
+def build_combined_model():
+    # Define input shapes
+    input_shape_3d = (8, 95, 95, 2)
+    input_shape_radial = (95, 95, 8)
+    input_shape_cnn = (8, 8, 1)
+    
+    input_shape_latitude = (8,)
+    input_shape_longitude = (8,)
+    input_shape_other = (9,)
+
+    # Build individual models
+    model_3d = build_3d_conv_lstm_model(input_shape=input_shape_3d)
+    model_radial = radial_structure_subnet(input_shape=input_shape_radial)
+    model_cnn = build_cnn_model(input_shape=input_shape_cnn)
+
+    # Define new inputs
+    input_latitude = Input(shape=input_shape_latitude ,name="latitude_input")
+    input_longitude = Input(shape=input_shape_longitude, name="longitude_input")
+    input_other = Input(shape=input_shape_other, name="other_input")
+
+    # Flatten the additional inputs
+    flat_latitude = layers.Dense(32,activation='relu')(input_latitude)
+    flat_longitude = layers.Dense(32,activation='relu')(input_longitude)
+    flat_other = layers.Dense(64,activation='relu')(input_other)
+
+    # Combine all outputs
+    combined = layers.concatenate([
+        model_3d.output, 
+        model_radial.output, 
+        model_cnn.output,
+        flat_latitude, 
+        flat_longitude, 
+        flat_other
+    ])
+
+    # Add dense layers for final processing
+    x = layers.Dense(128, activation='relu')(combined)  
+    x = layers.Dense(1, activation=None)(x)
+
+    # Create the final model
+    final_model = models.Model(
+        inputs=[model_3d.input, model_radial.input, model_cnn.input,
+                input_latitude, input_longitude, input_other ],
+        outputs=x
+    )
+
+    return final_model
+
+import h5py
+with h5py.File(r"E:\1MAIN PROJECT\tf_env\lstm3dcnn-model.h5", 'r') as f:
+    print(f.attrs.get('keras_version'))
+    print(f.attrs.get('backend'))
+    print("Model layers:", list(f['model_weights'].keys()))
+
+model = build_combined_model()  # Your original model building function
+model.load_weights(r"E:\1MAIN PROJECT\tf_env\lstm3dcnn-model.h5")
+
+
+def predict_lstm(reduced_images_test,hov_m_test,test_vmax_3d,lat_test,lon_test,int_diff_test):
+    y=model.predict([reduced_images_test,hov_m_test,test_vmax_3d,lat_test,lon_test,int_diff_test ])
+    return y

final_model.h5

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

gru_model.py

@@ -0,0 +1,245 @@
+import tensorflow as tf
+from tensorflow.keras import layers, models # type: ignore
+import numpy as np
+
+# Define the ConvGRU2DLayer (same as before)
+class ConvGRU2DLayer(layers.Layer):
+    def __init__(self, filters, kernel_size, return_sequences=True, **kwargs):
+        super().__init__(**kwargs)
+        self.filters = filters
+        self.kernel_size = kernel_size
+        self.return_sequences = return_sequences
+
+    def build(self, input_shape):
+        self.input_projection = layers.Conv2D(self.filters, (1, 1), padding="same")
+        self.conv_z = layers.Conv2D(self.filters, self.kernel_size, padding="same", activation="sigmoid")
+        self.conv_r = layers.Conv2D(self.filters, self.kernel_size, padding="same", activation="sigmoid")
+        self.conv_h = layers.Conv2D(self.filters, self.kernel_size, padding="same", activation="tanh")
+        super().build(input_shape)
+
+    def call(self, inputs):
+        batch_size, time_steps, height, width, channels = tf.unstack(tf.shape(inputs))
+        time_steps=inputs.shape[1]
+        h_t = tf.zeros((batch_size, height, width, self.filters))
+        outputs = []
+
+        for t in range(time_steps):
+            x_t = inputs[:, t, :, :, :]
+            x_projected = self.input_projection(x_t)
+            z = self.conv_z(x_projected)+self.conv_z(h_t)
+            r = self.conv_r(x_projected)+self.conv_z(h_t)
+            h_tilde = self.conv_h(r * h_t)
+            h_t = (1 - z) * h_t + z * h_tilde
+
+            if self.return_sequences:
+                outputs.append(h_t)
+
+        if self.return_sequences:
+            outputs = tf.stack(outputs, axis=1)
+        else:
+            outputs = h_t
+
+        return outputs
+
+# Define the model (same as before)
+def build_convgru_model(input_shape=(8, 95, 95, 2)):
+    input_tensor = layers.Input(shape=input_shape)
+    x = ConvGRU2DLayer(filters=32, kernel_size=(3, 3), return_sequences=True)(input_tensor)
+    x = layers.Conv3D(filters=32, kernel_size=(3, 3, 3), padding='same', activation='relu')(x)
+    x = layers.MaxPooling3D(pool_size=(2, 2, 2), strides=(4, 3, 3), padding='same')(x)
+    x = ConvGRU2DLayer(filters=64, kernel_size=(3, 3), return_sequences=True)(x)
+    x = layers.Conv3D(filters=64, kernel_size=(3, 3, 3), padding='same', activation='relu')(x)
+    x = layers.MaxPooling3D(pool_size=(2, 2, 2), strides=(4, 3, 3), padding='same')(x)
+    x = ConvGRU2DLayer(filters=128, kernel_size=(3, 3), return_sequences=True)(x)
+    x = layers.Conv3D(filters=128, kernel_size=(3, 3, 3), padding='same', activation='relu')(x)
+    x = layers.MaxPooling3D(pool_size=(2, 2, 2), strides=(2, 2, 2), padding='same')(x)
+    x = layers.Flatten()(x)
+    model = models.Model(inputs=input_tensor, outputs=x)
+    return model
+
+def radial_structure_subnet(input_shape):
+    """
+    Creates the subnet for extracting TC radial structure features using a five-branch CNN design with 2D convolutions.
+
+    Parameters:
+    - input_shape: tuple, shape of the input data (e.g., (95, 95, 3))
+
+    Returns:
+    - model: tf.keras.Model, the radial structure subnet model
+    """
+    
+    input_tensor = layers.Input(shape=input_shape)
+
+    # Divide input data into four quadrants (NW, NE, SW, SE)
+    # Assuming the input shape is (batch_size, height, width, channels)
+    
+    # Quadrant extraction - using slicing to separate quadrants
+    nw_quadrant = input_tensor[:, :input_shape[0]//2, :input_shape[1]//2, :]
+    ne_quadrant = input_tensor[:, :input_shape[0]//2, input_shape[1]//2:, :]
+    sw_quadrant = input_tensor[:, input_shape[0]//2:, :input_shape[1]//2, :]
+    se_quadrant = input_tensor[:, input_shape[0]//2:, input_shape[1]//2:, :]
+
+
+    target_height = max(input_shape[0]//2, input_shape[0] - input_shape[0]//2)  # 48
+    target_width = max(input_shape[1]//2, input_shape[1] - input_shape[1]//2)  # 48
+    
+    # Padding the quadrants to match the target size (48, 48)
+    nw_quadrant = layers.ZeroPadding2D(padding=((0, target_height - nw_quadrant.shape[1]), 
+                                                (0, target_width - nw_quadrant.shape[2])))(nw_quadrant)
+    ne_quadrant = layers.ZeroPadding2D(padding=((0, target_height - ne_quadrant.shape[1]), 
+                                                (0, target_width - ne_quadrant.shape[2])))(ne_quadrant)
+    sw_quadrant = layers.ZeroPadding2D(padding=((0, target_height - sw_quadrant.shape[1]), 
+                                                (0, target_width - sw_quadrant.shape[2])))(sw_quadrant)
+    se_quadrant = layers.ZeroPadding2D(padding=((0, target_height - se_quadrant.shape[1]), 
+                                                (0, target_width - se_quadrant.shape[2])))(se_quadrant)
+
+    print(nw_quadrant.shape)
+    print(ne_quadrant.shape)
+    print(sw_quadrant.shape)
+    print(se_quadrant.shape)
+    # Main branch (processing the entire structure)
+    main_branch = layers.Conv2D(filters=8, kernel_size=(3, 3), padding='same', activation='relu')(input_tensor)
+    y=layers.MaxPool2D()(main_branch)
+
+    y = layers.ZeroPadding2D(padding=((0, target_height - y.shape[1]), 
+                                   (0, target_width - y.shape[2])))(y)
+    # Side branches (processing the individual quadrants)
+    nw_branch = layers.Conv2D(filters=8, kernel_size=(3, 3), padding='same', activation='relu')(nw_quadrant)
+    ne_branch = layers.Conv2D(filters=8, kernel_size=(3, 3), padding='same', activation='relu')(ne_quadrant)
+    sw_branch = layers.Conv2D(filters=8, kernel_size=(3, 3), padding='same', activation='relu')(sw_quadrant)
+    se_branch = layers.Conv2D(filters=8, kernel_size=(3, 3), padding='same', activation='relu')(se_quadrant)
+    
+    # Apply padding to the side branches to match the dimensions of the main branch
+    # nw_branch = layers.UpSampling2D(size=(2, 2), interpolation='nearest')(nw_branch)
+    # ne_branch = layers.UpSampling2D(size=(2, 2), interpolation='nearest')(ne_branch)
+    # sw_branch = layers.UpSampling2D(size=(2, 2), interpolation='nearest')(sw_branch)
+    # se_branch = layers.UpSampling2D(size=(2, 2), interpolation='nearest')(se_branch)
+    
+    # Fusion operations (concatenate the outputs from the main branch and side branches)
+    fusion = layers.concatenate([y, nw_branch, ne_branch, sw_branch, se_branch], axis=-1)
+    
+    # Additional convolution layer to combine the fused features
+    x = layers.Conv2D(filters=16, kernel_size=(3, 3), padding='same', activation='relu')(fusion)
+    x=layers.MaxPool2D(pool_size=(2, 2))(x)
+    # Final dense layer for further processing
+    nw_branch = layers.Conv2D(filters=16, kernel_size=(3, 3), padding='same', activation='relu')(nw_branch)
+    
+    ne_branch = layers.Conv2D(filters=16, kernel_size=(3, 3), padding='same', activation='relu')(ne_branch)
+    sw_branch = layers.Conv2D(filters=16, kernel_size=(3, 3), padding='same', activation='relu')(sw_branch)
+    se_branch = layers.Conv2D(filters=16, kernel_size=(3, 3), padding='same', activation='relu')(se_branch)
+    nw_branch = layers.MaxPool2D(pool_size=(2, 2))(nw_branch)
+    ne_branch = layers.MaxPool2D(pool_size=(2, 2))(ne_branch)
+    sw_branch = layers.MaxPool2D(pool_size=(2, 2))(sw_branch)
+    se_branch = layers.MaxPool2D(pool_size=(2, 2))(se_branch)
+
+    fusion = layers.concatenate([x, nw_branch, ne_branch, sw_branch, se_branch], axis=-1)
+    x = layers.Conv2D(filters=32, kernel_size=(3, 3), padding='same', activation='relu')(fusion)
+    x=layers.MaxPool2D(pool_size=(2, 2))(x)
+    
+    nw_branch = layers.Conv2D(filters=32, kernel_size=(3, 3), padding='same', activation='relu')(nw_branch)
+    
+    ne_branch = layers.Conv2D(filters=32, kernel_size=(3, 3), padding='same', activation='relu')(ne_branch)
+    sw_branch = layers.Conv2D(filters=32, kernel_size=(3, 3), padding='same', activation='relu')(sw_branch)
+    se_branch = layers.Conv2D(filters=32, kernel_size=(3, 3), padding='same', activation='relu')(se_branch)
+    nw_branch = layers.MaxPool2D(pool_size=(2, 2))(nw_branch)
+    ne_branch = layers.MaxPool2D(pool_size=(2, 2))(ne_branch)
+    sw_branch = layers.MaxPool2D(pool_size=(2, 2))(sw_branch)
+    se_branch = layers.MaxPool2D(pool_size=(2, 2))(se_branch)
+
+    fusion = layers.concatenate([x, nw_branch, ne_branch, sw_branch, se_branch], axis=-1)
+    x = layers.Conv2D(filters=32, kernel_size=(3, 3),  activation='relu')(fusion)
+    x=layers.Conv2D(filters=32, kernel_size=(3, 3), activation=None)(x)
+    # Create and return the model
+    x=layers.Flatten()(x)
+    model = models.Model(inputs=input_tensor, outputs=x)
+    return model
+
+# Define input shape (batch_size, height, width, channels)
+# input_shape = (95, 95, 8)  # Example input shape (95x95 spatial resolution, 3 channels)
+
+# # Build the model
+# model = radial_structure_subnet(input_shape)
+
+# # Model summary
+# model.summary()
+
+def build_cnn_model(input_shape=(8, 8, 1)):
+    # Define the input layer
+    input_tensor = layers.Input(shape=input_shape)
+    
+    # Convolutional layer
+    x = layers.Conv2D(64, (3, 3), padding='same')(input_tensor)
+    x = layers.BatchNormalization()(x)
+    x = layers.ReLU()(x)
+    
+    # Flatten layer
+    x = layers.Flatten()(x)
+    
+    # Create the model
+    model = models.Model(inputs=input_tensor, outputs=x)
+    
+    return model
+
+from tensorflow.keras import layers, models, Input # type: ignore
+
+def build_combined_model():
+    # Define input shapes
+    input_shape_3d = (8, 95, 95, 2)
+    input_shape_radial = (95, 95, 8)
+    input_shape_cnn = (8, 8, 1)
+    
+    input_shape_latitude = (8,)
+    input_shape_longitude = (8,)
+    input_shape_other = (9,)
+
+    # Build individual models
+    model_3d = build_convgru_model(input_shape=input_shape_3d)
+    model_radial = radial_structure_subnet(input_shape=input_shape_radial)
+    model_cnn = build_cnn_model(input_shape=input_shape_cnn)
+
+    # Define new inputs
+    input_latitude = Input(shape=input_shape_latitude ,name="latitude_input")
+    input_longitude = Input(shape=input_shape_longitude, name="longitude_input")
+    input_other = Input(shape=input_shape_other, name="other_input")
+
+    # Flatten the additional inputs
+    flat_latitude = layers.Dense(32,activation='relu')(input_latitude)
+    flat_longitude = layers.Dense(32,activation='relu')(input_longitude)
+    flat_other = layers.Dense(64,activation='relu')(input_other)
+
+    # Combine all outputs
+    combined = layers.concatenate([
+        model_3d.output, 
+        model_radial.output, 
+        model_cnn.output,
+        flat_latitude, 
+        flat_longitude, 
+        flat_other
+    ])
+
+    # Add dense layers for final processing
+    x = layers.Dense(128, activation='relu')(combined)  
+    x = layers.Dense(1, activation=None)(x)
+
+    # Create the final model
+    final_model = models.Model(
+        inputs=[model_3d.input, model_radial.input, model_cnn.input,
+                input_latitude, input_longitude, input_other ],
+        outputs=x
+    )
+
+    return final_model
+
+import h5py
+with h5py.File(r"E:\1MAIN PROJECT\tf_env\convgru-model.h5", 'r') as f:
+    print(f.attrs.get('keras_version'))
+    print(f.attrs.get('backend'))
+    print("Model layers:", list(f['model_weights'].keys()))
+
+model = build_combined_model()  # Your original model building function
+model.load_weights(r"E:\1MAIN PROJECT\tf_env\convgru-model.h5")
+
+
+def predict(reduced_images_test,hov_m_test,test_vmax_3d,lat_test,lon_test,int_diff_test):
+    y=model.predict([reduced_images_test,hov_m_test,test_vmax_3d,lat_test,lon_test,int_diff_test ])
+    return y

lstm3dcnn-model.h5

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

requirements.txt

@@ -0,0 +1,66 @@
+absl-py==2.2.2
+altair==5.5.0
+astunparse==1.6.3
+attrs==25.3.0
+blinker==1.9.0
+cachetools==5.5.2
+certifi==2025.1.31
+charset-normalizer==3.4.1
+click==8.1.8
+colorama==0.4.6
+flatbuffers==25.2.10
+gast==0.6.0
+gitdb==4.0.12
+GitPython==3.1.44
+google-pasta==0.2.0
+grpcio==1.71.0
+h5py==3.13.0
+idna==3.10
+Jinja2==3.1.6
+jsonschema==4.23.0
+jsonschema-specifications==2024.10.1
+keras==3.9.2
+libclang==18.1.1
+Markdown==3.8
+markdown-it-py==3.0.0
+MarkupSafe==3.0.2
+mdurl==0.1.2
+ml_dtypes==0.5.1
+namex==0.0.8
+narwhals==1.34.1
+numpy==2.1.3
+opencv-python==4.11.0.86
+opt_einsum==3.4.0
+optree==0.15.0
+packaging==24.2
+pandas==2.2.3
+pillow==11.2.1
+protobuf==5.29.4
+pyarrow==19.0.1
+pydeck==0.9.1
+Pygments==2.19.1
+python-dateutil==2.9.0.post0
+pytz==2025.2
+referencing==0.36.2
+requests==2.32.3
+rich==14.0.0
+rpds-py==0.24.0
+scipy==1.15.2
+setuptools==78.1.0
+six==1.17.0
+smmap==5.0.2
+streamlit==1.44.1
+tenacity==9.1.2
+tensorboard==2.19.0
+tensorboard-data-server==0.7.2
+tensorflow==2.19.0
+termcolor==3.0.1
+toml==0.10.2
+tornado==6.4.2
+typing_extensions==4.13.2
+tzdata==2025.2
+urllib3==2.4.0
+watchdog==6.0.0
+Werkzeug==3.1.3
+wheel==0.45.1
+wrapt==1.17.2

spaio_temp.py

@@ -0,0 +1,327 @@
+import tensorflow as tf
+from tensorflow.keras import layers, models # type: ignore
+import numpy as np
+
+
+class SpatiotemporalLSTMCell(layers.Layer):
+    """
+    SpatiotemporalLSTMCell: A custom LSTM cell that captures both spatial and temporal dependencies.
+    It extends the traditional LSTM by adding a memory state (m_t) that focuses on spatial correlations.
+    """
+    def __init__(self, filters, kernel_size, **kwargs):
+        super().__init__(**kwargs)
+        self.filters = filters  # Number of output filters in the convolution
+        self.kernel_size = kernel_size  # Size of the convolutional kernel
+        
+        # Convolutional components for standard LSTM operations
+        self.conv_xg = layers.Conv2D(filters, kernel_size, padding="same", activation="tanh")    # For cell input
+        self.conv_xi = layers.Conv2D(filters, kernel_size, padding="same", activation="sigmoid") # For input gate
+        self.conv_xf = layers.Conv2D(filters, kernel_size, padding="same", activation="sigmoid") # For forget gate
+        self.conv_xo = layers.Conv2D(filters, kernel_size, padding="same", activation="sigmoid") # For output gate
+        
+        # Convolutional components for spatiotemporal memory operations
+        self.conv_xg_st = layers.Conv2D(filters, kernel_size, padding="same", activation="tanh")    # For ST cell input
+        self.conv_xi_st = layers.Conv2D(filters, kernel_size, padding="same", activation="sigmoid") # For ST input gate
+        self.conv_xf_st = layers.Conv2D(filters, kernel_size, padding="same", activation="sigmoid") # For ST forget gate
+        
+        # Fusion layer to combine the cell state and spatiotemporal memory
+        self.conv_fusion = layers.Conv2D(filters, (1, 1), padding="same")  # 1x1 conv for dimensionality reduction
+    
+    def call(self, inputs, states):
+        """
+        Forward pass of the spatiotemporal LSTM cell.
+        
+        Args:
+            inputs: Input tensor of shape [batch_size, height, width, channels]
+            states: List of previous states [h_t-1, c_t-1, m_t-1]
+                   h_t-1: previous hidden state
+                   c_t-1: previous cell state
+                   m_t-1: previous spatiotemporal memory
+        """
+        prev_h, prev_c, prev_m = states
+        
+        # Standard LSTM operations
+        g_t = self.conv_xg(inputs) + self.conv_xg(prev_h)  # Cell input activation
+        i_t = self.conv_xi(inputs) + self.conv_xi(prev_h)  # Input gate
+        f_t = self.conv_xf(inputs) + self.conv_xf(prev_h)  # Forget gate
+        o_t = self.conv_xo(inputs) + self.conv_xo(prev_h)  # Output gate
+        
+        # Cell state update - bug detected: should use prev_c instead of self.conv_xo(prev_h)
+        c_t = tf.sigmoid(f_t) * self.conv_xo(prev_h) + tf.sigmoid(i_t) * tf.tanh(g_t)
+        
+        # Spatiotemporal memory operations
+        g_t_st = self.conv_xg_st(inputs) + self.conv_xg_st(prev_m)  # ST cell input
+        i_t_st = self.conv_xi_st(inputs) + self.conv_xi_st(prev_m)  # ST input gate
+        f_t_st = self.conv_xf_st(inputs) + self.conv_xf_st(prev_m)  # ST forget gate
+        
+        # Spatiotemporal memory update - bug detected: should use prev_m directly instead of self.conv_xf_st(prev_m)
+        m_t = tf.sigmoid(f_t_st) * self.conv_xf_st(prev_m) + tf.sigmoid(i_t_st) * tf.tanh(g_t_st)
+        
+        # Hidden state update by fusing cell state and spatiotemporal memory
+        h_t = tf.sigmoid(o_t) * tf.tanh(self.conv_fusion(tf.concat([c_t, m_t], axis=-1)))
+        
+        return h_t, [h_t, c_t, m_t]  # Return the hidden state and all updated states
+
+class SpatiotemporalLSTM(layers.Layer):
+    """
+    SpatiotemporalLSTM: Custom layer that applies the SpatiotemporalLSTMCell to a sequence of inputs.
+    This processes 3D data with spatial and temporal dimensions.
+    """
+    def __init__(self, filters, kernel_size, **kwargs):
+        super().__init__(**kwargs)
+        self.cell = SpatiotemporalLSTMCell(filters, kernel_size)
+    
+    def call(self, inputs):
+        """
+        Forward pass of the SpatiotemporalLSTM layer.
+        
+        Args:
+            inputs: Input tensor of shape [batch_size, time_steps, height, width, channels]
+        """
+        batch_size = tf.shape(inputs)[0]
+        time_steps = inputs.shape[1]
+        height = inputs.shape[2]
+        width = inputs.shape[3]
+        channels = inputs.shape[4]
+        
+        # Initialize states with zeros
+        h_t = tf.zeros((batch_size, height, width, channels))  # Hidden state
+        c_t = tf.zeros((batch_size, height, width, channels))  # Cell state
+        m_t = tf.zeros((batch_size, height, width, channels))  # Spatiotemporal memory
+        
+        outputs = []
+        # Process sequence step by step
+        for t in range(time_steps):
+            # Apply the cell to the current time step and previous states
+            h_t, [h_t, c_t, m_t] = self.cell(inputs[:, t], [h_t[:,:,:,:inputs.shape[4]], 
+                                                          c_t[:,:,:,:inputs.shape[4]], 
+                                                          m_t[:,:,:,:inputs.shape[4]]])
+            outputs.append(h_t)
+        
+        # Stack outputs along time dimension
+        return tf.stack(outputs, axis=1)
+
+def build_st_lstm_model(input_shape=(8, 95, 95, 2)):
+    """
+    Build a complete spatiotemporal LSTM model for sequence processing of spatial data.
+    
+    Args:
+        input_shape: Tuple of (time_steps, height, width, channels)
+    
+    Returns:
+        A Keras model with spatiotemporal LSTM layers
+    """
+    # Create input layer with fixed batch size
+    input_tensor = layers.Input(shape=input_shape, batch_size=16)
+    
+    # First spatiotemporal LSTM block
+    st_lstm_layer = SpatiotemporalLSTM(filters=32, kernel_size=(3, 3))
+    x = st_lstm_layer(input_tensor)
+    x = layers.Conv3D(filters=32, kernel_size=(3, 3, 3), padding='same', activation='relu')(x)
+    x = layers.MaxPooling3D(pool_size=(2, 2, 2), strides=(2, 2, 2), padding='same')(x)
+    
+    # Second spatiotemporal LSTM block
+    st_lstm_layer = SpatiotemporalLSTM(filters=64, kernel_size=(3, 3))
+    x = st_lstm_layer(x)
+    x = layers.Conv3D(filters=64, kernel_size=(3, 3, 3), padding='same', activation='relu')(x)
+    x = layers.MaxPooling3D(pool_size=(2, 2, 2), strides=(2, 2, 2), padding='same')(x)
+    
+    # Third spatiotemporal LSTM block
+    st_lstm_layer = SpatiotemporalLSTM(filters=128, kernel_size=(3, 3))
+    x = st_lstm_layer(x)
+    x = layers.Conv3D(filters=128, kernel_size=(3, 3, 3), padding='same', activation='relu')(x)
+    x = layers.MaxPooling3D(pool_size=(2, 2, 2), strides=(2, 2, 2), padding='same')(x)
+    
+    # Flatten and prepare for output layers (not included in this model)
+    x = layers.Flatten()(x)
+    
+    # Create and return the model
+    model = models.Model(inputs=input_tensor, outputs=x)
+    return model
+
+def radial_structure_subnet(input_shape):
+    """
+    Creates the subnet for extracting TC radial structure features using a five-branch CNN design with 2D convolutions.
+
+    Parameters:
+    - input_shape: tuple, shape of the input data (e.g., (95, 95, 3))
+
+    Returns:
+    - model: tf.keras.Model, the radial structure subnet model
+    """
+    
+    input_tensor = layers.Input(shape=input_shape)
+
+    # Divide input data into four quadrants (NW, NE, SW, SE)
+    # Assuming the input shape is (batch_size, height, width, channels)
+    
+    # Quadrant extraction - using slicing to separate quadrants
+    nw_quadrant = input_tensor[:, :input_shape[0]//2, :input_shape[1]//2, :]
+    ne_quadrant = input_tensor[:, :input_shape[0]//2, input_shape[1]//2:, :]
+    sw_quadrant = input_tensor[:, input_shape[0]//2:, :input_shape[1]//2, :]
+    se_quadrant = input_tensor[:, input_shape[0]//2:, input_shape[1]//2:, :]
+
+
+    target_height = max(input_shape[0]//2, input_shape[0] - input_shape[0]//2)  # 48
+    target_width = max(input_shape[1]//2, input_shape[1] - input_shape[1]//2)  # 48
+    
+    # Padding the quadrants to match the target size (48, 48)
+    nw_quadrant = layers.ZeroPadding2D(padding=((0, target_height - nw_quadrant.shape[1]), 
+                                                (0, target_width - nw_quadrant.shape[2])))(nw_quadrant)
+    ne_quadrant = layers.ZeroPadding2D(padding=((0, target_height - ne_quadrant.shape[1]), 
+                                                (0, target_width - ne_quadrant.shape[2])))(ne_quadrant)
+    sw_quadrant = layers.ZeroPadding2D(padding=((0, target_height - sw_quadrant.shape[1]), 
+                                                (0, target_width - sw_quadrant.shape[2])))(sw_quadrant)
+    se_quadrant = layers.ZeroPadding2D(padding=((0, target_height - se_quadrant.shape[1]), 
+                                                (0, target_width - se_quadrant.shape[2])))(se_quadrant)
+
+    print(nw_quadrant.shape)
+    print(ne_quadrant.shape)
+    print(sw_quadrant.shape)
+    print(se_quadrant.shape)
+    # Main branch (processing the entire structure)
+    main_branch = layers.Conv2D(filters=8, kernel_size=(3, 3), padding='same', activation='relu')(input_tensor)
+    y=layers.MaxPool2D()(main_branch)
+
+    y = layers.ZeroPadding2D(padding=((0, target_height - y.shape[1]), 
+                                   (0, target_width - y.shape[2])))(y)
+    # Side branches (processing the individual quadrants)
+    nw_branch = layers.Conv2D(filters=8, kernel_size=(3, 3), padding='same', activation='relu')(nw_quadrant)
+    ne_branch = layers.Conv2D(filters=8, kernel_size=(3, 3), padding='same', activation='relu')(ne_quadrant)
+    sw_branch = layers.Conv2D(filters=8, kernel_size=(3, 3), padding='same', activation='relu')(sw_quadrant)
+    se_branch = layers.Conv2D(filters=8, kernel_size=(3, 3), padding='same', activation='relu')(se_quadrant)
+    
+    # Apply padding to the side branches to match the dimensions of the main branch
+    # nw_branch = layers.UpSampling2D(size=(2, 2), interpolation='nearest')(nw_branch)
+    # ne_branch = layers.UpSampling2D(size=(2, 2), interpolation='nearest')(ne_branch)
+    # sw_branch = layers.UpSampling2D(size=(2, 2), interpolation='nearest')(sw_branch)
+    # se_branch = layers.UpSampling2D(size=(2, 2), interpolation='nearest')(se_branch)
+    
+    # Fusion operations (concatenate the outputs from the main branch and side branches)
+    fusion = layers.concatenate([y, nw_branch, ne_branch, sw_branch, se_branch], axis=-1)
+    
+    # Additional convolution layer to combine the fused features
+    x = layers.Conv2D(filters=16, kernel_size=(3, 3), padding='same', activation='relu')(fusion)
+    x=layers.MaxPool2D(pool_size=(2, 2))(x)
+    # Final dense layer for further processing
+    nw_branch = layers.Conv2D(filters=16, kernel_size=(3, 3), padding='same', activation='relu')(nw_branch)
+    
+    ne_branch = layers.Conv2D(filters=16, kernel_size=(3, 3), padding='same', activation='relu')(ne_branch)
+    sw_branch = layers.Conv2D(filters=16, kernel_size=(3, 3), padding='same', activation='relu')(sw_branch)
+    se_branch = layers.Conv2D(filters=16, kernel_size=(3, 3), padding='same', activation='relu')(se_branch)
+    nw_branch = layers.MaxPool2D(pool_size=(2, 2))(nw_branch)
+    ne_branch = layers.MaxPool2D(pool_size=(2, 2))(ne_branch)
+    sw_branch = layers.MaxPool2D(pool_size=(2, 2))(sw_branch)
+    se_branch = layers.MaxPool2D(pool_size=(2, 2))(se_branch)
+
+    fusion = layers.concatenate([x, nw_branch, ne_branch, sw_branch, se_branch], axis=-1)
+    x = layers.Conv2D(filters=32, kernel_size=(3, 3), padding='same', activation='relu')(fusion)
+    x=layers.MaxPool2D(pool_size=(2, 2))(x)
+    
+    nw_branch = layers.Conv2D(filters=32, kernel_size=(3, 3), padding='same', activation='relu')(nw_branch)
+    
+    ne_branch = layers.Conv2D(filters=32, kernel_size=(3, 3), padding='same', activation='relu')(ne_branch)
+    sw_branch = layers.Conv2D(filters=32, kernel_size=(3, 3), padding='same', activation='relu')(sw_branch)
+    se_branch = layers.Conv2D(filters=32, kernel_size=(3, 3), padding='same', activation='relu')(se_branch)
+    nw_branch = layers.MaxPool2D(pool_size=(2, 2))(nw_branch)
+    ne_branch = layers.MaxPool2D(pool_size=(2, 2))(ne_branch)
+    sw_branch = layers.MaxPool2D(pool_size=(2, 2))(sw_branch)
+    se_branch = layers.MaxPool2D(pool_size=(2, 2))(se_branch)
+
+    fusion = layers.concatenate([x, nw_branch, ne_branch, sw_branch, se_branch], axis=-1)
+    x = layers.Conv2D(filters=32, kernel_size=(3, 3),  activation='relu')(fusion)
+    x=layers.Conv2D(filters=32, kernel_size=(3, 3), activation=None)(x)
+    # Create and return the model
+    x=layers.Flatten()(x)
+    model = models.Model(inputs=input_tensor, outputs=x)
+    return model
+
+# Define input shape (batch_size, height, width, channels)
+# input_shape = (95, 95, 8)  # Example input shape (95x95 spatial resolution, 3 channels)
+
+# # Build the model
+# model = radial_structure_subnet(input_shape)
+
+# # Model summary
+# model.summary()
+
+def build_cnn_model(input_shape=(8, 8, 1)):
+    # Define the input layer
+    input_tensor = layers.Input(shape=input_shape)
+    
+    # Convolutional layer
+    x = layers.Conv2D(64, (3, 3), padding='same')(input_tensor)
+    x = layers.BatchNormalization()(x)
+    x = layers.ReLU()(x)
+    
+    # Flatten layer
+    x = layers.Flatten()(x)
+    
+    # Create the model
+    model = models.Model(inputs=input_tensor, outputs=x)
+    
+    return model
+
+from tensorflow.keras import layers, models, Input # type: ignore
+
+def build_combined_model():
+    # Define input shapes
+    input_shape_3d = (8, 95, 95, 2)
+    input_shape_radial = (95, 95, 8)
+    input_shape_cnn = (8, 8, 1)
+    
+    input_shape_latitude = (8,)
+    input_shape_longitude = (8,)
+    input_shape_other = (9,)
+
+    # Build individual models
+    model_3d = build_st_lstm_model(input_shape=input_shape_3d)
+    model_radial = radial_structure_subnet(input_shape=input_shape_radial)
+    model_cnn = build_cnn_model(input_shape=input_shape_cnn)
+
+    # Define new inputs
+    input_latitude = Input(shape=input_shape_latitude ,name="latitude_input")
+    input_longitude = Input(shape=input_shape_longitude, name="longitude_input")
+    input_other = Input(shape=input_shape_other, name="other_input")
+
+    # Flatten the additional inputs
+    flat_latitude = layers.Dense(32,activation='relu')(input_latitude)
+    flat_longitude = layers.Dense(32,activation='relu')(input_longitude)
+    flat_other = layers.Dense(64,activation='relu')(input_other)
+
+    # Combine all outputs
+    combined = layers.concatenate([
+        model_3d.output, 
+        model_radial.output, 
+        model_cnn.output,
+        flat_latitude, 
+        flat_longitude, 
+        flat_other
+    ])
+
+    # Add dense layers for final processing
+    x = layers.Dense(128, activation='relu')(combined)  
+    x = layers.Dense(1, activation=None)(x)
+
+    # Create the final model
+    final_model = models.Model(
+        inputs=[model_3d.input, model_radial.input, model_cnn.input,
+                input_latitude, input_longitude, input_other ],
+        outputs=x
+    )
+
+    return final_model
+
+import h5py
+with h5py.File(r"E:\1MAIN PROJECT\tf_env\spatio_tempral_LSTM.h5", 'r') as f:
+    print(f.attrs.get('keras_version'))
+    print(f.attrs.get('backend'))
+    print("Model layers:", list(f['model_weights'].keys()))
+
+model = build_combined_model()  # Your original model building function
+model.load_weights(r"E:\1MAIN PROJECT\tf_env\spatio_tempral_LSTM.h5")
+
+
+def predict_stlstm(reduced_images_test,hov_m_test,test_vmax_3d,lat_test,lon_test,int_diff_test):
+    y=model.predict([reduced_images_test,hov_m_test,test_vmax_3d,lat_test,lon_test,int_diff_test ])
+    return y

spatio_tempral_LSTM.h5

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

trjgru.py

@@ -0,0 +1,302 @@
+import tensorflow as tf
+from tensorflow.keras import layers, models # type: ignore
+import numpy as np
+
+
+class TrajectoryGRU2D(layers.Layer):
+    def __init__(self, filters, kernel_size, return_sequences=True, **kwargs):
+        super().__init__(**kwargs)
+        self.filters = filters
+        self.kernel_size = kernel_size
+        self.return_sequences = return_sequences
+
+        # Projection layer to match GRU feature space
+        self.input_projection = layers.Conv2D(filters, (1, 1), padding="same")
+
+        # GRU Gates
+        self.conv_z = layers.Conv2D(filters, kernel_size, padding="same", activation="sigmoid")
+        self.conv_r = layers.Conv2D(filters, kernel_size, padding="same", activation="sigmoid")
+        self.conv_h = layers.Conv2D(filters, kernel_size, padding="same", activation="tanh")
+
+        # Motion-based trajectory update
+        self.motion_conv = layers.Conv2D(filters, kernel_size, padding="same", activation="tanh")
+
+    def build(self, input_shape):
+        # Ensures input_projection is built with the correct input shape
+        self.input_projection.build(input_shape[1:])  # Ignore batch dimension
+        super().build(input_shape)
+
+    def call(self, inputs):
+        # inputs shape: (batch_size, time_steps, height, width, channels)
+        batch_size, time_steps, height, width, channels = tf.unstack(tf.shape(inputs))
+        time_steps = inputs.shape[1]
+
+        # Initialize hidden state
+        h_t = tf.zeros((batch_size, height, width, self.filters))
+
+        # List to store outputs at each time step
+        outputs = []
+
+        # Iterate over time steps
+        for t in range(time_steps):
+            # Get the input at time step t
+            x_t = inputs[:, t, :, :, :]
+
+            # Project input to match GRU feature dimension
+            x_projected = self.input_projection(x_t)
+
+            # Compute motion-based trajectory update
+            motion_update = self.motion_conv(x_projected)
+
+            # Concatenate projected input, previous hidden state, and motion update
+            combined = tf.concat([x_projected, h_t, motion_update], axis=-1)
+
+            # Compute GRU gates
+            z = self.conv_z(combined)  # Update gate
+            r = self.conv_r(combined)  # Reset gate
+
+            # Compute candidate hidden state
+            h_tilde = self.conv_h(tf.concat([x_projected, r * h_t], axis=-1))
+
+            # Update hidden state with motion-based trajectory
+            h_t = (1 - z) * h_t + z * h_tilde + motion_update  # Add motion update
+
+            # Store the output if return_sequences is True
+            if self.return_sequences:
+                outputs.append(h_t)
+
+        # Stack outputs along the time dimension if return_sequences is True
+        if self.return_sequences:
+            outputs = tf.stack(outputs, axis=1)
+        else:
+            outputs = h_t
+
+        return outputs
+
+    def compute_output_shape(self, input_shape):
+        if self.return_sequences:
+            return (input_shape[0], input_shape[1], input_shape[2], input_shape[3], self.filters)
+        else:
+            return (input_shape[0], input_shape[2], input_shape[3], self.filters)
+
+
+def build_tgru_model(input_shape=(8, 95, 95, 2)):  # (time_steps, height, width, channels)
+    input_tensor = layers.Input(shape=input_shape)
+
+    # Apply TGRU Layers
+    x = TrajectoryGRU2D(filters=32, kernel_size=(3, 3), return_sequences=True)(input_tensor)
+    x = layers.Conv3D(filters=32, kernel_size=(3, 3, 3), padding='same', activation='relu')(x)
+    x = layers.MaxPooling3D(pool_size=(2, 2, 2), strides=(2, 2, 2), padding='same')(x)
+
+    x = TrajectoryGRU2D(filters=64, kernel_size=(3, 3), return_sequences=True)(x)
+    x = layers.Conv3D(filters=64, kernel_size=(3, 3, 3), padding='same', activation='relu')(x)
+    x = layers.MaxPooling3D(pool_size=(2, 2, 2), strides=(2, 2, 2), padding='same')(x)
+
+    x = TrajectoryGRU2D(filters=128, kernel_size=(3, 3), return_sequences=True)(x)
+    x = layers.Conv3D(filters=128, kernel_size=(3, 3, 3), padding='same', activation='relu')(x)
+    x = layers.MaxPooling3D(pool_size=(2, 2, 2), strides=(2, 2, 2), padding='same')(x)
+
+    # Flatten before Fully Connected Layer
+    x = layers.Flatten()(x)
+    # x = layers.Dense(1, activation='sigmoid')(x)  
+
+    model = models.Model(inputs=input_tensor, outputs=x)
+    return model
+
+def radial_structure_subnet(input_shape):
+    """
+    Creates the subnet for extracting TC radial structure features using a five-branch CNN design with 2D convolutions.
+
+    Parameters:
+    - input_shape: tuple, shape of the input data (e.g., (95, 95, 3))
+
+    Returns:
+    - model: tf.keras.Model, the radial structure subnet model
+    """
+    
+    input_tensor = layers.Input(shape=input_shape)
+
+    # Divide input data into four quadrants (NW, NE, SW, SE)
+    # Assuming the input shape is (batch_size, height, width, channels)
+    
+    # Quadrant extraction - using slicing to separate quadrants
+    nw_quadrant = input_tensor[:, :input_shape[0]//2, :input_shape[1]//2, :]
+    ne_quadrant = input_tensor[:, :input_shape[0]//2, input_shape[1]//2:, :]
+    sw_quadrant = input_tensor[:, input_shape[0]//2:, :input_shape[1]//2, :]
+    se_quadrant = input_tensor[:, input_shape[0]//2:, input_shape[1]//2:, :]
+
+
+    target_height = max(input_shape[0]//2, input_shape[0] - input_shape[0]//2)  # 48
+    target_width = max(input_shape[1]//2, input_shape[1] - input_shape[1]//2)  # 48
+    
+    # Padding the quadrants to match the target size (48, 48)
+    nw_quadrant = layers.ZeroPadding2D(padding=((0, target_height - nw_quadrant.shape[1]), 
+                                                (0, target_width - nw_quadrant.shape[2])))(nw_quadrant)
+    ne_quadrant = layers.ZeroPadding2D(padding=((0, target_height - ne_quadrant.shape[1]), 
+                                                (0, target_width - ne_quadrant.shape[2])))(ne_quadrant)
+    sw_quadrant = layers.ZeroPadding2D(padding=((0, target_height - sw_quadrant.shape[1]), 
+                                                (0, target_width - sw_quadrant.shape[2])))(sw_quadrant)
+    se_quadrant = layers.ZeroPadding2D(padding=((0, target_height - se_quadrant.shape[1]), 
+                                                (0, target_width - se_quadrant.shape[2])))(se_quadrant)
+
+    print(nw_quadrant.shape)
+    print(ne_quadrant.shape)
+    print(sw_quadrant.shape)
+    print(se_quadrant.shape)
+    # Main branch (processing the entire structure)
+    main_branch = layers.Conv2D(filters=8, kernel_size=(3, 3), padding='same', activation='relu')(input_tensor)
+    y=layers.MaxPool2D()(main_branch)
+
+    y = layers.ZeroPadding2D(padding=((0, target_height - y.shape[1]), 
+                                   (0, target_width - y.shape[2])))(y)
+    # Side branches (processing the individual quadrants)
+    nw_branch = layers.Conv2D(filters=8, kernel_size=(3, 3), padding='same', activation='relu')(nw_quadrant)
+    ne_branch = layers.Conv2D(filters=8, kernel_size=(3, 3), padding='same', activation='relu')(ne_quadrant)
+    sw_branch = layers.Conv2D(filters=8, kernel_size=(3, 3), padding='same', activation='relu')(sw_quadrant)
+    se_branch = layers.Conv2D(filters=8, kernel_size=(3, 3), padding='same', activation='relu')(se_quadrant)
+    
+    # Apply padding to the side branches to match the dimensions of the main branch
+    # nw_branch = layers.UpSampling2D(size=(2, 2), interpolation='nearest')(nw_branch)
+    # ne_branch = layers.UpSampling2D(size=(2, 2), interpolation='nearest')(ne_branch)
+    # sw_branch = layers.UpSampling2D(size=(2, 2), interpolation='nearest')(sw_branch)
+    # se_branch = layers.UpSampling2D(size=(2, 2), interpolation='nearest')(se_branch)
+    
+    # Fusion operations (concatenate the outputs from the main branch and side branches)
+    fusion = layers.concatenate([y, nw_branch, ne_branch, sw_branch, se_branch], axis=-1)
+    
+    # Additional convolution layer to combine the fused features
+    x = layers.Conv2D(filters=16, kernel_size=(3, 3), padding='same', activation='relu')(fusion)
+    x=layers.MaxPool2D(pool_size=(2, 2))(x)
+    # Final dense layer for further processing
+    nw_branch = layers.Conv2D(filters=16, kernel_size=(3, 3), padding='same', activation='relu')(nw_branch)
+    
+    ne_branch = layers.Conv2D(filters=16, kernel_size=(3, 3), padding='same', activation='relu')(ne_branch)
+    sw_branch = layers.Conv2D(filters=16, kernel_size=(3, 3), padding='same', activation='relu')(sw_branch)
+    se_branch = layers.Conv2D(filters=16, kernel_size=(3, 3), padding='same', activation='relu')(se_branch)
+    nw_branch = layers.MaxPool2D(pool_size=(2, 2))(nw_branch)
+    ne_branch = layers.MaxPool2D(pool_size=(2, 2))(ne_branch)
+    sw_branch = layers.MaxPool2D(pool_size=(2, 2))(sw_branch)
+    se_branch = layers.MaxPool2D(pool_size=(2, 2))(se_branch)
+
+    fusion = layers.concatenate([x, nw_branch, ne_branch, sw_branch, se_branch], axis=-1)
+    x = layers.Conv2D(filters=32, kernel_size=(3, 3), padding='same', activation='relu')(fusion)
+    x=layers.MaxPool2D(pool_size=(2, 2))(x)
+    
+    nw_branch = layers.Conv2D(filters=32, kernel_size=(3, 3), padding='same', activation='relu')(nw_branch)
+    
+    ne_branch = layers.Conv2D(filters=32, kernel_size=(3, 3), padding='same', activation='relu')(ne_branch)
+    sw_branch = layers.Conv2D(filters=32, kernel_size=(3, 3), padding='same', activation='relu')(sw_branch)
+    se_branch = layers.Conv2D(filters=32, kernel_size=(3, 3), padding='same', activation='relu')(se_branch)
+    nw_branch = layers.MaxPool2D(pool_size=(2, 2))(nw_branch)
+    ne_branch = layers.MaxPool2D(pool_size=(2, 2))(ne_branch)
+    sw_branch = layers.MaxPool2D(pool_size=(2, 2))(sw_branch)
+    se_branch = layers.MaxPool2D(pool_size=(2, 2))(se_branch)
+
+    fusion = layers.concatenate([x, nw_branch, ne_branch, sw_branch, se_branch], axis=-1)
+    x = layers.Conv2D(filters=32, kernel_size=(3, 3),  activation='relu')(fusion)
+    x=layers.Conv2D(filters=32, kernel_size=(3, 3), activation=None)(x)
+    # Create and return the model
+    x=layers.Flatten()(x)
+    model = models.Model(inputs=input_tensor, outputs=x)
+    return model
+
+# Define input shape (batch_size, height, width, channels)
+# input_shape = (95, 95, 8)  # Example input shape (95x95 spatial resolution, 3 channels)
+
+# # Build the model
+# model = radial_structure_subnet(input_shape)
+
+# # Model summary
+# model.summary()
+
+def build_cnn_model(input_shape=(8, 8, 1)):
+    # Define the input layer
+    input_tensor = layers.Input(shape=input_shape)
+    
+    # Convolutional layer
+    x = layers.Conv2D(64, (3, 3), padding='same')(input_tensor)
+    x = layers.BatchNormalization()(x)
+    x = layers.ReLU()(x)
+    
+    # Flatten layer
+    x = layers.Flatten()(x)
+    
+    # Create the model
+    model = models.Model(inputs=input_tensor, outputs=x)
+    
+    return model
+
+from tensorflow.keras import layers, models, Input # type: ignore
+
+def build_combined_model():
+    # Define input shapes
+    input_shape_3d = (8, 95, 95, 2)
+    input_shape_radial = (95, 95, 8)
+    input_shape_cnn = (8, 8, 1)
+    
+    input_shape_latitude = (8,)
+    input_shape_longitude = (8,)
+    input_shape_other = (9,)
+
+    # Build individual models
+    model_3d = build_tgru_model(input_shape=input_shape_3d)
+    model_radial = radial_structure_subnet(input_shape=input_shape_radial)
+    model_cnn = build_cnn_model(input_shape=input_shape_cnn)
+
+    # Define new inputs
+    input_latitude = Input(shape=input_shape_latitude ,name="latitude_input")
+    input_longitude = Input(shape=input_shape_longitude, name="longitude_input")
+    input_other = Input(shape=input_shape_other, name="other_input")
+
+    # Flatten the additional inputs
+    flat_latitude = layers.Dense(32,activation='relu')(input_latitude)
+    flat_longitude = layers.Dense(32,activation='relu')(input_longitude)
+    flat_other = layers.Dense(64,activation='relu')(input_other)
+
+    # Combine all outputs
+    combined = layers.concatenate([
+        model_3d.output, 
+        model_radial.output, 
+        model_cnn.output,
+        flat_latitude, 
+        flat_longitude, 
+        flat_other
+    ])
+
+    # Add dense layers for final processing
+    x = layers.Dense(128, activation='relu')(combined)  
+    x = layers.Dense(1, activation=None)(x)
+
+    # Create the final model
+    final_model = models.Model(
+        inputs=[model_3d.input, model_radial.input, model_cnn.input,
+                input_latitude, input_longitude, input_other ],
+        outputs=x
+    )
+
+    return final_model
+
+import h5py
+with h5py.File(r"E:\1MAIN PROJECT\tf_env\Trj_GRU.h5", 'r') as f:
+    print(f.attrs.get('keras_version'))
+    print(f.attrs.get('backend'))
+
+    print("Model layers:", list(f['model_weights'].keys()))
+
+model = build_combined_model()  # Your original model building function
+# Rebuild the model architecture
+model = build_tgru_model(input_shape=(8, 95, 95, 2))
+
+# Build the model by calling it once (to initialize all weights)
+dummy_input = tf.random.normal((1, 8, 95, 95, 2))  # batch_size=1
+_ = model(dummy_input)  # Forward pass to build all layers
+
+# Now load the saved weights
+# model.load_weights("Trj_GRU.weights.h5")
+
+model.load_weights(r"E:\1MAIN PROJECT\tf_env\Trj_GRU.weights.h5")
+
+
+def predict_trajgru(reduced_images_test,hov_m_test,test_vmax_3d,lat_test,lon_test,int_diff_test):
+    y=model.predict([reduced_images_test,hov_m_test,test_vmax_3d,lat_test,lon_test,int_diff_test ])
+    return y

unetlstm.py

@@ -0,0 +1,243 @@
+import tensorflow as tf
+from tensorflow.keras import layers, models  # type: ignore
+
+def encoder_block(inputs, filters):
+    x = layers.Conv3D(filters=filters, kernel_size=(3, 3, 4), padding="same", activation="relu")(inputs)
+    x = layers.BatchNormalization()(x)
+    return x
+
+def convlstm_block(inputs, filters):
+    # Reshape to (timesteps, height, width, channels) for ConvLSTM
+    x = layers.Reshape((inputs.shape[1], inputs.shape[2], inputs.shape[3], inputs.shape[4]))(inputs)
+    x = layers.ConvLSTM2D(filters=filters, kernel_size=(3, 3), padding="same", return_sequences=True)(x)
+    x = layers.BatchNormalization()(x)
+    # Reshape back to 3D conv format
+    x = layers.Reshape((inputs.shape[1], inputs.shape[2], inputs.shape[3], filters))(x)
+    return x
+
+def decoder_block(inputs, skip_connection, filters):
+    x = layers.Conv3DTranspose(filters=filters, kernel_size=(3, 3, 4), padding="same", activation="relu")(inputs)
+    x = layers.BatchNormalization()(x)
+    skip_resized = layers.Conv3D(filters, (1, 1, 1), padding="same")(skip_connection)
+    x = layers.Concatenate()([x, skip_resized]) 
+    x = layers.ConvLSTM2D(filters=filters, kernel_size=(3, 3), padding="same", return_sequences=True)(x)
+    return x
+
+def build_unet_convlstm(input_shape=(8, 95, 95, 3)):
+    input_tensor = layers.Input(shape=input_shape)
+
+    # Encoder with ConvLSTM
+    skip1 = encoder_block(input_tensor, filters=8)
+    skip1 = convlstm_block(skip1, filters=8)  # Added ConvLSTM
+    
+    skip2 = encoder_block(skip1, filters=16)
+    skip2 = convlstm_block(skip2, filters=16)  # Added ConvLSTM
+
+    # Bottleneck with ConvLSTM
+    x = layers.Conv3D(filters=32, kernel_size=(3, 3, 3), padding="same", activation="relu")(skip2)
+    x = layers.BatchNormalization()(x)
+    x = convlstm_block(x, filters=32)  # Bottleneck ConvLSTM
+
+    # Decoder
+    x = decoder_block(x, skip2, filters=16)
+    x = decoder_block(x, skip1, filters=8)
+
+    # Final Output Layer
+    x = layers.Conv3D(filters=1, kernel_size=(1, 1, 1), activation="relu")(x)
+    x = layers.GlobalAveragePooling3D()(x)
+
+    model = models.Model(inputs=input_tensor, outputs=x)
+    return model
+
+
+import tensorflow as tf
+from tensorflow.keras import layers, models # type: ignore
+
+def RSTNet(input_shape):
+    """
+    Creates the subnet for extracting TC radial structure features using a five-branch CNN design with 2D convolutions.
+
+    Parameters:
+    - input_shape: tuple, shape of the input data (e.g., (95, 95, 3))
+
+    Returns:
+    - model: tf.keras.Model, the radial structure subnet model
+    """
+    
+    input_tensor = layers.Input(shape=input_shape)
+
+    # Divide input data into four quadrants (NW, NE, SW, SE)
+    # Assuming the input shape is (batch_size, height, width, channels)
+    
+    # Quadrant extraction - using slicing to separate quadrants
+    nw_quadrant = input_tensor[:, :input_shape[0]//2, :input_shape[1]//2, :]
+    ne_quadrant = input_tensor[:, :input_shape[0]//2, input_shape[1]//2:, :]
+    sw_quadrant = input_tensor[:, input_shape[0]//2:, :input_shape[1]//2, :]
+    se_quadrant = input_tensor[:, input_shape[0]//2:, input_shape[1]//2:, :]
+
+
+    target_height = max(input_shape[0]//2, input_shape[0] - input_shape[0]//2)  # 48
+    target_width = max(input_shape[1]//2, input_shape[1] - input_shape[1]//2)  # 48
+    
+    # Padding the quadrants to match the target size (48, 48)
+    nw_quadrant = layers.ZeroPadding2D(padding=((0, target_height - nw_quadrant.shape[1]), 
+                                                (0, target_width - nw_quadrant.shape[2])))(nw_quadrant)
+    ne_quadrant = layers.ZeroPadding2D(padding=((0, target_height - ne_quadrant.shape[1]), 
+                                                (0, target_width - ne_quadrant.shape[2])))(ne_quadrant)
+    sw_quadrant = layers.ZeroPadding2D(padding=((0, target_height - sw_quadrant.shape[1]), 
+                                                (0, target_width - sw_quadrant.shape[2])))(sw_quadrant)
+    se_quadrant = layers.ZeroPadding2D(padding=((0, target_height - se_quadrant.shape[1]), 
+                                                (0, target_width - se_quadrant.shape[2])))(se_quadrant)
+
+    print(nw_quadrant.shape)
+    print(ne_quadrant.shape)
+    print(sw_quadrant.shape)
+    print(se_quadrant.shape)
+    # Main branch (processing the entire structure)
+    main_branch = layers.Conv2D(filters=8, kernel_size=(3, 3), padding='same', activation='relu')(input_tensor)
+    y=layers.MaxPool2D()(main_branch)
+
+    y = layers.ZeroPadding2D(padding=((0, target_height - y.shape[1]), 
+                                   (0, target_width - y.shape[2])))(y)
+    # Side branches (processing the individual quadrants)
+    nw_branch = layers.Conv2D(filters=8, kernel_size=(3, 3), padding='same', activation='relu')(nw_quadrant)
+    ne_branch = layers.Conv2D(filters=8, kernel_size=(3, 3), padding='same', activation='relu')(ne_quadrant)
+    sw_branch = layers.Conv2D(filters=8, kernel_size=(3, 3), padding='same', activation='relu')(sw_quadrant)
+    se_branch = layers.Conv2D(filters=8, kernel_size=(3, 3), padding='same', activation='relu')(se_quadrant)
+    
+    # Apply padding to the side branches to match the dimensions of the main branch
+    # nw_branch = layers.UpSampling2D(size=(2, 2), interpolation='nearest')(nw_branch)
+    # ne_branch = layers.UpSampling2D(size=(2, 2), interpolation='nearest')(ne_branch)
+    # sw_branch = layers.UpSampling2D(size=(2, 2), interpolation='nearest')(sw_branch)
+    # se_branch = layers.UpSampling2D(size=(2, 2), interpolation='nearest')(se_branch)
+    
+    # Fusion operations (concatenate the outputs from the main branch and side branches)
+    fusion = layers.concatenate([y, nw_branch, ne_branch, sw_branch, se_branch], axis=-1)
+    
+    # Additional convolution layer to combine the fused features
+    # x = layers.Conv2D(filters=16, kernel_size=(3, 3), padding='same', activation='relu')(fusion)
+    x=layers.Reshape((1, 48, 48, 40))(fusion)
+    x = layers.ConvLSTM2D(filters=16, kernel_size=(3, 3), padding="same", return_sequences=True)(x)
+    x=layers.Reshape((48, 48, 16))(x)
+    x=layers.MaxPool2D(pool_size=(2, 2))(x)
+    # Final dense layer for further processing
+    nw_branch = layers.Conv2D(filters=16, kernel_size=(3, 3), padding='same', activation='relu')(nw_branch)
+    
+    ne_branch = layers.Conv2D(filters=16, kernel_size=(3, 3), padding='same', activation='relu')(ne_branch)
+    sw_branch = layers.Conv2D(filters=16, kernel_size=(3, 3), padding='same', activation='relu')(sw_branch)
+    se_branch = layers.Conv2D(filters=16, kernel_size=(3, 3), padding='same', activation='relu')(se_branch)
+    nw_branch = layers.MaxPool2D(pool_size=(2, 2))(nw_branch)
+    ne_branch = layers.MaxPool2D(pool_size=(2, 2))(ne_branch)
+    sw_branch = layers.MaxPool2D(pool_size=(2, 2))(sw_branch)
+    se_branch = layers.MaxPool2D(pool_size=(2, 2))(se_branch)
+
+    fusion = layers.concatenate([x, nw_branch, ne_branch, sw_branch, se_branch], axis=-1)
+    # x = layers.Conv2D(filters=32, kernel_size=(3, 3), padding='same', activation='relu')(fusion)
+    x=layers.Reshape((1, 24, 24, 80))(fusion)
+    x = layers.ConvLSTM2D(filters=32, kernel_size=(3, 3), padding="same", return_sequences=True)(x)
+    x=layers.Reshape((24, 24, 32))(x)
+    x=layers.MaxPool2D(pool_size=(2, 2))(x)
+    
+    nw_branch = layers.Conv2D(filters=32, kernel_size=(3, 3), padding='same', activation='relu')(nw_branch)
+    
+    ne_branch = layers.Conv2D(filters=32, kernel_size=(3, 3), padding='same', activation='relu')(ne_branch)
+    sw_branch = layers.Conv2D(filters=32, kernel_size=(3, 3), padding='same', activation='relu')(sw_branch)
+    se_branch = layers.Conv2D(filters=32, kernel_size=(3, 3), padding='same', activation='relu')(se_branch)
+    nw_branch = layers.MaxPool2D(pool_size=(2, 2))(nw_branch)
+    ne_branch = layers.MaxPool2D(pool_size=(2, 2))(ne_branch)
+    sw_branch = layers.MaxPool2D(pool_size=(2, 2))(sw_branch)
+    se_branch = layers.MaxPool2D(pool_size=(2, 2))(se_branch)
+
+    fusion = layers.concatenate([x, nw_branch, ne_branch, sw_branch, se_branch], axis=-1)
+    # x = layers.Conv2D(filters=32, kernel_size=(3, 3),  activation='relu')(fusion)
+    x=layers.Reshape((1,12, 12, 160))(fusion)
+    x = layers.ConvLSTM2D(filters=32, kernel_size=(3, 3), padding="same", return_sequences=True)(x)
+    x=layers.Reshape((12, 12, 32))(x)
+    x=layers.Conv2D(filters=32, kernel_size=(3, 3), activation=None)(x)
+    # Create and return the model
+    x=layers.Flatten()(x)
+    model = models.Model(inputs=input_tensor, outputs=x)
+    return model
+
+from tensorflow.keras import layers, models # type: ignore
+
+def build_cnn_model(input_shape=(8, 8, 1)):
+    # Define the input layer
+    input_tensor = layers.Input(shape=input_shape)
+    
+    # Convolutional layer
+    x = layers.Conv2D(64, (3, 3), padding='same')(input_tensor)
+    x = layers.BatchNormalization()(x)
+    x = layers.ReLU()(x)
+    
+    # Flatten layer
+    x = layers.Flatten()(x)
+    
+    # Create the model
+    model = models.Model(inputs=input_tensor, outputs=x)
+    
+    return model
+
+from tensorflow.keras import layers, models, Input # type: ignore
+
+def build_combined_model():
+    # Define input shapes
+    input_shape_3d = (8, 95, 95, 2)
+    input_shape_radial = (95, 95, 8)
+    input_shape_cnn = (8, 8, 1)
+    
+    input_shape_latitude = (8,)
+    input_shape_longitude = (8,)
+    input_shape_other = (9,)
+
+    # Build individual models
+    model_3d = build_unet_convlstm(input_shape=input_shape_3d)
+    model_radial = RSTNet(input_shape=input_shape_radial)
+    model_cnn = build_cnn_model(input_shape=input_shape_cnn)
+
+    # Define new inputs
+    input_latitude = Input(shape=input_shape_latitude ,name="latitude_input")
+    input_longitude = Input(shape=input_shape_longitude, name="longitude_input")
+    input_other = Input(shape=input_shape_other, name="other_input")
+
+    # Flatten the additional inputs
+    flat_latitude = layers.Dense(32,activation='relu')(input_latitude)
+    flat_longitude = layers.Dense(32,activation='relu')(input_longitude)
+    flat_other = layers.Dense(64,activation='relu')(input_other)
+
+    # Combine all outputs
+    combined = layers.concatenate([
+        model_3d.output, 
+        model_radial.output, 
+        model_cnn.output,
+        flat_latitude, 
+        flat_longitude, 
+        flat_other
+    ])
+
+    # Add dense layers for final processing
+    x = layers.Dense(128, activation='relu')(combined)  
+    x = layers.Dense(1, activation=None)(x)
+
+    # Create the final model
+    final_model = models.Model(
+        inputs=[model_3d.input, model_radial.input, model_cnn.input,
+                input_latitude, input_longitude, input_other ],
+        outputs=x
+    )
+
+    return final_model
+
+import h5py
+with h5py.File(r"E:\1MAIN PROJECT\tf_env\final_model.h5", 'r') as f:
+    print(f.attrs.get('keras_version'))
+    print(f.attrs.get('backend'))
+    print("Model layers:", list(f['model_weights'].keys()))
+
+model = build_combined_model()  # Your original model building function
+model.load_weights(r"E:\1MAIN PROJECT\tf_env\final_model.h5")
+
+
+def predict_unetlstm(reduced_images_test,hov_m_test,test_vmax_3d,lat_test,lon_test,int_diff_test):
+    y=model.predict([reduced_images_test,hov_m_test,test_vmax_3d,lat_test,lon_test,int_diff_test ])
+    return y