diff --git a/nikki_exp_conv_temporal_static/demo.ipynb b/nikki_exp_conv_temporal_static/demo.ipynb
new file mode 100644
index 0000000..0f7879e
--- /dev/null
+++ b/nikki_exp_conv_temporal_static/demo.ipynb
@@ -0,0 +1,332 @@
+{
+ "cells": [
+  {
+   "cell_type": "code",
+   "execution_count": 1,
+   "metadata": {},
+   "outputs": [],
+   "source": [
+    "import rasterio\n",
+    "import numpy as np\n",
+    "from sklearn.model_selection import train_test_split\n",
+    "import lightgbm as lgbm\n",
+    "\n",
+    "from typing import Any, Dict, Optional, List\n",
+    "from tqdm import tqdm as tqdm\n",
+    "import matplotlib.pyplot as plt\n",
+    "import seaborn as sns\n",
+    "import utils\n",
+    "import main\n",
+    "import sys"
+   ]
+  },
+  {
+   "cell_type": "markdown",
+   "metadata": {},
+   "source": [
+    "## Arguments to be passed"
+   ]
+  },
+  {
+   "cell_type": "code",
+   "execution_count": 2,
+   "metadata": {},
+   "outputs": [],
+   "source": [
+    "\n",
+    "data_dir = \"gs://earth-engine-seminar/urbanization/data/export_22122024\"\n",
+    "output_path=\"prediction_tiff.tiff\"\n",
+    "filter_size=5\n",
+    "block_coverage=0.3\n",
+    "total_blocks=100\n",
+    "test_size=0.3"
+   ]
+  },
+  {
+   "cell_type": "markdown",
+   "metadata": {},
+   "source": [
+    "## Loading the input files "
+   ]
+  },
+  {
+   "cell_type": "code",
+   "execution_count": 3,
+   "metadata": {},
+   "outputs": [],
+   "source": [
+    "\n",
+    "labels = utils.files_in_dir(data_dir, \"label.tif\")\n",
+    "features = utils.files_in_dir(data_dir, \"feat.tif\")\n",
+    "train_labels = utils.files_in_dir(data_dir, \"label.tif\")\n",
+    "train_features = utils.files_in_dir(data_dir, \"feat.tif\")\n",
+    "test_labels = utils.load_tif_data(labels[0])\n",
+    "test_features = utils.load_tif_data(features[0])\n",
+    "\n",
+    "\n"
+   ]
+  },
+  {
+   "cell_type": "markdown",
+   "metadata": {},
+   "source": [
+    "## Pre-processing"
+   ]
+  },
+  {
+   "cell_type": "markdown",
+   "metadata": {},
+   "source": [
+    "### Removing dublicate features from train and test set of features"
+   ]
+  },
+  {
+   "cell_type": "code",
+   "execution_count": null,
+   "metadata": {},
+   "outputs": [],
+   "source": [
+    "\n",
+    "train_feature=np.concatenate((train_features.data[0,:,:].reshape(1,train_features.metadata['height'],train_features.metadata['width'] ), train_features.data[2:,:,:]), axis=0)\n",
+    "test_feature= np.concatenate((test_features.data[0,:,:].reshape(1,test_features.metadata['height'],test_features.metadata['width']),test_features.data[2:,:,:]),axis=0)"
+   ]
+  },
+  {
+   "cell_type": "code",
+   "execution_count": 6,
+   "metadata": {},
+   "outputs": [
+    {
+     "name": "stdout",
+     "output_type": "stream",
+     "text": [
+      "block size 121\n"
+     ]
+    },
+    {
+     "name": "stderr",
+     "output_type": "stream",
+     "text": [
+      "  0%|          | 0/226 [00:00<?, ?it/s]/home/nikki/Downloads/urbanan_google_earth/main.py:186: RuntimeWarning: Mean of empty slice\n",
+      "  new_data.append(np.concatenate(((np.nanmean(mean_data,axis=(1,2))),static_data),axis=0 ))\n",
+      "100%|██████████| 226/226 [07:41<00:00,  2.04s/it] \n",
+      "100%|██████████| 98/98 [00:08<00:00, 11.17it/s]\n",
+      "  2%|▏         | 41/2207 [00:04<03:46,  9.56it/s]/home/nikki/Downloads/urbanan_google_earth/main.py:92: RuntimeWarning: Mean of empty slice\n",
+      "  new_data.append(np.concatenate(((np.nanmean(mean_data,axis=(1,2))),static_data),axis=0 ))\n",
+      "100%|██████████| 2207/2207 [04:13<00:00,  8.72it/s]\n"
+     ]
+    },
+    {
+     "name": "stdout",
+     "output_type": "stream",
+     "text": [
+      "(26442, 15) (26442,)\n",
+      "(4932645, 15) (4932645,)\n",
+      "(11466, 15) (11466,)\n",
+      "(18200, 15) (18200,)\n",
+      "(3304360, 15) (3304360,)\n",
+      "(3304360, 15) (3304360,)\n"
+     ]
+    }
+   ],
+   "source": [
+    "x_train,y_train,x_test,y_test,x_val,y_val,train_mask, test_mask, val_mask=main.pre_process(train_feature,train_labels.data,test_feature, test_labels.data, block_coverage, total_blocks,test_size)\n"
+   ]
+  },
+  {
+   "cell_type": "markdown",
+   "metadata": {},
+   "source": [
+    "### Correlation-Matrix"
+   ]
+  },
+  {
+   "cell_type": "code",
+   "execution_count": null,
+   "metadata": {},
+   "outputs": [],
+   "source": [
+    "y_train=y_train.reshape(len(y_train),1)\n",
+    "train=np.concatenate((x_train, y_train), axis=1)\n",
+    "\n",
+    "# Normalizing features \n",
+    "\n",
+    "col_means = np.mean(train,axis=0)\n",
+    "train_normalized = (train - col_means) / np.std(train, axis=0)\n",
+    "print(np.mean(train_normalized,axis=0))\n",
+    "print(np.std(train_normalized,axis=0))\n",
+    "coerr=np.corrcoef(train, rowvar=False)\n",
+    "\n",
+    "\n",
+    "\n",
+    "plt.figure(figsize=(12, 8))\n",
+    "sns.heatmap(coerr, annot=True, xticklabels=['Palmer Drought Severity Index','Precipitation accumulation',\n",
+    "'min temp','max temp','16-day NDVI avg','16-day EVI avg','LC_Type1','population_density','urban'], yticklabels=['Palmer Drought Severity Index','Precipitation accumulation',\n",
+    "'min temp','max temp','16-day NDVI avg','16-day EVI avg','LC_Type1','population_density','urban'], cmap='coolwarm', linewidths=0.5)\n",
+    "plt.title('Correlation Heatmap')\n",
+    "plt.show()"
+   ]
+  },
+  {
+   "cell_type": "markdown",
+   "metadata": {},
+   "source": [
+    "## Training"
+   ]
+  },
+  {
+   "cell_type": "code",
+   "execution_count": 7,
+   "metadata": {},
+   "outputs": [
+    {
+     "name": "stderr",
+     "output_type": "stream",
+     "text": [
+      "/home/nikki/Downloads/venv/lib/python3.12/site-packages/sklearn/utils/deprecation.py:151: FutureWarning: 'force_all_finite' was renamed to 'ensure_all_finite' in 1.6 and will be removed in 1.8.\n",
+      "  warnings.warn(\n"
+     ]
+    },
+    {
+     "name": "stdout",
+     "output_type": "stream",
+     "text": [
+      "[LightGBM] [Info] Auto-choosing row-wise multi-threading, the overhead of testing was 0.000569 seconds.\n",
+      "You can set `force_row_wise=true` to remove the overhead.\n",
+      "And if memory is not enough, you can set `force_col_wise=true`.\n",
+      "[LightGBM] [Info] Total Bins 3483\n",
+      "[LightGBM] [Info] Number of data points in the train set: 18200, number of used features: 15\n",
+      "[LightGBM] [Info] Start training from score -6.551080\n",
+      "[LightGBM] [Info] Start training from score -7.611952\n",
+      "[LightGBM] [Info] Start training from score -6.198259\n",
+      "[LightGBM] [Info] Start training from score -0.003964\n",
+      "[LightGBM] [Warning] No further splits with positive gain, best gain: -inf\n",
+      "[LightGBM] [Warning] No further splits with positive gain, best gain: -inf\n"
+     ]
+    }
+   ],
+   "source": [
+    "\n",
+    "model = lgbm.LGBMClassifier(objective=\"multiclass\", num_class=4)\n",
+    "main.train(model,x_train,y_train,x_val,y_val)\n"
+   ]
+  },
+  {
+   "cell_type": "markdown",
+   "metadata": {},
+   "source": [
+    "## Testing"
+   ]
+  },
+  {
+   "cell_type": "code",
+   "execution_count": 8,
+   "metadata": {},
+   "outputs": [
+    {
+     "name": "stderr",
+     "output_type": "stream",
+     "text": [
+      "/home/nikki/Downloads/venv/lib/python3.12/site-packages/sklearn/utils/deprecation.py:151: FutureWarning: 'force_all_finite' was renamed to 'ensure_all_finite' in 1.6 and will be removed in 1.8.\n",
+      "  warnings.warn(\n"
+     ]
+    }
+   ],
+   "source": [
+    "test_pred,cm,report=main.predict(model,x_test,y_test)"
+   ]
+  },
+  {
+   "cell_type": "markdown",
+   "metadata": {},
+   "source": [
+    "## Results"
+   ]
+  },
+  {
+   "cell_type": "code",
+   "execution_count": 9,
+   "metadata": {},
+   "outputs": [
+    {
+     "name": "stdout",
+     "output_type": "stream",
+     "text": [
+      "              precision    recall  f1-score   support\n",
+      "\n",
+      "           0       0.01      0.04      0.02      8586\n",
+      "           1       0.01      0.06      0.01      2260\n",
+      "           2       0.02      0.11      0.04      6524\n",
+      "           3       1.00      0.98      0.99   3286990\n",
+      "\n",
+      "    accuracy                           0.98   3304360\n",
+      "   macro avg       0.26      0.30      0.27   3304360\n",
+      "weighted avg       0.99      0.98      0.98   3304360\n",
+      "\n"
+     ]
+    }
+   ],
+   "source": [
+    "print(report)"
+   ]
+  },
+  {
+   "cell_type": "code",
+   "execution_count": 10,
+   "metadata": {},
+   "outputs": [
+    {
+     "name": "stdout",
+     "output_type": "stream",
+     "text": [
+      "[[    318     489     152    7627]\n",
+      " [    127     143     358    1632]\n",
+      " [    213     115     717    5479]\n",
+      " [  20568   16523   28307 3221592]]\n"
+     ]
+    }
+   ],
+   "source": [
+    "# Confusion matrix\n",
+    "print(cm)"
+   ]
+  },
+  {
+   "cell_type": "markdown",
+   "metadata": {},
+   "source": [
+    "## Saving"
+   ]
+  },
+  {
+   "cell_type": "code",
+   "execution_count": 14,
+   "metadata": {},
+   "outputs": [],
+   "source": [
+    "main.save_prediction(test_labels,filter_size,test_mask,test_pred,output_path)"
+   ]
+  }
+ ],
+ "metadata": {
+  "kernelspec": {
+   "display_name": "venv",
+   "language": "python",
+   "name": "python3"
+  },
+  "language_info": {
+   "codemirror_mode": {
+    "name": "ipython",
+    "version": 3
+   },
+   "file_extension": ".py",
+   "mimetype": "text/x-python",
+   "name": "python",
+   "nbconvert_exporter": "python",
+   "pygments_lexer": "ipython3",
+   "version": "3.12.3"
+  }
+ },
+ "nbformat": 4,
+ "nbformat_minor": 2
+}
diff --git a/nikki_exp_conv_temporal_static/main.py b/nikki_exp_conv_temporal_static/main.py
new file mode 100644
index 0000000..dfb6fa0
--- /dev/null
+++ b/nikki_exp_conv_temporal_static/main.py
@@ -0,0 +1,222 @@
+import rasterio
+import numpy as np
+from rasterio.windows import Window
+from sklearn.model_selection import train_test_split
+from tqdm import tqdm as tqdm
+from sklearn.metrics import classification_report, confusion_matrix
+
+PROJECT_ID = "ai-sandbox-399505"
+
+
+
+
+def ndarray_tiff(data, src_profile, output_file):
+    src_profile.update(
+        dtype=rasterio.int32,  # Adjust the data type if needed
+        count=1,  # Number of bands
+        # compress='lzw'  # Optional: Add compression
+    )
+
+    
+    with rasterio.open(output_file, 'w', src_profile) as dst:
+        dst.write(data, 1)  # Write
+
+def padding(features,labels):
+    axis_padwidth={}
+    for i in range(1,len(features.shape)):
+        if(features.shape[i]<labels.shape[i]):
+            axis_padwidth[i]=labels.shape[i]-features.shape[i]
+          
+        else:
+            axis_padwidth[i]=0
+
+
+    return axis_padwidth
+
+
+
+def window(block_coverage, total_blocks, height, width):
+    total_pixels = height*width
+    pixels_covered = total_pixels*block_coverage
+    block_size = int(np.sqrt(pixels_covered/total_blocks))
+    print("block size",block_size)
+
+    windows = []
+    for i in range(0, height-block_size+1, block_size):
+        for j in range(0, width-block_size+1, block_size):
+            windows.append(Window(j, i, block_size, block_size))
+    return windows
+
+
+def get_sampled_data(data, windows):
+    
+    new_data=[]
+    nan_indices=np.argwhere(np.isnan(data))
+
+    for window in tqdm(windows):
+        row_start = int(window.row_off)
+        row_stop = int(window.row_off + window.height)
+        col_start = int(window.col_off)
+        col_stop = int(window.col_off + window.width)
+        for i in range(row_start,row_stop):
+            for j in range(col_start, col_stop):
+                if [0,i,j] not in nan_indices:
+                 
+                    new_data.append(data[:,i,j])
+
+                
+    return new_data
+
+
+
+
+def get_sampled_test(test_data):
+    new_data=[]
+    new_label=[]
+   
+    for i in tqdm(range(2,test_data.shape[1]-2)):
+        for j in range(2,test_data.shape[2]-2):
+            mean_data=np.concatenate((test_data[1:7,i-2:i+3,j-2:j+3], test_data[8:9,i-2:i+3,j-2:j+3]),axis=0)
+            static_data=test_data[1:,i,j]
+            
+            new_data.append(np.concatenate(((np.nanmean(mean_data,axis=(1,2))),static_data),axis=0 ))
+            new_label.append(test_data[0,i,j])
+    return new_data, new_label
+
+
+
+def get_sampled_spatial_convolve_data(data,windows):
+    new_data=[]
+    new_label=[]
+    
+    for window in tqdm(windows):
+        row_start = int(window.row_off)
+        row_stop = int(window.row_off + window.height)
+        col_start = int(window.col_off)
+        col_stop = int(window.col_off + window.width)
+       
+        for i in range(row_start+2,row_stop-2):
+            for j in range(col_start+2, col_stop-2):
+                    mean_data=np.concatenate((data[1:7,i-2:i+3,j-2:j+3], data[8:9,i-2:i+3,j-2:j+3]),axis=0)
+                    static_data=data[1:,i,j]
+            new_data.append(np.concatenate(((np.nanmean(mean_data,axis=(1,2))),static_data),axis=0 ))
+            new_label.append(data[0,i,j])
+               
+    return new_data,new_label
+
+
+def get_sampled_spatial_temporal_convolve_data(data,windows):
+
+    new_data=[]
+    for window in tqdm(windows):
+        row_start = int(window.row_off)
+        row_stop = int(window.row_off + window.height)
+        col_start = int(window.col_off)
+        col_stop = int(window.col_off + window.width)
+        for i in range(row_start+2,row_stop-2):
+            for j in range(col_start+2, col_stop-2):
+                    temp_data=data[:,i-2:i+2,j-2:j+2]
+
+                    print(temp_data)
+                
+                    new_data.append(np.nanmean(temp_data,axis=(0,1,2)))
+       
+    return new_data
+
+
+
+def save_prediction(test_labels, filter_size,pred_label_mask,test_pred,output_path):
+
+    test_profile=test_labels.profile 
+    shape=(test_labels.metadata["height"]-filter_size+1,test_labels.metadata["width"]-filter_size+1)
+    valid_pred_mask=pred_label_mask.flatten()
+    pred_array=np.full((shape[0]*shape[1]),np.nan)
+    pred_array[valid_pred_mask] = test_pred
+    pred_array = pred_array.reshape((shape[0], shape[1]))
+    with rasterio.open(output_path,"w",driver="GTiff",height=shape[0],width=shape[1],count=1,  dtype=pred_array.dtype,crs=test_profile['crs'],transform=test_profile['transform']) as dst:
+        dst.write(pred_array, 1)
+
+def eliminate_nan(data,label):
+    label=label.reshape(len(label),1)
+    concat=np.concatenate((label,data),axis=1)
+    mask=~np.isnan(concat).any(axis=1)
+    mask=mask.reshape(-1,1)
+    data_final=np.where(mask,concat,np.nan)
+    x=data_final[:,1:]
+    y=data_final[:,0]
+    mask=mask.squeeze()
+    x=x[mask,:]
+    y=y[mask]
+    
+    return x,y,mask
+    
+def pre_process(train_features, train_labels,test_features,test_labels, block_coverage, total_blocks,test_size):
+
+    train_labels=np.where(train_labels==-1, np.nan, train_labels)
+    test_labels=np.where(test_labels==-1, np.nan,test_labels)
+
+
+    train_axis_pad=padding(train_features,train_labels)
+    test_axis_pad=padding(test_features,test_labels)
+
+    train_features=np.pad(train_features, ((0,0),(0,train_axis_pad[1]),(0,train_axis_pad[2])),mode='constant',constant_values=np.nan)
+    test_features=np.pad(test_features,((0,0),(0,test_axis_pad[1]),(0,test_axis_pad[2])),mode='constant',constant_values=np.nan)
+
+    
+
+    train_stacked=np.concatenate((train_labels,train_features),axis=0)
+    test_stacked=np.concatenate((test_labels,test_features),axis=0)
+
+    train_valid_mask=~np.isnan(train_stacked).any(axis=0)
+    test_valid_mask=~np.isnan(test_stacked).any(axis=0)
+
+
+    train_stacked=np.where(train_valid_mask,train_stacked,np.nan)
+    test_stacked=np.where(test_valid_mask,test_stacked,np.nan)
+
+    train_height, train_width = train_stacked.shape[1], train_stacked.shape[2]
+    tr_windows=window(block_coverage,total_blocks,train_height,train_width)
+    train_windows, val_windows = train_test_split(tr_windows, test_size=test_size, random_state=42)
+
+    train_final_data,train_final_label= get_sampled_spatial_convolve_data(train_stacked, train_windows)
+    val_final_data,val_final_label = get_sampled_spatial_convolve_data(train_stacked, val_windows)
+    test_final_data, test_final_label=get_sampled_test(test_stacked)
+
+    
+
+    
+    train_final_data,train_final_label=np.array(train_final_data), np.array(train_final_label)
+    val_final_data,val_final_label=np.array(val_final_data), np.array(val_final_label)
+    test_final_data,test_final_label=np.array(test_final_data), np.array(test_final_label)
+
+    print(train_final_data.shape, train_final_label.shape)
+    print(test_final_data.shape, test_final_label.shape)
+    print(val_final_data.shape, val_final_label.shape)
+    
+    x_train,y_train,train_mask= eliminate_nan(train_final_data, train_final_label)
+    x_test,y_test,test_mask= eliminate_nan(test_final_data, test_final_label)
+    x_val,y_val,val_mask= eliminate_nan(test_final_data, test_final_label)
+
+
+    return x_train,y_train,x_test,y_test,x_val,y_val,train_mask, test_mask, val_mask
+
+
+
+
+def train(model,x_train,y_train,x_val,y_val):
+
+    model=model.fit(x_train,y_train,eval_set=[(x_val,y_val)])
+
+
+def predict(model,x_test,y_test):
+    y_pred=model.predict(x_test)
+    cm = confusion_matrix(y_test, y_pred, labels=[0,1,2,3])
+    report = classification_report(y_test, y_pred, labels=[0,1,2,3])
+    return y_pred,cm,report
+
+
+
+
+
+
+    
diff --git a/nikki_exp_conv_temporal_static/utils.py b/nikki_exp_conv_temporal_static/utils.py
new file mode 100644
index 0000000..190f2a0
--- /dev/null
+++ b/nikki_exp_conv_temporal_static/utils.py
@@ -0,0 +1,230 @@
+import numpy as np
+import rasterio
+import gcsfs
+from io import BytesIO
+from google.cloud import storage
+from dataclasses import dataclass
+from typing import Any, Dict, Optional, List
+
+PROJECT_ID = "ai-sandbox-399505"
+
+
+@dataclass
+class TIFF():
+    data: np.ndarray
+    metadata: Dict[str, Any]
+    bands: List[str]
+    profile: Dict[str, Any]
+
+
+def gcsfs_init():
+
+    return  gcsfs.GCSFileSystem()
+
+
+def get_storage_client():
+    # instantiates a bucket object owned by this client
+
+    return storage.Client(project=PROJECT_ID)
+
+def get_bucket_name(gcs_path):
+
+    if not gcs_path.startswith("gs://"):
+        raise ValueError("The path must start with 'gs://'")
+    
+    stripped_path = gcs_path[5:]
+    parts = stripped_path.split('/', 1)
+
+    bucket_name = parts[0]
+    file_path = parts[1] if len(parts) > 1 else ""
+
+    return bucket_name, file_path
+
+def rasterio_open(file):
+    with rasterio.open(file) as src:
+        tiff_data = src.read()  
+        metadata = src.meta 
+        bands = src.descriptions  
+        profile = src.profile
+    return TIFF(tiff_data, metadata, bands, profile)
+
+
+def load_tiff(gsc_path):
+    gcs = gcsfs_init()
+    with gcs.open(gsc_path, 'rb') as f:
+        file_bytes = BytesIO(f.read())
+    
+    tif = rasterio_open(file_bytes)
+    return tif
+
+def load_tif_data(gcs_tiff_path):
+
+    tif = load_tiff(gcs_tiff_path)
+
+    return tif.data
+
+def files_in_dir(bucket_path, file_extension):
+
+    all_files = []
+    client = get_storage_client()
+    bucket_name, file_path = get_bucket_name(bucket_path)
+    bucket = client.get_bucket(bucket_name)
+    for blob in bucket.list_blobs(prefix = file_path):
+        all_files.append(blob.name)
+    file_prefix = "gs://" + bucket_name + "/"
+    if file_extension:
+        fileterd_files = [file_prefix+ file for file in all_files if file.endswith(file_extension)]
+
+    client.close()
+        
+    return fileterd_files
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+   
+
+    
+
+
+
+def pre_process(train_features, train_labels,test_features,test_labels, block_coverage, total_blocks,test_size):
+
+    train_labels=np.where(train_labels==-1, np.nan, train_labels)
+    test_labels=np.where(test_labels==-1, np.nan,test_labels)
+    train_axis_pad=padding(train_features,train_labels)
+    test_axis_pad=padding(test_features,test_labels)
+    train_features=np.pad(train_features, ((0,0),(0,train_axis_pad[1]),(0,train_axis_pad[2])),mode='constant',constant_values=np.nan)
+    # print("after padding",train_features)
+    test_features=np.pad(test_features,((0,0),(0,test_axis_pad[1]),(0,test_axis_pad[2])),mode='constant',constant_values=np.nan)
+    train_stacked=np.concatenate((train_labels,train_features),axis=0)
+    test_stacked=np.concatenate((test_labels,test_features),axis=0)
+    train_valid_mask=~np.isnan(train_stacked).any(axis=0)
+    test_valid_mask=~np.isnan(test_stacked).any(axis=0)
+    train_stacked=np.where(train_valid_mask,train_stacked,np.nan)
+    test_data=np.where(test_valid_mask,test_stacked,np.nan)
+    height, width = train_stacked.shape[1], train_stacked.shape[2]
+    windows=window(block_coverage,total_blocks,height,width)
+    train_windows, val_windows = train_test_split(windows, test_size=test_size, random_state=42)
+    train_final_data,train_final_label= get_sampled_spatial_convolve_data(train_stacked, train_windows)
+
+    val_final_data,val_final_label = get_sampled_spatial_convolve_data(train_stacked, val_windows)
+    train_final_data,train_final_label=np.array(train_final_data), np.array(train_final_label)
+    val_final_data,val_final_label=np.array(val_final_data), np.array(val_final_label)
+    print(train_final_data.shape, train_final_label.shape)
+    print(val_final_data.shape, val_final_label.shape)
+
+    # train_data,train_final_data= get_sampled_spatial_temporal_convolve_data(train_stacked, train_windows)
+
+    # val_data,val_final_data = get_sampled_spatial_temporal_convolve_data(train_stacked, val_windows)
+    # print(train_final_data.shape)
+    # print(val_final_data.shape)
+    # train_final_data=np.array(train_final_data)
+    # val_final_data=np.array(val_final_data)
+    # print(train_final_data.shape)
+    # print(val_final_data.shape)
+    nan_train_feat = ~np.any(np.isnan(train_final_data),axis=1)
+    nan_val_feat=~np.any(np.isnan(val_final_data),axis=1) 
+    train_feat_=train_final_data[nan_train_feat]
+    val_feat_=val_final_data[nan_val_feat]
+    train_label_=train_final_label[nan_train_feat]
+    val_label_=val_final_label[nan_val_feat]
+    # train_feat_=train_final_data[:,1:]
+    # train_label_=train_final_data[:,0]
+    # val_feat_=val_final_data[:,1:]
+    # val_label_=val_final_data[:,0]
+    # print(train_feat_.shape)
+    # print(train_label_.shape)
+    # print(val_feat_.shape)
+    # print(val_label_.shape)
+
+
+    # train_feat =train_data[1:,:,:]
+    # train_label=train_data[0,:,:]
+    # val_feat=val_data[1:,:,:]
+    # val_label=val_data[0,:,:]
+    test_feat=test_data[1:,:,:]
+    test_label=test_data[0,:,:]
+    test_feat=test_feat[:,test_valid_mask].transpose()
+    test_label=test_label[test_valid_mask]
+
+
+    return train_feat_,train_label_,val_feat_,val_label_,test_feat,test_label,test_valid_mask
+
+    # return x_train, y_train,x_val,y_val,x_test, y_test,test_label_mask,train_feat_, val_feat_, train_label_,val_label_
+def get_sampled_spatial_convolve_data(data,windows):
+    new_data=[]
+    new_label=[]
+    # 4 window size
+    # data=np.pad(data,((0,0),(4,4),(4,4)),mode='constant',constant_values=np.nan)
+    for window in tqdm(windows):
+        row_start = int(window.row_off)
+        row_stop = int(window.row_off + window.height)
+        col_start = int(window.col_off)
+        col_stop = int(window.col_off + window.width)
+        # row_start=max(row_start,4)
+        # col_start=max(col_start,4) 
+        for i in range(row_start+2,row_stop-2):
+            for j in range(col_start+2, col_stop-2):
+                    temp_data=data[1:,i-2:i+3,j-2:j+3]
+                    print(temp_data)
+                    # print(temp_data)
+                    # temp_data=np.where(temp_data==np.nan,0,temp_data)
+                    # print(temp_data)
+                    # print(temp_data.mean(axis=(1,2)))
+                    print(np.nanmean(temp_data,axis=(1,2)))
+                    print(data[0,i,j])
+                    new_data.append(np.nanmean(temp_data,axis=(1,2)))
+                    new_label.append(data[0,i,j])
+                    
+                # if ~np.isnan(data[0,i,j]):
+                    
+                    
+
+                # else:
+                    
+                #     print("nan value",data[:,i,j])
+        # if data[0,row_start,col_start]!=np.nan:
+        #             new_data.append(data[:,row_start:row_stop,col_start:col_stop].mean(axis=(1,2)))
+    return new_data,new_label
+def get_sampled_spatial_temporal_convolve_data(data,windows):
+
+    new_data=[]
+    for window in tqdm(windows):
+        row_start = int(window.row_off)
+        row_stop = int(window.row_off + window.height)
+        col_start = int(window.col_off)
+        col_stop = int(window.col_off + window.width)
+        for i in range(row_start+2,row_stop-2):
+            for j in range(col_start+2, col_stop-2):
+                    temp_data=data[:,i-2:i+2,j-2:j+2]
+
+                    print(temp_data)
+                    # print(temp_data)
+                    # temp_data=np.where(temp_data==np.nan,0,temp_data)
+                    # print(temp_data)
+                    # print(temp_data.mean(axis=(1,2)))
+                    new_data.append(np.nanmean(temp_data,axis=(0,1,2)))
+       
+        # if data[0,row_start,col_start]!=np.nan:
+        #         new_data.append(data[:,row_start:row_stop,col_start:col_stop].mean(axis=(0,1,2)))
+    return new_data
+
+
+
+
+
diff --git a/vis_to_gif.py b/vis_to_gif.py
new file mode 100644
index 0000000..e69de29