Upload 284 files

.gitattributes

@@ -53,3 +53,11 @@ saved_model/**/* filter=lfs diff=lfs merge=lfs -text
 *.jpg filter=lfs diff=lfs merge=lfs -text
 *.jpeg filter=lfs diff=lfs merge=lfs -text
 *.webp filter=lfs diff=lfs merge=lfs -text
+videos[[:space:]]compressed/instant_heat_tend_259_compressed.mp4 filter=lfs diff=lfs merge=lfs -text
+videos[[:space:]]compressed/instant_heat_tend_494_compressed.mp4 filter=lfs diff=lfs merge=lfs -text
+videos[[:space:]]compressed/instant_heat_tend_761_1_compressed.mp4 filter=lfs diff=lfs merge=lfs -text
+videos[[:space:]]compressed/instant_heat_tend_761_2_compressed.mp4 filter=lfs diff=lfs merge=lfs -text
+videos[[:space:]]compressed/instant_moist_tend_259_compressed.mp4 filter=lfs diff=lfs merge=lfs -text
+videos[[:space:]]compressed/instant_moist_tend_494_compressed.mp4 filter=lfs diff=lfs merge=lfs -text
+videos[[:space:]]compressed/instant_moist_tend_761_1_compressed.mp4 filter=lfs diff=lfs merge=lfs -text
+videos[[:space:]]compressed/instant_moist_tend_761_2_compressed.mp4 filter=lfs diff=lfs merge=lfs -text

0_data_process_CAM5.py

@@ -0,0 +1,229 @@
+#!/usr/bin/env python3
+# -*- coding: utf-8 -*-
+"""
+Created on Mon Apr 3 11:22:45 2023
+
+@author: mohamedazizbhouri
+"""
+
+import os
+current_dirs_parent = os.path.dirname(os.getcwd())
+current_dirs_parent = os.path.dirname(current_dirs_parent)
+import netCDF4 as nc
+import numpy as onp
+
+def read_data(ds0, ds1, ds2):
+    
+    TBP = onp.transpose(ds0.variables['TBP'],axes=(1,0,2,3))
+    QBP = onp.transpose(ds0.variables['QBP'],axes=(1,0,2,3))
+    CLDLIQBP = onp.transpose(ds0.variables['CLDLIQBP'],axes=(1,0,2,3))
+    CLDICEBP = onp.transpose(ds0.variables['CLDICEBP'],axes=(1,0,2,3))
+    
+    TBP = onp.reshape(TBP, (lev, time*lat*lon))
+    QBP = onp.reshape(QBP, (lev, time*lat*lon))
+    CLDLIQBP = onp.reshape(CLDLIQBP, (lev, time*lat*lon))
+    CLDICEBP = onp.reshape(CLDICEBP, (lev, time*lat*lon))
+    
+    PS = onp.reshape(ds0.variables['PS'], (1, time*lat*lon))
+    SOLIN = onp.reshape(ds0.variables['SOLIN'], (1, time*lat*lon))
+    SHFLX = onp.reshape(ds0.variables['SHFLX'], (1, time*lat*lon))
+    LHFLX = onp.reshape(ds0.variables['LHFLX'], (1, time*lat*lon))
+    
+    is_land = onp.reshape(ds0.variables['LANDFRAC'], (1, time*lat*lon)) > onp.reshape(ds0.variables['OCNFRAC'], (1, time*lat*lon))
+    
+    inputs = onp.concatenate((TBP,QBP,CLDLIQBP,CLDICEBP,PS,SOLIN,SHFLX,LHFLX,is_land)).T
+    
+    TBC = onp.transpose(ds1.variables['TBC'],axes=(1,0,2,3))
+    TBC = onp.reshape(TBC, (lev, time*lat*lon))
+    TBCTEND=(TBC-TBP)/DT
+    
+    QBC = onp.transpose(ds1.variables['QBC'],axes=(1,0,2,3))
+    QBC = onp.reshape(QBC, (lev, time*lat*lon))
+    QBCTEND=(QBC-QBP)/DT
+    
+    CLDLIQBC = onp.transpose(ds1.variables['CLDLIQBC'],axes=(1,0,2,3))
+    CLDLIQBC = onp.reshape(CLDLIQBC, (lev, time*lat*lon))
+    CLDLIQBCTEND=(CLDLIQBC-CLDLIQBP)/DT
+    
+    CLDICEBC = onp.transpose(ds1.variables['CLDICEBC'],axes=(1,0,2,3))
+    CLDICEBC = onp.reshape(CLDICEBC, (lev, time*lat*lon))
+    CLDICEBCTEND=(CLDICEBC-CLDICEBP)/DT
+    
+    NN2L_FLWDS = onp.reshape(ds2.variables['NN2L_FLWDS'], (1, time*lat*lon))
+    
+    NN2L_NETSW = onp.reshape(ds2.variables['NN2L_NETSW'], (1, time*lat*lon))
+    
+    NN2L_PRECC = onp.reshape(ds2.variables['NN2L_PRECC'], (1, time*lat*lon))
+    
+    NN2L_PRECSC = onp.reshape(ds2.variables['NN2L_PRECSC'], (1, time*lat*lon))
+    
+    NN2L_SOLL = onp.reshape(ds2.variables['NN2L_SOLL'], (1, time*lat*lon))
+    
+    NN2L_SOLLD = onp.reshape(ds2.variables['NN2L_SOLLD'], (1, time*lat*lon))
+    
+    NN2L_SOLS = onp.reshape(ds2.variables['NN2L_SOLS'], (1, time*lat*lon))
+    
+    NN2L_SOLSD = onp.reshape(ds2.variables['NN2L_SOLSD'], (1, time*lat*lon))
+    
+    outputs = onp.concatenate((TBCTEND,QBCTEND,CLDLIQBCTEND,CLDICEBCTEND,
+                              NN2L_FLWDS,NN2L_NETSW,NN2L_PRECC,NN2L_PRECSC,
+                              NN2L_SOLL,NN2L_SOLLD,NN2L_SOLS,NN2L_SOLSD)).T
+    return inputs, outputs
+    
+is_4K = 0
+is_8K = 1
+if is_4K == 1:
+    pp = current_dirs_parent+'/07088/tg863871/CESM2_case/CAM5_1024_NN_L26_Feb27_4K/archive/CAM5_1024_NN_L26_Feb27_4K/atm/hist/'
+elif is_8K == 1:
+    pp = current_dirs_parent+'/07088/tg863871/CESM2_case/CAM5_1024_NN_L26_Apr26_8K/archive/CAM5_1024_NN_L26_Apr26_8K/atm/hist/'
+    
+case = 4 
+if is_4K == 1:
+    if case == 1:
+        l_year = ['2003']
+        l_month = ['01','03','05','07','08','10','12']
+        l_day = [1,7,13,19,25,31]
+        l_N = [5,5,5,5,5,0]
+    elif case == 2:
+        l_year = ['2004']
+        l_month = ['01']
+        l_day = [1,7,13,19,25,31]
+        l_N = [5,5,5,5,5,0]
+    elif case == 3:
+        l_year = ['2003']
+        l_month = ['02','04','06','09','11']
+        l_day = [1,7,13,19,25]
+        l_N_other = [5,5,5,5,5]
+        l_N_02 = [5,5,5,5,3]
+    elif case == 4:
+        l_year = ['2004']
+        l_month = ['02']
+        l_day = [1]
+        l_N = [2]
+elif is_8K == 1:
+    if case == 1:
+        l_year = ['2004']
+        l_month = ['02']
+        l_day = [1,7,13,19,25]
+        l_N = [5,5,5,5,3]
+    elif case == 2:
+        l_year = ['2004']
+        l_month = ['03']
+        l_day = [1,7,13]
+        l_N = [5,5,0]
+    elif case == 3:
+        l_year = ['2003']
+        l_month = ['02','04','06','09','11']
+        l_day = [1,7,13,19,25]
+        l_N_other = [5,5,5,5,5]
+        l_N_02 = [5,5,5,5,3]
+    elif case == 4: 
+        l_year = ['2004']
+        l_month = ['01']
+        l_day = [1,7,13,19,25,31]
+        l_N = [5,5,5,5,5,0]
+    elif case == 5:
+        l_year = ['2003']
+        l_month = ['01','03','05','07','08','10','12']
+        l_day = [1,7,13,19,25,31]
+        l_N = [5,5,5,5,5,0]
+
+for k in range(len(l_year)):
+    i_year = l_year[k]
+    
+    for i in range(len(l_month)):
+        
+        i_month = l_month[i]    
+        
+        #case 1, 2, 4, 5
+        # nothing, l_N and l_day are the same for any i index
+        if case == 3:
+            if i_month == '02':
+                l_N = l_N_02
+            else:
+                l_N = l_N_other
+        
+        for ii in range(len(l_day)):
+            i_day = l_day[ii]
+            N_day = l_N[ii]
+            
+            if i_day<10:
+                i_day_str = '0'+str(i_day)
+            else:
+                i_day_str = str(i_day)
+            
+            if is_4K == 1:
+                ds0 = nc.Dataset(pp+'CAM5_1024_NN_L26_Feb27_4K.cam.h0.'+i_year+'-'+i_month+'-'+i_day_str+'-01800.nc')
+                ds1 = nc.Dataset(pp+'CAM5_1024_NN_L26_Feb27_4K.cam.h1.'+i_year+'-'+i_month+'-'+i_day_str+'-01800.nc')
+                ds2 = nc.Dataset(pp+'CAM5_1024_NN_L26_Feb27_4K.cam.h2.'+i_year+'-'+i_month+'-'+i_day_str+'-01800.nc')
+            elif is_8K == 1:
+                ds0 = nc.Dataset(pp+'CAM5_1024_NN_L26_Apr26_8K.cam.h0.'+i_year+'-'+i_month+'-'+i_day_str+'-01800.nc')
+                ds1 = nc.Dataset(pp+'CAM5_1024_NN_L26_Apr26_8K.cam.h1.'+i_year+'-'+i_month+'-'+i_day_str+'-01800.nc')
+                ds2 = nc.Dataset(pp+'CAM5_1024_NN_L26_Apr26_8K.cam.h2.'+i_year+'-'+i_month+'-'+i_day_str+'-01800.nc')                
+            
+            DT = 30*60
+            lat = ds0.dimensions['lat'].size
+            time = ds0.dimensions['time'].size
+            lon = ds0.dimensions['lon'].size
+            lev = ds0.dimensions['lev'].size
+            
+            inputs, outputs = read_data(ds0, ds1, ds2)
+            
+            #due to zero solar insulation remove half of the points
+            name_end = ['01800','05400','09000','12600','16200',
+                        '19800','23400','27000','30600','34200',
+                        '37800','41400','45000','48600','52200',
+                        '55800','59400','63000','66600','70200',
+                        '73800','77400','81000','84600']
+            
+            num_name = len(name_end)
+            
+            for i in range(num_name-1):
+                if is_4K == 1:
+                    ds0 = nc.Dataset(pp+'CAM5_1024_NN_L26_Feb27_4K.cam.h0.'+i_year+'-'+i_month+'-'+i_day_str+'-'+name_end[i+1]+'.nc')
+                    ds1 = nc.Dataset(pp+'CAM5_1024_NN_L26_Feb27_4K.cam.h1.'+i_year+'-'+i_month+'-'+i_day_str+'-'+name_end[i+1]+'.nc')
+                    ds2 = nc.Dataset(pp+'CAM5_1024_NN_L26_Feb27_4K.cam.h2.'+i_year+'-'+i_month+'-'+i_day_str+'-'+name_end[i+1]+'.nc')
+                elif is_8K == 1:
+                    ds0 = nc.Dataset(pp+'CAM5_1024_NN_L26_Apr26_8K.cam.h0.'+i_year+'-'+i_month+'-'+i_day_str+'-'+name_end[i+1]+'.nc')
+                    ds1 = nc.Dataset(pp+'CAM5_1024_NN_L26_Apr26_8K.cam.h1.'+i_year+'-'+i_month+'-'+i_day_str+'-'+name_end[i+1]+'.nc')
+                    ds2 = nc.Dataset(pp+'CAM5_1024_NN_L26_Apr26_8K.cam.h2.'+i_year+'-'+i_month+'-'+i_day_str+'-'+name_end[i+1]+'.nc')
+                
+                inputs_l, outputs_l = read_data(ds0, ds1, ds2)
+                inputs = onp.concatenate((inputs,inputs_l))
+                outputs = onp.concatenate((outputs,outputs_l))
+            
+            for j in range(N_day):
+                print(j)
+                i_day += 1
+                if i_day<10:
+                    i_day_str = '0'+str(i_day)
+                else:
+                    i_day_str = str(i_day)        
+                for i in range(num_name):
+                    if is_4K == 1:
+                        ds0 = nc.Dataset(pp+'CAM5_1024_NN_L26_Feb27_4K.cam.h0.'+i_year+'-'+i_month+'-'+i_day_str+'-'+name_end[i]+'.nc')
+                        ds1 = nc.Dataset(pp+'CAM5_1024_NN_L26_Feb27_4K.cam.h1.'+i_year+'-'+i_month+'-'+i_day_str+'-'+name_end[i]+'.nc')
+                        ds2 = nc.Dataset(pp+'CAM5_1024_NN_L26_Feb27_4K.cam.h2.'+i_year+'-'+i_month+'-'+i_day_str+'-'+name_end[i]+'.nc')
+                    elif is_8K == 1:
+                        ds0 = nc.Dataset(pp+'CAM5_1024_NN_L26_Apr26_8K.cam.h0.'+i_year+'-'+i_month+'-'+i_day_str+'-'+name_end[i]+'.nc')
+                        ds1 = nc.Dataset(pp+'CAM5_1024_NN_L26_Apr26_8K.cam.h1.'+i_year+'-'+i_month+'-'+i_day_str+'-'+name_end[i]+'.nc')
+                        ds2 = nc.Dataset(pp+'CAM5_1024_NN_L26_Apr26_8K.cam.h2.'+i_year+'-'+i_month+'-'+i_day_str+'-'+name_end[i]+'.nc')
+                       
+                    inputs_l, outputs_l = read_data(ds0, ds1, ds2)
+                    inputs = onp.concatenate((inputs,inputs_l))
+                    outputs = onp.concatenate((outputs,outputs_l))
+            
+            if i_day<10:
+                i_day_str = '0'+str(i_day)
+            else:
+                i_day_str = str(i_day)
+                
+            if is_4K == 1:
+                onp.save('data_CAM5_4K/inputs_'+i_year+'_'+i_month+'_'+i_day_str,inputs)
+                onp.save('data_CAM5_4K/outputs_'+i_year+'_'+i_month+'_'+i_day_str,outputs)
+            elif is_8K == 1:
+                onp.save('data_CAM5_8K/inputs_'+i_year+'_'+i_month+'_'+i_day_str,inputs)
+                onp.save('data_CAM5_8K/outputs_'+i_year+'_'+i_month+'_'+i_day_str,outputs)
+            
+            print('h0.'+i_year+'-'+i_month+'-'+i_day_str, ', train data shape: ',inputs.shape, outputs.shape) # (221184, 108) (221184, 112)
+            

0_data_process_SPCAM5.py

@@ -0,0 +1,246 @@
+#!/usr/bin/env python3
+# -*- coding: utf-8 -*-
+"""
+Created on Mon Apr 3 11:28:31 2023
+
+@author: mohamedazizbhouri
+"""
+
+import os
+current_dirs_parent = os.path.dirname(os.getcwd())
+current_dirs_parent = os.path.dirname(current_dirs_parent)
+import netCDF4 as nc
+import numpy as onp
+
+def read_data(ds0, ds1, ds2):
+        
+    TBP = onp.transpose(ds0.variables['TBP'],axes=(1,0,2,3))
+    QBP = onp.transpose(ds0.variables['QBP'],axes=(1,0,2,3))
+    CLDLIQBP = onp.transpose(ds0.variables['CLDLIQBP'],axes=(1,0,2,3))
+    CLDICEBP = onp.transpose(ds0.variables['CLDICEBP'],axes=(1,0,2,3))
+    
+    TBP = onp.reshape(TBP, (lev, time*lat*lon))
+    QBP = onp.reshape(QBP, (lev, time*lat*lon))
+    CLDLIQBP = onp.reshape(CLDLIQBP, (lev, time*lat*lon))
+    CLDICEBP = onp.reshape(CLDICEBP, (lev, time*lat*lon))
+    
+    PS = onp.reshape(ds0.variables['PS'], (1, time*lat*lon))
+    SOLIN = onp.reshape(ds0.variables['SOLIN'], (1, time*lat*lon))
+    SHFLX = onp.reshape(ds0.variables['SHFLX'], (1, time*lat*lon))
+    LHFLX = onp.reshape(ds0.variables['LHFLX'], (1, time*lat*lon))
+    
+    is_land = onp.reshape(ds0.variables['LANDFRAC'], (1, time*lat*lon)) > onp.reshape(ds0.variables['OCNFRAC'], (1, time*lat*lon))
+    
+    inputs = onp.concatenate((TBP,QBP,CLDLIQBP,CLDICEBP,PS,SOLIN,SHFLX,LHFLX,is_land)).T
+    
+    TBC = onp.transpose(ds1.variables['TBC'],axes=(1,0,2,3))
+    TBC = onp.reshape(TBC, (lev, time*lat*lon))
+    TBCTEND=(TBC-TBP)/DT
+    
+    QBC = onp.transpose(ds1.variables['QBC'],axes=(1,0,2,3))
+    QBC = onp.reshape(QBC, (lev, time*lat*lon))
+    QBCTEND=(QBC-QBP)/DT
+    
+    CLDLIQBC = onp.transpose(ds1.variables['CLDLIQBC'],axes=(1,0,2,3))
+    CLDLIQBC = onp.reshape(CLDLIQBC, (lev, time*lat*lon))
+    CLDLIQBCTEND=(CLDLIQBC-CLDLIQBP)/DT
+    
+    CLDICEBC = onp.transpose(ds1.variables['CLDICEBC'],axes=(1,0,2,3))
+    CLDICEBC = onp.reshape(CLDICEBC, (lev, time*lat*lon))
+    CLDICEBCTEND=(CLDICEBC-CLDICEBP)/DT
+    
+    NN2L_FLWDS = onp.reshape(ds2.variables['NN2L_FLWDS'], (1, time*lat*lon))
+    
+    NN2L_NETSW = onp.reshape(ds2.variables['NN2L_NETSW'], (1, time*lat*lon))
+    
+    NN2L_PRECC = onp.reshape(ds2.variables['NN2L_PRECC'], (1, time*lat*lon))
+    
+    NN2L_PRECSC = onp.reshape(ds2.variables['NN2L_PRECSC'], (1, time*lat*lon))
+    
+    NN2L_SOLL = onp.reshape(ds2.variables['NN2L_SOLL'], (1, time*lat*lon))
+    
+    NN2L_SOLLD = onp.reshape(ds2.variables['NN2L_SOLLD'], (1, time*lat*lon))
+    
+    NN2L_SOLS = onp.reshape(ds2.variables['NN2L_SOLS'], (1, time*lat*lon))
+    
+    NN2L_SOLSD = onp.reshape(ds2.variables['NN2L_SOLSD'], (1, time*lat*lon))
+    
+    outputs = onp.concatenate((TBCTEND,QBCTEND,CLDLIQBCTEND,CLDICEBCTEND,
+                              NN2L_FLWDS,NN2L_NETSW,NN2L_PRECC,NN2L_PRECSC,
+                              NN2L_SOLL,NN2L_SOLLD,NN2L_SOLS,NN2L_SOLSD)).T
+    return inputs, outputs
+
+is_4K = 0
+is_hist = 1
+if is_4K == 1:
+    pp = current_dirs_parent+'/07088/tg863871/CESM2_case/SPCAM_NN_4K/archive/SPCAM_NN_4K/atm/hist/'
+elif is_hist == 1:   
+    pp = current_dirs_parent+'/07088/tg863871/CESM2_case/SPCAM_NN_v2/archive/SPCAM_NN_v2/atm/hist/'
+    
+case = 4 
+
+if is_4K == 1:
+    if case == 1:
+        l_year = ['2003']
+        l_month = ['01','03','05','07','08','10','12']
+        l_day = [1,7,13,19,25,31]
+        l_N = [5,5,5,5,5,0]
+    elif case == 2: 
+        l_year = ['2004']
+        l_month = ['01']
+        l_day = [1,7,13,19,25,31]
+        l_N = [5,5,5,5,5,0]
+    elif case == 3:
+        l_year = ['2003']
+        l_month = ['02','04','06','09','11']
+        l_day = [1,7,13,19,25]
+        l_N_other = [5,5,5,5,5]
+        l_N_02 = [5,5,5,5,3]
+    elif case == 4:
+        l_year = ['2004']
+        l_month = ['02']
+        l_day = [1]
+        l_N = [2]
+elif is_hist == 1:  
+    if case == 1:
+        l_year = ['2003']
+        l_month = ['01','03','05','07','08','10','12']
+        l_day = [1,7,13,19,25,31]
+        l_N = [5,5,5,5,5,0]
+    elif case == 2:
+        l_year = ['2004']
+        l_month = ['01','03','05','07','08']
+        l_day_other = [1,7,13,19,25,31]
+        l_N_other = [5,5,5,5,5,0]
+        l_day_08 = [1]
+        l_N_08 = [2]
+    elif case == 3:
+        l_year = ['2003']
+        l_month = ['02','04','06','09','11']
+        l_day = [1,7,13,19,25]
+        l_N_other = [5,5,5,5,5]
+        l_N_02 = [5,5,5,5,3]
+    elif case == 4:
+        l_year = ['2004']
+        l_month = ['02','04','06']
+        l_day = [1,7,13,19,25]
+        l_N_04_06 = [5,5,5,5,5]
+        l_N_02 = [5,5,5,5,3]
+
+for k in range(len(l_year)):
+    i_year = l_year[k]
+    
+    for i in range(len(l_month)):
+        
+        i_month = l_month[i]    
+        
+        if is_4K == 1:
+            #case 1, 2, 4
+            # nothing, l_N and l_day are the same for any i index
+            if case == 3:
+                if i_month == '02':
+                    l_N = l_N_02
+                else:
+                    l_N = l_N_other
+        elif is_hist == 1:
+            #case 1
+            # nothing, l_N and l_day are the same for any i index
+            if case == 2:
+                if i_month == '08':
+                    l_N = l_N_08
+                    l_day = l_day_08
+                else:
+                    l_N = l_N_other
+                    l_day = l_day_other
+            elif case == 3:
+                if i_month == '02':
+                    l_N = l_N_02
+                else:
+                    l_N = l_N_other
+            elif case == 4:
+                if i_month == '02':
+                    l_N = l_N_02
+                else:
+                    l_N = l_N_04_06
+        for ii in range(len(l_day)):
+            i_day = l_day[ii]
+            N_day = l_N[ii]
+            
+            if i_day<10:
+                i_day_str = '0'+str(i_day)
+            else:
+                i_day_str = str(i_day)
+            
+            if is_4K == 1:
+                ds0 = nc.Dataset(pp+'SPCAM_NN_4K.cam.h0.'+i_year+'-'+i_month+'-'+i_day_str+'-01800.nc')
+                ds1 = nc.Dataset(pp+'SPCAM_NN_4K.cam.h1.'+i_year+'-'+i_month+'-'+i_day_str+'-01800.nc')
+                ds2 = nc.Dataset(pp+'SPCAM_NN_4K.cam.h2.'+i_year+'-'+i_month+'-'+i_day_str+'-01800.nc')
+            elif is_hist == 1:
+                ds0 = nc.Dataset(pp+'SPCAM_NN_v2.cam.h0.'+i_year+'-'+i_month+'-'+i_day_str+'-01800.nc')
+                ds1 = nc.Dataset(pp+'SPCAM_NN_v2.cam.h1.'+i_year+'-'+i_month+'-'+i_day_str+'-01800.nc')
+                ds2 = nc.Dataset(pp+'SPCAM_NN_v2.cam.h2.'+i_year+'-'+i_month+'-'+i_day_str+'-01800.nc')
+            DT = 30*60
+            lat = ds0.dimensions['lat'].size
+            time = ds0.dimensions['time'].size
+            lon = ds0.dimensions['lon'].size
+            lev = ds0.dimensions['lev'].size
+            
+            inputs, outputs = read_data(ds0, ds1, ds2)
+            
+            #due to zero solar insulation remove half of the points
+            name_end = ['01800','05400','09000','12600','16200',
+                        '19800','23400','27000','30600','34200',
+                        '37800','41400','45000','48600','52200',
+                        '55800','59400','63000','66600','70200',
+                        '73800','77400','81000','84600']
+            
+            num_name = len(name_end)
+            
+            for i in range(num_name-1):
+                if is_4K == 1:
+                    ds0 = nc.Dataset(pp+'SPCAM_NN_4K.cam.h0.'+i_year+'-'+i_month+'-'+i_day_str+'-'+name_end[i+1]+'.nc')
+                    ds1 = nc.Dataset(pp+'SPCAM_NN_4K.cam.h1.'+i_year+'-'+i_month+'-'+i_day_str+'-'+name_end[i+1]+'.nc')
+                    ds2 = nc.Dataset(pp+'SPCAM_NN_4K.cam.h2.'+i_year+'-'+i_month+'-'+i_day_str+'-'+name_end[i+1]+'.nc')
+                elif is_hist == 1:
+                    ds0 = nc.Dataset(pp+'SPCAM_NN_v2.cam.h0.'+i_year+'-'+i_month+'-'+i_day_str+'-'+name_end[i+1]+'.nc')
+                    ds1 = nc.Dataset(pp+'SPCAM_NN_v2.cam.h1.'+i_year+'-'+i_month+'-'+i_day_str+'-'+name_end[i+1]+'.nc')
+                    ds2 = nc.Dataset(pp+'SPCAM_NN_v2.cam.h2.'+i_year+'-'+i_month+'-'+i_day_str+'-'+name_end[i+1]+'.nc')
+                inputs_l, outputs_l = read_data(ds0, ds1, ds2)
+                inputs = onp.concatenate((inputs,inputs_l))
+                outputs = onp.concatenate((outputs,outputs_l))
+            
+            for j in range(N_day):
+                print(j)
+                i_day += 1
+                if i_day<10:
+                    i_day_str = '0'+str(i_day)
+                else:
+                    i_day_str = str(i_day)        
+                for i in range(num_name):
+                    if is_4K == 1:
+                        ds0 = nc.Dataset(pp+'SPCAM_NN_4K.cam.h0.'+i_year+'-'+i_month+'-'+i_day_str+'-'+name_end[i]+'.nc')
+                        ds1 = nc.Dataset(pp+'SPCAM_NN_4K.cam.h1.'+i_year+'-'+i_month+'-'+i_day_str+'-'+name_end[i]+'.nc')
+                        ds2 = nc.Dataset(pp+'SPCAM_NN_4K.cam.h2.'+i_year+'-'+i_month+'-'+i_day_str+'-'+name_end[i]+'.nc')
+                    elif is_hist == 1:
+                        ds0 = nc.Dataset(pp+'SPCAM_NN_v2.cam.h0.'+i_year+'-'+i_month+'-'+i_day_str+'-'+name_end[i]+'.nc')
+                        ds1 = nc.Dataset(pp+'SPCAM_NN_v2.cam.h1.'+i_year+'-'+i_month+'-'+i_day_str+'-'+name_end[i]+'.nc')
+                        ds2 = nc.Dataset(pp+'SPCAM_NN_v2.cam.h2.'+i_year+'-'+i_month+'-'+i_day_str+'-'+name_end[i]+'.nc')
+                        
+                    inputs_l, outputs_l = read_data(ds0, ds1, ds2)
+                    inputs = onp.concatenate((inputs,inputs_l))
+                    outputs = onp.concatenate((outputs,outputs_l))
+            
+            if i_day<10:
+                i_day_str = '0'+str(i_day)
+            else:
+                i_day_str = str(i_day)
+            
+            if is_4K == 1:
+                onp.save('data_SPCAM5_4K/inputs_'+i_year+'_'+i_month+'_'+i_day_str,inputs)
+                onp.save('data_SPCAM5_4K/outputs_'+i_year+'_'+i_month+'_'+i_day_str,outputs)
+            elif is_hist == 1:
+                onp.save('data_SPCAM5_hist/inputs_'+i_year+'_'+i_month+'_'+i_day_str,inputs)
+                onp.save('data_SPCAM5_hist/outputs_'+i_year+'_'+i_month+'_'+i_day_str,outputs)
+                
+            print('h0.'+i_year+'-'+i_month+'-'+i_day_str, ', train data shape: ',inputs.shape, outputs.shape) # (221184, 108) (221184, 112)
+            

1_create_train_test.py

@@ -0,0 +1,144 @@
+#!/usr/bin/env python3
+# -*- coding: utf-8 -*-
+"""
+Created on Wed Apr 12 12:04:50 2023
+
+@author: mohamedazizbhouri
+"""
+
+CAM_train_input = 0
+CAM_train_output = 0
+CAM_4K_input = 0
+CAM_4K_output = 0
+
+SPCAM_train_input = 0
+SPCAM_train_output = 0
+SPCAM_test_input = 0
+SPCAM_test_output = 0
+
+is_output_heat = 1
+
+if SPCAM_train_input == 1 or SPCAM_train_output == 1:
+    pp_SPCAM = 'data_SPCAM5_hist/'
+if SPCAM_test_input == 1 or SPCAM_test_output == 1:
+    pp_SPCAM ='data_SPCAM5_4K/'
+if CAM_train_input == 1 or CAM_train_output == 1:
+    pp_CAM = 'data_CAM5_8K/' 
+if CAM_4K_input == 1 or CAM_4K_output == 1:
+    pp_CAM = 'data_CAM5_4K/' 
+    
+import numpy as np
+
+train_CAM =['2003_02_06','2003_02_12','2003_02_18','2003_02_24','2003_02_28',
+            '2003_03_06','2003_03_12','2003_03_18','2003_03_24','2003_03_30','2003_03_31',
+            '2003_04_06','2003_04_12','2003_04_18','2003_04_24','2003_04_30',
+            '2003_05_06','2003_05_12','2003_05_18','2003_05_24','2003_05_30','2003_05_31',
+            '2003_06_06','2003_06_12','2003_06_18','2003_06_24','2003_06_30',
+            '2003_07_06','2003_07_12','2003_07_18','2003_07_24','2003_07_30','2003_07_31',
+            '2003_08_06','2003_08_12','2003_08_18','2003_08_24','2003_08_30','2003_08_31',
+            '2003_09_06','2003_09_12','2003_09_18','2003_09_24','2003_09_30',
+            '2003_10_06','2003_10_12','2003_10_18','2003_10_24','2003_10_30','2003_10_31',
+            '2003_11_06','2003_11_12','2003_11_18','2003_11_24','2003_11_30',
+            '2003_12_06','2003_12_12','2003_12_18','2003_12_24','2003_12_30','2003_12_31',
+            '2004_01_06','2004_01_12','2004_01_18','2004_01_24','2004_01_30','2004_01_31']
+
+train_SPCAM =['2003_02_06','2003_02_12','2003_02_18','2003_02_24','2003_02_28',
+              '2003_03_06','2003_03_12','2003_03_18','2003_03_24','2003_03_30','2003_03_31',
+              '2003_04_06','2003_04_12','2003_04_18','2003_04_24','2003_04_30']
+
+test_SPCAM =['2003_02_06','2003_02_12','2003_02_18','2003_02_24','2003_02_28',
+              '2003_03_06','2003_03_12','2003_03_18','2003_03_24','2003_03_30','2003_03_31',
+              '2003_04_06','2003_04_12','2003_04_18','2003_04_24','2003_04_30',
+              '2003_05_06','2003_05_12','2003_05_18','2003_05_24','2003_05_30','2003_05_31',
+              '2003_06_06','2003_06_12','2003_06_18','2003_06_24','2003_06_30',
+              '2003_07_06','2003_07_12','2003_07_18','2003_07_24','2003_07_30','2003_07_31',
+              '2003_08_06','2003_08_12','2003_08_18','2003_08_24','2003_08_30','2003_08_31',
+              '2003_09_06','2003_09_12','2003_09_18','2003_09_24','2003_09_30',
+              '2003_10_06','2003_10_12','2003_10_18','2003_10_24','2003_10_30','2003_10_31',
+              '2003_11_06','2003_11_12','2003_11_18','2003_11_24','2003_11_30',
+              '2003_12_06','2003_12_12','2003_12_18','2003_12_24','2003_12_30','2003_12_31',
+              '2004_01_06','2004_01_12','2004_01_18','2004_01_24','2004_01_30','2004_01_31']
+
+import gc
+
+ind_input = np.concatenate( (np.arange(52),np.array([104,105,106,107])) )
+if is_output_heat == 1:
+    ind_output = np.arange(26) # heat tend
+else:
+    ind_output = 26+np.arange(26) # moist tend
+
+if CAM_train_input == 1 or CAM_4K_input == 1: 
+    train_CAM_in = np.load(pp_CAM+'inputs_'+train_CAM[0]+'.npy')[:,ind_input]
+    gc.collect()
+    for i in range(len(train_CAM)-1):
+        print(train_CAM[i+1])
+        train_CAM_in = np.concatenate((train_CAM_in,
+                                       np.load(pp_CAM+'inputs_'+train_CAM[i+1]+'.npy')[:,ind_input]),axis=0)
+        gc.collect()
+    np.save(pp_CAM+'all_inputs.npy',train_CAM_in)
+    print('Final data shape: ', train_CAM_in.shape)
+
+if CAM_train_output == 1 or CAM_4K_output == 1:    
+    train_CAM_out = np.load(pp_CAM+'outputs_'+train_CAM[0]+'.npy')[:,ind_output]
+    gc.collect()
+    for i in range(len(train_CAM)-1):
+        print(train_CAM[i+1])
+        train_CAM_out = np.concatenate((train_CAM_out,
+                                        np.load(pp_CAM+'outputs_'+train_CAM[i+1]+'.npy')[:,ind_output]),axis=0)
+        gc.collect()
+    
+    if is_output_heat == 1:
+        np.save(pp_CAM+'all_outputs_heat.npy',train_CAM_out)
+    else:
+        np.save(pp_CAM+'all_outputs_moist.npy',train_CAM_out)
+    print('Final data shape: ', train_CAM_out.shape) 
+    
+if SPCAM_train_input == 1:
+    train_SPCAM_in = np.load(pp_SPCAM+'inputs_'+train_SPCAM[0]+'.npy')[:,ind_input] 
+    gc.collect()
+    for i in range(len(train_SPCAM)-1):
+        print(train_SPCAM[i+1])
+        train_SPCAM_in = np.concatenate((train_SPCAM_in,
+                                         np.load(pp_SPCAM+'inputs_'+train_SPCAM[i+1]+'.npy')[:,ind_input]),axis=0)
+        gc.collect()
+    np.save(pp_SPCAM+'three_month_inputs.npy',train_SPCAM_in)
+    print('Final data shape: ', train_SPCAM_in.shape)
+    
+if SPCAM_train_output == 1:   
+    train_SPCAM_out = np.load(pp_SPCAM+'outputs_'+train_SPCAM[0]+'.npy')[:,ind_output]
+    gc.collect()
+    for i in range(len(train_SPCAM)-1):
+        print(train_SPCAM[i+1])
+        train_SPCAM_out = np.concatenate((train_SPCAM_out,
+                                          np.load(pp_SPCAM+'outputs_'+train_SPCAM[i+1]+'.npy')[:,ind_output]),axis=0)
+        gc.collect()
+    if is_output_heat == 1:
+        np.save(pp_SPCAM+'three_month_outputs_heat.npy',train_SPCAM_out)
+    else:
+        np.save(pp_SPCAM+'three_month_outputs_moist.npy',train_SPCAM_out)
+    print('Final data shape: ', train_SPCAM_out.shape) 
+
+if SPCAM_test_input == 1:
+    test_SPCAM_in = np.load(pp_SPCAM+'inputs_'+test_SPCAM[0]+'.npy')[:,ind_input]
+    gc.collect()
+    for i in range(len(test_SPCAM)-1):
+        print(test_SPCAM[i+1])
+        test_SPCAM_in = np.concatenate((test_SPCAM_in,
+                                        np.load(pp_SPCAM+'inputs_'+test_SPCAM[i+1]+'.npy')[:,ind_input]),axis=0)
+        gc.collect()
+    np.save(pp_SPCAM+'all_inputs.npy',test_SPCAM_in)
+    print('Final data shape: ', test_SPCAM_in.shape) 
+    
+if SPCAM_test_output == 1:   
+    test_SPCAM_out = np.load(pp_SPCAM+'outputs_'+test_SPCAM[0]+'.npy')[:,ind_output]
+    gc.collect()
+    for i in range(len(test_SPCAM)-1):
+        print(test_SPCAM[i+1])
+        test_SPCAM_out = np.concatenate((test_SPCAM_out,
+                                         np.load(pp_SPCAM+'outputs_'+test_SPCAM[i+1]+'.npy')[:,ind_output]),axis=0)
+        gc.collect()
+    if is_output_heat == 1:
+        np.save(pp_SPCAM+'all_outputs_heat.npy',test_SPCAM_out)
+    else:
+        np.save(pp_SPCAM+'all_outputs_moist.npy',test_SPCAM_out)
+    print('Final data shape: ', test_SPCAM_out.shape) 

2_candle_plots_data_distr.py

@@ -0,0 +1,175 @@
+#!/usr/bin/env python3
+# -*- coding: utf-8 -*-
+"""
+Created on Tue Apr 18 12:31:04 2023
+
+@author: mohamedazizbhouri
+"""
+
+import os
+os.environ['KMP_DUPLICATE_LIB_OK']='True'
+
+import numpy as np
+import matplotlib as mpl
+
+def figsize(scale, nplots = 1):
+    fig_width_pt = 390.0                          
+    inches_per_pt = 1.0/72.27                       # Convert pt to inch
+    golden_mean = (np.sqrt(5.0)-1.0)/2.0            # Aesthetic ratio (you could change this)
+    fig_width = fig_width_pt*inches_per_pt*scale    # width in inches
+    fig_height = nplots*fig_width*golden_mean              # height in inches
+    fig_size = [fig_width,fig_height]
+    return fig_size
+
+pgf_with_latex = {          
+    "font.monospace": [],
+    "axes.labelsize": 32,
+    "axes.titlesize": 32,
+    "axes.linewidth": 3,
+    "font.size": 32,
+    "lines.linewidth": 3,
+    "legend.fontsize": 32,               
+    "xtick.labelsize": 32,
+    "ytick.labelsize": 32,
+    "figure.figsize": figsize(1.0)}
+mpl.rcParams.update(pgf_with_latex)
+
+import matplotlib.pyplot as plt
+
+plt.ticklabel_format(axis='both', style='sci', scilimits=(0,0))
+
+def newfig(width, nplots = 1):
+    fig = plt.figure(figsize=figsize(width, nplots))
+    ax = fig.add_subplot(111)
+    return fig, ax
+
+def savefig(filename, crop = True):
+    if crop == True:
+        plt.savefig('{}.png'.format(filename), bbox_inches='tight', pad_inches=0.1 , dpi = 300)
+    else:
+        plt.savefig('{}.png'.format(filename), dpi = 300)
+
+plt.close('all')
+
+is_5_pr_lvls_heat_tend_and_spec_hum = 1 # to plot 5 pressure levels for heat tendency and specific humidity
+is_1st_lvl_SS_moist_tend = 1 # to plot highest pressure level (lowest altitude) for moist tendency
+
+if 1==1:
+    
+    with_fliers = False 
+    print('loading data')
+    
+    CAM5_4K = np.load('data_CAM5_4K/all_outputs_moist.npy')
+    CAM5_8K = np.load('data_CAM5_8K/all_outputs_moist.npy')
+    SPCAM5_hist = np.load('data_SPCAM5_hist/three_month_outputs_moist.npy') 
+    SPCAM5_4K = np.load('data_SPCAM5_4K/all_outputs_moist.npy') 
+    
+    name = ['958 hPa']
+
+    CAM5_4K = np.array(CAM5_4K,dtype=np.float64)
+    CAM5_8K = np.array(CAM5_8K,dtype=np.float64)
+    SPCAM5_hist = np.array(SPCAM5_hist,dtype=np.float64)
+    SPCAM5_4K = np.array(SPCAM5_4K,dtype=np.float64)
+    
+    print('data loaded, making candle plots')
+    
+    Data_CAM5_4K = [CAM5_4K[:,25]]
+    Data_CAM5_8K = [CAM5_8K[:,25]]
+    Data_SPCAM5_hist = [SPCAM5_hist[:,25]]
+    Data_SPCAM5_4K = [SPCAM5_4K[:,25]]
+    
+    fig = plt.figure()
+    fig.set_size_inches(8, 15)
+    
+    for j in range(1):
+        ax = plt.subplot(1, 1, j+1)
+        ax.ticklabel_format(axis="y", style="sci", scilimits=(0,0))
+        bp1 = ax.boxplot([Data_SPCAM5_hist[j]], positions=[1], patch_artist=True, notch=True, boxprops=dict(facecolor="red"), showfliers=with_fliers)
+        bp2 = ax.boxplot([Data_SPCAM5_4K[j]], positions=[1.5], patch_artist=True, notch=True, boxprops=dict(facecolor="orange"), showfliers=with_fliers)
+        bp3 = ax.boxplot([Data_CAM5_4K[j]], positions=[2], patch_artist=True, notch=True, boxprops=dict(facecolor="blue"), showfliers=with_fliers)
+        bp4 = ax.boxplot([Data_CAM5_8K[j]], positions=[2.5], patch_artist=True, notch=True, boxprops=dict(facecolor="pink"), showfliers=with_fliers)
+        ax.ticklabel_format(axis="y", style="sci", scilimits=(0,0))
+        ax.set_xticklabels([])
+        ax.set_xticks([])
+        if j == 0:
+            ax.legend([bp1["boxes"][0], bp2["boxes"][0], bp3["boxes"][0], bp4["boxes"][0]], 
+                      ['SPCAM5 hist 3 m. (HF tr.)', 'SPCAM5 +4K 1 y. (HF ts.)', 'CAM5 +4K 1 y.', 'CAM5 +8K 1 y. (LF tr.)'], ncol=1, loc='upper center', bbox_to_anchor=[0.5, 1.3])#bbox_to_anchor=(2,1.2))#2.95, 1.5))
+    savefig('candle_plots_1st_lvl_SS_moist_tend', True)
+
+        
+if is_5_pr_lvls_heat_tend_and_spec_hum == 1:
+    
+    with_fliers = False
+    print('loading data')
+    
+    CAM5_4K_v1 = np.load('data_CAM5_4K/all_outputs_heat.npy')
+    CAM5_8K_v1 = np.load('data_CAM5_8K/all_outputs_heat.npy')
+    SPCAM5_hist_v1 = np.load('data_SPCAM5_hist/three_month_outputs_heat.npy') 
+    
+    CAM5_4K_v2 = np.load('data_CAM5_4K/all_inputs.npy')[:,26:26*2] 
+    CAM5_8K_v2 = np.load('data_CAM5_8K/all_inputs.npy')[:,26:26*2] 
+    SPCAM5_hist_v2 = np.load('data_SPCAM5_hist/three_month_inputs.npy')[:,26:26*2]
+    
+    name = ['137 hPa', '259 hPa', '494 hPa', '761 hPa', '958 hPa']
+
+    name2 = ['3.5', '7.4', '14', '24', '37', '53', '70', '85', '100', '117',
+                '137', '160', '188', '221', '259', '305', '358', '420', '494',
+                '581', '673', '761', '837', '897', '937', '958']
+    
+    CAM5_4K_v1 = np.array(CAM5_4K_v1,dtype=np.float64)
+    CAM5_8K_v1 = np.array(CAM5_8K_v1,dtype=np.float64)
+    SPCAM5_hist_v1 = np.array(SPCAM5_hist_v1,dtype=np.float64)
+    
+    CAM5_4K_v2 = np.array(CAM5_4K_v2,dtype=np.float64)
+    CAM5_8K_v2 = np.array(CAM5_8K_v2,dtype=np.float64)
+    SPCAM5_hist_v2 = np.array(SPCAM5_hist_v2,dtype=np.float64)
+    
+    print('data loaded, making candle plots')
+    
+    Data_CAM5_4K_v1 = [CAM5_4K_v1[:,10],CAM5_4K_v1[:,14],CAM5_4K_v1[:,18],CAM5_4K_v1[:,21],CAM5_4K_v1[:,25]]
+    Data_CAM5_8K_v1 = [CAM5_8K_v1[:,10],CAM5_8K_v1[:,14],CAM5_8K_v1[:,18],CAM5_8K_v1[:,21],CAM5_8K_v1[:,25]]
+    Data_SPCAM5_hist_v1 = [SPCAM5_hist_v1[:,10],SPCAM5_hist_v1[:,14],SPCAM5_hist_v1[:,18],SPCAM5_hist_v1[:,21],SPCAM5_hist_v1[:,25]]
+    
+    Data_CAM5_4K_v2 = [CAM5_4K_v2[:,10],CAM5_4K_v2[:,14],CAM5_4K_v2[:,18],CAM5_4K_v2[:,21],CAM5_4K_v2[:,25]]
+    Data_CAM5_8K_v2 = [CAM5_8K_v2[:,10],CAM5_8K_v2[:,14],CAM5_8K_v2[:,18],CAM5_8K_v2[:,21],CAM5_8K_v2[:,25]]
+    Data_SPCAM5_hist_v2 = [SPCAM5_hist_v2[:,10],SPCAM5_hist_v2[:,14],SPCAM5_hist_v2[:,18],SPCAM5_hist_v2[:,21],SPCAM5_hist_v2[:,25]]
+           
+    fig = plt.figure()
+    fig.set_size_inches(32, 18)
+    
+    for j in range(5):
+        ax = plt.subplot(2, 5, j+1)
+        ax.ticklabel_format(axis="y", style="sci", scilimits=(0,0))
+        bp1 = ax.boxplot([Data_SPCAM5_hist_v1[j]], positions=[1], patch_artist=True, notch=True, boxprops=dict(facecolor="red"), showfliers=with_fliers)
+        bp2 = ax.boxplot([Data_CAM5_4K_v1[j]], positions=[1.5], patch_artist=True, notch=True, boxprops=dict(facecolor="blue"), showfliers=with_fliers)
+        bp3 = ax.boxplot([Data_CAM5_8K_v1[j]], positions=[2], patch_artist=True, notch=True, boxprops=dict(facecolor="pink"), showfliers=with_fliers)
+        ax.ticklabel_format(axis="y", style="sci", scilimits=(0,0))
+        
+        ax.set_xticklabels([])
+        ax.set_xticks([])
+        ax.set_xlabel(name[j])
+        
+        
+        if j == 0:
+            ax.set_ylabel('Heat tendency (K/s)')
+        
+        if j == 2:
+            ax.legend([bp1["boxes"][0], bp2["boxes"][0], bp3["boxes"][0]], 
+                      ['SPCAM5 hist 3 m. (HF tr.)', 'CAM5 +4K 1 y.', 'CAM5 +8K 1 y.'], ncol=3, loc='upper center', bbox_to_anchor=[0.5, 1.25])#bbox_to_anchor=(2,1.2))#2.95, 1.5))
+    for j in range(5):
+        ax = plt.subplot(2, 5, 5+j+1)
+        ax.ticklabel_format(axis="y", style="sci", scilimits=(0,0))
+        bp1 = ax.boxplot([Data_SPCAM5_hist_v2[j]], positions=[1], patch_artist=True, notch=True, boxprops=dict(facecolor="red"), showfliers=with_fliers)
+        bp2 = ax.boxplot([Data_CAM5_4K_v2[j]], positions=[1.5], patch_artist=True, notch=True, boxprops=dict(facecolor="blue"), showfliers=with_fliers)
+        bp3 = ax.boxplot([Data_CAM5_8K_v2[j]], positions=[2], patch_artist=True, notch=True, boxprops=dict(facecolor="pink"), showfliers=with_fliers)
+        ax.ticklabel_format(axis="y", style="sci", scilimits=(0,0))
+        
+        ax.set_xticklabels([])
+        ax.set_xticks([])
+        ax.set_xlabel(name[j])
+        
+        
+        if j == 0:
+            ax.set_ylabel('Specific humidity (kg/kg)')
+
+    savefig('candle_plots_5_pr_lvls_heat_tend_and_spec_hum', True) 

2_norm.py

@@ -0,0 +1,94 @@
+#!/usr/bin/env python3
+# -*- coding: utf-8 -*-
+"""
+Created on Wed Apr 19 23:40:45 2023
+
+@author: mohamedazizbhouri
+"""
+
+import numpy as np
+
+is_input = 0 # 0 or 1
+case_var = 'moist' # 'moist' or 'heat' if is_input == 0
+sim = 'CAM' # 'CAM' or 'SPCAM'
+
+if sim == 'CAM':
+    if is_input == 1:
+        X = np.load('data_CAM5_8K/all_inputs.npy')
+        X = np.array(X,dtype=np.float64)
+        
+        mu_X_CAM5, sigma_X_CAM5 = [], []
+        # we do not use the vectorial format of computing mean and std on purpose
+        # in order to avoid the risk of precision error given the dataset size
+        for i in range(X.shape[1]):
+            mu_X_CAM5.append(np.mean(X[:,i]))
+            sigma_X_CAM5.append(np.std(X[:,i]))
+        mu_X_CAM5 = np.array(np.array(mu_X_CAM5),dtype=np.float32)
+        sigma_X_CAM5 = np.array(np.array(sigma_X_CAM5),dtype=np.float32)
+        np.save('norm/mu_X_CAM5.npy',mu_X_CAM5)
+        np.save('norm/sigma_X_CAM5.npy',sigma_X_CAM5)
+    else:
+        if case_var == 'moist':
+            X = np.load('data_CAM5_8K/all_outputs_moist.npy')
+            X = np.array(X,dtype=np.float64)
+            
+            mu_y_moist_CAM5, sigma_y_moist_CAM5 = [], []
+            for i in range(X.shape[1]):
+                mu_y_moist_CAM5.append(np.mean(X[:,i]))
+                sigma_y_moist_CAM5.append(np.std(X[:,i]))
+            mu_y_moist_CAM5 = np.array(np.array(mu_y_moist_CAM5),dtype=np.float32)
+            sigma_y_moist_CAM5 = np.array(np.array(sigma_y_moist_CAM5),dtype=np.float32)
+            np.save('norm/mu_y_moist_CAM5.npy',mu_y_moist_CAM5)
+            np.save('norm/sigma_y_moist_CAM5.npy',sigma_y_moist_CAM5)
+        else:
+            X = np.load('data_CAM5_8K/all_outputs_heat.npy')
+            X = np.array(X,dtype=np.float64)
+            
+            mu_y_heat_CAM5, sigma_y_heat_CAM5 = [], []
+            for i in range(X.shape[1]):
+                mu_y_heat_CAM5.append(np.mean(X[:,i]))
+                sigma_y_heat_CAM5.append(np.std(X[:,i]))
+            mu_y_heat_CAM5 = np.array(np.array(mu_y_heat_CAM5),dtype=np.float32)
+            sigma_y_heat_CAM5 = np.array(np.array(sigma_y_heat_CAM5),dtype=np.float32)
+            np.save('norm/mu_y_heat_CAM5.npy',mu_y_heat_CAM5)
+            np.save('norm/sigma_y_heat_CAM5.npy',sigma_y_heat_CAM5)
+elif sim == 'SPCAM':
+    if is_input == 1:
+        X = np.load('data_SPCAM5_hist/three_month_inputs.npy')
+        X = np.array(X,dtype=np.float64)
+        
+        mu_X_SPCAM5, sigma_X_SPCAM5 = [], []
+        # we do not use the vectorial format of computing mean and std on purpose
+        # in order to avoid the risk of precision error given the dataset size
+        for i in range(X.shape[1]):
+            mu_X_SPCAM5.append(np.mean(X[:,i]))
+            sigma_X_SPCAM5.append(np.std(X[:,i]))
+        mu_X_SPCAM5 = np.array(np.array(mu_X_SPCAM5),dtype=np.float32)
+        sigma_X_SPCAM5 = np.array(np.array(sigma_X_SPCAM5),dtype=np.float32)
+        np.save('norm/mu_X_SPCAM5.npy',mu_X_SPCAM5)
+        np.save('norm/sigma_X_SPCAM5.npy',sigma_X_SPCAM5)
+    else:
+        if case_var == 'moist':
+            X = np.load('data_SPCAM5_hist/three_month_outputs_moist.npy')
+            X = np.array(X,dtype=np.float64)
+            
+            mu_y_moist_SPCAM5, sigma_y_moist_SPCAM5 = [], []
+            for i in range(X.shape[1]):
+                mu_y_moist_SPCAM5.append(np.mean(X[:,i]))
+                sigma_y_moist_SPCAM5.append(np.std(X[:,i]))
+            mu_y_moist_SPCAM5 = np.array(np.array(mu_y_moist_SPCAM5),dtype=np.float32)
+            sigma_y_moist_SPCAM5 = np.array(np.array(sigma_y_moist_SPCAM5),dtype=np.float32)
+            np.save('norm/mu_y_moist_SPCAM5.npy',mu_y_moist_SPCAM5)
+            np.save('norm/sigma_y_moist_SPCAM5.npy',sigma_y_moist_SPCAM5)
+        else:
+            X = np.load('data_SPCAM5_hist/three_month_outputs_heat.npy')
+            X = np.array(X,dtype=np.float64)
+            
+            mu_y_heat_SPCAM5, sigma_y_heat_SPCAM5 = [], []
+            for i in range(X.shape[1]):
+                mu_y_heat_SPCAM5.append(np.mean(X[:,i]))
+                sigma_y_heat_SPCAM5.append(np.std(X[:,i]))
+            mu_y_heat_SPCAM5 = np.array(np.array(mu_y_heat_SPCAM5),dtype=np.float32)
+            sigma_y_heat_SPCAM5 = np.array(np.array(sigma_y_heat_SPCAM5),dtype=np.float32)
+            np.save('norm/mu_y_heat_SPCAM5.npy',mu_y_heat_SPCAM5)
+            np.save('norm/sigma_y_heat_SPCAM5.npy',sigma_y_heat_SPCAM5)

3_train_RPN_MF.py

@@ -0,0 +1,325 @@
+#!/usr/bin/env python3
+# -*- coding: utf-8 -*-
+"""
+Created on Mon May 1 17:19:00 2023
+
+@author: mohamedazizbhouri
+"""
+
+import os
+os.environ['XLA_PYTHON_CLIENT_PREALLOCATE']='false'
+
+from jax import numpy as np
+from jax import vmap, jit, random
+import numpy as onp
+
+import time
+
+##########################################################
+##########################################################
+##########################################################
+
+def leakyRELU(x):
+    return np.where(x > 0, x, x * 0.15)
+
+def MLP(layers, activation=leakyRELU): # np.tanh
+    def init(rng_key):
+        def init_layer(key, d_in, d_out):
+            k1, k2 = random.split(key)
+            glorot_stddev = 1. / np.sqrt((d_in + d_out) / 2.)
+            W = glorot_stddev*random.normal(k1, (d_in, d_out))
+            b = np.zeros(d_out)
+            return W, b
+        key, *keys = random.split(rng_key, len(layers))
+        params = list(map(init_layer, keys, layers[:-1], layers[1:]))
+        return params
+    def apply(params, inputs):
+        for W, b in params[:-1]:
+            outputs = np.dot(inputs, W) + b
+            inputs = activation(outputs)
+        W, b = params[-1]
+        outputs = np.dot(inputs, W) + b
+        return outputs
+    return init, apply
+
+##########################################################
+##########################################################
+##########################################################
+
+from jax import grad
+from jax.example_libraries import optimizers
+from functools import partial
+import itertools
+
+def exponential_decay_loc(step_size, decay_steps, decay_rate):
+  def schedule(i):
+    return step_size * decay_rate ** (i / decay_steps)
+  return schedule
+
+# Define the model
+class EnsembleRegression:
+    def __init__(self, layers_H, layers_L, ensemble_size, rng_key = random.PRNGKey(0)):  
+        # Network initialization and evaluation functions
+        self.init_H, self.apply_H = MLP(layers_H)
+        self.init_prior_H, self.apply_prior_H = MLP(layers_H)
+        
+        self.init_L, self.apply_L = MLP(layers_L)
+        self.init_prior_L, self.apply_prior_L = MLP(layers_L)
+                
+        # Random keys
+        k1, k2, k3 = random.split(rng_key, 3)
+        keys_1 = random.split(k1, ensemble_size)
+        keys_2 = random.split(k2, ensemble_size)
+        keys_3 = random.split(k3, ensemble_size)
+        
+        # Initialize
+        params = vmap(self.init_H)(keys_1)
+        params_prior = vmap(self.init_prior_H)(keys_2)
+        
+        rng_key, _ = random.split(rng_key, 2)
+        k1, k2, k3 = random.split(rng_key, 3)
+        keys_1 = random.split(k1, ensemble_size)
+        keys_2 = random.split(k2, ensemble_size)
+        keys_3 = random.split(k3, ensemble_size)
+        params = params + vmap(self.init_L)(keys_1)
+        params_prior = params_prior + vmap(self.init_prior_L)(keys_2)
+        
+        # Use optimizers to set optimizer initialization and update functions
+        lr = optimizers.exponential_decay(1e-4, decay_steps=1000, decay_rate=0.99)
+        self.opt_init, \
+        self.opt_update, \
+        self.get_params = optimizers.adam(lr)
+
+        self.opt_state = vmap(self.opt_init)(params)
+        self.prior_opt_state = vmap(self.opt_init)(params_prior)
+        self.key_opt_state = vmap(self.opt_init)(keys_3)
+
+        # Logger
+        self.itercount = itertools.count()
+        self.loss_log = []
+        self.loss_log_L = []
+        self.loss_log_H = []
+
+    # Define the forward pass
+    def net_forward_H(self, params, params_prior, inputs):
+        Y_pred = self.apply_H(params, inputs) + self.apply_prior_H(params_prior, inputs) 
+        return Y_pred
+    def net_forward_L(self, params, params_prior, inputs):
+        Y_pred = self.apply_L(params, inputs) + self.apply_prior_L(params_prior, inputs) 
+        return Y_pred
+
+    def loss(self, params, params_prior, batch, batch_L):
+        inputs, targets = batch
+        inputs_L, targets_L = batch_L
+        outputs = vmap(self.net_forward_H, (None, None, 0))(params[:len(layers_H)-1], params_prior[:len(layers_H)-1], inputs)
+        outputs_L = vmap(self.net_forward_L, (None, None, 0))(params[len(layers_H)-1:], params_prior[len(layers_H)-1:], inputs_L)
+        loss = np.mean((targets - outputs)**2) + alpha * np.mean((targets_L - outputs_L)**2)
+        return loss
+    def loss_H(self, params, params_prior, batch):
+        inputs, targets = batch
+        outputs = vmap(self.net_forward_H, (None, None, 0))(params, params_prior, inputs)
+        loss_H = np.mean((targets - outputs)**2)
+        return loss_H
+    def loss_L(self, params, params_prior, batch):
+        inputs, targets = batch
+        outputs = vmap(self.net_forward_L, (None, None, 0))(params, params_prior, inputs)
+        loss_L = np.mean((targets - outputs)**2)
+        return loss_L
+    
+    # Define the update step
+    def step(self, i, opt_state, prior_opt_state, key_opt_state, batch, batch_L):
+        params = self.get_params(opt_state)
+        params_prior = self.get_params(prior_opt_state)
+        g = grad(self.loss)(params, params_prior, batch, batch_L)
+        return self.opt_update(i, g, opt_state)
+    
+    def monitor_loss(self, opt_state, prior_opt_state, batch, batch_L):
+        params = self.get_params(opt_state)
+        params_prior = self.get_params(prior_opt_state)
+        loss_value = self.loss(params, params_prior, batch, batch_L)
+        return loss_value
+    def monitor_loss_H(self, opt_state, prior_opt_state, batch):
+        params = self.get_params(opt_state)[:len(layers_H)-1]
+        params_prior = self.get_params(prior_opt_state)[:len(layers_H)-1]
+        loss_value = self.loss_H(params, params_prior, batch)
+        return loss_value
+    def monitor_loss_L(self, opt_state, prior_opt_state, batch):
+        params = self.get_params(opt_state)[len(layers_H)-1:]
+        params_prior = self.get_params(prior_opt_state)[len(layers_H)-1:]
+        loss_value = self.loss_L(params, params_prior, batch)
+        return loss_value
+    
+    def predict_L(self, x):
+        params = self.get_params(self.opt_state)[len(layers_H)-1:]
+        params_prior = self.get_params(self.prior_opt_state)[len(layers_H)-1:]
+        samples = self.posterior(params, params_prior, x)
+        return samples
+
+    # Evaluates predictions at test points  
+    @partial(jit, static_argnums=(0,))
+    def posterior(self, params, params_prior, inputs):
+        samples = vmap(self.net_forward_L, (0, 0, 0))(params, params_prior, inputs)
+        return samples
+    
+    def train(self, nIter = 1000):
+        # Define vectorized SGD step across the entire ensemble
+        v_step = jit(vmap(self.step, in_axes = (None, 0, 0, 0, 0, 0)))
+        v_monitor_loss = jit(vmap(self.monitor_loss, in_axes = (0, 0, 0, 0)))
+        v_monitor_loss_H = jit(vmap(self.monitor_loss_H, in_axes = (0, 0, 0)))
+        v_monitor_loss_L = jit(vmap(self.monitor_loss_L, in_axes = (0, 0, 0)))
+
+        # Main training loop
+        tt = time.time()
+        for it in range(nIter):
+            id_SF = it%nb_SF
+            id_b_MF = it%nb_MF
+            pred_L = self.predict_L( (batches_in_SF[0][id_SF][None,:,:]-mu_MF_in)/sigma_MF_in )
+            batch = pred_L, (batches_out_SF[0][id_SF][None,:,:]-mu_SF_out)/sigma_SF_out
+            
+            batch_L = (batches_in_MF[0][id_b_MF][None,:,:]-mu_MF_in)/sigma_MF_in, (batches_out_MF[0][id_b_MF][None,:,:]-mu_MF_out)/sigma_MF_out
+            
+            self.opt_state = v_step(it, self.opt_state, self.prior_opt_state, self.key_opt_state, batch, batch_L)
+            
+            if it % nloss == 0:
+                loss_value = v_monitor_loss(self.opt_state, self.prior_opt_state, batch, batch_L)
+                loss_value_H = v_monitor_loss_H(self.opt_state, self.prior_opt_state, batch)
+                loss_value_L = v_monitor_loss_L(self.opt_state, self.prior_opt_state, batch_L)
+                self.loss_log.append(loss_value)
+                self.loss_log_H.append(loss_value_H)
+                self.loss_log_L.append(loss_value_L)
+                print(it, nIter, time.time() - tt, n_run_param)
+                tt = time.time()
+            if (it+1) % nsave == 0:
+                params = vmap(self.get_params)(self.opt_state)
+                params_H = params[:len(layers_H)-1]
+                params_L = params[len(layers_H)-1:]
+                for i in range(len(layers_H)-1):
+                    for j in range(2):
+                        np.save('MF_param/MF_param_'+str(n_run_param)+'/HF_params_'+str(i)+'_'+str(j),params_H[i][j])
+                for i in range(len(layers_L)-1):
+                    for j in range(2):
+                        np.save('MF_param/MF_param_'+str(n_run_param)+'/LF_params_'+str(i)+'_'+str(j),params_L[i][j])
+    
+##########################################################
+##########################################################
+##########################################################
+
+n_remove = 4
+ind_input = np.concatenate( (np.arange(26),n_remove+26+np.arange(26-n_remove),np.array([52,53,54,55])) ) 
+dim_xH = ind_input.shape[0]
+dim_xL = ind_input.shape[0]
+
+ind_output_heat = np.arange(26)
+ind_output_moist = n_remove+np.arange(26-n_remove)
+
+dim_yH = ind_output_heat.shape[0]+ind_output_moist.shape[0]
+dim_yL = ind_output_heat.shape[0]+ind_output_moist.shape[0]
+
+ensemble_size = 1
+
+layers_H = [dim_yL, 512, 512, 512, 512, 512, 512, 512, dim_yH]
+layers_L = [dim_xL, 512, 512, 512, 512, 512, 512, 512, dim_yL]
+
+n_run_param = 0
+batch_size_MF = 2048
+batch_size_SF = 2048
+nsave = 50000
+nloss = 500
+alpha = 1.0
+
+nepoch = 5
+
+mu_SF_out = onp.concatenate((onp.load('norm/mu_y_heat_CAM5.npy')[None,None,ind_output_heat],
+                             onp.load('norm/mu_y_moist_CAM5.npy')[None,None,ind_output_moist]),axis=2)
+sigma_SF_out = onp.concatenate((onp.load('norm/sigma_y_heat_CAM5.npy')[None,None,ind_output_heat],
+                                onp.load('norm/sigma_y_moist_CAM5.npy')[None,None,ind_output_moist]),axis=2)
+
+mu_MF_in = onp.load('norm/mu_X_CAM5.npy')[None,None,ind_input]
+sigma_MF_in = onp.load('norm/sigma_X_CAM5.npy')[None,None,ind_input]
+mu_MF_out = onp.concatenate((onp.load('norm/mu_y_heat_CAM5.npy')[None,None,ind_output_heat],
+                             onp.load('norm/mu_y_moist_CAM5.npy')[None,None,ind_output_moist]),axis=2)
+sigma_MF_out = onp.concatenate((onp.load('norm/sigma_y_heat_CAM5.npy')[None,None,ind_output_heat],
+                                onp.load('norm/sigma_y_moist_CAM5.npy')[None,None,ind_output_moist]),axis=2)
+print('loading data')
+
+train_MF_in = onp.load('data_CAM5_8K/all_inputs.npy')[:,ind_input]
+train_MF_out = onp.concatenate((onp.load('data_CAM5_8K/all_outputs_heat.npy')[:,ind_output_heat],
+                                onp.load('data_CAM5_8K/all_outputs_moist.npy')[:,ind_output_moist]),axis=1)
+train_SF_in = onp.load('data_SPCAM5_hist/three_month_inputs.npy')[:,ind_input]
+train_SF_out = onp.concatenate((onp.load('data_SPCAM5_hist/three_month_outputs_heat.npy')[:,ind_output_heat],
+                                onp.load('data_SPCAM5_hist/three_month_outputs_moist.npy')[:,ind_output_moist]),axis=1)    
+print('data loaded')
+
+N_tot_MF = 121098240
+N_tot_SF = 29528064
+
+N_rpn_MF = 96878592 
+N_rpn_SF = 23623680
+
+nb_MF = 47304
+nb_SF = 11535 
+
+batches_in_MF = []
+batches_out_MF = []
+batches_in_SF = []
+batches_out_SF = []
+
+for i in range(ensemble_size):
+    print(i,ensemble_size)
+    
+    idx_SF = onp.arange(N_rpn_SF)
+    idx_MF = onp.arange(N_tot_MF)
+    
+    onp.random.seed(n_run_param)
+    onp.random.shuffle(idx_SF)
+
+    onp.random.seed(n_run_param)
+    onp.random.shuffle(idx_MF)
+    
+    batches_in_MF_loc = []
+    batches_out_MF_loc = []
+    batches_in_SF_loc = []
+    batches_out_SF_loc = []
+    
+    for j in range(nb_MF):
+        if j % (nb_MF%5000) == 0:
+            print(i,'MF',j,nb_MF)
+        batches_in_MF_loc.append( train_MF_in[idx_MF[:N_rpn_MF][j*batch_size_MF:(j+1)*batch_size_MF],:] )
+        batches_out_MF_loc.append( train_MF_out[idx_MF[:N_rpn_MF][j*batch_size_MF:(j+1)*batch_size_MF],:] )
+    for j in range(nb_SF):
+        if j % (nb_SF%5000) == 0:
+            print(i,'SF',j,nb_SF)
+        batches_in_SF_loc.append( train_SF_in[idx_SF[:N_rpn_SF][j*batch_size_SF:(j+1)*batch_size_SF],:] )
+        batches_out_SF_loc.append( train_SF_out[idx_SF[:N_rpn_SF][j*batch_size_SF:(j+1)*batch_size_SF],:] )
+    batches_in_MF.append(batches_in_MF_loc)
+    batches_out_MF.append(batches_out_MF_loc)
+    batches_in_SF.append(batches_in_SF_loc)
+    batches_out_SF.append(batches_out_SF_loc)
+
+# Initialize model
+model = EnsembleRegression(layers_H, layers_L, ensemble_size, rng_key = random.PRNGKey(0))
+
+params_prior = vmap(model.get_params)(model.prior_opt_state)
+params_prior_H = params_prior[:len(layers_H)-1]
+params_prior_L = params_prior[len(layers_H)-1:]  
+print('saving parameters')
+for i in range(len(layers_H)-1):
+    for j in range(2):
+        np.save('MF_param/MF_param_'+str(n_run_param)+'/HF_params_prior_'+str(i)+'_'+str(j),params_prior_H[i][j])
+for i in range(len(layers_L)-1):
+    for j in range(2):
+        np.save('MF_param/MF_param_'+str(n_run_param)+'/LF_params_prior_'+str(i)+'_'+str(j),params_prior_L[i][j])   
+print('finished saving')
+
+# Train model
+model.train(nIter=nepoch*max(nb_MF,nb_SF))
+
+params = vmap(model.get_params)(model.opt_state)
+params_H = params[:len(layers_H)-1]
+params_L = params[len(layers_H)-1:]
+for i in range(len(layers_H)-1):
+    for j in range(2):
+        np.save('MF_param/MF_param_'+str(n_run_param)+'/HF_params_'+str(i)+'_'+str(j),params_H[i][j])
+for i in range(len(layers_L)-1):
+    for j in range(2):
+        np.save('MF_param/MF_param_'+str(n_run_param)+'/LF_params_'+str(i)+'_'+str(j),params_L[i][j])

3_train_RPN_SF.py

@@ -0,0 +1,238 @@
+#!/usr/bin/env python3
+# -*- coding: utf-8 -*-
+"""
+Created on Mon May 1 17:26:17 2023
+
+@author: mohamedazizbhouri
+"""
+
+import os
+os.environ['XLA_PYTHON_CLIENT_PREALLOCATE']='false'
+
+from jax import numpy as np
+from jax import vmap, jit, random
+import numpy as onp
+
+import time
+
+##########################################################
+##########################################################
+##########################################################
+
+def leakyRELU(x):
+    return np.where(x > 0, x, x * 0.15)
+
+def MLP(layers, activation=leakyRELU): # np.tanh
+    def init(rng_key):
+        def init_layer(key, d_in, d_out):
+            k1, k2 = random.split(key)
+            glorot_stddev = 1. / np.sqrt((d_in + d_out) / 2.)
+            W = glorot_stddev*random.normal(k1, (d_in, d_out))
+            b = np.zeros(d_out)
+            return W, b
+        key, *keys = random.split(rng_key, len(layers))
+        params = list(map(init_layer, keys, layers[:-1], layers[1:]))
+        return params
+    def apply(params, inputs):
+        for W, b in params[:-1]:
+            outputs = np.dot(inputs, W) + b
+            inputs = activation(outputs)
+        W, b = params[-1]
+        outputs = np.dot(inputs, W) + b
+        return outputs
+    return init, apply
+
+##########################################################
+##########################################################
+##########################################################
+    
+from jax import grad
+from jax.example_libraries import optimizers
+import itertools
+
+def exponential_decay_loc(step_size, decay_steps, decay_rate):
+  def schedule(i):
+    return step_size * decay_rate ** (i / decay_steps)
+  return schedule
+
+# Define the model
+class EnsembleRegression:
+    def __init__(self, layers, ensemble_size, rng_key = random.PRNGKey(0)):  
+        # Network initialization and evaluation functions
+        self.init, self.apply = MLP(layers)
+        self.init_prior, self.apply_prior = MLP(layers)
+        
+        # Random keys
+        k1, k2, k3 = random.split(rng_key, 3)
+        keys_1 = random.split(k1, ensemble_size)
+        keys_2 = random.split(k2, ensemble_size)
+        keys_3 = random.split(k3, ensemble_size)
+        
+        # Initialize
+        params = vmap(self.init)(keys_1)
+        params_prior = vmap(self.init_prior)(keys_2)
+                
+        # Use optimizers to set optimizer initialization and update functions
+        lr = optimizers.exponential_decay(1e-4, decay_steps=1000, decay_rate=0.99)
+        self.opt_init, \
+        self.opt_update, \
+        self.get_params = optimizers.adam(lr)
+
+        self.opt_state = vmap(self.opt_init)(params)
+        self.prior_opt_state = vmap(self.opt_init)(params_prior)
+        self.key_opt_state = vmap(self.opt_init)(keys_3)
+
+        # Logger
+        self.itercount = itertools.count()
+        self.loss_log = []
+
+    # Define the forward pass
+    def net_forward(self, params, params_prior, inputs):
+        Y_pred = self.apply(params, inputs) + self.apply_prior(params_prior, inputs) 
+        return Y_pred
+
+    def loss(self, params, params_prior, batch):
+        inputs, targets = batch
+        # Compute forward pass
+        outputs = vmap(self.net_forward, (None, None, 0))(params, params_prior, inputs)
+        # Compute loss
+        loss = np.mean((targets - outputs)**2)
+        return loss
+
+    # Define the update step
+    def step(self, i, opt_state, prior_opt_state, key_opt_state, batch):
+        params = self.get_params(opt_state)
+        params_prior = self.get_params(prior_opt_state)
+        g = grad(self.loss)(params, params_prior, batch)
+        return self.opt_update(i, g, opt_state)
+    
+    def monitor_loss(self, opt_state, prior_opt_state, batch):
+        params = self.get_params(opt_state)
+        params_prior = self.get_params(prior_opt_state)
+        loss_value = self.loss(params, params_prior, batch)
+        return loss_value
+
+    # Optimize parameters in a loop
+    def train(self, nIter = 1000):
+        # Define vectorized SGD step across the entire ensemble
+        v_step = jit(vmap(self.step, in_axes = (None, 0, 0, 0, 0)))
+        v_monitor_loss = jit(vmap(self.monitor_loss, in_axes = (0, 0, 0)))
+
+        # Main training loop
+        tt = time.time()
+        for it in range(nIter):
+            id_SF = (it+n_iter_prev)%nb_SF
+            
+            inputs0_H = batches_in_SF[0][id_SF][None,:,:]
+            targets0_H = batches_out_SF[0][id_SF][None,:,:]
+            for ii in range(ensemble_size-1):
+                inputs0_H = onp.concatenate( (inputs0_H,batches_in_SF[ii+1][id_SF][None,:,:]), axis=0)
+                targets0_H = onp.concatenate( (targets0_H,batches_out_SF[ii+1][id_SF][None,:,:]), axis=0)
+                        
+            batch = (inputs0_H-mu_SF_in)/sigma_SF_in, (targets0_H-mu_SF_out)/sigma_SF_out
+            
+            self.opt_state = v_step(it, self.opt_state, self.prior_opt_state, self.key_opt_state, batch)
+            
+            if it % nloss == 0:
+                loss_value = v_monitor_loss(self.opt_state, self.prior_opt_state, batch)
+                self.loss_log.append(loss_value)
+                
+                print(it, nIter, time.time() - tt, n_run_param)
+                tt = time.time()
+            if (it+1) % nsave == 0:
+                params = vmap(self.get_params)(self.opt_state)
+                for i in range(len(layers_H)-1):
+                    for j in range(2):
+                        np.save('SF_param/SF_param_'+str(n_run_param)+'/params_'+str(i)+'_'+str(j),params[i][j])
+                
+##########################################################
+##########################################################
+##########################################################
+
+n_remove = 4
+ind_input = np.concatenate( (np.arange(26),n_remove+26+np.arange(26-n_remove),np.array([52,53,54,55])) ) 
+dim_xH = ind_input.shape[0]
+dim_xL = ind_input.shape[0]
+
+ind_output_heat = np.arange(26)
+ind_output_moist = n_remove+np.arange(26-n_remove)
+
+dim_yH = ind_output_heat.shape[0]+ind_output_moist.shape[0]
+dim_yL = ind_output_heat.shape[0]+ind_output_moist.shape[0]
+
+ensemble_size = 1
+layers_H = [dim_xH, 512, 512, 512, 512, 512, 512, 512, dim_yH]
+
+n_iter_prev = 0
+
+n_run_param = 0
+batch_size_SF = 2048
+nsave = 50000
+nloss = 500
+
+nepoch = 5 
+
+mu_SF_in = onp.load('norm/mu_X_SPCAM5.npy')[None,None,ind_input]
+sigma_SF_in = onp.load('norm/sigma_X_SPCAM5.npy')[None,None,ind_input]
+
+mu_SF_out = onp.concatenate((onp.load('norm/mu_y_heat_SPCAM5.npy')[None,None,ind_output_heat],
+                             onp.load('norm/mu_y_moist_SPCAM5.npy')[None,None,ind_output_moist]),axis=2)
+sigma_SF_out = onp.concatenate((onp.load('norm/sigma_y_heat_SPCAM5.npy')[None,None,ind_output_heat],
+                                onp.load('norm/sigma_y_moist_SPCAM5.npy')[None,None,ind_output_moist]),axis=2)
+print('loading data')
+
+train_SF_in = onp.load('data_SPCAM5_hist/three_month_inputs.npy')[:,ind_input]
+train_SF_out = onp.concatenate((onp.load('data_SPCAM5_hist/three_month_outputs_heat.npy')[:,ind_output_heat],
+                                onp.load('data_SPCAM5_hist/three_month_outputs_moist.npy')[:,ind_output_moist]),axis=1)
+print('data loaded')
+
+N_tot_MF = 121098240
+N_tot_SF = 29528064
+
+N_rpn_MF = 96878592
+N_rpn_SF = 23623680
+
+nb_MF = 47304
+nb_SF = 11535
+
+batches_in_SF = []
+batches_out_SF = []
+for i in range(ensemble_size):
+    print(i,ensemble_size)
+    
+    idx_SF = onp.arange(N_rpn_SF)
+    
+    onp.random.seed(n_run_param)
+    onp.random.shuffle(idx_SF)
+    
+    batches_in_SF_loc = []
+    batches_out_SF_loc = []
+    
+    for j in range(nb_SF):
+        if j % (nb_SF%5000) == 0:
+            print(i,'SF',j,nb_SF)
+        batches_in_SF_loc.append( train_SF_in[idx_SF[:N_rpn_SF][j*batch_size_SF:(j+1)*batch_size_SF],:] )
+        batches_out_SF_loc.append( train_SF_out[idx_SF[:N_rpn_SF][j*batch_size_SF:(j+1)*batch_size_SF],:] )
+    batches_in_SF.append(batches_in_SF_loc)
+    batches_out_SF.append(batches_out_SF_loc)
+
+model = EnsembleRegression(layers_H, ensemble_size, rng_key = random.PRNGKey(0))#n_run_param))
+
+params_prior = vmap(model.get_params)(model.prior_opt_state)
+params_prior_H = params_prior[:len(layers_H)-1]
+params_prior_L = params_prior[len(layers_H)-1:]  
+print('saving parameters')
+for i in range(len(layers_H)-1):
+    for j in range(2):
+        np.save('SF_param/SF_param_'+str(n_run_param)+'/params_prior_'+str(i)+'_'+str(j),params_prior_H[i][j])
+print('finished saving')
+
+# Train model
+model.train(nIter=nepoch*max(nb_MF,nb_SF)-n_iter_prev)
+
+params = vmap(model.get_params)(model.opt_state)
+params_H = params[:len(layers_H)-1]
+for i in range(len(layers_H)-1):
+    for j in range(2):
+        np.save('SF_param/SF_param_'+str(n_run_param)+'/params_'+str(i)+'_'+str(j),params_H[i][j])
+        

4_concat_param.py

@@ -0,0 +1,429 @@
+#!/usr/bin/env python3
+# -*- coding: utf-8 -*-
+"""
+Created on Tue Sep 5 13:42:56 2023
+
+@author: mohamedazizbhouri
+"""
+
+import numpy as np
+
+N_param_gp = 128
+
+is_MF = 0
+is_LF = 0
+is_SF = 1
+
+if is_MF == 1:
+    HF_params_0_0 = np.load('MF_param/MF_param_0/HF_params_0_0.npy')
+    HF_params_0_1 = np.load('MF_param/MF_param_0/HF_params_0_1.npy')
+    HF_params_1_0 = np.load('MF_param/MF_param_0/HF_params_1_0.npy')
+    HF_params_1_1 = np.load('MF_param/MF_param_0/HF_params_1_1.npy')
+    HF_params_2_0 = np.load('MF_param/MF_param_0/HF_params_2_0.npy')
+    HF_params_2_1 = np.load('MF_param/MF_param_0/HF_params_2_1.npy')
+    HF_params_3_0 = np.load('MF_param/MF_param_0/HF_params_3_0.npy')
+    HF_params_3_1 = np.load('MF_param/MF_param_0/HF_params_3_1.npy')
+    HF_params_4_0 = np.load('MF_param/MF_param_0/HF_params_4_0.npy')
+    HF_params_4_1 = np.load('MF_param/MF_param_0/HF_params_4_1.npy')
+    HF_params_5_0 = np.load('MF_param/MF_param_0/HF_params_5_0.npy')
+    HF_params_5_1 = np.load('MF_param/MF_param_0/HF_params_5_1.npy')
+    HF_params_6_0 = np.load('MF_param/MF_param_0/HF_params_6_0.npy')
+    HF_params_6_1 = np.load('MF_param/MF_param_0/HF_params_6_1.npy')
+    HF_params_7_0 = np.load('MF_param/MF_param_0/HF_params_7_0.npy')
+    HF_params_7_1 = np.load('MF_param/MF_param_0/HF_params_7_1.npy')
+    
+    HF_params_prior_0_0 = np.load('MF_param/MF_param_0/HF_params_prior_0_0.npy')
+    HF_params_prior_0_1 = np.load('MF_param/MF_param_0/HF_params_prior_0_1.npy')
+    HF_params_prior_1_0 = np.load('MF_param/MF_param_0/HF_params_prior_1_0.npy')
+    HF_params_prior_1_1 = np.load('MF_param/MF_param_0/HF_params_prior_1_1.npy')
+    HF_params_prior_2_0 = np.load('MF_param/MF_param_0/HF_params_prior_2_0.npy')
+    HF_params_prior_2_1 = np.load('MF_param/MF_param_0/HF_params_prior_2_1.npy')
+    HF_params_prior_3_0 = np.load('MF_param/MF_param_0/HF_params_prior_3_0.npy')
+    HF_params_prior_3_1 = np.load('MF_param/MF_param_0/HF_params_prior_3_1.npy')
+    HF_params_prior_4_0 = np.load('MF_param/MF_param_0/HF_params_prior_4_0.npy')
+    HF_params_prior_4_1 = np.load('MF_param/MF_param_0/HF_params_prior_4_1.npy')
+    HF_params_prior_5_0 = np.load('MF_param/MF_param_0/HF_params_prior_5_0.npy')
+    HF_params_prior_5_1 = np.load('MF_param/MF_param_0/HF_params_prior_5_1.npy')
+    HF_params_prior_6_0 = np.load('MF_param/MF_param_0/HF_params_prior_6_0.npy')
+    HF_params_prior_6_1 = np.load('MF_param/MF_param_0/HF_params_prior_6_1.npy')
+    HF_params_prior_7_0 = np.load('MF_param/MF_param_0/HF_params_prior_7_0.npy')
+    HF_params_prior_7_1 = np.load('MF_param/MF_param_0/HF_params_prior_7_1.npy')
+    
+    for i in range(N_param_gp-1):
+        
+        print(i)
+        HF_params_0_0 = np.concatenate( (HF_params_0_0,
+                                         np.load('MF_param/MF_param_'+str(i+1)+'/HF_params_0_0.npy')), axis = 0)
+        HF_params_0_1 = np.concatenate( (HF_params_0_1,
+                                         np.load('MF_param/MF_param_'+str(i+1)+'/HF_params_0_1.npy')), axis = 0)
+        HF_params_1_0 = np.concatenate( (HF_params_1_0,
+                                         np.load('MF_param/MF_param_'+str(i+1)+'/HF_params_1_0.npy')), axis = 0)
+        HF_params_1_1 = np.concatenate( (HF_params_1_1,
+                                         np.load('MF_param/MF_param_'+str(i+1)+'/HF_params_1_1.npy')), axis = 0)
+        HF_params_2_0 = np.concatenate( (HF_params_2_0,
+                                         np.load('MF_param/MF_param_'+str(i+1)+'/HF_params_2_0.npy')), axis = 0)
+        HF_params_2_1 = np.concatenate( (HF_params_2_1,
+                                         np.load('MF_param/MF_param_'+str(i+1)+'/HF_params_2_1.npy')), axis = 0)
+        HF_params_3_0 = np.concatenate( (HF_params_3_0,
+                                         np.load('MF_param/MF_param_'+str(i+1)+'/HF_params_3_0.npy')), axis = 0)
+        HF_params_3_1 = np.concatenate( (HF_params_3_1,
+                                         np.load('MF_param/MF_param_'+str(i+1)+'/HF_params_3_1.npy')), axis = 0)
+        HF_params_4_0 = np.concatenate( (HF_params_4_0,
+                                         np.load('MF_param/MF_param_'+str(i+1)+'/HF_params_4_0.npy')), axis = 0)
+        HF_params_4_1 = np.concatenate( (HF_params_4_1,
+                                         np.load('MF_param/MF_param_'+str(i+1)+'/HF_params_4_1.npy')), axis = 0)
+        HF_params_5_0 = np.concatenate( (HF_params_5_0,
+                                         np.load('MF_param/MF_param_'+str(i+1)+'/HF_params_5_0.npy')), axis = 0)
+        HF_params_5_1 = np.concatenate( (HF_params_5_1,
+                                         np.load('MF_param/MF_param_'+str(i+1)+'/HF_params_5_1.npy')), axis = 0)    
+        HF_params_6_0 = np.concatenate( (HF_params_6_0,
+                                         np.load('MF_param/MF_param_'+str(i+1)+'/HF_params_6_0.npy')), axis = 0)
+        HF_params_6_1 = np.concatenate( (HF_params_6_1,
+                                         np.load('MF_param/MF_param_'+str(i+1)+'/HF_params_6_1.npy')), axis = 0)    
+        HF_params_7_0 = np.concatenate( (HF_params_7_0,
+                                         np.load('MF_param/MF_param_'+str(i+1)+'/HF_params_7_0.npy')), axis = 0)
+        HF_params_7_1 = np.concatenate( (HF_params_7_1,
+                                         np.load('MF_param/MF_param_'+str(i+1)+'/HF_params_7_1.npy')), axis = 0)
+    
+        HF_params_prior_0_0 = np.concatenate( (HF_params_prior_0_0,
+                                         np.load('MF_param/MF_param_'+str(i+1)+'/HF_params_prior_0_0.npy')), axis = 0)
+        HF_params_prior_0_1 = np.concatenate( (HF_params_prior_0_1,
+                                         np.load('MF_param/MF_param_'+str(i+1)+'/HF_params_prior_0_1.npy')), axis = 0)
+        HF_params_prior_1_0 = np.concatenate( (HF_params_prior_1_0,
+                                         np.load('MF_param/MF_param_'+str(i+1)+'/HF_params_prior_1_0.npy')), axis = 0)
+        HF_params_prior_1_1 = np.concatenate( (HF_params_prior_1_1,
+                                         np.load('MF_param/MF_param_'+str(i+1)+'/HF_params_prior_1_1.npy')), axis = 0)        
+        HF_params_prior_2_0 = np.concatenate( (HF_params_prior_2_0,
+                                         np.load('MF_param/MF_param_'+str(i+1)+'/HF_params_prior_2_0.npy')), axis = 0)
+        HF_params_prior_2_1 = np.concatenate( (HF_params_prior_2_1,
+                                         np.load('MF_param/MF_param_'+str(i+1)+'/HF_params_prior_2_1.npy')), axis = 0)        
+        HF_params_prior_3_0 = np.concatenate( (HF_params_prior_3_0,
+                                         np.load('MF_param/MF_param_'+str(i+1)+'/HF_params_prior_3_0.npy')), axis = 0)
+        HF_params_prior_3_1 = np.concatenate( (HF_params_prior_3_1,
+                                         np.load('MF_param/MF_param_'+str(i+1)+'/HF_params_prior_3_1.npy')), axis = 0)        
+        HF_params_prior_4_0 = np.concatenate( (HF_params_prior_4_0,
+                                         np.load('MF_param/MF_param_'+str(i+1)+'/HF_params_prior_4_0.npy')), axis = 0)
+        HF_params_prior_4_1 = np.concatenate( (HF_params_prior_4_1,
+                                         np.load('MF_param/MF_param_'+str(i+1)+'/HF_params_prior_4_1.npy')), axis = 0)        
+        HF_params_prior_5_0 = np.concatenate( (HF_params_prior_5_0,
+                                         np.load('MF_param/MF_param_'+str(i+1)+'/HF_params_prior_5_0.npy')), axis = 0)
+        HF_params_prior_5_1 = np.concatenate( (HF_params_prior_5_1,
+                                         np.load('MF_param/MF_param_'+str(i+1)+'/HF_params_prior_5_1.npy')), axis = 0)        
+        HF_params_prior_6_0 = np.concatenate( (HF_params_prior_6_0,
+                                         np.load('MF_param/MF_param_'+str(i+1)+'/HF_params_prior_6_0.npy')), axis = 0)
+        HF_params_prior_6_1 = np.concatenate( (HF_params_prior_6_1,
+                                         np.load('MF_param/MF_param_'+str(i+1)+'/HF_params_prior_6_1.npy')), axis = 0)        
+        HF_params_prior_7_0 = np.concatenate( (HF_params_prior_7_0,
+                                         np.load('MF_param/MF_param_'+str(i+1)+'/HF_params_prior_7_0.npy')), axis = 0)
+        HF_params_prior_7_1 = np.concatenate( (HF_params_prior_7_1,
+                                         np.load('MF_param/MF_param_'+str(i+1)+'/HF_params_prior_7_1.npy')), axis = 0)
+    
+    np.save('MF_param/saved_param/HF_params_0_0.npy', HF_params_0_0)
+    np.save('MF_param/saved_param/HF_params_0_1.npy', HF_params_0_1)
+    np.save('MF_param/saved_param/HF_params_1_0.npy', HF_params_1_0)
+    np.save('MF_param/saved_param/HF_params_1_1.npy', HF_params_1_1)
+    np.save('MF_param/saved_param/HF_params_2_0.npy', HF_params_2_0)
+    np.save('MF_param/saved_param/HF_params_2_1.npy', HF_params_2_1)
+    np.save('MF_param/saved_param/HF_params_3_0.npy', HF_params_3_0)
+    np.save('MF_param/saved_param/HF_params_3_1.npy', HF_params_3_1)
+    np.save('MF_param/saved_param/HF_params_4_0.npy', HF_params_4_0)
+    np.save('MF_param/saved_param/HF_params_4_1.npy', HF_params_4_1)
+    np.save('MF_param/saved_param/HF_params_5_0.npy', HF_params_5_0)
+    np.save('MF_param/saved_param/HF_params_5_1.npy', HF_params_5_1)
+    np.save('MF_param/saved_param/HF_params_6_0.npy', HF_params_6_0)
+    np.save('MF_param/saved_param/HF_params_6_1.npy', HF_params_6_1)
+    np.save('MF_param/saved_param/HF_params_7_0.npy', HF_params_7_0)
+    np.save('MF_param/saved_param/HF_params_7_1.npy', HF_params_7_1)
+    
+    np.save('MF_param/saved_param/HF_params_prior_0_0.npy', HF_params_prior_0_0)
+    np.save('MF_param/saved_param/HF_params_prior_0_1.npy', HF_params_prior_0_1)
+    np.save('MF_param/saved_param/HF_params_prior_1_0.npy', HF_params_prior_1_0)
+    np.save('MF_param/saved_param/HF_params_prior_1_1.npy', HF_params_prior_1_1)
+    np.save('MF_param/saved_param/HF_params_prior_2_0.npy', HF_params_prior_2_0)
+    np.save('MF_param/saved_param/HF_params_prior_2_1.npy', HF_params_prior_2_1)
+    np.save('MF_param/saved_param/HF_params_prior_3_0.npy', HF_params_prior_3_0)
+    np.save('MF_param/saved_param/HF_params_prior_3_1.npy', HF_params_prior_3_1)
+    np.save('MF_param/saved_param/HF_params_prior_4_0.npy', HF_params_prior_4_0)
+    np.save('MF_param/saved_param/HF_params_prior_4_1.npy', HF_params_prior_4_1)
+    np.save('MF_param/saved_param/HF_params_prior_5_0.npy', HF_params_prior_5_0)
+    np.save('MF_param/saved_param/HF_params_prior_5_1.npy', HF_params_prior_5_1)
+    np.save('MF_param/saved_param/HF_params_prior_6_0.npy', HF_params_prior_6_0)
+    np.save('MF_param/saved_param/HF_params_prior_6_1.npy', HF_params_prior_6_1)
+    np.save('MF_param/saved_param/HF_params_prior_7_0.npy', HF_params_prior_7_0)
+    np.save('MF_param/saved_param/HF_params_prior_7_1.npy', HF_params_prior_7_1)
+
+if is_LF == 1:
+    LF_params_0_0 = np.load('MF_param/MF_param_0/LF_params_0_0.npy')
+    LF_params_0_1 = np.load('MF_param/MF_param_0/LF_params_0_1.npy')
+    LF_params_1_0 = np.load('MF_param/MF_param_0/LF_params_1_0.npy')
+    LF_params_1_1 = np.load('MF_param/MF_param_0/LF_params_1_1.npy')
+    LF_params_2_0 = np.load('MF_param/MF_param_0/LF_params_2_0.npy')
+    LF_params_2_1 = np.load('MF_param/MF_param_0/LF_params_2_1.npy')
+    LF_params_3_0 = np.load('MF_param/MF_param_0/LF_params_3_0.npy')
+    LF_params_3_1 = np.load('MF_param/MF_param_0/LF_params_3_1.npy')
+    LF_params_4_0 = np.load('MF_param/MF_param_0/LF_params_4_0.npy')
+    LF_params_4_1 = np.load('MF_param/MF_param_0/LF_params_4_1.npy')
+    LF_params_5_0 = np.load('MF_param/MF_param_0/LF_params_5_0.npy')
+    LF_params_5_1 = np.load('MF_param/MF_param_0/LF_params_5_1.npy')
+    LF_params_6_0 = np.load('MF_param/MF_param_0/LF_params_6_0.npy')
+    LF_params_6_1 = np.load('MF_param/MF_param_0/LF_params_6_1.npy')
+    LF_params_7_0 = np.load('MF_param/MF_param_0/LF_params_7_0.npy')
+    LF_params_7_1 = np.load('MF_param/MF_param_0/LF_params_7_1.npy')
+    
+    LF_params_prior_0_0 = np.load('MF_param/MF_param_0/LF_params_prior_0_0.npy')
+    LF_params_prior_0_1 = np.load('MF_param/MF_param_0/LF_params_prior_0_1.npy')
+    LF_params_prior_1_0 = np.load('MF_param/MF_param_0/LF_params_prior_1_0.npy')
+    LF_params_prior_1_1 = np.load('MF_param/MF_param_0/LF_params_prior_1_1.npy')
+    LF_params_prior_2_0 = np.load('MF_param/MF_param_0/LF_params_prior_2_0.npy')
+    LF_params_prior_2_1 = np.load('MF_param/MF_param_0/LF_params_prior_2_1.npy')
+    LF_params_prior_3_0 = np.load('MF_param/MF_param_0/LF_params_prior_3_0.npy')
+    LF_params_prior_3_1 = np.load('MF_param/MF_param_0/LF_params_prior_3_1.npy')
+    LF_params_prior_4_0 = np.load('MF_param/MF_param_0/LF_params_prior_4_0.npy')
+    LF_params_prior_4_1 = np.load('MF_param/MF_param_0/LF_params_prior_4_1.npy')
+    LF_params_prior_5_0 = np.load('MF_param/MF_param_0/LF_params_prior_5_0.npy')
+    LF_params_prior_5_1 = np.load('MF_param/MF_param_0/LF_params_prior_5_1.npy')
+    LF_params_prior_6_0 = np.load('MF_param/MF_param_0/LF_params_prior_6_0.npy')
+    LF_params_prior_6_1 = np.load('MF_param/MF_param_0/LF_params_prior_6_1.npy')
+    LF_params_prior_7_0 = np.load('MF_param/MF_param_0/LF_params_prior_7_0.npy')
+    LF_params_prior_7_1 = np.load('MF_param/MF_param_0/LF_params_prior_7_1.npy')
+    
+    for i in range(N_param_gp-1):
+        
+        print(i)
+        LF_params_0_0 = np.concatenate( (LF_params_0_0,
+                                         np.load('MF_param/MF_param_'+str(i+1)+'/LF_params_0_0.npy')), axis = 0)
+        LF_params_0_1 = np.concatenate( (LF_params_0_1,
+                                         np.load('MF_param/MF_param_'+str(i+1)+'/LF_params_0_1.npy')), axis = 0)
+        LF_params_1_0 = np.concatenate( (LF_params_1_0,
+                                         np.load('MF_param/MF_param_'+str(i+1)+'/LF_params_1_0.npy')), axis = 0)
+        LF_params_1_1 = np.concatenate( (LF_params_1_1,
+                                         np.load('MF_param/MF_param_'+str(i+1)+'/LF_params_1_1.npy')), axis = 0)
+        LF_params_2_0 = np.concatenate( (LF_params_2_0,
+                                         np.load('MF_param/MF_param_'+str(i+1)+'/LF_params_2_0.npy')), axis = 0)
+        LF_params_2_1 = np.concatenate( (LF_params_2_1,
+                                         np.load('MF_param/MF_param_'+str(i+1)+'/LF_params_2_1.npy')), axis = 0)
+        LF_params_3_0 = np.concatenate( (LF_params_3_0,
+                                         np.load('MF_param/MF_param_'+str(i+1)+'/LF_params_3_0.npy')), axis = 0)
+        LF_params_3_1 = np.concatenate( (LF_params_3_1,
+                                         np.load('MF_param/MF_param_'+str(i+1)+'/LF_params_3_1.npy')), axis = 0)
+        LF_params_4_0 = np.concatenate( (LF_params_4_0,
+                                         np.load('MF_param/MF_param_'+str(i+1)+'/LF_params_4_0.npy')), axis = 0)
+        LF_params_4_1 = np.concatenate( (LF_params_4_1,
+                                         np.load('MF_param/MF_param_'+str(i+1)+'/LF_params_4_1.npy')), axis = 0)
+        LF_params_5_0 = np.concatenate( (LF_params_5_0,
+                                         np.load('MF_param/MF_param_'+str(i+1)+'/LF_params_5_0.npy')), axis = 0)
+        LF_params_5_1 = np.concatenate( (LF_params_5_1,
+                                         np.load('MF_param/MF_param_'+str(i+1)+'/LF_params_5_1.npy')), axis = 0)    
+        LF_params_6_0 = np.concatenate( (LF_params_6_0,
+                                         np.load('MF_param/MF_param_'+str(i+1)+'/LF_params_6_0.npy')), axis = 0)
+        LF_params_6_1 = np.concatenate( (LF_params_6_1,
+                                         np.load('MF_param/MF_param_'+str(i+1)+'/LF_params_6_1.npy')), axis = 0)    
+        LF_params_7_0 = np.concatenate( (LF_params_7_0,
+                                         np.load('MF_param/MF_param_'+str(i+1)+'/LF_params_7_0.npy')), axis = 0)
+        LF_params_7_1 = np.concatenate( (LF_params_7_1,
+                                         np.load('MF_param/MF_param_'+str(i+1)+'/LF_params_7_1.npy')), axis = 0)
+    
+        LF_params_prior_0_0 = np.concatenate( (LF_params_prior_0_0,
+                                         np.load('MF_param/MF_param_'+str(i+1)+'/LF_params_prior_0_0.npy')), axis = 0)
+        LF_params_prior_0_1 = np.concatenate( (LF_params_prior_0_1,
+                                         np.load('MF_param/MF_param_'+str(i+1)+'/LF_params_prior_0_1.npy')), axis = 0)
+        LF_params_prior_1_0 = np.concatenate( (LF_params_prior_1_0,
+                                         np.load('MF_param/MF_param_'+str(i+1)+'/LF_params_prior_1_0.npy')), axis = 0)
+        LF_params_prior_1_1 = np.concatenate( (LF_params_prior_1_1,
+                                         np.load('MF_param/MF_param_'+str(i+1)+'/LF_params_prior_1_1.npy')), axis = 0)        
+        LF_params_prior_2_0 = np.concatenate( (LF_params_prior_2_0,
+                                         np.load('MF_param/MF_param_'+str(i+1)+'/LF_params_prior_2_0.npy')), axis = 0)
+        LF_params_prior_2_1 = np.concatenate( (LF_params_prior_2_1,
+                                         np.load('MF_param/MF_param_'+str(i+1)+'/LF_params_prior_2_1.npy')), axis = 0)        
+        LF_params_prior_3_0 = np.concatenate( (LF_params_prior_3_0,
+                                         np.load('MF_param/MF_param_'+str(i+1)+'/LF_params_prior_3_0.npy')), axis = 0)
+        LF_params_prior_3_1 = np.concatenate( (LF_params_prior_3_1,
+                                         np.load('MF_param/MF_param_'+str(i+1)+'/LF_params_prior_3_1.npy')), axis = 0)        
+        LF_params_prior_4_0 = np.concatenate( (LF_params_prior_4_0,
+                                         np.load('MF_param/MF_param_'+str(i+1)+'/LF_params_prior_4_0.npy')), axis = 0)
+        LF_params_prior_4_1 = np.concatenate( (LF_params_prior_4_1,
+                                         np.load('MF_param/MF_param_'+str(i+1)+'/LF_params_prior_4_1.npy')), axis = 0)        
+        LF_params_prior_5_0 = np.concatenate( (LF_params_prior_5_0,
+                                         np.load('MF_param/MF_param_'+str(i+1)+'/LF_params_prior_5_0.npy')), axis = 0)
+        LF_params_prior_5_1 = np.concatenate( (LF_params_prior_5_1,
+                                         np.load('MF_param/MF_param_'+str(i+1)+'/LF_params_prior_5_1.npy')), axis = 0)        
+        LF_params_prior_6_0 = np.concatenate( (LF_params_prior_6_0,
+                                         np.load('MF_param/MF_param_'+str(i+1)+'/LF_params_prior_6_0.npy')), axis = 0)
+        LF_params_prior_6_1 = np.concatenate( (LF_params_prior_6_1,
+                                         np.load('MF_param/MF_param_'+str(i+1)+'/LF_params_prior_6_1.npy')), axis = 0)        
+        LF_params_prior_7_0 = np.concatenate( (LF_params_prior_7_0,
+                                         np.load('MF_param/MF_param_'+str(i+1)+'/LF_params_prior_7_0.npy')), axis = 0)
+        LF_params_prior_7_1 = np.concatenate( (LF_params_prior_7_1,
+                                         np.load('MF_param/MF_param_'+str(i+1)+'/LF_params_prior_7_1.npy')), axis = 0)
+    
+    np.save('MF_param/saved_param/LF_params_0_0.npy', LF_params_0_0)
+    np.save('MF_param/saved_param/LF_params_0_1.npy', LF_params_0_1)
+    np.save('MF_param/saved_param/LF_params_1_0.npy', LF_params_1_0)
+    np.save('MF_param/saved_param/LF_params_1_1.npy', LF_params_1_1)
+    np.save('MF_param/saved_param/LF_params_2_0.npy', LF_params_2_0)
+    np.save('MF_param/saved_param/LF_params_2_1.npy', LF_params_2_1)
+    np.save('MF_param/saved_param/LF_params_3_0.npy', LF_params_3_0)
+    np.save('MF_param/saved_param/LF_params_3_1.npy', LF_params_3_1)
+    np.save('MF_param/saved_param/LF_params_4_0.npy', LF_params_4_0)
+    np.save('MF_param/saved_param/LF_params_4_1.npy', LF_params_4_1)
+    np.save('MF_param/saved_param/LF_params_5_0.npy', LF_params_5_0)
+    np.save('MF_param/saved_param/LF_params_5_1.npy', LF_params_5_1)
+    np.save('MF_param/saved_param/LF_params_6_0.npy', LF_params_6_0)
+    np.save('MF_param/saved_param/LF_params_6_1.npy', LF_params_6_1)
+    np.save('MF_param/saved_param/LF_params_7_0.npy', LF_params_7_0)
+    np.save('MF_param/saved_param/LF_params_7_1.npy', LF_params_7_1)
+    
+    np.save('MF_param/saved_param/LF_params_prior_0_0.npy', LF_params_prior_0_0)
+    np.save('MF_param/saved_param/LF_params_prior_0_1.npy', LF_params_prior_0_1)
+    np.save('MF_param/saved_param/LF_params_prior_1_0.npy', LF_params_prior_1_0)
+    np.save('MF_param/saved_param/LF_params_prior_1_1.npy', LF_params_prior_1_1)
+    np.save('MF_param/saved_param/LF_params_prior_2_0.npy', LF_params_prior_2_0)
+    np.save('MF_param/saved_param/LF_params_prior_2_1.npy', LF_params_prior_2_1)
+    np.save('MF_param/saved_param/LF_params_prior_3_0.npy', LF_params_prior_3_0)
+    np.save('MF_param/saved_param/LF_params_prior_3_1.npy', LF_params_prior_3_1)
+    np.save('MF_param/saved_param/LF_params_prior_4_0.npy', LF_params_prior_4_0)
+    np.save('MF_param/saved_param/LF_params_prior_4_1.npy', LF_params_prior_4_1)
+    np.save('MF_param/saved_param/LF_params_prior_5_0.npy', LF_params_prior_5_0)
+    np.save('MF_param/saved_param/LF_params_prior_5_1.npy', LF_params_prior_5_1)
+    np.save('MF_param/saved_param/LF_params_prior_6_0.npy', LF_params_prior_6_0)
+    np.save('MF_param/saved_param/LF_params_prior_6_1.npy', LF_params_prior_6_1)
+    np.save('MF_param/saved_param/LF_params_prior_7_0.npy', LF_params_prior_7_0)
+    np.save('MF_param/saved_param/LF_params_prior_7_1.npy', LF_params_prior_7_1)
+
+if is_SF == 1:
+    SF_params_0_0 = np.load('SF_param/SF_param_0/params_0_0.npy')
+    SF_params_0_1 = np.load('SF_param/SF_param_0/params_0_1.npy')
+    SF_params_1_0 = np.load('SF_param/SF_param_0/params_1_0.npy')
+    SF_params_1_1 = np.load('SF_param/SF_param_0/params_1_1.npy')
+    SF_params_2_0 = np.load('SF_param/SF_param_0/params_2_0.npy')
+    SF_params_2_1 = np.load('SF_param/SF_param_0/params_2_1.npy')
+    SF_params_3_0 = np.load('SF_param/SF_param_0/params_3_0.npy')
+    SF_params_3_1 = np.load('SF_param/SF_param_0/params_3_1.npy')
+    SF_params_4_0 = np.load('SF_param/SF_param_0/params_4_0.npy')
+    SF_params_4_1 = np.load('SF_param/SF_param_0/params_4_1.npy')
+    SF_params_5_0 = np.load('SF_param/SF_param_0/params_5_0.npy')
+    SF_params_5_1 = np.load('SF_param/SF_param_0/params_5_1.npy')
+    SF_params_6_0 = np.load('SF_param/SF_param_0/params_6_0.npy')
+    SF_params_6_1 = np.load('SF_param/SF_param_0/params_6_1.npy')
+    SF_params_7_0 = np.load('SF_param/SF_param_0/params_7_0.npy')
+    SF_params_7_1 = np.load('SF_param/SF_param_0/params_7_1.npy')
+    
+    SF_params_prior_0_0 = np.load('SF_param/SF_param_0/params_prior_0_0.npy')
+    SF_params_prior_0_1 = np.load('SF_param/SF_param_0/params_prior_0_1.npy')
+    SF_params_prior_1_0 = np.load('SF_param/SF_param_0/params_prior_1_0.npy')
+    SF_params_prior_1_1 = np.load('SF_param/SF_param_0/params_prior_1_1.npy')
+    SF_params_prior_2_0 = np.load('SF_param/SF_param_0/params_prior_2_0.npy')
+    SF_params_prior_2_1 = np.load('SF_param/SF_param_0/params_prior_2_1.npy')
+    SF_params_prior_3_0 = np.load('SF_param/SF_param_0/params_prior_3_0.npy')
+    SF_params_prior_3_1 = np.load('SF_param/SF_param_0/params_prior_3_1.npy')
+    SF_params_prior_4_0 = np.load('SF_param/SF_param_0/params_prior_4_0.npy')
+    SF_params_prior_4_1 = np.load('SF_param/SF_param_0/params_prior_4_1.npy')
+    SF_params_prior_5_0 = np.load('SF_param/SF_param_0/params_prior_5_0.npy')
+    SF_params_prior_5_1 = np.load('SF_param/SF_param_0/params_prior_5_1.npy')
+    SF_params_prior_6_0 = np.load('SF_param/SF_param_0/params_prior_6_0.npy')
+    SF_params_prior_6_1 = np.load('SF_param/SF_param_0/params_prior_6_1.npy')
+    SF_params_prior_7_0 = np.load('SF_param/SF_param_0/params_prior_7_0.npy')
+    SF_params_prior_7_1 = np.load('SF_param/SF_param_0/params_prior_7_1.npy')
+    
+    for i in range(N_param_gp-1):
+        
+        print(i)
+        SF_params_0_0 = np.concatenate( (SF_params_0_0,
+                                         np.load('SF_param/SF_param_'+str(i+1)+'/params_0_0.npy')), axis = 0)
+        SF_params_0_1 = np.concatenate( (SF_params_0_1,
+                                         np.load('SF_param/SF_param_'+str(i+1)+'/params_0_1.npy')), axis = 0)
+        SF_params_1_0 = np.concatenate( (SF_params_1_0,
+                                         np.load('SF_param/SF_param_'+str(i+1)+'/params_1_0.npy')), axis = 0)
+        SF_params_1_1 = np.concatenate( (SF_params_1_1,
+                                         np.load('SF_param/SF_param_'+str(i+1)+'/params_1_1.npy')), axis = 0)
+        SF_params_2_0 = np.concatenate( (SF_params_2_0,
+                                         np.load('SF_param/SF_param_'+str(i+1)+'/params_2_0.npy')), axis = 0)
+        SF_params_2_1 = np.concatenate( (SF_params_2_1,
+                                         np.load('SF_param/SF_param_'+str(i+1)+'/params_2_1.npy')), axis = 0)
+        SF_params_3_0 = np.concatenate( (SF_params_3_0,
+                                         np.load('SF_param/SF_param_'+str(i+1)+'/params_3_0.npy')), axis = 0)
+        SF_params_3_1 = np.concatenate( (SF_params_3_1,
+                                         np.load('SF_param/SF_param_'+str(i+1)+'/params_3_1.npy')), axis = 0)
+        SF_params_4_0 = np.concatenate( (SF_params_4_0,
+                                         np.load('SF_param/SF_param_'+str(i+1)+'/params_4_0.npy')), axis = 0)
+        SF_params_4_1 = np.concatenate( (SF_params_4_1,
+                                         np.load('SF_param/SF_param_'+str(i+1)+'/params_4_1.npy')), axis = 0)
+        SF_params_5_0 = np.concatenate( (SF_params_5_0,
+                                         np.load('SF_param/SF_param_'+str(i+1)+'/params_5_0.npy')), axis = 0)
+        SF_params_5_1 = np.concatenate( (SF_params_5_1,
+                                         np.load('SF_param/SF_param_'+str(i+1)+'/params_5_1.npy')), axis = 0)    
+        SF_params_6_0 = np.concatenate( (SF_params_6_0,
+                                         np.load('SF_param/SF_param_'+str(i+1)+'/params_6_0.npy')), axis = 0)
+        SF_params_6_1 = np.concatenate( (SF_params_6_1,
+                                         np.load('SF_param/SF_param_'+str(i+1)+'/params_6_1.npy')), axis = 0)    
+        SF_params_7_0 = np.concatenate( (SF_params_7_0,
+                                         np.load('SF_param/SF_param_'+str(i+1)+'/params_7_0.npy')), axis = 0)
+        SF_params_7_1 = np.concatenate( (SF_params_7_1,
+                                         np.load('SF_param/SF_param_'+str(i+1)+'/params_7_1.npy')), axis = 0)
+    
+        SF_params_prior_0_0 = np.concatenate( (SF_params_prior_0_0,
+                                         np.load('SF_param/SF_param_'+str(i+1)+'/params_prior_0_0.npy')), axis = 0)
+        SF_params_prior_0_1 = np.concatenate( (SF_params_prior_0_1,
+                                         np.load('SF_param/SF_param_'+str(i+1)+'/params_prior_0_1.npy')), axis = 0)
+        SF_params_prior_1_0 = np.concatenate( (SF_params_prior_1_0,
+                                         np.load('SF_param/SF_param_'+str(i+1)+'/params_prior_1_0.npy')), axis = 0)
+        SF_params_prior_1_1 = np.concatenate( (SF_params_prior_1_1,
+                                         np.load('SF_param/SF_param_'+str(i+1)+'/params_prior_1_1.npy')), axis = 0)        
+        SF_params_prior_2_0 = np.concatenate( (SF_params_prior_2_0,
+                                         np.load('SF_param/SF_param_'+str(i+1)+'/params_prior_2_0.npy')), axis = 0)
+        SF_params_prior_2_1 = np.concatenate( (SF_params_prior_2_1,
+                                         np.load('SF_param/SF_param_'+str(i+1)+'/params_prior_2_1.npy')), axis = 0)        
+        SF_params_prior_3_0 = np.concatenate( (SF_params_prior_3_0,
+                                         np.load('SF_param/SF_param_'+str(i+1)+'/params_prior_3_0.npy')), axis = 0)
+        SF_params_prior_3_1 = np.concatenate( (SF_params_prior_3_1,
+                                         np.load('SF_param/SF_param_'+str(i+1)+'/params_prior_3_1.npy')), axis = 0)        
+        SF_params_prior_4_0 = np.concatenate( (SF_params_prior_4_0,
+                                         np.load('SF_param/SF_param_'+str(i+1)+'/params_prior_4_0.npy')), axis = 0)
+        SF_params_prior_4_1 = np.concatenate( (SF_params_prior_4_1,
+                                         np.load('SF_param/SF_param_'+str(i+1)+'/params_prior_4_1.npy')), axis = 0)        
+        SF_params_prior_5_0 = np.concatenate( (SF_params_prior_5_0,
+                                         np.load('SF_param/SF_param_'+str(i+1)+'/params_prior_5_0.npy')), axis = 0)
+        SF_params_prior_5_1 = np.concatenate( (SF_params_prior_5_1,
+                                         np.load('SF_param/SF_param_'+str(i+1)+'/params_prior_5_1.npy')), axis = 0)        
+        SF_params_prior_6_0 = np.concatenate( (SF_params_prior_6_0,
+                                         np.load('SF_param/SF_param_'+str(i+1)+'/params_prior_6_0.npy')), axis = 0)
+        SF_params_prior_6_1 = np.concatenate( (SF_params_prior_6_1,
+                                         np.load('SF_param/SF_param_'+str(i+1)+'/params_prior_6_1.npy')), axis = 0)        
+        SF_params_prior_7_0 = np.concatenate( (SF_params_prior_7_0,
+                                         np.load('SF_param/SF_param_'+str(i+1)+'/params_prior_7_0.npy')), axis = 0)
+        SF_params_prior_7_1 = np.concatenate( (SF_params_prior_7_1,
+                                         np.load('SF_param/SF_param_'+str(i+1)+'/params_prior_7_1.npy')), axis = 0)
+    
+    np.save('SF_param/saved_param/SF_params_0_0.npy', SF_params_0_0)
+    np.save('SF_param/saved_param/SF_params_0_1.npy', SF_params_0_1)
+    np.save('SF_param/saved_param/SF_params_1_0.npy', SF_params_1_0)
+    np.save('SF_param/saved_param/SF_params_1_1.npy', SF_params_1_1)
+    np.save('SF_param/saved_param/SF_params_2_0.npy', SF_params_2_0)
+    np.save('SF_param/saved_param/SF_params_2_1.npy', SF_params_2_1)
+    np.save('SF_param/saved_param/SF_params_3_0.npy', SF_params_3_0)
+    np.save('SF_param/saved_param/SF_params_3_1.npy', SF_params_3_1)
+    np.save('SF_param/saved_param/SF_params_4_0.npy', SF_params_4_0)
+    np.save('SF_param/saved_param/SF_params_4_1.npy', SF_params_4_1)
+    np.save('SF_param/saved_param/SF_params_5_0.npy', SF_params_5_0)
+    np.save('SF_param/saved_param/SF_params_5_1.npy', SF_params_5_1)
+    np.save('SF_param/saved_param/SF_params_6_0.npy', SF_params_6_0)
+    np.save('SF_param/saved_param/SF_params_6_1.npy', SF_params_6_1)
+    np.save('SF_param/saved_param/SF_params_7_0.npy', SF_params_7_0)
+    np.save('SF_param/saved_param/SF_params_7_1.npy', SF_params_7_1)
+    
+    np.save('SF_param/saved_param/SF_params_prior_0_0.npy', SF_params_prior_0_0)
+    np.save('SF_param/saved_param/SF_params_prior_0_1.npy', SF_params_prior_0_1)
+    np.save('SF_param/saved_param/SF_params_prior_1_0.npy', SF_params_prior_1_0)
+    np.save('SF_param/saved_param/SF_params_prior_1_1.npy', SF_params_prior_1_1)
+    np.save('SF_param/saved_param/SF_params_prior_2_0.npy', SF_params_prior_2_0)
+    np.save('SF_param/saved_param/SF_params_prior_2_1.npy', SF_params_prior_2_1)
+    np.save('SF_param/saved_param/SF_params_prior_3_0.npy', SF_params_prior_3_0)
+    np.save('SF_param/saved_param/SF_params_prior_3_1.npy', SF_params_prior_3_1)
+    np.save('SF_param/saved_param/SF_params_prior_4_0.npy', SF_params_prior_4_0)
+    np.save('SF_param/saved_param/SF_params_prior_4_1.npy', SF_params_prior_4_1)
+    np.save('SF_param/saved_param/SF_params_prior_5_0.npy', SF_params_prior_5_0)
+    np.save('SF_param/saved_param/SF_params_prior_5_1.npy', SF_params_prior_5_1)
+    np.save('SF_param/saved_param/SF_params_prior_6_0.npy', SF_params_prior_6_0)
+    np.save('SF_param/saved_param/SF_params_prior_6_1.npy', SF_params_prior_6_1)
+    np.save('SF_param/saved_param/SF_params_prior_7_0.npy', SF_params_prior_7_0)
+    np.save('SF_param/saved_param/SF_params_prior_7_1.npy', SF_params_prior_7_1)

4_pred_RPN_LF.py

@@ -0,0 +1,171 @@
+#!/usr/bin/env python3
+# -*- coding: utf-8 -*-
+"""
+Created on Fri May 26 11:19:06 2023
+
+@author: mohamedazizbhouri
+"""
+
+import os
+os.environ['XLA_PYTHON_CLIENT_PREALLOCATE']='false'
+
+from jax import numpy as np
+from jax import vmap, jit, random
+
+import numpy as onp
+import time
+
+##########################################################
+##########################################################
+##########################################################
+
+def leakyRELU(x):
+    return np.where(x > 0, x, x * 0.15) 
+      
+def MLP(layers, activation=leakyRELU):
+    def init(rng_key):
+        def init_layer(key, d_in, d_out):
+            k1, k2 = random.split(key)
+            glorot_stddev = 1. / np.sqrt((d_in + d_out) / 2.)
+            W = glorot_stddev*random.normal(k1, (d_in, d_out))
+            b = np.zeros(d_out)
+            return W, b
+        key, *keys = random.split(rng_key, len(layers))
+        params = list(map(init_layer, keys, layers[:-1], layers[1:]))
+        return params
+    def apply(params, inputs):
+        for W, b in params[:-1]:
+            outputs = np.dot(inputs, W) + b
+            inputs = activation(outputs)
+        W, b = params[-1]
+        outputs = np.dot(inputs, W) + b
+        return outputs
+    return init, apply
+
+##########################################################
+##########################################################
+##########################################################
+    
+from jax.example_libraries import optimizers
+from functools import partial
+import itertools
+
+# Define the model
+class EnsembleRegression:
+    def __init__(self, layers, ensemble_size, rng_key = random.PRNGKey(0)):  
+        # Network initialization and evaluation functions
+        self.init, self.apply = MLP(layers)
+        self.init_prior, self.apply_prior = MLP(layers)
+        
+        # Random keys
+        k1, k2, k3 = random.split(rng_key, 3)
+        keys_1 = random.split(k1, ensemble_size)
+        keys_2 = random.split(k2, ensemble_size)
+        keys_3 = random.split(k3, ensemble_size)
+        
+        # Initialize
+        params = vmap(self.init)(keys_1)
+        params_prior = vmap(self.init_prior)(keys_2)
+                
+        # Use optimizers to set optimizer initialization and update functions
+        lr = optimizers.exponential_decay(1e-4, decay_steps=1000, decay_rate=0.999)
+        lr = optimizers.exponential_decay(0.000227, decay_steps=1000, decay_rate=0.999)
+        self.opt_init, \
+        self.opt_update, \
+        self.get_params = optimizers.adam(lr)
+
+        self.opt_state = vmap(self.opt_init)(params)
+        self.prior_opt_state = vmap(self.opt_init)(params_prior)
+        self.key_opt_state = vmap(self.opt_init)(keys_3)
+
+        # Logger
+        self.itercount = itertools.count()
+        self.loss_log = []
+        
+    # Define the forward pass
+    def net_forward(self, params, params_prior, inputs):
+        Y_pred = self.apply(params, inputs) + self.apply_prior(params_prior, inputs) 
+        return Y_pred
+     
+    # Evaluates predictions at test points  
+    @partial(jit, static_argnums=(0,))
+    def posterior(self, params, inputs):
+        params, params_prior = params
+        samples = vmap(self.net_forward, (0, 0, 0))(params, params_prior, inputs)
+        return samples
+    
+##########################################################
+##########################################################
+##########################################################
+
+# Helper functions
+normalize = lambda x, mu, std: (x-mu)/std
+
+n_remove = 4
+ind_input = np.concatenate( (np.arange(26),n_remove+26+np.arange(26-n_remove),np.array([52,53,54,55])) ) 
+dim_xH = ind_input.shape[0]
+dim_xL = ind_input.shape[0]
+
+ind_output_heat = np.arange(26) 
+ind_output_moist = n_remove+np.arange(26-n_remove)
+
+dim_yH = ind_output_heat.shape[0]+ind_output_moist.shape[0]
+dim_yL = ind_output_heat.shape[0]+ind_output_moist.shape[0]
+
+ensemble_size = 1
+
+layers_L = [dim_xL, 512, 512, 512, 512, 512, 512, 512, dim_yL]
+    
+id_step = 1 # 1 or 2 for instance in case we dont have enough RAM memory to make
+            # predictions for the whole test dataset at once.
+n_run_param = 0 
+
+key = random.PRNGKey(n_run_param)
+model_L = EnsembleRegression(layers_L, ensemble_size, key)
+
+mu_MF_in = onp.load('norm/mu_X_CAM5.npy')[None,ind_input]
+sigma_MF_in = onp.load('norm/sigma_X_CAM5.npy')[None,ind_input]
+
+print('loading NN parameters')
+
+params_L = []
+params_prior_L = []
+
+for i in range(len(layers_L)-1):
+    params_L.append( ( np.load('MF_param/MF_param_'+str(n_run_param)+'/LF_params_'+str(i)+'_'+str(0)+'.npy')[0:1,:,:] , 
+                       np.load('MF_param/MF_param_'+str(n_run_param)+'/LF_params_'+str(i)+'_'+str(1)+'.npy')[0:1,:] )  )   
+    params_prior_L.append( ( np.load('MF_param/MF_param_'+str(n_run_param)+'/LF_params_prior_'+str(i)+'_'+str(0)+'.npy')[0:1,:,:] , 
+                             np.load('MF_param/MF_param_'+str(n_run_param)+'/LF_params_prior_'+str(i)+'_'+str(1)+'.npy')[0:1,:] )  )     
+
+opt_params_L = (params_L, params_prior_L)
+    
+@jit
+def predict_L(x):
+    # accepts and returns un-normalized data
+    x = np.tile(x[np.newaxis,:,:], (ensemble_size, 1, 1))
+    x = normalize(x, mu_MF_in, sigma_MF_in)
+    samples = model_L.posterior(opt_params_L, x)
+    return samples
+    
+##################################      
+############## test ##############
+##################################
+
+print('loading test')
+if id_step == 1:
+    t = time.time()
+    test_XH = onp.load('data_SPCAM5_4K/all_inputs.npy')[:59387904,ind_input]
+    print('test loaded', 'time (s):', time.time() - t)
+elif id_step == 2:
+    t = time.time()
+    test_XH = onp.load('data_SPCAM5_4K/all_inputs.npy')[59387904:,ind_input]        
+    print('test loaded', 'time (s):', time.time() - t)
+
+print('n_run_param : ', n_run_param, 'id_step : ', id_step, 'Computing pred')
+t = time.time()
+samples_test_H = predict_L(test_XH)
+print('Computing pred', 'time (s):', time.time() - t)
+print('Saving pred')
+t = time.time()
+np.save('MF_param/MF_param_'+str(n_run_param)+'/LF_test_pred_'+str(id_step)+'.npy', samples_test_H)
+print('Saving pred', 'time (s):', time.time() - t)

4_pred_RPN_MF.py

@@ -0,0 +1,190 @@
+#!/usr/bin/env python3
+# -*- coding: utf-8 -*-
+"""
+Created on Wed May 3 17:32:12 2023
+
+@author: mohamedazizbhouri
+"""
+
+import os
+os.environ['XLA_PYTHON_CLIENT_PREALLOCATE']='false'
+
+from jax import numpy as np
+from jax import vmap, jit, random
+
+import numpy as onp
+import time
+
+##########################################################
+##########################################################
+##########################################################
+
+def leakyRELU(x):
+    return np.where(x > 0, x, x * 0.15)
+      
+def MLP(layers, activation=leakyRELU): # np.tanh
+    def init(rng_key):
+        def init_layer(key, d_in, d_out):
+            k1, k2 = random.split(key)
+            glorot_stddev = 1. / np.sqrt((d_in + d_out) / 2.)
+            W = glorot_stddev*random.normal(k1, (d_in, d_out))
+            b = np.zeros(d_out)
+            return W, b
+        key, *keys = random.split(rng_key, len(layers))
+        params = list(map(init_layer, keys, layers[:-1], layers[1:]))
+        return params
+    def apply(params, inputs):
+        for W, b in params[:-1]:
+            outputs = np.dot(inputs, W) + b
+            inputs = activation(outputs)
+        W, b = params[-1]
+        outputs = np.dot(inputs, W) + b
+        return outputs
+    return init, apply
+
+##########################################################
+##########################################################
+##########################################################
+    
+from jax.example_libraries import optimizers
+from functools import partial
+import itertools
+
+# Define the model
+class EnsembleRegression:
+    def __init__(self, layers, ensemble_size, rng_key = random.PRNGKey(0)):  
+        # Network initialization and evaluation functions
+        self.init, self.apply = MLP(layers)
+        self.init_prior, self.apply_prior = MLP(layers)
+        
+        # Random keys
+        k1, k2, k3 = random.split(rng_key, 3)
+        keys_1 = random.split(k1, ensemble_size)
+        keys_2 = random.split(k2, ensemble_size)
+        keys_3 = random.split(k3, ensemble_size)
+        
+        # Initialize
+        params = vmap(self.init)(keys_1)
+        params_prior = vmap(self.init_prior)(keys_2)
+                
+        # Use optimizers to set optimizer initialization and update functions
+        lr = optimizers.exponential_decay(1e-4, decay_steps=1000, decay_rate=0.999)
+        lr = optimizers.exponential_decay(0.000227, decay_steps=1000, decay_rate=0.999)
+        self.opt_init, \
+        self.opt_update, \
+        self.get_params = optimizers.adam(lr)
+
+        self.opt_state = vmap(self.opt_init)(params)
+        self.prior_opt_state = vmap(self.opt_init)(params_prior)
+        self.key_opt_state = vmap(self.opt_init)(keys_3)
+
+        # Logger
+        self.itercount = itertools.count()
+        self.loss_log = []
+        
+    # Define the forward pass
+    def net_forward(self, params, params_prior, inputs):
+        Y_pred = self.apply(params, inputs) + self.apply_prior(params_prior, inputs) 
+        return Y_pred
+     
+    # Evaluates predictions at test points  
+    @partial(jit, static_argnums=(0,))
+    def posterior(self, params, inputs):
+        params, params_prior = params
+        samples = vmap(self.net_forward, (0, 0, 0))(params, params_prior, inputs)
+        return samples
+    
+##########################################################
+##########################################################
+##########################################################
+
+# Helper functions
+normalize = lambda x, mu, std: (x-mu)/std
+
+n_remove = 4
+ind_input = np.concatenate( (np.arange(26),n_remove+26+np.arange(26-n_remove),np.array([52,53,54,55])) ) 
+dim_xH = ind_input.shape[0]
+dim_xL = ind_input.shape[0]
+
+ind_output_heat = np.arange(26)
+ind_output_moist = n_remove+np.arange(26-n_remove)
+
+dim_yH = ind_output_heat.shape[0]+ind_output_moist.shape[0]
+dim_yL = ind_output_heat.shape[0]+ind_output_moist.shape[0]
+
+ensemble_size = 1
+i_ensemble = 0
+layers_H = [dim_yL, 512, 512, 512, 512, 512, 512, 512, dim_yH]
+layers_L = [dim_xL, 512, 512, 512, 512, 512, 512, 512, dim_yL]
+    
+id_step = 1 # 1 or 2 for instance in case we dont have enough RAM memory to make
+            # predictions for the whole test dataset at once.
+n_run_param = 0
+
+key = random.PRNGKey(n_run_param)
+model_H = EnsembleRegression(layers_H, ensemble_size, key)
+model_L = EnsembleRegression(layers_L, ensemble_size, key)
+
+mu_MF_in = onp.load('norm/mu_X_CAM5.npy')[None,ind_input]
+sigma_MF_in = onp.load('norm/sigma_X_CAM5.npy')[None,ind_input]
+
+print('loading NN parameters')
+params = []
+params_prior = []
+
+for i in range(len(layers_H)-1):
+    params.append( ( np.load('MF_param/MF_param_'+str(n_run_param)+'/HF_params_'+str(i)+'_'+str(0)+'.npy')[i_ensemble:i_ensemble+1,:,:] , 
+                       np.load('MF_param/MF_param_'+str(n_run_param)+'/HF_params_'+str(i)+'_'+str(1)+'.npy')[i_ensemble:i_ensemble+1,:] )  )   
+    params_prior.append( ( np.load('MF_param/MF_param_'+str(n_run_param)+'/HF_params_prior_'+str(i)+'_'+str(0)+'.npy')[i_ensemble:i_ensemble+1,:,:] , 
+                             np.load('MF_param/MF_param_'+str(n_run_param)+'/HF_params_prior_'+str(i)+'_'+str(1)+'.npy')[i_ensemble:i_ensemble+1,:] )  )     
+
+opt_params_H = (params, params_prior)
+
+params_L = []
+params_prior_L = []
+
+for i in range(len(layers_L)-1):
+    params_L.append( ( np.load('MF_param/MF_param_'+str(n_run_param)+'/LF_params_'+str(i)+'_'+str(0)+'.npy')[i_ensemble:i_ensemble+1,:,:] , 
+                       np.load('MF_param/MF_param_'+str(n_run_param)+'/LF_params_'+str(i)+'_'+str(1)+'.npy')[i_ensemble:i_ensemble+1,:] )  )   
+    params_prior_L.append( ( np.load('MF_param/MF_param_'+str(n_run_param)+'/LF_params_prior_'+str(i)+'_'+str(0)+'.npy')[i_ensemble:i_ensemble+1,:,:] , 
+                             np.load('MF_param/MF_param_'+str(n_run_param)+'/LF_params_prior_'+str(i)+'_'+str(1)+'.npy')[i_ensemble:i_ensemble+1,:] )  )     
+
+opt_params_L = (params_L, params_prior_L)
+    
+@jit
+def predict_L(x):
+    # accepts and returns un-normalized data
+    x = np.tile(x[np.newaxis,:,:], (ensemble_size, 1, 1))
+    samples = model_L.posterior(opt_params_L, x)
+    return samples
+
+@jit
+def predict_H(x):
+    # accepts and returns un-normalized data
+    xL = normalize(x, mu_MF_in, sigma_MF_in)
+    x = predict_L(xL)
+    samples = model_H.posterior(opt_params_H, x)
+    return samples
+
+##################################      
+############## test ##############
+##################################
+print('loading test')
+if id_step == 1:
+    t = time.time()
+    test_XH = onp.load('data_SPCAM5_4K/all_inputs.npy')[:59387904,ind_input]
+    print('test loaded', 'time (s):', time.time() - t)
+elif id_step == 2:
+    t = time.time()
+    test_XH = onp.load('data_SPCAM5_4K/all_inputs.npy')[59387904:,ind_input]
+    print('test loaded', 'time (s):', time.time() - t)
+
+print('n_run_param : ', n_run_param, 'id_step : ', id_step, 'Computing pred')
+t = time.time()
+samples_test_H = predict_H(test_XH)
+print('Computing pred', 'time (s):', time.time() - t)
+print('Saving pred')
+t = time.time()
+np.save('MF_param/MF_param_'+str(n_run_param)+'/test_pred_'+str(id_step)+'.npy', samples_test_H)
+print('Saving pred', 'time (s):', time.time() - t)
+    

4_pred_RPN_SF.py

@@ -0,0 +1,168 @@
+#!/usr/bin/env python3
+# -*- coding: utf-8 -*-
+"""
+Created on Thu May 4 10:34:47 2023
+
+@author: mohamedazizbhouri
+"""
+
+import os
+os.environ['XLA_PYTHON_CLIENT_PREALLOCATE']='false'
+
+from jax import numpy as np
+from jax import vmap, jit, random
+
+import numpy as onp
+import time
+
+##########################################################
+##########################################################
+##########################################################
+
+def leakyRELU(x):
+    return np.where(x > 0, x, x * 0.15)
+      
+def MLP(layers, activation=leakyRELU):
+    def init(rng_key):
+        def init_layer(key, d_in, d_out):
+            k1, k2 = random.split(key)
+            glorot_stddev = 1. / np.sqrt((d_in + d_out) / 2.)
+            W = glorot_stddev*random.normal(k1, (d_in, d_out))
+            b = np.zeros(d_out)
+            return W, b
+        key, *keys = random.split(rng_key, len(layers))
+        params = list(map(init_layer, keys, layers[:-1], layers[1:]))
+        return params
+    def apply(params, inputs):
+        for W, b in params[:-1]:
+            outputs = np.dot(inputs, W) + b
+            inputs = activation(outputs)
+        W, b = params[-1]
+        outputs = np.dot(inputs, W) + b
+        return outputs
+    return init, apply
+
+##########################################################
+##########################################################
+##########################################################
+    
+from jax.example_libraries import optimizers  
+from functools import partial
+import itertools
+
+# Define the model
+class EnsembleRegression:
+    def __init__(self, layers, ensemble_size, rng_key = random.PRNGKey(0)):  
+        # Network initialization and evaluation functions
+        self.init, self.apply = MLP(layers)
+        self.init_prior, self.apply_prior = MLP(layers)
+        
+        # Random keys
+        k1, k2, k3 = random.split(rng_key, 3)
+        keys_1 = random.split(k1, ensemble_size)
+        keys_2 = random.split(k2, ensemble_size)
+        keys_3 = random.split(k2, ensemble_size)
+        
+        # Initialize
+        params = vmap(self.init)(keys_1)
+        params_prior = vmap(self.init_prior)(keys_2)
+                
+        # Use optimizers to set optimizer initialization and update functions
+        lr = optimizers.exponential_decay(1e-4, decay_steps=1000, decay_rate=0.999)
+        lr = optimizers.exponential_decay(0.000227, decay_steps=1000, decay_rate=0.999)
+        self.opt_init, \
+        self.opt_update, \
+        self.get_params = optimizers.adam(lr)
+
+        self.opt_state = vmap(self.opt_init)(params)
+        self.prior_opt_state = vmap(self.opt_init)(params_prior)
+        self.key_opt_state = vmap(self.opt_init)(keys_3)
+
+        # Logger
+        self.itercount = itertools.count()
+        self.loss_log = []
+        
+    # Define the forward pass
+    def net_forward(self, params, params_prior, inputs):
+        Y_pred = self.apply(params, inputs) + self.apply_prior(params_prior, inputs) 
+        return Y_pred
+     
+    # Evaluates predictions at test points  
+    @partial(jit, static_argnums=(0,))
+    def posterior(self, params, inputs):
+        params, params_prior = params
+        samples = vmap(self.net_forward, (0, 0, 0))(params, params_prior, inputs)
+        return samples
+    
+##########################################################
+##########################################################
+##########################################################
+
+# Helper functions
+normalize = lambda x, mu, std: (x-mu)/std
+
+n_remove = 4
+ind_input = np.concatenate( (np.arange(26),n_remove+26+np.arange(26-n_remove),np.array([52,53,54,55])) ) 
+dim_xH = ind_input.shape[0]
+dim_xL = ind_input.shape[0]
+
+ind_output_heat = np.arange(26)
+ind_output_moist = n_remove+np.arange(26-n_remove)
+
+dim_yH = ind_output_heat.shape[0]+ind_output_moist.shape[0]
+dim_yL = ind_output_heat.shape[0]+ind_output_moist.shape[0]
+    
+ensemble_size = 1
+layers_H = [dim_xH, 512, 512, 512, 512, 512, 512, 512, dim_yH]
+
+id_step = 1 # 1 or 2 for instance in case we dont have enough RAM memory to make
+            # predictions for the whole test dataset at once.
+n_run_param = 0
+
+key = random.PRNGKey(n_run_param)
+model_H = EnsembleRegression(layers_H, ensemble_size, key)
+
+mu_SF_in = onp.load('norm/mu_X_SPCAM5.npy')[None,None,ind_input]
+sigma_SF_in = onp.load('norm/sigma_X_SPCAM5.npy')[None,None,ind_input]
+
+print('loading NN parameters')
+params = []
+params_prior = []
+for i in range(len(layers_H)-1):
+    params.append( ( np.load('SF_param/SF_param_'+str(n_run_param)+'/params_'+str(i)+'_'+str(0)+'.npy') , 
+                       np.load('SF_param/SF_param_'+str(n_run_param)+'/params_'+str(i)+'_'+str(1)+'.npy') )  )   
+    params_prior.append( ( np.load('SF_param/SF_param_'+str(n_run_param)+'/params_prior_'+str(i)+'_'+str(0)+'.npy') , 
+                             np.load('SF_param/SF_param_'+str(n_run_param)+'/params_prior_'+str(i)+'_'+str(1)+'.npy') )  )     
+
+opt_params_H = (params, params_prior)
+
+@jit
+def predict_H(x):
+    # accepts and returns un-normalized data
+    x = np.tile(x[np.newaxis,:,:], (ensemble_size, 1, 1))
+    x = normalize(x, mu_SF_in, sigma_SF_in) 
+    samples = model_H.posterior(opt_params_H, x)
+    return samples
+
+##################################      
+############## test ##############
+##################################
+
+print('loading test')
+if id_step == 1:
+    t = time.time()
+    test_XH = onp.load('data_SPCAM5_4K/all_inputs.npy')[:59387904,ind_input]
+    print('test loaded', 'time (s):', time.time() - t)
+elif id_step == 2:
+    t = time.time()
+    test_XH = onp.load('data_SPCAM5_4K/all_inputs.npy')[59387904:,ind_input]
+    print('test loaded', 'time (s):', time.time() - t)
+
+print('n_run_param : ', n_run_param, 'id_step : ', id_step, 'Computing pred')
+t = time.time()
+samples_test_H = predict_H(test_XH)
+print('Computing pred', 'time (s):', time.time() - t)
+print('Saving pred')
+t = time.time()
+np.save('SF_param/SF_param_'+str(n_run_param)+'/test_pred_'+str(id_step)+'.npy', samples_test_H)
+print('Saving pred', 'time (s):', time.time() - t)

4_pred_RPN_det.py

@@ -0,0 +1,167 @@
+#!/usr/bin/env python3
+# -*- coding: utf-8 -*-
+"""
+Created on Wed May 3 17:19:00 2023
+
+@author: mohamedazizbhouri
+"""
+
+import os
+os.environ['XLA_PYTHON_CLIENT_PREALLOCATE']='false'
+
+from jax import numpy as np
+from jax import vmap, jit, random
+
+import numpy as onp
+import time
+
+##########################################################
+##########################################################
+##########################################################
+
+def leakyRELU(x):
+    return np.where(x > 0, x, x * 0.15)
+      
+def MLP(layers, activation=leakyRELU):
+    def init(rng_key):
+        def init_layer(key, d_in, d_out):
+            k1, k2 = random.split(key)
+            glorot_stddev = 1. / np.sqrt((d_in + d_out) / 2.)
+            W = glorot_stddev*random.normal(k1, (d_in, d_out))
+            b = np.zeros(d_out)
+            return W, b
+        key, *keys = random.split(rng_key, len(layers))
+        params = list(map(init_layer, keys, layers[:-1], layers[1:]))
+        return params
+    def apply(params, inputs):
+        for W, b in params[:-1]:
+            outputs = np.dot(inputs, W) + b
+            inputs = activation(outputs)
+        W, b = params[-1]
+        outputs = np.dot(inputs, W) + b
+        return outputs
+    return init, apply
+
+##########################################################
+##########################################################
+##########################################################
+    
+from jax.example_libraries import optimizers  
+from functools import partial
+import itertools
+
+# Define the model
+class EnsembleRegression:
+    def __init__(self, layers, ensemble_size, rng_key = random.PRNGKey(0)):  
+        # Network initialization and evaluation functions
+        self.init, self.apply = MLP(layers)
+        self.init_prior, self.apply_prior = MLP(layers)
+        
+        # Random keys
+        k1, k2, k3 = random.split(rng_key, 3)
+        keys_1 = random.split(k1, ensemble_size)
+        keys_2 = random.split(k2, ensemble_size)
+        keys_3 = random.split(k2, ensemble_size)
+        
+        # Initialize
+        params = vmap(self.init)(keys_1)
+        params_prior = vmap(self.init_prior)(keys_2)
+                
+        # Use optimizers to set optimizer initialization and update functions
+        lr = optimizers.exponential_decay(1e-4, decay_steps=1000, decay_rate=0.999)
+        lr = optimizers.exponential_decay(0.000227, decay_steps=1000, decay_rate=0.999)
+        self.opt_init, \
+        self.opt_update, \
+        self.get_params = optimizers.adam(lr)
+
+        self.opt_state = vmap(self.opt_init)(params)
+        self.prior_opt_state = vmap(self.opt_init)(params_prior)
+        self.key_opt_state = vmap(self.opt_init)(keys_3)
+
+        # Logger
+        self.itercount = itertools.count()
+        self.loss_log = []
+        
+    # Define the forward pass
+    def net_forward(self, params, params_prior, inputs):
+        Y_pred = self.apply(params, inputs) + self.apply_prior(params_prior, inputs) 
+        return Y_pred
+     
+    # Evaluates predictions at test points  
+    @partial(jit, static_argnums=(0,))
+    def posterior(self, params, inputs):
+        params, params_prior = params
+        samples = vmap(self.net_forward, (0, 0, 0))(params, params_prior, inputs)
+        return samples
+    
+##########################################################
+##########################################################
+##########################################################
+
+# Helper functions
+normalize = lambda x, mu, std: (x-mu)/std
+
+n_remove = 4
+ind_input = np.concatenate( (np.arange(26),n_remove+26+np.arange(26-n_remove),np.array([52,53,54,55])) ) 
+dim_xH = ind_input.shape[0]
+dim_xL = ind_input.shape[0]
+
+ind_output_heat = np.arange(26)
+ind_output_moist = n_remove+np.arange(26-n_remove)
+
+dim_yH = ind_output_heat.shape[0]+ind_output_moist.shape[0]
+dim_yL = ind_output_heat.shape[0]+ind_output_moist.shape[0]
+    
+ensemble_size = 1
+layers_H = [dim_xH, 512, 512, 512, 512, 512, 512, 512, dim_yH]
+
+id_step = 1 # 1 or 2 for instance in case we dont have enough RAM memory to make
+            # predictions for the whole test dataset at once.
+
+key = random.PRNGKey(0)
+model_H = EnsembleRegression(layers_H, ensemble_size, key)
+
+mu_SF_in = onp.load('norm/mu_X_SPCAM5.npy')[None,None,ind_input]
+sigma_SF_in = onp.load('norm/sigma_X_SPCAM5.npy')[None,None,ind_input]
+
+print('loading NN parameters')
+params = []
+params_prior = []
+for i in range(len(layers_H)-1):
+    params.append( ( np.load('SF_param/SF_param_det/params_'+str(i)+'_'+str(0)+'.npy') , 
+                       np.load('SF_param/SF_param_det/params_'+str(i)+'_'+str(1)+'.npy') )  )   
+    params_prior.append( ( np.load('SF_param/SF_param_det/params_prior_'+str(i)+'_'+str(0)+'.npy') , 
+                             np.load('SF_param/SF_param_det/params_prior_'+str(i)+'_'+str(1)+'.npy') )  )     
+
+opt_params_H = (params, params_prior)
+
+@jit
+def predict_H(x):
+    # accepts and returns un-normalized data
+    x = np.tile(x[np.newaxis,:,:], (ensemble_size, 1, 1))
+    x = normalize(x, mu_SF_in, sigma_SF_in) 
+    samples = model_H.posterior(opt_params_H, x)
+    return samples
+
+##################################      
+############## test ##############
+##################################
+
+print('loading test')
+if id_step == 1:
+    t = time.time()
+    test_XH = onp.load('data_SPCAM5_4K/all_inputs.npy')[:59387904,ind_input]
+    print('test loaded', 'time (s):', time.time() - t)
+elif id_step == 2:
+    t = time.time()
+    test_XH = onp.load('data_SPCAM5_4K/all_inputs.npy')[59387904:,ind_input]
+    print('test loaded', 'time (s):', time.time() - t)
+
+print('det NN, id_step : ', id_step, 'Computing pred')
+t = time.time()
+samples_test_H = predict_H(test_XH)
+print('Computing pred', 'time (s):', time.time() - t)
+print('Saving pred')
+t = time.time()
+np.save('SF_param/SF_param_det/test_pred_'+str(id_step)+'.npy', samples_test_H)
+print('Saving pred', 'time (s):', time.time() - t)

5_mean_std_RPN_LF.py

@@ -0,0 +1,55 @@
+#!/usr/bin/env python3
+# -*- coding: utf-8 -*-
+"""
+Created on Fri May 26 23:27:52 2023
+
+@author: mohamedazizbhouri
+"""
+
+import numpy as onp
+import time
+
+n_remove = 4
+ind_input = onp.concatenate( (onp.arange(26),n_remove+26+onp.arange(26-n_remove),onp.array([52,53,54,55])) ) 
+dim_xH = ind_input.shape[0]
+dim_xL = ind_input.shape[0]
+
+ind_output_heat = onp.arange(26)
+ind_output_moist = n_remove+onp.arange(26-n_remove)
+
+dim_yH = ind_output_heat.shape[0]+ind_output_moist.shape[0]
+dim_yL = ind_output_heat.shape[0]+ind_output_moist.shape[0]
+
+mu_MF_out = onp.concatenate((onp.load('norm/mu_y_heat_CAM5.npy')[None,ind_output_heat],
+                             onp.load('norm/mu_y_moist_CAM5.npy')[None,ind_output_moist]),axis=1)
+sigma_MF_out = onp.concatenate((onp.load('norm/sigma_y_heat_CAM5.npy')[None,ind_output_heat],
+                                onp.load('norm/sigma_y_moist_CAM5.npy')[None,ind_output_moist]),axis=1)
+
+is_comp_mean = 1
+id_step = 2
+N_rpn = 128
+print('loading data')
+
+if is_comp_mean == 1: # RPN mean computation
+    samples_test_H = onp.load('MF_param/MF_param_'+str(0)+'/LF_test_pred_'+str(id_step)+'.npy')[0,:,:]/N_rpn
+    t = time.time()
+    for i in range(N_rpn-1):
+        print(id_step,i,N_rpn-1)
+        samples_test_H = samples_test_H + onp.load('MF_param/MF_param_'+str(i+1)+'/LF_test_pred_'+str(id_step)+'.npy')[0,:,:]/N_rpn
+        print(time.time()-t)
+        t = time.time()
+    samples_test_H = mu_MF_out + sigma_MF_out * samples_test_H
+    onp.save('MF_param/mean_RPN_LF_'+str(id_step)+'.npy',samples_test_H)
+else: # RPN std computation
+    mu = onp.load('MF_param/mean_RPN_LF_'+str(id_step)+'.npy')
+    
+    sigma = (mu_MF_out + onp.load('MF_param/MF_param_'+str(0)+'/LF_test_pred_'+str(id_step)+'.npy')[0,:,:] * sigma_MF_out - mu)**2/N_rpn
+    t = time.time()
+    for i in range(N_rpn-1):
+        print(id_step,i,N_rpn-1)
+        sigma = sigma + (mu_MF_out + onp.load('MF_param/MF_param_'+str(i+1)+'/LF_test_pred_'+str(id_step)+'.npy')[0,:,:] * sigma_MF_out - mu)**2/N_rpn
+        print(time.time()-t)
+        t = time.time()
+    sigma = onp.sqrt(sigma)
+    onp.save('MF_param/std_RPN_LF_'+str(id_step)+'.npy',sigma)
+    

5_mean_std_RPN_MF.py

@@ -0,0 +1,123 @@
+#!/usr/bin/env python3
+# -*- coding: utf-8 -*-
+"""
+Created on Thu May 4 10:20:14 2023
+
+@author: mohamedazizbhouri
+"""
+
+import numpy as onp
+import time
+
+n_remove = 4
+ind_output_heat = onp.arange(26)
+ind_output_moist = n_remove+onp.arange(26-n_remove)
+
+is_MF = 1
+is_SF = 0
+is_LF = 0
+
+if is_MF == 1:
+    mu_SF_out = onp.concatenate((onp.load('norm/mu_y_heat_CAM5.npy')[None,ind_output_heat],
+                                 onp.load('norm/mu_y_moist_CAM5.npy')[None,ind_output_moist]),axis=1)
+    sigma_SF_out = onp.concatenate((onp.load('norm/sigma_y_heat_CAM5.npy')[None,ind_output_heat],
+                                    onp.load('norm/sigma_y_moist_CAM5.npy')[None,ind_output_moist]),axis=1)
+    
+    is_comp_mean = 1
+    id_step = 1
+    N_rpn = 128
+    print('loading data')
+    
+    if is_comp_mean == 1: # RPN mean computation
+        samples_test_H = onp.load('MF_param/MF_param_'+str(0)+'/test_pred_'+str(id_step)+'.npy')[0,:,:]/N_rpn
+        t = time.time()
+        for i in range(N_rpn-1):
+            print(id_step,i,N_rpn-1)
+            samples_test_H = samples_test_H +onp.load('MF_param/MF_param_'+str(i+1)+'/test_pred_'+str(id_step)+'.npy')[0,:,:]/N_rpn
+            print(time.time()-t)
+            t = time.time()
+        samples_test_H = mu_SF_out + sigma_SF_out * samples_test_H
+        onp.save('MF_param/mean_RPN_MF_'+str(id_step)+'.npy',samples_test_H)
+    else: # RPN std computation
+        mu = onp.load('MF_param/mean_RPN_MF_'+str(id_step)+'.npy')
+        
+        sigma = (mu_SF_out + onp.load('MF_param/MF_param_'+str(0)+'/test_pred_'+str(id_step)+'.npy')[0,:,:] * sigma_SF_out - mu)**2/N_rpn
+        t = time.time()
+        for i in range(N_rpn-1):
+            print(id_step,i,N_rpn-1)
+            sigma = sigma + (mu_SF_out + onp.load('MF_param/MF_param_'+str(0)+'/test_pred_'+str(id_step)+'.npy')[0,:,:] * sigma_SF_out - mu)**2/N_rpn
+            print(time.time()-t)
+            t = time.time()
+        sigma = onp.sqrt(sigma)
+        onp.save('MF_param/std_RPN_MF_'+str(id_step)+'.npy',sigma)
+
+if is_SF == 1:
+    mu_SF_out = onp.concatenate((onp.load('norm/mu_y_heat_SPCAM5.npy')[None,ind_output_heat],
+                                 onp.load('norm/mu_y_moist_SPCAM5.npy')[None,ind_output_moist]),axis=1)
+    sigma_SF_out = onp.concatenate((onp.load('norm/sigma_y_heat_SPCAM5.npy')[None,ind_output_heat],
+                                    onp.load('norm/sigma_y_moist_SPCAM5.npy')[None,ind_output_moist]),axis=1)
+    
+    is_comp_mean = 1
+    N_rpn = 128
+    print('loading data')
+    
+    if is_comp_mean == 1: # RPN mean computation
+        samples_test_H = onp.concatenate( (onp.load('SF_param/SF_param_'+str(0)+'/test_pred_1.npy'),
+                                          onp.load('SF_param/SF_param_'+str(0)+'/test_pred_2.npy')), axis=1)[0,:,:]/N_rpn
+        t = time.time()
+        for i in range(N_rpn-1):
+            print(i,N_rpn-1)
+            samples_test_H = samples_test_H + onp.concatenate( (onp.load('SF_param/SF_param_'+str(i+1)+'/test_pred_1.npy'),
+                                                                onp.load('SF_param/SF_param_'+str(i+1)+'/test_pred_2.npy')), axis=1)[0,:,:]/N_rpn
+            print(time.time()-t)
+            t = time.time()
+        samples_test_H = mu_SF_out + sigma_SF_out * samples_test_H
+        onp.save('SF_param/mean_RPN_SF.npy',samples_test_H)
+    else: # RPN std computation
+        mu = onp.load('SF_param/mean_RPN_SF.npy')
+        sigma = (mu_SF_out + onp.concatenate( (onp.load('SF_param/SF_param_'+str(0)+'/test_pred_1.npy'),
+                                               onp.load('SF_param/SF_param_'+str(0)+'/test_pred_2.npy')), axis=1)[0,:,:] * sigma_SF_out - mu)**2/N_rpn
+        t = time.time()
+        for i in range(N_rpn-1):
+            print(i,N_rpn-1)
+            sigma = sigma + (mu_SF_out + onp.concatenate( (onp.load('SF_param/SF_param_'+str(i+1)+'/test_pred_1.npy'),
+                                                           onp.load('SF_param/SF_param_'+str(i+1)+'/test_pred_2.npy')), axis=1)[0,:,:] * sigma_SF_out - mu)**2/N_rpn
+            print(time.time()-t)
+            t = time.time()
+        sigma = onp.sqrt(sigma)
+        onp.save('SF_param/std_RPN_SF.npy',sigma)
+
+if is_LF == 1:
+    mu_MF_out = onp.concatenate((onp.load('norm/mu_y_heat_CAM5.npy')[None,ind_output_heat],
+                                 onp.load('norm/mu_y_moist_CAM5.npy')[None,ind_output_moist]),axis=1)
+    sigma_MF_out = onp.concatenate((onp.load('norm/sigma_y_heat_CAM5.npy')[None,ind_output_heat],
+                                    onp.load('norm/sigma_y_moist_CAM5.npy')[None,ind_output_moist]),axis=1)
+    
+    is_comp_mean = 1
+    id_step = 2
+    N_rpn = 128
+    print('loading data')
+    
+    if is_comp_mean == 1: # RPN mean computation
+        samples_test_H = onp.load('MF_param/MF_param_'+str(0)+'/LF_test_pred_'+str(id_step)+'.npy')[0,:,:]/N_rpn
+        t = time.time()
+        for i in range(N_rpn-1):
+            print(id_step,i,N_rpn-1)
+            samples_test_H = samples_test_H + onp.load('MF_param/MF_param_'+str(i+1)+'/LF_test_pred_'+str(id_step)+'.npy')[0,:,:]/N_rpn
+            print(time.time()-t)
+            t = time.time()
+        samples_test_H = mu_MF_out + sigma_MF_out * samples_test_H
+        onp.save('MF_param/mean_RPN_LF_'+str(id_step)+'.npy',samples_test_H)
+    else: # RPN std computation
+        mu = onp.load('MF_param/mean_RPN_LF_'+str(id_step)+'.npy')
+        
+        sigma = (mu_MF_out + onp.load('MF_param/MF_param_'+str(0)+'/LF_test_pred_'+str(id_step)+'.npy')[0,:,:] * sigma_MF_out - mu)**2/N_rpn
+        t = time.time()
+        for i in range(N_rpn-1):
+            print(id_step,i,N_rpn-1)
+            sigma = sigma + (mu_MF_out + onp.load('MF_param/MF_param_'+str(i+1)+'/LF_test_pred_'+str(id_step)+'.npy')[0,:,:] * sigma_MF_out - mu)**2/N_rpn
+            print(time.time()-t)
+            t = time.time()
+        sigma = onp.sqrt(sigma)
+        onp.save('MF_param/std_RPN_LF_'+str(id_step)+'.npy',sigma)
+    

5_mean_std_RPN_SF.py

@@ -0,0 +1,57 @@
+#!/usr/bin/env python3
+# -*- coding: utf-8 -*-
+"""
+Created on Thu May 4 20:12:05 2023
+
+@author: mohamedazizbhouri
+"""
+
+import numpy as onp
+import time
+
+n_remove = 4
+ind_input = onp.concatenate( (onp.arange(26),n_remove+26+onp.arange(26-n_remove),onp.array([52,53,54,55])) ) 
+dim_xH = ind_input.shape[0]
+dim_xL = ind_input.shape[0]
+
+ind_output_heat = onp.arange(26)
+ind_output_moist = n_remove+onp.arange(26-n_remove)
+
+dim_yH = ind_output_heat.shape[0]+ind_output_moist.shape[0]
+dim_yL = ind_output_heat.shape[0]+ind_output_moist.shape[0]
+
+mu_SF_out = onp.concatenate((onp.load('norm/mu_y_heat_SPCAM5.npy')[None,ind_output_heat],
+                             onp.load('norm/mu_y_moist_SPCAM5.npy')[None,ind_output_moist]),axis=1)
+sigma_SF_out = onp.concatenate((onp.load('norm/sigma_y_heat_SPCAM5.npy')[None,ind_output_heat],
+                                onp.load('norm/sigma_y_moist_SPCAM5.npy')[None,ind_output_moist]),axis=1)
+
+is_comp_mean = 1
+N_rpn = 128
+print('loading data')
+
+if is_comp_mean == 1: # RPN mean computation
+    samples_test_H = onp.concatenate( (onp.load('SF_param/SF_param_'+str(0)+'/test_pred_1.npy'),
+                                      onp.load('SF_param/SF_param_'+str(0)+'/test_pred_2.npy')), axis=1)[0,:,:]/N_rpn
+    t = time.time()
+    for i in range(N_rpn-1):
+        print(i,N_rpn-1)
+        samples_test_H = samples_test_H + onp.concatenate( (onp.load('SF_param/SF_param_'+str(i+1)+'/test_pred_1.npy'),
+                                                            onp.load('SF_param/SF_param_'+str(i+1)+'/test_pred_2.npy')), axis=1)[0,:,:]/N_rpn
+        print(time.time()-t)
+        t = time.time()
+    samples_test_H = mu_SF_out + sigma_SF_out * samples_test_H
+    onp.save('SF_param/mean_RPN_SF.npy',samples_test_H)
+else: # RPN std computation
+    mu = onp.load('SF_param/mean_RPN_SF.npy')
+    sigma = (mu_SF_out + onp.concatenate( (onp.load('SF_param/SF_param_'+str(0)+'/test_pred_1.npy'),
+                                           onp.load('SF_param/SF_param_'+str(0)+'/test_pred_2.npy')), axis=1)[0,:,:] * sigma_SF_out - mu)**2/N_rpn
+    t = time.time()
+    for i in range(N_rpn-1):
+        print(i,N_rpn-1)
+        sigma = sigma + (mu_SF_out + onp.concatenate( (onp.load('SF_param/SF_param_'+str(i+1)+'/test_pred_1.npy'),
+                                                       onp.load('SF_param/SF_param_'+str(i+1)+'/test_pred_2.npy')), axis=1)[0,:,:] * sigma_SF_out - mu)**2/N_rpn
+        print(time.time()-t)
+        t = time.time()
+    sigma = onp.sqrt(sigma)
+    onp.save('SF_param/std_RPN_SF.npy',sigma)
+    

6_reshape_pred_RPN.py

@@ -0,0 +1,110 @@
+#!/usr/bin/env python3
+# -*- coding: utf-8 -*-
+"""
+Created on Sat May 27 20:02:33 2023
+
+@author: mohamedazizbhouri
+"""
+import numpy as onp
+
+lat = 96
+lon = 144
+dim_y = 48
+
+is_create_Npts_per_file = 0
+
+is_det = 0
+is_rpn_SF = 0
+is_rpn_MF = 0
+is_test_data = 0
+is_LF = 1
+
+test_SPCAM =['2003_02_06','2003_02_12','2003_02_18','2003_02_24','2003_02_28',
+              '2003_03_06','2003_03_12','2003_03_18','2003_03_24','2003_03_30','2003_03_31',
+              '2003_04_06','2003_04_12','2003_04_18','2003_04_24','2003_04_30',
+              '2003_05_06','2003_05_12','2003_05_18','2003_05_24','2003_05_30','2003_05_31',
+              '2003_06_06','2003_06_12','2003_06_18','2003_06_24','2003_06_30',
+              '2003_07_06','2003_07_12','2003_07_18','2003_07_24','2003_07_30','2003_07_31',
+              '2003_08_06','2003_08_12','2003_08_18','2003_08_24','2003_08_30','2003_08_31',
+              '2003_09_06','2003_09_12','2003_09_18','2003_09_24','2003_09_30',
+              '2003_10_06','2003_10_12','2003_10_18','2003_10_24','2003_10_30','2003_10_31',
+              '2003_11_06','2003_11_12','2003_11_18','2003_11_24','2003_11_30',
+              '2003_12_06','2003_12_12','2003_12_18','2003_12_24','2003_12_30','2003_12_31',
+              '2004_01_06','2004_01_12','2004_01_18','2004_01_24','2004_01_30','2004_01_31']
+
+if is_create_Npts_per_file == 1:
+    print('create Npts_per_file')
+    Npts_per_file = []
+    for i in range(len(test_SPCAM)):
+        Npts_per_file.append( onp.load('data_SPCAM5_4K/inputs_'+test_SPCAM[i]+'.npy').shape[0] )
+    Npts_per_file = onp.array(Npts_per_file)
+    onp.save('data_SPCAM5_4K/Npts_per_file_test.npy',Npts_per_file)
+    print('Npts_per_file created')
+else:
+    Npts_per_file = onp.load('data_SPCAM5_4K/Npts_per_file_test.npy')
+    
+def reshape_loc_onp(pred, dim_y):
+    pred_loc = pred[:Npts_per_file[0],:]
+    pred = pred[Npts_per_file[0]:,:]
+    nt_total = pred_loc.shape[0]//(lat*lon)
+    pred_array = onp.reshape(pred_loc.T, (dim_y,nt_total,lat,lon))
+    
+    for i in range(len(test_SPCAM)-1):
+        print(i,len(test_SPCAM)-1)
+        pred_loc = pred[:Npts_per_file[i+1],:]
+        pred = pred[Npts_per_file[i+1]:,:]
+        nt_total = pred_loc.shape[0]//(lat*lon)
+        
+        pred_array = onp.concatenate( (pred_array, onp.reshape(pred_loc.T, (dim_y,nt_total,lat,lon))),axis=1)
+    return pred_array
+    
+if is_det == 1:
+    print('load and reshape det')
+    n_run = 128
+    case_var = 'all'
+    samples_test_H = reshape_loc_onp( onp.concatenate( (onp.load('SF_param/SF_param_det/test_pred_1.npy')[0,:,:],
+                                                        onp.load('SF_param/SF_param_det/test_pred_2.npy')[0,:,:]), axis=0 ), dim_y )
+    onp.save('SF_param/SF_param_det/test_pred_reshaped.npy', samples_test_H)
+
+if is_LF == 1:
+    print('load and reshape det')
+    
+    mean_rpn_LF = reshape_loc_onp( onp.concatenate( (onp.load('MF_param/mean_RPN_LF_1.npy'),
+                                                  onp.load('MF_param/mean_RPN_LF_2.npy')), axis=0), dim_y ) # dim_y x nt x lon x lat
+    std_rpn_LF = reshape_loc_onp( onp.concatenate( (onp.load('MF_param/std_RPN_LF_1.npy'),
+                                                  onp.load('MF_param/std_RPN_LF_2.npy')), axis=0), dim_y ) # dim_y x nt x lon x lat
+    
+    onp.save('MF_param/mean_RPN_LF_reshaped.npy', mean_rpn_LF)
+    onp.save('MF_param/std_RPN_LF_reshaped.npy', std_rpn_LF)
+        
+if is_rpn_SF == 1:
+    print('load and reshape rpn SF')
+    mean_rpn = reshape_loc_onp( onp.load('SF_param/mean_RPN_SF.npy'), dim_y ) # dim_y x nt x lon x lat
+    std_rpn = reshape_loc_onp( onp.load('SF_param/std_RPN_SF.npy'), dim_y )
+    
+    onp.save('SF_param/mean_RPN_SF_reshaped.npy', mean_rpn)
+    onp.save('SF_param/std_RPN_SF_reshaped.npy', std_rpn)
+    
+if is_rpn_MF == 1:
+    print('load and reshape rpn MF')
+    mean_rpn_MF = reshape_loc_onp( onp.concatenate( (onp.load('MF_param/mean_RPN_MF_1.npy'),
+                                                  onp.load('MF_param/mean_RPN_MF_2.npy')), axis=0), dim_y ) # dim_y x nt x lon x lat
+    std_rpn_MF = reshape_loc_onp( onp.concatenate( (onp.load('MF_param/std_RPN_MF_1.npy'),
+                                                  onp.load('MF_param/std_RPN_MF_2.npy')), axis=0), dim_y ) # dim_y x nt x lon x lat
+    
+    onp.save('MF_param/mean_RPN_MF_reshaped.npy', mean_rpn_MF)
+    onp.save('MF_param/std_RPN_MF_reshaped.npy', std_rpn_MF)
+    
+if is_test_data == 1:
+    print('load and reshape test')
+
+    n_remove = 4
+    ind_output_heat = onp.arange(26) 
+    ind_output_moist = n_remove+onp.arange(26-n_remove)
+    test_yH = onp.concatenate((onp.load('data_SPCAM5_4K/all_outputs_heat.npy')[:,ind_output_heat],
+                               onp.load('data_SPCAM5_4K/all_outputs_moist.npy')[:,ind_output_moist]),axis=1)
+    
+    test_yH = reshape_loc_onp(test_yH, dim_y)
+    
+    onp.save('data_SPCAM5_4K/all_outputs_reshaped.npy', test_yH)
+    

7_global_crps.py

@@ -0,0 +1,220 @@
+#!/usr/bin/env python3
+# -*- coding: utf-8 -*-
+"""
+Created on Mon Aug 7 14:20:34 2023
+
+@author: mohamedazizbhouri
+"""
+
+import numpy as onp
+import time
+
+from matplotlib import pyplot as plt
+plt.close('all')
+
+plt.rcParams.update(plt.rcParamsDefault)
+plt.rc('font', family='serif')
+plt.rcParams.update({'font.size': 32,
+                     'lines.linewidth': 2,
+                     'axes.labelsize': 32,
+                     'axes.titlesize': 32,
+                     'xtick.labelsize': 32,
+                     'ytick.labelsize': 32,
+                     'legend.fontsize': 32,
+                     'axes.linewidth': 2,
+                     "pgf.texsystem": "pdflatex"
+                     })
+
+dim_y = 48 
+dim_heat = 26
+dim_moist = 22
+n_remove = 4
+ind_input = onp.concatenate( (onp.arange(26),n_remove+26+onp.arange(26-n_remove),onp.array([52,53,54,55])) ) 
+dim_xH = ind_input.shape[0]
+dim_xL = ind_input.shape[0]
+
+ind_output_heat = onp.arange(26)
+ind_output_moist = n_remove+onp.arange(26-n_remove)
+    
+mu_error_out = onp.concatenate((onp.zeros((1,dim_heat),dtype=onp.float32),
+                                onp.zeros((1,dim_moist),dtype=onp.float32)),axis=1)
+
+sigma_error_out = onp.concatenate((1/1004.6*onp.ones((1,dim_heat),dtype=onp.float32),
+                                    1/2.26e6*onp.ones((1,dim_moist),dtype=onp.float32)),axis=1)
+
+is_reshape_single_pred = 1
+
+is_MF = 0
+is_LF = 0
+is_SF = 1
+
+if is_reshape_single_pred == 1:
+    
+    test_SPCAM =['2003_02_06','2003_02_12','2003_02_18','2003_02_24','2003_02_28',
+              '2003_03_06','2003_03_12','2003_03_18','2003_03_24','2003_03_30','2003_03_31',
+              '2003_04_06','2003_04_12','2003_04_18','2003_04_24','2003_04_30',
+              '2003_05_06','2003_05_12','2003_05_18','2003_05_24','2003_05_30','2003_05_31',
+              '2003_06_06','2003_06_12','2003_06_18','2003_06_24','2003_06_30',
+              '2003_07_06','2003_07_12','2003_07_18','2003_07_24','2003_07_30','2003_07_31',
+              '2003_08_06','2003_08_12','2003_08_18','2003_08_24','2003_08_30','2003_08_31',
+              '2003_09_06','2003_09_12','2003_09_18','2003_09_24','2003_09_30',
+              '2003_10_06','2003_10_12','2003_10_18','2003_10_24','2003_10_30','2003_10_31',
+              '2003_11_06','2003_11_12','2003_11_18','2003_11_24','2003_11_30',
+              '2003_12_06','2003_12_12','2003_12_18','2003_12_24','2003_12_30','2003_12_31',
+              '2004_01_06','2004_01_12','2004_01_18','2004_01_24','2004_01_30','2004_01_31']
+
+    Npts_per_file = onp.load('data_SPCAM5_4K/Npts_per_file_test.npy')
+        
+    def reshape_loc_onp(pred, dim_y):
+        pred_loc = pred[:Npts_per_file[0],:]
+        pred = pred[Npts_per_file[0]:,:]
+        nt_total = pred_loc.shape[0]//(lat*lon)
+        pred_array = onp.reshape(pred_loc.T, (dim_y,nt_total,lat,lon))
+        
+        for i in range(len(test_SPCAM)-1):
+            print(i,len(test_SPCAM)-1)
+            pred_loc = pred[:Npts_per_file[i+1],:]
+            pred = pred[Npts_per_file[i+1]:,:]
+            nt_total = pred_loc.shape[0]//(lat*lon)
+            
+            pred_array = onp.concatenate( (pred_array, onp.reshape(pred_loc.T, (dim_y,nt_total,lat,lon))),axis=1)
+        return pred_array 
+
+    case_var = 'all'
+    lat = 96
+    lon = 144
+    N_dt_day = 24 # we have a dt=1hour
+    def daily_avg(test):
+        test_daily = []
+        N_time_steps = test.shape[1]
+        for i in range(test.shape[0]):
+            test_daily.append( onp.mean( test[i,:,:,:].reshape( (N_time_steps//N_dt_day, N_dt_day, lat, lon) ), axis=1 ) )
+        return onp.array(test_daily) # dim_y x N_day x lat x lon
+      
+    if is_MF == 1 or is_LF == 1:
+        mu_SF_out = onp.concatenate((onp.load('norm/mu_y_heat_CAM5.npy')[None,ind_output_heat],
+                                     onp.load('norm/mu_y_moist_CAM5.npy')[None,ind_output_moist]),axis=1)
+        sigma_SF_out = onp.concatenate((onp.load('norm/sigma_y_heat_CAM5.npy')[None,ind_output_heat],
+                                        onp.load('norm/sigma_y_moist_CAM5.npy')[None,ind_output_moist]),axis=1)
+    
+    if is_SF == 1:
+        mu_SF_out = onp.concatenate((onp.load('norm/mu_y_heat_SPCAM5.npy')[None,ind_output_heat],
+                                     onp.load('norm/mu_y_moist_SPCAM5.npy')[None,ind_output_moist]),axis=1)
+        sigma_SF_out = onp.concatenate((onp.load('norm/sigma_y_heat_SPCAM5.npy')[None,ind_output_heat],
+                                        onp.load('norm/sigma_y_moist_SPCAM5.npy')[None,ind_output_moist]),axis=1)
+    
+    tt = time.time()
+    for i in range(32):
+        ieff = i + 0
+        print(ieff,time.time()-tt)
+        tt = time.time()
+        if is_MF == 1:
+            samples_test_H = onp.concatenate( (onp.load('MF_param/MF_param_'+str(ieff)+'/test_pred_1.npy')[0,:,:],
+                                               onp.load('MF_param/MF_param_'+str(ieff)+'/test_pred_2.npy')[0,:,:]),axis=0)
+        if is_SF == 1:
+            samples_test_H = onp.concatenate( (onp.load('SF_param/SF_param_'+str(ieff)+'/test_pred_1.npy')[0,:,:],
+                                               onp.load('SF_param/SF_param_'+str(ieff)+'/test_pred_1.npy')[0,:,:]),axis=0)
+        if is_LF == 1:
+            samples_test_H = onp.concatenate( (onp.load('MF_param/MF_param_'+str(ieff)+'/LF_test_pred_1.npy')[0,:,:],
+                                               onp.load('MF_param/MF_param_'+str(ieff)+'/LF_test_pred_2.npy')[0,:,:]),axis=0)
+        samples_test_H = mu_SF_out + sigma_SF_out * samples_test_H
+        samples_test_H = (samples_test_H - mu_error_out) / sigma_error_out
+        
+        samples_test_H = reshape_loc_onp(samples_test_H, dim_y)
+        samples_test_H = daily_avg(samples_test_H)
+        samples_test_H = samples_test_H.reshape((dim_y, samples_test_H.shape[1]*lat*lon))
+        samples_test_H = samples_test_H.T
+        print(samples_test_H.shape)
+        # Npts x dim_y
+        if is_MF == 1:
+            onp.save('MF_param/MF_param_'+str(ieff)+'/test_pred_reshaped.npy', samples_test_H)
+        if is_SF == 1:
+            onp.save('SF_param/SF_param_'+str(ieff)+'/test_pred_reshaped.npy', samples_test_H)
+        if is_LF == 1:
+            onp.save('MF_param/MF_param_'+str(ieff)+'/LF_test_pred_reshaped.npy', samples_test_H)
+    
+    test = onp.load('data_SPCAM5_4K/all_outputs_reshaped.npy')
+    test = daily_avg(test)
+    test = test.reshape((dim_y, test.shape[1]*lat*lon)) # dim_y x N_samples
+    test = test.T
+    test = (test - mu_error_out) / sigma_error_out
+    onp.save('data_SPCAM5_4K/all_outputs_reshaped_temp_avg.npy', test)
+
+else:
+    
+    test = onp.load('data_SPCAM5_4K/all_outputs_reshaped_temp_avg.npy')
+    test = onp.array(test,dtype=onp.float64)
+         
+    def crps(outputs, target, weights=None):
+        """
+        Computes the Continuous Ranked Probability Score (CRPS) between the target and the ecdf for each output variable and then takes a weighted average over them.
+    
+        Input
+        -----
+        outputs - float[B, F, S] samples from the model
+        target - float[B, F] ground truth target
+        """
+        tt = time.time()
+        n = outputs.shape[2]
+        y_hats = onp.sort(outputs, axis=-1)
+        print('sort',time.time()-tt)
+        
+        tt = time.time()
+        # E[Y - y]
+        mae = onp.abs(target[..., None] - y_hats).mean(axis=(0, -1))
+        print('abs',time.time()-tt)
+        
+        tt = time.time()
+        # E[Y - Y'] ~= sum_i sum_j |Y_i - Y_j| / (2 * n * (n-1))
+        diff = y_hats[..., 1:] - y_hats[..., :-1]
+        print('abs2',time.time()-tt)
+        
+        tt = time.time()
+        count = onp.arange(1, n) * onp.arange(n - 1, 0, -1)
+        print('arange',time.time()-tt)
+        
+        tt = time.time()
+        crps = mae - (diff * count).sum(axis=-1).mean(axis=0) / (2 * n * (n-1))
+        print('crps final',time.time()-tt)
+        return crps
+    
+    if is_MF == 1:
+        ieff = 0
+        pred_daily = onp.load('MF_param/MF_param_'+str(ieff)+'/test_pred_reshaped.npy')[:,:,None]
+        for i in range(31):
+            print(i)
+            ieff = i+1
+            pred_daily = onp.concatenate( (pred_daily,onp.load('MF_param/MF_param_'+str(ieff)+'/test_pred_reshaped.npy')[:,:,None]),axis=2)
+        pred_daily = onp.array(pred_daily,dtype=onp.float64)
+    
+        crps_f = crps(pred_daily, test)
+        onp.save('glob_errors/crps_rpn_MF.npy',crps_f)
+    
+    if is_SF == 1:
+        ieff = 0
+        pred_daily = onp.load('SF_param/SF_param_'+str(ieff)+'/test_pred_reshaped.npy')[:,:,None]
+        for i in range(31):
+            print(i)
+            ieff = i+1
+            pred_daily = onp.concatenate( (pred_daily,onp.load('SF_param/SF_param_'+str(ieff)+'/test_pred_reshaped.npy')[:,:,None]),axis=2)
+        pred_daily = onp.array(pred_daily,dtype=onp.float64)
+    
+        crps_f = crps(pred_daily, test)
+        print(crps_f.shape)
+        print(onp.array(crps_f).shape)
+        onp.save('glob_errors/crps_rpn_SF.npy',crps_f)
+    
+    if is_LF == 1:
+        ieff = 0
+        pred_daily = onp.load('MF_param/MF_param_'+str(ieff)+'/LF_test_pred_reshaped.npy')[:,:,None]
+        for i in range(31):
+            print(i)
+            ieff = i+1
+            pred_daily = onp.concatenate( (pred_daily,onp.load('MF_param/MF_param_'+str(ieff)+'/LF_test_pred_reshaped.npy')[:,:,None]),axis=2)
+        pred_daily = onp.array(pred_daily,dtype=onp.float64)
+    
+        crps_f = crps(pred_daily, test)
+        print(crps_f.shape)
+        print(onp.array(crps_f).shape)
+        onp.save('glob_errors/crps_rpn_LF.npy',crps_f)
+      

7_global_errors_temporal_errors.py

@@ -0,0 +1,163 @@
+#!/usr/bin/env python3
+# -*- coding: utf-8 -*-
+"""
+Created on Sat May 27 20:48:41 2023
+
+@author: mohamedazizbhouri
+"""
+from matplotlib import pyplot as plt
+import numpy as onp
+
+plt.rcParams.update(plt.rcParamsDefault)
+plt.rc('font', family='serif')
+plt.rcParams.update({'font.size': 32,
+                     'lines.linewidth': 2,
+                     'axes.labelsize': 32, 
+                     'axes.titlesize': 32,
+                     'xtick.labelsize': 32,
+                     'ytick.labelsize': 32,
+                     'legend.fontsize': 32,
+                     'axes.linewidth': 2,
+                     "pgf.texsystem": "pdflatex"
+                     })
+plt.close('all')
+
+lat = 96
+lon = 144
+
+is_glob_err = 0
+is_temp_MAE = 0
+is_temp_r2 = 1
+
+dim_y = 48
+dim_heat = 26
+dim_moist = 22
+
+mu_error_out = onp.concatenate((onp.zeros((1,dim_heat),dtype=onp.float32),
+                                onp.zeros((1,dim_moist),dtype=onp.float32)),axis=1)
+mu_error_out = mu_error_out.T[:,:,None,None]
+
+sigma_error_out = onp.concatenate((1/1004.6*onp.ones((1,dim_heat),dtype=onp.float32),
+                                    1/2.26e6*onp.ones((1,dim_moist),dtype=onp.float32)),axis=1)
+    
+sigma_error_out = sigma_error_out.T[:,:,None,None]
+
+test = (onp.load('data_SPCAM5_4K/all_outputs_reshaped.npy') - mu_error_out) / sigma_error_out
+test = onp.array(test,dtype=onp.float64)
+
+n_run = 128
+pred_det = (onp.load('SF_param/SF_param_det/test_pred_reshaped.npy') - mu_error_out) / sigma_error_out
+pred_det = onp.array(pred_det,dtype=onp.float64)
+    
+pred_rpn = onp.load('SF_param/mean_RPN_SF_reshaped.npy')
+pred_rpn = (pred_rpn - mu_error_out) / sigma_error_out
+pred_rpn = onp.array(pred_rpn,dtype=onp.float64)
+
+pred_rpn_MF = onp.load('MF_param/mean_RPN_MF_reshaped.npy')
+pred_rpn_MF = (pred_rpn_MF - mu_error_out) / sigma_error_out
+pred_rpn_MF = onp.array(pred_rpn_MF,dtype=onp.float64)
+
+pred_rpn_LF = onp.load('MF_param/mean_RPN_LF_reshaped.npy')
+pred_rpn_LF = (pred_rpn_LF - mu_error_out) / sigma_error_out
+pred_rpn_LF = onp.array(pred_rpn_LF,dtype=onp.float64)
+
+N_dt_day = 24 # we have a dt=1hour
+def daily_avg(test):
+    test_daily = []
+    N_time_steps = test.shape[1]
+    for i in range(test.shape[0]):
+        test_daily.append( onp.mean( test[i,:,:,:].reshape( (N_time_steps//N_dt_day, N_dt_day, lat, lon) ), axis=1 ) )
+    return onp.array(test_daily) # dim_y x N_day x lat x lon
+pred_det = daily_avg(pred_det)
+pred_rpn = daily_avg(pred_rpn)
+pred_rpn_MF = daily_avg(pred_rpn_MF)
+pred_rpn_LF = daily_avg(pred_rpn_LF)
+test = daily_avg(test)
+
+if is_glob_err == 1:
+    MAE_det = onp.mean(onp.abs(pred_det-test),axis=(1,2,3)) # dim_y x nt
+    MAE_rpn_SF = onp.mean(onp.abs(pred_rpn-test),axis=(1,2,3)) # dim_y x nt
+    MAE_rpn_MF = onp.mean( onp.abs(pred_rpn_MF - test) ,axis=(1,2,3)) 
+    MAE_rpn_LF = onp.mean( onp.abs(pred_rpn_LF - test) ,axis=(1,2,3)) 
+    
+    onp.save('glob_errors/MAE_det.npy',MAE_det)
+    onp.save('glob_errors/MAE_rpn_SF.npy',MAE_rpn_SF)
+    onp.save('glob_errors/MAE_rpn_MF.npy',MAE_rpn_MF)
+    onp.save('glob_errors/MAE_rpn_LF.npy',MAE_rpn_LF)
+    
+    r2_det = 1 - onp.sum( (test-pred_det)**2, axis=(1,2,3) ) / onp.sum( (test-onp.mean(test,axis=(1,2,3))[:,None,None,None])**2, axis=(1,2,3) )
+    r2_rpn = 1 - onp.sum( (test-pred_rpn)**2, axis=(1,2,3) ) / onp.sum( (test-onp.mean(test,axis=(1,2,3))[:,None,None,None])**2, axis=(1,2,3) )
+    r2_rpn_MF = 1 - onp.sum( (test-pred_rpn_MF)**2, axis=(1,2,3) ) / onp.sum( (test-onp.mean(test,axis=(1,2,3))[:,None,None,None])**2, axis=(1,2,3) )
+    r2_rpn_LF = 1 - onp.sum( (test-pred_rpn_LF)**2, axis=(1,2,3) ) / onp.sum( (test-onp.mean(test,axis=(1,2,3))[:,None,None,None])**2, axis=(1,2,3) )
+    
+    onp.save('glob_errors/r2_det.npy',r2_det)
+    onp.save('glob_errors/r2_rpn_SF.npy',r2_rpn)
+    onp.save('glob_errors/r2_rpn_MF.npy',r2_rpn_MF)
+    onp.save('glob_errors/r2_rpn_LF.npy',r2_rpn_LF)
+    
+if is_temp_MAE == 1:
+    x_labels = ['02/2003','03/2003','04/2003','05/2003','06/2003','07/2003',
+                '08/2003','09/2003','10/2003','11/2003','12/2003','01/2004','02/2004']
+    
+    print('Compute MAE')
+    err_det = onp.mean(onp.abs(pred_det-test),axis=(2,3)) # dim_y x nt
+    err_rpn = onp.mean(onp.abs(pred_rpn-test),axis=(2,3)) # dim_y x nt
+    err_rpn_MF = onp.mean( onp.abs(pred_rpn_MF - test) ,axis=(2,3)) 
+    err_rpn_LF = onp.mean( onp.abs(pred_rpn_LF - test) ,axis=(2,3)) 
+    
+    for i in range(dim_y):
+        fig = plt.figure(figsize=(15,8))
+        ax = fig.add_subplot(111)
+        x_labels = ['02/2003','03/2003','04/2003','05/2003','06/2003','07/2003',
+                    '08/2003','09/2003','10/2003','11/2003','12/2003','01/2004','02/2004']
+        ax.set_xticks(onp.linspace(0,err_det.shape[1]-1,13))
+        ax.set_xticklabels(x_labels, rotation =45, fontsize=22)
+        ax.yaxis.set_tick_params(labelsize=22)
+        ax.plot(onp.arange(err_det.shape[1]), err_det[i,:], color='blue', linewidth=3, label = "Det. NN")
+        ax.plot(onp.arange(err_det.shape[1]), err_rpn[i,:], '--', color='black', linewidth=3, label = "SF-RPN")
+        ax.plot(onp.arange(err_det.shape[1]), err_rpn_LF[i,:], '--', color='orange', linewidth=3, label = "LF-RPN")
+        ax.plot(onp.arange(err_det.shape[1]), err_rpn_MF[i,:], color='red', linewidth=3, label = "MF-RPN")
+        ax.set_ylabel('MAE')
+        ax.set_xlabel('Time')
+        ax.grid()
+        ax.legend(bbox_to_anchor=[0.5, 1.2], loc='center', ncol=4)
+
+        if i > 25:
+            plt.savefig('temp_plots/moist_MAE_temp_'+str(i-26+4)+'.png', bbox_inches='tight', pad_inches=0.1 , dpi = 300)
+            
+        else:
+            plt.savefig('temp_plots/heat_MAE_temp_'+str(i)+'.png', bbox_inches='tight', pad_inches=0.1 , dpi = 300)
+
+if is_temp_r2 == 1:
+    x_labels = ['02/2003','03/2003','04/2003','05/2003','06/2003','07/2003',
+                '08/2003','09/2003','10/2003','11/2003','12/2003','01/2004','02/2004']
+    
+    print('Compute R^2')
+    r2_det = 1 - onp.sum( (test-pred_det)**2, axis=(2,3) ) / onp.sum( (test-onp.mean(test,axis=(2,3))[:,:,None,None])**2, axis=(2,3) )
+    r2_rpn_SF = 1 - onp.sum( (test-pred_rpn)**2, axis=(2,3) ) / onp.sum( (test-onp.mean(test,axis=(2,3))[:,:,None,None])**2, axis=(2,3) )
+    r2_rpn_MF = 1 - onp.sum( (test-pred_rpn_MF)**2, axis=(2,3) ) / onp.sum( (test-onp.mean(test,axis=(2,3))[:,:,None,None])**2, axis=(2,3) )
+    r2_rpn_LF = 1 - onp.sum( (test-pred_rpn_LF)**2, axis=(2,3) ) / onp.sum( (test-onp.mean(test,axis=(2,3))[:,:,None,None])**2, axis=(2,3) )
+    
+    for i in range(dim_y):
+        fig = plt.figure(figsize=(15,8))
+        ax = fig.add_subplot(111)
+        
+        ax.set_xticks(onp.linspace(0,r2_det.shape[1]-1,13))
+        ax.set_xticklabels(x_labels, rotation =45, fontsize=22)
+        ax.yaxis.set_tick_params(labelsize=22)
+        ax.plot(onp.arange(r2_det.shape[1]), r2_det[i,:], color='blue', linewidth=3, label = "Det. NN")
+        ax.plot(onp.arange(r2_det.shape[1]), r2_rpn_SF[i,:], '--', color='black', linewidth=3, label = "SF-RPN")
+        ax.plot(onp.arange(r2_det.shape[1]), r2_rpn_LF[i,:], '--', color='orange', linewidth=3, label = "LF-RPN")
+        ax.plot(onp.arange(r2_det.shape[1]), r2_rpn_MF[i,:], color='red', linewidth=3, label = "MF-RPN")
+        ax.set_ylabel('$R^2$')
+        ax.set_xlabel('Time')
+        ax.grid()
+        ax.legend(bbox_to_anchor=[0.5, 1.2], loc='center', ncol=4)
+        
+        if i > 25:
+            plt.savefig('temp_plots/moist_r2_temp_'+str(i-26+4)+'.png', bbox_inches='tight', pad_inches=0.1 , dpi = 300)
+            
+        else:
+            plt.savefig('temp_plots/heat_r2_temp_'+str(i)+'.png', bbox_inches='tight', pad_inches=0.1 , dpi = 300)
+            
+            

7_long_lat_errors.py

@@ -0,0 +1,95 @@
+#!/usr/bin/env python3
+# -*- coding: utf-8 -*-
+"""
+Created on Thu Jun 8 00:59:59 2023
+
+@author: mohamedazizbhouri
+"""
+import numpy as onp
+
+lat = 96
+lon = 144
+
+dim_y = 48 
+dim_heat = 26
+dim_moist = 22
+
+mu_error_out = onp.concatenate((onp.zeros((1,dim_heat),dtype=onp.float32),
+                                onp.zeros((1,dim_moist),dtype=onp.float32)),axis=1)
+mu_error_out = mu_error_out.T[:,:,None,None]
+
+sigma_error_out = onp.concatenate((1/1004.6*onp.ones((1,dim_heat),dtype=onp.float32),
+                                    1/2.26e6*onp.ones((1,dim_moist),dtype=onp.float32)),axis=1)
+    
+sigma_error_out = sigma_error_out.T[:,:,None,None]
+
+is_det = 0
+is_SF = 0
+is_rpn_MF = 0
+is_LF = 1
+
+N_dt_day = 24 # we have a dt=1hour
+
+test = (onp.load('data_SPCAM5_4K/all_outputs_reshaped.npy') - mu_error_out) / sigma_error_out
+test = onp.array(test,dtype=onp.float64)
+
+def daily_avg(test):
+    test_daily = []
+    N_time_steps = test.shape[1]
+    for i in range(test.shape[0]):
+        test_daily.append( onp.mean( test[i,:,:,:].reshape( (N_time_steps//N_dt_day, N_dt_day, lat, lon) ), axis=1 ) )
+    return onp.array(test_daily)
+
+test = daily_avg(test)
+
+if is_det == 1:
+
+    pred = (onp.load('SF_param/SF_param_det/test_pred_reshaped.npy') - mu_error_out) / sigma_error_out
+    pred = onp.array(pred,dtype=onp.float64)
+    pred = daily_avg(pred)
+    print('Compute MAE')
+    err = onp.mean(onp.abs(pred-test),axis=1) # dim_y x lon x lat
+    onp.save('SF_results/MAE_det_long_lat.npy',err)
+    
+    print('Compute R^2')
+    r2 = 1 - onp.sum( (test-pred)**2, axis=1 ) / onp.sum( (test-onp.mean(test,axis=1)[:,None,:,:])**2, axis=1 )
+    onp.save('SF_results/r2_det_long_lat.npy',r2)
+    
+if is_LF == 1:
+    pred = (onp.load('MF_param/mean_RPN_LF_reshaped.npy') - mu_error_out) / sigma_error_out
+    pred = onp.array(pred,dtype=onp.float64)
+    pred = daily_avg(pred)
+    print('Compute MAE')
+    err = onp.mean(onp.abs(pred-test),axis=1) # dim_y x lon x lat
+    onp.save('MF_results/MAE_LF_long_lat.npy',err)
+    
+    print('Compute R^2')
+    r2 = 1 - onp.sum( (test-pred)**2, axis=1 ) / onp.sum( (test-onp.mean(test,axis=1)[:,None,:,:])**2, axis=1 )
+    onp.save('MF_results/r2_LF_long_lat',r2)
+    
+if is_SF == 1:
+    pred = (onp.load('SF_param/mean_RPN_SF_reshaped.npy') - mu_error_out) / sigma_error_out
+    pred = onp.array(pred,dtype=onp.float64)
+    pred = daily_avg(pred)
+    print('Compute MAE')
+    err = onp.mean(onp.abs(pred-test),axis=1) # dim_y x lon x lat
+    onp.save('SF_results/MAE_SF_long_lat.npy', err)
+
+    print('Compute R^2')
+    r2 = 1 - onp.sum( (test-pred)**2, axis=1)/onp.sum( (test-onp.mean(test,axis=1)[:,None,:,:])**2, axis=1)
+    onp.save('SF_results/r2_SF_long_lat.npy', r2)
+    
+if is_rpn_MF == 1:
+    pred = (onp.load('MF_param/mean_RPN_MF_reshaped.npy') - mu_error_out) / sigma_error_out
+    pred = onp.array(pred,dtype=onp.float64)
+    pred = daily_avg(pred)
+    print('Compute MAE')
+    err = onp.mean( onp.abs(pred - test) ,axis=1) 
+    onp.save('MF_results/MAE_MF_long_lat.npy', err)
+    
+    print('Compute R^2')
+    r2 = 1 - onp.sum( (test-pred)**2, axis=1)/onp.sum( (test-onp.mean(test,axis=1)[:,None,:,:])**2, axis=1)
+    onp.save('MF_results/r2_MF_long_lat.npy', r2)
+    
+    
+    

7_pressure_lat_errors.py

@@ -0,0 +1,83 @@
+#!/usr/bin/env python3
+# -*- coding: utf-8 -*-
+"""
+Created on Wed Jun 21 09:14:29 2023
+
+@author: mohamedazizbhouri
+"""
+import numpy as onp
+
+lat = 96
+lon = 144
+
+dim_heat = 26
+dim_moist = 22
+mu_error_out = onp.concatenate((onp.zeros((1,dim_heat),dtype=onp.float32),
+                                onp.zeros((1,dim_moist),dtype=onp.float32)),axis=1)
+mu_error_out = mu_error_out.T[:,:,None,None]
+sigma_error_out = onp.concatenate((1/1004.6*onp.ones((1,dim_heat),dtype=onp.float32),
+                                    1/2.26e6*onp.ones((1,dim_moist),dtype=onp.float32)),axis=1)    
+sigma_error_out = sigma_error_out.T[:,:,None,None]
+
+is_det = 0
+is_SF = 0
+is_MF = 0
+is_LF = 1
+
+N_dt_day = 24 # we have a dt=1hour
+
+test = (onp.load('data_SPCAM5_4K/all_outputs_reshaped.npy') - mu_error_out) / sigma_error_out
+test = onp.array(test,dtype=onp.float64)
+
+def daily_avg(test):
+    test_daily = []
+    N_time_steps = test.shape[1]
+    for i in range(test.shape[0]):
+        test_daily.append( onp.mean( test[i,:,:,:].reshape( (N_time_steps//N_dt_day, N_dt_day, lat, lon) ), axis=1 ) )
+    return onp.array(test_daily)
+
+test = daily_avg(test)
+
+if is_LF == 1:
+    pred = (onp.load('MF_param/mean_RPN_LF_reshaped.npy') - mu_error_out) / sigma_error_out
+    pred = onp.array(pred,dtype=onp.float64)
+    pred = daily_avg(pred)
+    pred = onp.mean(pred, axis = 3)
+    test = onp.mean(test, axis = 3)
+    
+    print('Compute R^2')
+    r2 = 1 - onp.sum( (test-pred)**2, axis=1)/onp.sum( (test-onp.mean(test,axis=1)[:,None,:])**2, axis=1)
+    onp.save('MF_results/r2_LF_pres_lat.npy', r2)
+
+if is_det == 1:
+    pred = (onp.load('SF_param/SF_param_det/test_pred_reshaped.npy') - mu_error_out) / sigma_error_out
+    pred = onp.array(pred,dtype=onp.float64)
+    pred = daily_avg(pred)
+    pred = onp.mean(pred, axis = 3)
+    test = onp.mean(test, axis = 3)
+    
+    print('Compute R^2')
+    r2 = 1 - onp.sum( (test-pred)**2, axis=1)/onp.sum( (test-onp.mean(test,axis=1)[:,None,:])**2, axis=1)
+    onp.save('SF_results/r2_det_pres_lat.npy',r2)
+    
+if is_SF == 1:
+    pred = (onp.load('SF_param/mean_RPN_SF_reshaped.npy') - mu_error_out) / sigma_error_out
+    pred = onp.array(pred,dtype=onp.float64)
+    pred = daily_avg(pred)
+    pred = onp.mean(pred, axis = 3)
+    test = onp.mean(test, axis = 3)
+    
+    print('Compute R^2')
+    r2 = 1 - onp.sum( (test-pred)**2, axis=1)/onp.sum( (test-onp.mean(test,axis=1)[:,None,:])**2, axis=1)
+    onp.save('SF_results/r2_SF_pres_lat.npy', r2)
+    
+if is_MF == 1:
+    pred = (onp.load('MF_param/mean_RPN_MF_reshaped.npy') - mu_error_out) / sigma_error_out
+    pred = onp.array(pred,dtype=onp.float64)
+    pred = daily_avg(pred)
+    pred = onp.mean(pred, axis = 3)
+    test = onp.mean(test, axis = 3)
+    
+    print('Compute R^2')
+    r2 = 1 - onp.sum( (test-pred)**2, axis=1)/onp.sum( (test-onp.mean(test,axis=1)[:,None,:])**2, axis=1)
+    onp.save('MF_results/r2_MF_pres_lat.npy', r2)

8_long_lat_plots.py

@@ -0,0 +1,234 @@
+#!/usr/bin/env python3
+# -*- coding: utf-8 -*-
+"""
+Created on Fri Jun 9 07:14:37 2023
+
+@author: mohamedazizbhouri
+"""
+from matplotlib import pyplot as plt
+import numpy as np
+
+plt.rcParams.update(plt.rcParamsDefault)
+plt.rc('font', family='serif')
+plt.rcParams.update({'font.size': 16,
+                     'lines.linewidth': 2,
+                     'axes.labelsize': 20,
+                     'axes.titlesize': 20,
+                     'xtick.labelsize': 16,
+                     'ytick.labelsize': 16,
+                     'legend.fontsize': 20,
+                     'axes.linewidth': 2,
+                     "pgf.texsystem": "pdflatex"
+                     })
+
+lat = 96
+lon = 144
+x = np.linspace(0, 360-360/144, lon)
+y = np.linspace(-90, 90, lat)
+X, Y = np.meshgrid(x, y)
+
+from mpl_toolkits.basemap import Basemap
+
+dim_y = 26+22 
+
+MAE_det = np.load('SF_results/MAE_det_long_lat.npy')
+r2_det = np.load('SF_results/r2_det_long_lat.npy')
+
+MAE_SF = np.load('SF_results/MAE_SF_long_lat.npy')
+r2_SF = np.load('SF_results/r2_SF_long_lat.npy')
+
+MAE_MF = np.load('MF_results/MAE_MF_long_lat.npy')
+r2_MF = np.load('MF_results/r2_MF_long_lat.npy')
+
+MAE_LF = np.load('MF_results/MAE_LF_long_lat.npy')
+r2_LF = np.load('MF_results/r2_LF_long_lat.npy')
+
+dim_heat = 26
+dim_moist = 22
+mu_error_out = np.concatenate((np.zeros((1,dim_heat),dtype=np.float32),
+                               np.zeros((1,dim_moist),dtype=np.float32)),axis=1)
+mu_error_out = mu_error_out.T[:,:,None,None]
+sigma_error_out = np.concatenate((1/1004.6*np.ones((1,dim_heat),dtype=np.float32),
+                                    1/2.26e6*np.ones((1,dim_moist),dtype=np.float32)),axis=1)
+sigma_error_out = sigma_error_out.T[:,:,None,None]
+
+print('Create err plots')
+
+is_uncert = 1
+is_MAE = 1
+is_R2 = 1
+
+if is_uncert == 1: # uncertainty plots
+    std_rpn_MF = np.load('MF_param/std_RPN_MF_reshaped.npy')/ sigma_error_out 
+    
+    std_rpn_MF = np.mean(std_rpn_MF, axis=1)
+    for i in range(dim_y):
+        fig = plt.figure(figsize=(10.5, 14))        
+        ax = fig.add_subplot(211)
+        ax.set_title("MAE")
+        m = Basemap(projection='robin',lon_0=-180)
+        MAE_MF_p = MAE_MF[i,:,:]
+        contour_plot = m.pcolormesh(X, Y,MAE_MF_p, latlon = True, cmap='Blues_r')
+        m.drawcoastlines(linewidth=2.0, color='0.25')
+        m.colorbar(contour_plot)
+        
+        ax = fig.add_subplot(212)
+        ax.set_title("Uncertainty "+r'$\sigma_M$')
+        m = Basemap(projection='robin',lon_0=-180)
+        std_rpn_MF_p = std_rpn_MF[i,:,:]
+        contour_plot = m.pcolormesh(X, Y, std_rpn_MF_p, latlon = True, cmap='Blues_r')
+        m.drawcoastlines(linewidth=2.0, color='0.25')
+        m.colorbar(contour_plot)
+        
+        plt.subplots_adjust(hspace=-0.35)
+            
+        if i > 25:
+            plt.savefig('long_lat_uncert_plots/MF_moist_long_lat_uncert_'+str(i-26+4)+'.png', bbox_inches='tight', pad_inches=0.1 , dpi = 300)
+            
+        else:
+            plt.savefig('long_lat_uncert_plots/MF_heat_long_lat_uncert_'+str(i)+'.png', bbox_inches='tight', pad_inches=0.1 , dpi = 300)
+
+    std_rpn_SF = np.load('SF_param/std_RPN_SF_reshaped.npy')/ sigma_error_out
+    std_rpn_SF = np.mean(std_rpn_SF, axis=1)
+    for i in range(dim_y):
+        fig = plt.figure(figsize=(10.5, 14))
+        ax = fig.add_subplot(211)
+        ax.set_title("MAE")
+        m = Basemap(projection='robin',lon_0=-180)
+        MAE_SF_p = MAE_SF[i,:,:]
+        contour_plot = m.pcolormesh(X, Y, MAE_SF_p, latlon = True, cmap='Blues_r')
+        m.drawcoastlines(linewidth=2.0, color='0.25')
+        m.colorbar(contour_plot)
+        ax = fig.add_subplot(212)
+        ax.set_title("Uncertainty "+r'$\sigma_M$')
+        m = Basemap(projection='robin',lon_0=-180)
+        std_rpn_SF_p = std_rpn_SF[i,:,:]
+        contour_plot = m.pcolormesh(X, Y, std_rpn_SF_p, latlon = True, cmap='Blues_r')
+        m.drawcoastlines(linewidth=2.0, color='0.25')
+        m.colorbar(contour_plot)
+        plt.subplots_adjust(hspace=-0.35)
+        if i > 25:
+            plt.savefig('long_lat_uncert_plots/SF_moist_long_lat_uncert_'+str(i-26+4)+'.png', bbox_inches='tight', pad_inches=0.1 , dpi = 300)
+            
+        else:
+            plt.savefig('long_lat_uncert_plots/SF_moist_long_lat_uncert_'+str(i)+'.png', bbox_inches='tight', pad_inches=0.1 , dpi = 300)
+
+    std_rpn_LF = np.load('MF_param/std_RPN_LF_reshaped.npy')/ sigma_error_out
+    std_rpn_LF = np.mean(std_rpn_LF, axis=1)
+    for i in range(dim_y):
+        fig = plt.figure(figsize=(10.5, 14))
+        ax = fig.add_subplot(211)
+        ax.set_title("MAE")
+        m = Basemap(projection='robin',lon_0=-180)
+        MAE_LF_p = MAE_LF[i,:,:]
+        contour_plot = m.pcolormesh(X, Y, MAE_LF_p, latlon = True, cmap='Blues_r')
+        m.drawcoastlines(linewidth=2.0, color='0.25')
+        m.colorbar(contour_plot)
+        ax = fig.add_subplot(212)
+        ax.set_title("Uncertainty "+r'$\sigma_M$')
+        m = Basemap(projection='robin',lon_0=-180)
+        std_rpn_LF_p = std_rpn_LF[i,:,:]
+        contour_plot = m.pcolormesh(X, Y, std_rpn_LF_p, latlon = True, cmap='Blues_r')
+        m.drawcoastlines(linewidth=2.0, color='0.25')
+        m.colorbar(contour_plot)
+        plt.subplots_adjust(hspace=-0.35)
+        if i > 25:
+            plt.savefig('long_lat_uncert_plots/LF_moist_long_lat_uncert_'+str(i-26+4)+'.png', bbox_inches='tight', pad_inches=0.1 , dpi = 300)
+            
+        else:
+            plt.savefig('long_lat_uncert_plots/LF_moist_long_lat_uncert_'+str(i)+'.png', bbox_inches='tight', pad_inches=0.1 , dpi = 300)
+             
+else:
+    if is_MAE == 1:
+        for i in range(dim_y):
+            
+            mmin = min( np.min(MAE_det[i,:,:]), np.min(MAE_SF[i,:,:]), np.min(MAE_MF[i,:,:]), np.min(MAE_LF[i,:,:]) )
+            mmax = max( np.max(MAE_det[i,:,:]), np.max(MAE_SF[i,:,:]), np.max(MAE_MF[i,:,:]), np.max(MAE_LF[i,:,:]) )
+            levels = np.linspace(mmin, mmax, 8)
+            fig = plt.figure(figsize=(21, 14))
+            ax = fig.add_subplot(221)
+            ax.set_title("Deterministic NN")
+            m = Basemap(projection='robin',lon_0=-180)
+            MAE_det_p = MAE_det[i,:,:]
+            contour_plot = m.pcolormesh(X, Y,MAE_det_p, latlon = True, cmap='Blues', vmin=mmin, vmax=mmax)
+            m.drawcoastlines(linewidth=2.0, color='0.25')
+            m.colorbar(contour_plot)
+            
+            ax = fig.add_subplot(222)
+            ax.set_title("SF-HF-RPN")
+            m = Basemap(projection='robin',lon_0=-180)
+            MAE_SF_p = MAE_SF[i,:,:]
+            contour_plot = m.pcolormesh(X, Y, MAE_SF_p, latlon = True, cmap='Blues', vmin=mmin, vmax=mmax)
+            m.drawcoastlines(linewidth=2.0, color='0.25')
+            m.colorbar(contour_plot)
+            
+            ax = fig.add_subplot(224)
+            ax.set_title("MF-RPN")
+            m = Basemap(projection='robin',lon_0=-180)
+            MAE_MF_p = MAE_MF[i,:,:]
+            contour_plot = m.pcolormesh(X, Y,MAE_MF_p, latlon = True, cmap='Blues', vmin=mmin, vmax=mmax)
+            m.drawcoastlines(linewidth=2.0, color='0.25')
+            m.colorbar(contour_plot)
+            
+            ax = fig.add_subplot(223)
+            ax.set_title("LF-RPN")
+            m = Basemap(projection='robin',lon_0=-180)
+            MAE_LF_p = MAE_LF[i,:,:]
+            contour_plot = m.pcolormesh(X, Y, MAE_LF_p, latlon = True, cmap='Blues', vmin=mmin, vmax=mmax)
+            m.drawcoastlines(linewidth=2.0, color='0.25')
+            m.colorbar(contour_plot)
+            
+            plt.subplots_adjust(wspace=0.15, hspace=-0.35)
+            if i > 25:
+                plt.savefig('long_lat_plots/moist_MAE_long_lat_'+str(i-26+4)+'.png', bbox_inches='tight', pad_inches=0.1 , dpi = 300)
+            else:
+                plt.savefig('long_lat_plots/heat_MAE_long_lat_'+str(i)+'.png', bbox_inches='tight', pad_inches=0.1 , dpi = 300)
+            
+    if is_R2 == 1:
+        for i in range(dim_y):
+            
+            mmin = max(min( np.min(r2_det[i,:,:]), np.min(r2_SF[i,:,:]), np.min(r2_MF[i,:,:]), np.min(r2_LF[i,:,:])), -10 )
+            levels = np.linspace(0, 1, 5)
+            fig = plt.figure(figsize=(21, 14))
+            ax = fig.add_subplot(221)
+            ax.set_title("Deterministic NN")
+            m = Basemap(projection='robin',lon_0=-180)
+            r2_det_p = r2_det[i,:,:]
+            contour_plot = m.pcolormesh(X, Y, r2_det_p, latlon = True, cmap='Blues', vmin=0, vmax=1)
+            m.contour(X, Y, r2_det_p, [0.7], latlon = True, colors='pink', linewidths=[2])
+            m.drawcoastlines(linewidth=2.0, color='0.25')
+            m.colorbar(contour_plot)
+            
+            ax = fig.add_subplot(222)
+            ax.set_title("SF-HF-RPN")
+            m = Basemap(projection='robin',lon_0=-180)
+            r2_SF_p = r2_SF[i,:,:]
+            contour_plot = m.pcolormesh(X, Y, r2_SF_p, latlon = True, cmap='Blues', vmin=0, vmax=1)
+            m.contour(X, Y, r2_SF_p, [0.7], latlon = True, colors='pink', linewidths=[2])
+            m.drawcoastlines(linewidth=2.0, color='0.25')
+            m.colorbar(contour_plot)
+            
+            ax = fig.add_subplot(224)
+            ax.set_title("MF-RPN")
+            m = Basemap(projection='robin',lon_0=-180)
+            r2_MF_p = r2_MF[i,:,:]
+            contour_plot = m.pcolormesh(X, Y, r2_MF_p, latlon = True, cmap='Blues', vmin=0, vmax=1)
+            m.contour(X, Y, r2_MF_p, [0.7], latlon = True, colors='pink', linewidths=[2])
+            m.drawcoastlines(linewidth=2.0, color='0.25')
+            m.colorbar(contour_plot)
+            
+            ax = fig.add_subplot(223)
+            ax.set_title("LF-RPN")
+            m = Basemap(projection='robin',lon_0=-180)
+            r2_LF_p = r2_LF[i,:,:]
+            contour_plot = m.pcolormesh(X, Y, r2_LF_p, latlon = True, cmap='Blues', vmin=0, vmax=1)
+            m.contour(X, Y, r2_LF_p, [0.7], latlon = True, colors='pink', linewidths=[2])
+            m.drawcoastlines(linewidth=2.0, color='0.25')
+            m.colorbar(contour_plot)
+            
+            plt.subplots_adjust(wspace=0.15, hspace=-0.35)
+            if i > 25:
+                plt.savefig('long_lat_plots/moist_r2_long_lat_'+str(i-26+4)+'.png', bbox_inches='tight', pad_inches=0.1 , dpi = 300)
+            else:
+                plt.savefig('long_lat_plots/heat_r2_long_lat_'+str(i)+'.png', bbox_inches='tight', pad_inches=0.1 , dpi = 300)
+            

8_plot_global_errors.py

@@ -0,0 +1,327 @@
+#!/usr/bin/env python3
+# -*- coding: utf-8 -*-
+"""
+Created on Tue May 16 16:02:19 2023
+
+@author: mohamedazizbhouri
+"""
+from matplotlib import pyplot as plt
+import numpy as onp
+
+#values of average pressure for different vertical levels
+press = ('3.5', '7.4', '14', '24', '37', '53', '70', '85', '100', '117',
+        '137', '160', '188', '221', '259', '305', '358', '420', '494',
+        '581', '673', '761', '837', '897', '937', '958')
+
+plt.rcParams.update(plt.rcParamsDefault)
+plt.rc('font', family='serif')
+plt.rcParams.update({'font.size': 32,
+                     'lines.linewidth': 2,
+                     'axes.labelsize': 32,
+                     'axes.titlesize': 32,
+                     'xtick.labelsize': 32,
+                     'ytick.labelsize': 32,
+                     'legend.fontsize': 32,
+                     'axes.linewidth': 2,
+                     "pgf.texsystem": "pdflatex"
+                     })
+plt.close('all')
+
+R2_w_neg = 1
+R2_wo_neg = 0
+MAE = 0
+CRPS = 0
+
+if R2_wo_neg == 1: # global R^2 plots without negative values
+    nn = 26
+    MF = onp.load('glob_errors/r2_rpn_MF.npy')[:26]
+    SF = onp.load('glob_errors/r2_rpn_SF.npy')[:26]
+    LF = onp.load('glob_errors/r2_rpn_LF.npy')[:26]
+    det = onp.load('glob_errors/r2_det.npy')[:26]
+    MF[MF<0] = 0
+    SF[SF<0] = 0
+    LF[LF<0] = 0
+    det[det<0] = 0
+    xx = onp.arange(nn)
+    fig , ax = plt.subplots(figsize=(12,8))
+    ax.plot(xx, det, color='blue')
+    ax.plot(xx, SF, '--', color='black')
+    ax.plot(xx, LF, '--', color='orange')
+    ax.plot(xx, MF, color='red')
+    ax.set_xlabel('Pressure (hPa)')
+    ax.set_xticks(onp.arange(nn))
+    ax.set_xticklabels(press, rotation =60, fontsize = 20)
+    ax.tick_params(axis='x',colors='grey')
+    ax.set_ylim([0,1])
+    ax.set_ylabel('$R^2$')
+    plt.grid()
+    ax.legend(['Det. NN', 'SF-HF-RPN', 'LF-RPN', 'MF-RPN'], bbox_to_anchor=[0.5, 1.2], loc='center', ncol=4)
+    plt.show()
+    plt.savefig('glob_errors/R2_w_neg_heat.png', bbox_inches='tight', pad_inches=0.1 , dpi = 300)
+    
+    nn = 22
+    MF = onp.load('glob_errors/r2_rpn_MF.npy')[26:]
+    SF = onp.load('glob_errors/r2_rpn_SF.npy')[26:]
+    LF = onp.load('glob_errors/r2_rpn_LF.npy')[26:]
+    det = onp.load('glob_errors/r2_det.npy')[26:]
+    MF[MF<0] = 0
+    SF[SF<0] = 0
+    LF[LF<0] = 0
+    det[det<0] = 0
+    press = press[4:]
+    xx = onp.arange(nn)
+    fig , ax = plt.subplots(figsize=(12,8))
+    ax.plot(xx, det, color='blue')
+    ax.plot(xx, SF, '--', color='black')
+    ax.plot(xx, LF, '--', color='orange')
+    ax.plot(xx, MF, color='red')
+    ax.set_xlabel('Pressure (hPa)')
+    ax.set_xticks(onp.arange(nn))
+    ax.set_xticklabels(press, rotation =60, fontsize = 20)
+    ax.tick_params(axis='x',colors='grey')
+    ax.set_ylim([0,1])
+    ax.set_ylabel('$R^2$')
+    plt.grid()
+    ax.legend(['Det. NN', 'SF-HF-RPN', 'LF-RPN', 'MF-RPN'], bbox_to_anchor=[0.5, 1.2], loc='center', ncol=4)
+    plt.show()
+    plt.savefig('glob_errors/R2_w_neg_moist.png', bbox_inches='tight', pad_inches=0.1 , dpi = 300)
+    
+if MAE == 1: # gloab MAE plots
+    nn = 26
+    MF = onp.load('glob_errors/MAE_rpn_MF.npy')[:26]
+    SF = onp.load('glob_errors/MAE_rpn_SF.npy')[:26]
+    LF = onp.load('glob_errors/MAE_rpn_LF.npy')[:26]
+    det = onp.load('glob_errors/MAE_det.npy')[:26]
+    xx = onp.arange(nn)
+    fig , ax = plt.subplots(figsize=(12,8))
+    plt.yscale("log")
+    ax.plot(xx, det, color='blue')
+    ax.plot(xx, SF, '--', color='black')
+    ax.plot(xx, LF, '--', color='orange')
+    ax.plot(xx, MF, color='red')
+    ax.set_xlabel('Pressure (hPa)')
+    ax.set_xticks(onp.arange(nn))
+    ax.set_xticklabels(press, rotation =60, fontsize = 20)
+    ax.tick_params(axis='x',colors='grey')
+    plt.ylabel('MAE')
+    plt.grid()
+    ax.legend(['Det. NN', 'SF-HF-RPN', 'LF-RPN', 'MF-RPN'], bbox_to_anchor=[0.5, 1.2], loc='center', ncol=4)
+    plt.show()
+    plt.savefig('glob_errors/MAE_heat.png', bbox_inches='tight', pad_inches=0.1 , dpi = 300)
+    
+    nn = 22
+    MF = onp.load('glob_errors/MAE_rpn_MF.npy')[26:]
+    SF = onp.load('glob_errors/MAE_rpn_SF.npy')[26:]
+    LF = onp.load('glob_errors/MAE_rpn_LF.npy')[26:]
+    det = onp.load('glob_errors/MAE_det.npy')[26:]
+    press = press[4:]
+    xx = onp.arange(nn)
+    fig , ax = plt.subplots(figsize=(12,8))
+    plt.yscale("log")
+    ax.plot(xx, det, color='blue')
+    ax.plot(xx, SF, '--', color='black')
+    ax.plot(xx, LF, '--', color='orange')
+    ax.plot(xx, MF, color='red')
+    ax.set_xlabel('Pressure (hPa)')
+    ax.set_xticks(onp.arange(nn))
+    ax.set_xticklabels(press, rotation =60, fontsize = 20)
+    ax.tick_params(axis='x',colors='grey')
+    plt.ylabel('MAE')
+    plt.grid()
+    ax.legend(['Det. NN', 'SF-HF-RPN', 'LF-RPN', 'MF-RPN'], bbox_to_anchor=[0.5, 1.2], loc='center', ncol=4)
+    plt.show()
+    plt.savefig('glob_errors/MAE_moist.png', bbox_inches='tight', pad_inches=0.1 , dpi = 300)
+    
+if R2_w_neg == 1: # global R^2 plots with negative values
+    nn = 26
+    MF = onp.load('glob_errors/r2_rpn_MF.npy')[:26]
+    SF = onp.load('glob_errors/r2_rpn_SF.npy')[:26]
+    LF = onp.load('glob_errors/r2_rpn_LF.npy')[:26]
+    det = onp.load('glob_errors/r2_det.npy')[:26]
+    MF[MF<0] = 0
+    SF[SF<0] = 0
+    LF[LF<0] = 0
+    det[det<0] = 0
+    xx = onp.arange(nn)
+    # values below are optained from r2_rpn_MF.npy, r2_rpn_SF.npy, r2_rpn_LF.npy and r2_det.npy
+    det_r = ['-2.3', '-2.4', '-2.1', '-1.6', '-0.6', '', '-26', '-43', '-15', 
+             '-13', '-11', '-3.5', '-3.2', '-2.4', '-1.2', '-0.4', '', '', 
+             '', '', '-0.01', '-0.2', '-0.4', '-0.01', '-2.6', '', '-5']
+    SF_r = ['-3.5', '-2.6', '-2.4', '-1.9', '-0.9', '', '-64', '-70', '-5.2',
+            '-13', '-4.9', '-2.6', '-2.1', '-1.1', '-0.9', '-0.8', '', '', '',
+            '', '', '', '', '', '-0.6', '']
+    LF_r = ['-5.6', '', '', '', '', '', '', '-1.4', '-0.3', '-0.6', '', '',
+            '', '', '', '', '', '', '', '', '', '', '', '', '-0.3', '-0.1']
+    fig , ax = plt.subplots(figsize=(12,8))
+    ax.plot(xx, det, color='blue')
+    ii= 0
+    for x,y in zip(xx,det):
+        ax.annotate(det_r[ii],
+                    (x,y),
+                    textcoords="offset points",
+                    xytext = (0,-60),
+                    ha='center',
+                    color = 'blue',
+                    fontsize = 20,
+                    rotation = -60)
+        ii+=1
+    ax.plot(xx, SF, '--', color='black')
+    ii= 0
+    for x,y in zip(xx,SF):
+        ax.annotate(SF_r[ii],
+                    (x,y),
+                    textcoords="offset points",
+                    xytext = (0,-120),
+                    ha='center',
+                    color = 'black',
+                    fontsize = 20,
+                    rotation = -60)
+        ii+=1
+    ax.plot(xx, LF, '--', color='orange')
+    ii= 0
+    for x,y in zip(xx,LF):
+        ax.annotate(LF_r[ii],
+                    (x,y),
+                    textcoords="offset points",
+                    xytext = (0,-180),
+                    ha='center',
+                    color = 'orange',
+                    fontsize = 20,
+                    rotation = -60)
+        ii+=1
+    ax.plot(xx, MF, color='red')
+    ax.set_ylim([0,1])
+    ax.set_xlabel('Pressure (hPa)')
+    ax.xaxis.set_label_coords(0.5, -0.55)
+    ax.set_xticks(onp.arange(nn))
+    ax.set_xticklabels(press, rotation =60, fontsize = 20, y=-0.4)
+    ax.tick_params(axis='x',colors='grey')
+    ax.set_ylabel('$R^2$')
+    plt.grid()
+    ax.legend(['Det. NN', 'SF-HF-RPN', 'LF-RPN', 'MF-RPN'], bbox_to_anchor=[0.5, 1.2], loc='center', ncol=4)
+    plt.show()
+    plt.savefig('glob_errors/R2_w_neg_heat.png', bbox_inches='tight', pad_inches=0.1 , dpi = 300)
+    
+    nn = 22
+    MF = onp.load('glob_errors/r2_rpn_MF.npy')[26:]
+    SF = onp.load('glob_errors/r2_rpn_SF.npy')[26:]
+    LF = onp.load('glob_errors/r2_rpn_LF.npy')[26:]
+    det = onp.load('glob_errors/r2_det.npy')[26:]
+    press = press[4:]
+    MF[MF<0] = 0
+    SF[SF<0] = 0
+    LF[LF<0] = 0
+    det[det<0] = 0
+    xx = onp.arange(nn)
+    det_r = ['-94', '-97', '-11', '-14', '-4.4', '-4.9', '-3.3', '-2.7', '-1.6',
+             '-1.2', '-0.4', '-0.3', '', '', '', '', '-2.7', '-1.0', '-0.7',
+             '-0.6', '-1.2', '']
+    SF_r = ['-145', '-71', '-16', '-14', '9.1', '6.3', '-3.9', '-2.8', '-1.8',
+            '-1.3', '-0.9', '-0.8', '-0.2', '', '', '', '-0.5', '-0.01', '-0.2',
+            '-0.2', '-0.03', '']
+    LF_r = ['', '-7.0', '-108', '-225', '-29', '-4.2', '', '', '',
+            '', '', '', '', '', '', '', '', '', '', '-2.1', '-0.6', '-0.6']
+    MF_r = ['', '', '-0.9', '-2.2', '-0.3', '', '', '', '', '', '', '', '', '',
+            '', '', '', '', '', '', '', '']
+    fig , ax = plt.subplots(figsize=(12,8))
+    ax.plot(xx, det, color='blue')
+    ii= 0
+    for x,y in zip(xx,det):
+        ax.annotate(det_r[ii],
+                    (x,y),
+                    textcoords="offset points",
+                    xytext = (0,-50),
+                    ha='center',
+                    color = 'blue',
+                    fontsize = 20,
+                    rotation = -60)
+        ii+=1
+    ax.plot(xx, SF, '--', color='black')
+    ii= 0
+    for x,y in zip(xx,SF):
+        ax.annotate(SF_r[ii],
+                    (x,y),
+                    textcoords="offset points",
+                    xytext = (0,-100),
+                    ha='center',
+                    color = 'black',
+                    fontsize = 20,
+                    rotation = -60)
+        ii+=1
+    ax.plot(xx, LF, '--', color='orange')
+    ii= 0
+    for x,y in zip(xx,LF):
+        ax.annotate(LF_r[ii],
+                    (x,y),
+                    textcoords="offset points",
+                    xytext = (0,-150),
+                    ha='center',
+                    color = 'orange',
+                    fontsize = 20,
+                    rotation = -60)
+        ii+=1
+    ax.plot(xx, MF, color='red')
+    ii= 0
+    for x,y in zip(xx,MF):
+        ax.annotate(MF_r[ii],
+                    (x,y),
+                    textcoords="offset points",
+                    xytext = (0,-200),
+                    ha='center',
+                    color = 'red',
+                    fontsize = 20,
+                    rotation = -60)
+        ii+=1
+    ax.set_ylim([0,1])
+    ax.set_xlabel('Pressure (hPa)')
+    ax.xaxis.set_label_coords(0.5, -0.6)
+    ax.set_xticks(onp.arange(nn))
+    ax.set_xticklabels(press, rotation =60, fontsize = 20, y=-0.45)
+    ax.tick_params(axis='x',colors='grey')
+    ax.set_ylabel('$R^2$')
+    plt.grid()
+    ax.legend(['Det. NN', 'SF-HF-RPN', 'LF-RPN', 'MF-RPN'], bbox_to_anchor=[0.5, 1.2], loc='center', ncol=4)
+    plt.show()
+    plt.savefig('glob_errors/R2_w_neg_moist.png', bbox_inches='tight', pad_inches=0.1 , dpi = 300)
+    
+if CRPS == 1: # global CRPS plots
+    nn = 26
+    MF = onp.load('glob_errors/crps_rpn_MF.npy')[:26]
+    SF = onp.load('glob_errors/crps_rpn_SF.npy')[:26]
+    LF = onp.load('glob_errors/crps_rpn_LF.npy')[:26]
+    xx = onp.arange(nn)
+    fig , ax = plt.subplots(figsize=(12,8))
+    plt.yscale("log")
+    ax.plot(xx, SF, '--', color='black')
+    ax.plot(xx, LF, '--', color='orange')
+    ax.plot(xx, MF, color='red')
+    ax.set_xlabel('Pressure (hPa)')
+    ax.set_xticks(onp.arange(nn))
+    ax.set_xticklabels(press, rotation =60, fontsize = 20)
+    ax.tick_params(axis='x',colors='grey')
+    plt.ylabel('CRPS')
+    plt.grid()
+    ax.legend(['Det. NN', 'SF-HF-RPN', 'LF-RPN', 'MF-RPN'], bbox_to_anchor=[0.5, 1.2], loc='center', ncol=4)
+    plt.show()
+    plt.savefig('glob_errors/CRPS_heat.png', bbox_inches='tight', pad_inches=0.1 , dpi = 300)
+    
+    nn = 22
+    MF = onp.load('glob_errors/crps_rpn_MF.npy')[26:]
+    SF = onp.load('glob_errors/crps_rpn_SF.npy')[26:]
+    LF = onp.load('glob_errors/crps_rpn_LF.npy')[26:]
+    press = press[4:]
+    xx = onp.arange(nn)
+    fig , ax = plt.subplots(figsize=(12,8))
+    plt.yscale("log")
+    ax.plot(xx, SF, '--', color='black')
+    ax.plot(xx, LF, '--', color='orange')
+    ax.plot(xx, MF, color='red')
+    ax.set_xlabel('Pressure (hPa)')
+    ax.set_xticks(onp.arange(nn))
+    ax.set_xticklabels(press, rotation =60, fontsize = 20)
+    ax.tick_params(axis='x',colors='grey')
+    plt.ylabel('CRPS')
+    plt.grid()
+    ax.legend(['Det. NN', 'SF-HF-RPN', 'LF-RPN', 'MF-RPN'], bbox_to_anchor=[0.5, 1.2], loc='center', ncol=4)
+    plt.show()
+    plt.savefig('glob_errors/CRPS_moist.png', bbox_inches='tight', pad_inches=0.1 , dpi = 300)

8_pressure_lat_plots.py

@@ -0,0 +1,130 @@
+#!/usr/bin/env python3
+# -*- coding: utf-8 -*-
+"""
+Created on Wed Jun 21 09:32:40 2023
+
+@author: mohamedazizbhouri
+"""
+from matplotlib import pyplot as plt
+import numpy as np
+
+plt.rcParams.update(plt.rcParamsDefault)
+plt.rc('font', family='serif')
+plt.rcParams.update({'font.size': 46,
+                     'lines.linewidth': 3,
+                     'axes.labelsize': 46,
+                     'axes.titlesize': 46,
+                     'xtick.labelsize': 46,
+                     'ytick.labelsize': 46,
+                     'legend.fontsize': 46,
+                     'axes.linewidth': 3,
+                     "pgf.texsystem": "pdflatex"
+                     })
+
+lat = 96
+x = np.linspace(-90, 90, lat)
+y = np.array([3.5, 7.4, 14, 24, 37, 53, 70, 85, 100, 117,
+               137, 160, 188, 221, 259, 305, 358, 420, 494,
+               581, 673, 761, 837, 897, 937, 958])
+X, Y = np.meshgrid(x, y)
+Xm, Ym = np.meshgrid(x, y[4:])
+  
+r2_det = np.load('SF_results/r2_det_pres_lat.npy')
+r2_SF = np.load('SF_results/r2_SF_pres_lat.npy')
+r2_MF = np.load('MF_results/r2_MF_pres_lat.npy.npy')
+r2_LF = np.load('MF_results/r2_LF_pres_lat.npy.npy')
+    
+dim_heat = 26
+
+print('Create err plots')
+    
+mmin = 0
+mmax = 1
+levels = np.linspace(mmin, mmax, 8)
+fig = plt.figure(figsize=(40, 15))
+
+ax = fig.add_subplot(141)
+ax.set_title("Deterministic NN")
+contour_plot = ax.pcolor(X, Y, r2_det[:dim_heat,:],cmap='Blues', vmin = mmin, vmax = mmax)
+ax.contour(X, Y, r2_det[:dim_heat,:], [0.7], colors='pink', linewidths=[4])
+ax.contour(X, Y, r2_det[:dim_heat,:], [0.9], colors='orange', linewidths=[4])
+ax.set_ylim(ax.get_ylim()[::-1])
+ax.set_ylabel("Pressure (hPa)")
+
+ax = fig.add_subplot(142)
+ax.set_title("SF-HF-RPN")
+contour_plot = ax.pcolor(X, Y, r2_SF[:dim_heat,:],cmap='Blues', vmin = mmin, vmax = mmax)
+ax.contour(X, Y, r2_SF[:dim_heat,:], [0.7], colors='pink', linewidths=[4])
+ax.contour(X, Y, r2_SF[:dim_heat,:], [0.9], colors='orange', linewidths=[4])
+ax.set_ylim(ax.get_ylim()[::-1])
+ax.set_yticks([]) 
+ax.set_xlabel("Degrees Latitude")
+ax.xaxis.set_label_coords(1.12, -0.1)
+
+ax = fig.add_subplot(143)
+ax.set_title("LF-RPN")
+contour_plot = ax.pcolor(X, Y, r2_LF[:dim_heat,:],cmap='Blues', vmin = mmin, vmax = mmax)
+ax.contour(X, Y, r2_LF[:dim_heat,:], [0.7], colors='pink', linewidths=[4])
+ax.contour(X, Y, r2_LF[:dim_heat,:], [0.9], colors='orange', linewidths=[4])
+ax.set_ylim(ax.get_ylim()[::-1])
+ax.set_yticks([]) 
+
+ax = fig.add_subplot(144)
+ax.set_title("MF-RPN")
+contour_plot = ax.pcolor(X, Y, r2_MF[:dim_heat,:],cmap='Blues', vmin = mmin, vmax = mmax)
+ax.contour(X, Y, r2_MF[:dim_heat,:], [0.7], colors='pink', linewidths=[4])
+ax.contour(X, Y, r2_MF[:dim_heat,:], [0.9], colors='orange', linewidths=[4])
+ax.set_ylim(ax.get_ylim()[::-1])
+ax.set_yticks([])        
+p3 = ax.get_position().get_points().flatten()
+
+cbar_ax = fig.add_axes([0.92, 0.12, 0.02, 0.76])
+fig.colorbar(contour_plot, label=r'$\mathrm{R^2}$', cax=cbar_ax)
+plt.suptitle("Heat tendency")
+plt.savefig('r2_press_lat_heat.png', bbox_inches='tight', pad_inches=0.1 , dpi = 300)
+
+mmin = 0
+mmax = 1
+levels = np.linspace(mmin, mmax, 8)
+fig = plt.figure(figsize=(40, 15))
+
+ax = fig.add_subplot(141)
+ax.set_title("Deterministic NN")
+contour_plot = ax.pcolor(Xm, Ym, r2_det[dim_heat:,:],cmap='Blues', vmin = mmin, vmax = mmax)
+ax.contour(Xm, Ym, r2_det[dim_heat:,:], [0.7], colors='pink', linewidths=[4])
+ax.contour(Xm, Ym, r2_det[dim_heat:,:], [0.9], colors='orange', linewidths=[4])
+ax.set_ylim(ax.get_ylim()[::-1])
+ax.set_ylabel("Pressure (hPa)")
+
+ax = fig.add_subplot(142)
+ax.set_title("SF-HF-RPN")
+contour_plot = ax.pcolor(Xm, Ym, r2_SF[dim_heat:,:],cmap='Blues', vmin = mmin, vmax = mmax)
+ax.contour(Xm, Ym, r2_SF[dim_heat:,:], [0.7], colors='pink', linewidths=[4])
+ax.contour(Xm, Ym, r2_SF[dim_heat:,:], [0.9], colors='orange', linewidths=[4])
+ax.set_ylim(ax.get_ylim()[::-1])
+ax.set_yticks([]) 
+ax.set_xlabel("Degrees Latitude")
+ax.xaxis.set_label_coords(1.12, -0.1)
+
+ax = fig.add_subplot(143)
+ax.set_title("LF-RPN")
+contour_plot = ax.pcolor(Xm, Ym, r2_LF[dim_heat:,:],cmap='Blues', vmin = mmin, vmax = mmax)
+ax.contour(Xm, Ym, r2_LF[dim_heat:,:], [0.7], colors='pink', linewidths=[4])
+ax.contour(Xm, Ym, r2_LF[dim_heat:,:], [0.9], colors='orange', linewidths=[4])
+ax.set_ylim(ax.get_ylim()[::-1])
+ax.set_yticks([])        
+
+ax = fig.add_subplot(144)
+ax.set_title("MF-RPN")
+contour_plot = ax.pcolor(Xm, Ym, r2_MF[dim_heat:,:],cmap='Blues', vmin = mmin, vmax = mmax)
+ax.contour(Xm, Ym, r2_MF[dim_heat:,:], [0.7], colors='pink', linewidths=[4])
+ax.contour(Xm, Ym, r2_MF[dim_heat:,:], [0.9], colors='orange', linewidths=[4])
+ax.set_ylim(ax.get_ylim()[::-1])
+ax.set_yticks([])        
+p3 = ax.get_position().get_points().flatten()
+
+cbar_ax = fig.add_axes([0.92, 0.12, 0.02, 0.76])
+fig.colorbar(contour_plot, label=r'$\mathrm{R^2}$', cax=cbar_ax)
+plt.suptitle("Moisture tendency")
+plt.savefig('r2_press_lat_moist.png', bbox_inches='tight', pad_inches=0.1 , dpi = 300)
+       

8_uncertainty_density_plot.py

@@ -0,0 +1,231 @@
+#!/usr/bin/env python3
+# -*- coding: utf-8 -*-
+"""
+Created on Wed Aug 2 17:42:05 2023
+
+@author: mohamedazizbhouri
+"""
+from matplotlib import pyplot as plt
+import numpy as onp
+
+from scipy.stats import kde
+
+plt.rcParams.update(plt.rcParamsDefault)
+plt.rc('font', family='serif')
+plt.rcParams.update({'font.size': 36,
+                     'lines.linewidth': 2,
+                     'axes.labelsize': 36,
+                     'axes.titlesize': 36,
+                     'xtick.labelsize': 36,
+                     'ytick.labelsize': 36,
+                     'legend.fontsize': 36,
+                     'axes.linewidth': 2,
+                     "pgf.texsystem": "pdflatex"
+                     })
+plt.rcParams['agg.path.chunksize'] = 20000
+
+lat = 96
+lon = 144
+nt_total = 365*24
+
+dim_y = 48
+dim_heat = 26
+dim_moist = 22
+mu_error_out = onp.concatenate((onp.zeros((1,dim_heat),dtype=onp.float32),
+                                onp.zeros((1,dim_moist),dtype=onp.float32)),axis=1)
+sigma_error_out = onp.concatenate((1/1004.6*onp.ones((1,dim_heat),dtype=onp.float32),
+                                    1/2.26e6*onp.ones((1,dim_moist),dtype=onp.float32)),axis=1)
+mu_error_out = onp.array(mu_error_out,dtype=onp.float64) 
+sigma_error_out = onp.array(sigma_error_out,dtype=onp.float64) 
+
+is_SF = 0
+is_MF = 0 
+is_LF = 1
+
+ilist = [14, 18, 21, 36, 40, 43] # indices for tendencies at pressure levels 259, 494 and 761 hPa
+ipress = [259, 494, 761, 259, 294, 761]
+itend = ['heat', 'heat', 'heat', 'moist', 'moist', 'moist']
+nbins = 100
+epsilon = 0.125
+fact_time = 4
+fact_lon = 8
+fact_lat = 8
+
+onp.random.seed(1234)
+
+import time
+
+if is_MF == 1:
+    print('loading')
+    mean_rpn_MF = onp.load('MF_param/mean_RPN_MF_reshaped.npy')[:,::fact_time,::fact_lat,::fact_lon]
+    mean_rpn_MF = onp.array(mean_rpn_MF,dtype=onp.float64) 
+    mean_rpn_MF = onp.reshape( mean_rpn_MF, ( dim_y, (nt_total*lat*lon)//(fact_time*fact_lon*fact_lat) ) )
+    mean_rpn_MF = mean_rpn_MF.T
+    mean_rpn_MF = (mean_rpn_MF-mu_error_out) / sigma_error_out
+    
+    std_rpn_MF = onp.load('MF_param/std_RPN_MF_reshaped.npy')[:,::fact_time,::fact_lat,::fact_lon]
+    std_rpn_MF = onp.array(std_rpn_MF,dtype=onp.float64) 
+    std_rpn_MF = onp.reshape( std_rpn_MF, ( dim_y, (nt_total*lat*lon)//(fact_time*fact_lon*fact_lat) ) )
+    std_rpn_MF = std_rpn_MF.T
+    std_rpn_MF = std_rpn_MF / sigma_error_out
+    
+    test_yH = onp.load('data_SPCAM5_4K/all_outputs_reshaped.npy')[:,::fact_time,::fact_lat,::fact_lon]
+    test_yH = onp.array(test_yH,dtype=onp.float64) 
+    test_yH = onp.reshape( test_yH, ( dim_y, (nt_total*lat*lon)//(fact_time*fact_lon*fact_lat) ) )
+    test_yH = test_yH.T
+    test_yH = (test_yH-mu_error_out) / sigma_error_out
+    
+    for ii in range(len(ilist)):
+        i = ilist[ii]
+        print(i)
+        err_MF = onp.abs(mean_rpn_MF[:,i]-test_yH[:,i])
+        x = err_MF
+        y = std_rpn_MF[:,i]
+        Ntot = x.shape[0]
+        y = y[~onp.isnan(x)]
+        x = x[~onp.isnan(x)]
+        x = x[~onp.isnan(y)]
+        y = y[~onp.isnan(y)]
+        ind = onp.argsort(x)
+        x = x[ind]
+        y = y[ind]
+        x = x[:Ntot-int(epsilon*Ntot)]
+        y = y[:Ntot-int(epsilon*Ntot)]
+        ind = onp.argsort(y)
+        x = x[ind]
+        y = y[ind]
+        x = onp.sqrt(x[:Ntot-2*int(epsilon*Ntot)])
+        y = y[:Ntot-2*int(epsilon*Ntot)]
+        
+        tt = time.time()
+        k = kde.gaussian_kde([x,y])
+        xi, yi = onp.mgrid[x.min():x.max():nbins*1j, y.min():y.max():nbins*1j]
+        zi = k(onp.vstack([xi.flatten(), yi.flatten()]))
+        zi = zi.reshape(xi.shape)
+        print('gaussian_kde', time.time()-tt )
+        
+        fig = plt.figure(figsize=(12,12))
+        ax = fig.add_subplot(111)
+        plt.pcolormesh(xi, yi, zi, shading='gouraud', cmap=plt.cm.jet)
+        ax.ticklabel_format(axis="y", style="sci", scilimits=(0,0))
+        plt.colorbar()
+        ax.set_xlabel('Error')
+        ax.set_ylabel(r'$\sigma_M$')
+        plt.savefig('uncertainty_density_plots/MF_uncert_dens_'+itend[ii]+'_'+str(ipress[ii])+'_hPa.png', bbox_inches='tight', pad_inches=0.1 , dpi = 300)
+            
+if is_LF == 1:
+    print('loading')
+    mean_rpn_MF = onp.load('MF_param/mean_RPN_LF_reshaped.npy')[:,::fact_time,::fact_lat,::fact_lon]
+    mean_rpn_MF = onp.array(mean_rpn_MF,dtype=onp.float64) 
+    mean_rpn_MF = onp.reshape( mean_rpn_MF, ( dim_y, (nt_total*lat*lon)//(fact_time*fact_lon*fact_lat) ) )
+    mean_rpn_MF = mean_rpn_MF.T
+    mean_rpn_MF = (mean_rpn_MF-mu_error_out) / sigma_error_out
+    
+    std_rpn_MF = onp.load('MF_param/std_RPN_LF_reshaped.npy')[:,::fact_time,::fact_lat,::fact_lon]
+    std_rpn_MF = onp.array(std_rpn_MF,dtype=onp.float64) 
+    std_rpn_MF = onp.reshape( std_rpn_MF, ( dim_y, (nt_total*lat*lon)//(fact_time*fact_lon*fact_lat) ) )
+    std_rpn_MF = std_rpn_MF.T
+    std_rpn_MF = std_rpn_MF / sigma_error_out
+    
+    test_yH = onp.load('data_SPCAM5_4K/all_outputs_reshaped.npy')[:,::fact_time,::fact_lat,::fact_lon]
+    test_yH = onp.array(test_yH,dtype=onp.float64) 
+    test_yH = onp.reshape( test_yH, ( dim_y, (nt_total*lat*lon)//(fact_time*fact_lon*fact_lat) ) )
+    test_yH = test_yH.T
+    test_yH = (test_yH-mu_error_out) / sigma_error_out
+    
+    for ii in range(len(ilist)):
+        i = ilist[ii]
+        print(i)
+        err_MF = onp.abs(mean_rpn_MF[:,i]-test_yH[:,i])
+        x = err_MF
+        y = std_rpn_MF[:,i]
+        Ntot = x.shape[0]
+        y = y[~onp.isnan(x)]
+        x = x[~onp.isnan(x)]
+        x = x[~onp.isnan(y)]
+        y = y[~onp.isnan(y)]
+        ind = onp.argsort(x)
+        x = x[ind]
+        y = y[ind]
+        x = x[:Ntot-int(epsilon*Ntot)]
+        y = y[:Ntot-int(epsilon*Ntot)]
+        ind = onp.argsort(y)
+        x = x[ind]
+        y = y[ind]
+        x = onp.sqrt(x[:Ntot-2*int(epsilon*Ntot)])
+        y = y[:Ntot-2*int(epsilon*Ntot)]
+        
+        tt = time.time()
+        k = kde.gaussian_kde([x,y])
+        xi, yi = onp.mgrid[x.min():x.max():nbins*1j, y.min():y.max():nbins*1j]
+        zi = k(onp.vstack([xi.flatten(), yi.flatten()]))
+        zi = zi.reshape(xi.shape)
+        print('gaussian_kde', time.time()-tt )
+        
+        fig = plt.figure(figsize=(12,12))
+        ax = fig.add_subplot(111)
+        plt.pcolormesh(xi, yi, zi, shading='gouraud', cmap=plt.cm.jet)
+        ax.ticklabel_format(axis="y", style="sci", scilimits=(0,0))
+        plt.colorbar()
+        ax.set_xlabel('Error')
+        ax.set_ylabel(r'$\sigma_M$')
+        plt.savefig('uncertainty_density_plots/LF_uncert_dens_'+itend[ii]+'_'+str(ipress[ii])+'_hPa.png', bbox_inches='tight', pad_inches=0.1 , dpi = 300)
+        
+if is_SF == 1:
+    print('loading')
+    mean_rpn = onp.load('SF_param/mean_RPN_SF_reshaped.npy')[:,::fact_time,::fact_lat,::fact_lon]
+    mean_rpn = onp.array(mean_rpn,dtype=onp.float64) 
+    mean_rpn = onp.reshape( mean_rpn, ( dim_y, (nt_total*lat*lon)//(fact_time*fact_lon*fact_lat) ) )
+    mean_rpn = mean_rpn.T
+    mean_rpn = (mean_rpn-mu_error_out) / sigma_error_out
+    
+    std_rpn = onp.load('SF_param/std_RPN_SF_reshaped.npy')[:,::fact_time,::fact_lat,::fact_lon]
+    std_rpn = onp.array(std_rpn,dtype=onp.float64) 
+    std_rpn = onp.reshape( std_rpn, ( dim_y, (nt_total*lat*lon)//(fact_time*fact_lon*fact_lat) ) )
+    std_rpn = std_rpn.T
+    std_rpn = std_rpn / sigma_error_out
+    
+    test_yH = onp.load('data_SPCAM5_4K/all_outputs_reshaped.npy')[:,::fact_time,::fact_lat,::fact_lon]
+    test_yH = onp.array(test_yH,dtype=onp.float64) 
+    test_yH = onp.reshape( test_yH, ( dim_y, (nt_total*lat*lon)//(fact_time*fact_lon*fact_lat) ) )
+    test_yH = test_yH.T
+    test_yH = (test_yH-mu_error_out) / sigma_error_out
+    
+    for ii in range(len(ilist)):
+        i = ilist[ii]
+        print(i)
+        err = onp.abs(mean_rpn[:,i]-test_yH[:,i])
+        x = err
+        y = std_rpn[:,i]
+        Ntot = x.shape[0]
+        y = y[~onp.isnan(x)]
+        x = x[~onp.isnan(x)]
+        x = x[~onp.isnan(y)]
+        y = y[~onp.isnan(y)]
+        ind = onp.argsort(x)
+        x = x[ind]
+        y = y[ind]
+        x = x[:Ntot-int(epsilon*Ntot)]
+        y = y[:Ntot-int(epsilon*Ntot)]
+        ind = onp.argsort(y)
+        x = x[ind]
+        y = y[ind]
+        x = onp.sqrt(x[:Ntot-2*int(epsilon*Ntot)])
+        y = y[:Ntot-2*int(epsilon*Ntot)]
+                 
+        tt = time.time()
+        k = kde.gaussian_kde([x,y])
+        xi, yi = onp.mgrid[x.min():x.max():nbins*1j, y.min():y.max():nbins*1j]
+        zi = k(onp.vstack([xi.flatten(), yi.flatten()]))
+        zi = zi.reshape(xi.shape)
+        print('gaussian_kde', time.time()-tt )
+        
+        fig = plt.figure(figsize=(12,12))
+        ax = fig.add_subplot(111)
+        plt.pcolormesh(xi, yi, zi, shading='gouraud', cmap=plt.cm.jet)
+        ax.ticklabel_format(axis="y", style="sci", scilimits=(0,0))
+        plt.colorbar()
+        ax.set_xlabel('Error')
+        ax.set_ylabel(r'$\sigma_M$')
+        plt.savefig('uncertainty_density_plots/SF_uncert_dens_'+itend[ii]+'_'+str(ipress[ii])+'_hPa.png', bbox_inches='tight', pad_inches=0.1 , dpi = 300)
+        

9_uncertainty_video.py

@@ -0,0 +1,180 @@
+#!/usr/bin/env python3
+# -*- coding: utf-8 -*-
+"""
+Created on Fri Sep 8 07:35:08 2023
+
+@author: mohamedazizbhouri
+"""
+from matplotlib import pyplot as plt
+import numpy as np
+from mpl_toolkits.basemap import Basemap
+from moviepy.editor import VideoClip
+from moviepy.video.io.bindings import mplfig_to_npimage
+
+plt.rcParams.update(plt.rcParamsDefault)
+plt.rc('font', family='serif')
+plt.rcParams.update({'font.size': 16,
+                     'lines.linewidth': 2,
+                     'axes.labelsize': 20,
+                     'axes.titlesize': 20,
+                     'xtick.labelsize': 16,
+                     'ytick.labelsize': 16,
+                     'legend.fontsize': 20,
+                     'axes.linewidth': 2,
+                     "pgf.texsystem": "pdflatex"
+                     })
+
+lat = 96
+lon = 144
+
+x = np.linspace(0, 360-360/144, lon)
+y = np.linspace(-90, 90, lat)
+X, Y = np.meshgrid(x, y)
+
+dim_heat = 26
+dim_moist = 22
+mu_error_out = np.concatenate((np.zeros((1,dim_heat),dtype=np.float32),
+                               np.zeros((1,dim_moist),dtype=np.float32)),axis=1)
+mu_error_out = mu_error_out.T[:,:,None,None]
+sigma_error_out = np.concatenate((1/1004.6*np.ones((1,dim_heat),dtype=np.float32),
+                                    1/2.26e6*np.ones((1,dim_moist),dtype=np.float32)),axis=1)
+sigma_error_out = sigma_error_out.T[:,:,None,None]
+
+y_var = 43 # 14, 18, 21, 36, 40, 43
+
+if y_var == 14:
+    ttl = 'Heat tendency at 259 hPa'
+    ttl_s = 'videos/instant_heat_tend_259.mp4'
+elif y_var == 18:
+    ttl = 'Heat tendency at 494 hPa'
+    ttl_s = 'videos/instant_heat_tend_494.mp4'
+elif y_var == 21:
+    ttl = 'Heat tendency at 761 hPa'
+    ttl_s = 'videos/instant_heat_tend_761.mp4'
+elif y_var == 36:
+    ttl = 'Moisture tendency at 259 hPa'
+    ttl_s = 'videos/instant_moist_tend_259.mp4'
+elif y_var == 40:
+    ttl = 'Moisture tendency at 494 hPa'
+    ttl_s = 'videos/instant_moist_tend_494.mp4'
+elif y_var == 43:
+    ttl = 'Moisture tendency at 761 hPa'
+    ttl_s = 'videos/instant_moist_tend_761.mp4'
+    
+test = (np.load('data_SPCAM5_4K/all_outputs_reshaped.npy')[y_var:y_var+1,:,:,:] - mu_error_out) / sigma_error_out
+test = np.array(test,dtype=np.float64)
+
+months = ['Feb', 'Mar', 'Apr', 'May', 'Jun', 'Jul', 'Aug', 'Sep', 'Oct', 'Nov', 'Dec', 'Jan']
+days = np.array([28, 28+31, 28+31+30, 28+31+30+31, 28+31+30+31+30, 28+31+30+31+30+31,
+                    28+31+30+31+30+31+31, 28+31+30+31+30+31+31+30, 28+31+30+31+30+31+31+30+31,
+                    28+31+30+31+30+31+31+30+31+30, 28+31+30+31+30+31+31+30+31+30+31,
+                    28+31+30+31+30+31+31+30+31+30+31+31])
+hours = 24*days
+
+std_rpn_MF = np.load('MF_param/mean_RPN_MF_reshaped.npy')[y_var:y_var+1,:,:,:]/ sigma_error_out
+mean_rpn_MF = (np.load('MF_param/std_RPN_MF_reshaped.npy')[y_var:y_var+1,:,:,:] - mu_error_out) / sigma_error_out
+mean_rpn_MF = np.array(mean_rpn_MF,dtype=np.float64)
+std_rpn_MF = np.array(std_rpn_MF,dtype=np.float64)
+
+std_rpn_LF = np.load('MF_param/mean_RPN_LF_reshaped.npy')[y_var:y_var+1,:,:,:]/ sigma_error_out
+mean_rpn_LF = (np.load('MF_param/std_RPN_LF_reshaped.npy')[y_var:y_var+1,:,:,:] - mu_error_out) / sigma_error_out
+mean_rpn_LF = np.array(mean_rpn_LF,dtype=np.float64)
+std_rpn_LF = np.array(std_rpn_LF,dtype=np.float64)
+
+std_rpn_SF = np.load('SF_param/mean_RPN_SF_reshaped.npy')[y_var:y_var+1,:,:,:]/ sigma_error_out
+mean_rpn_SF = (np.load('SF_param/std_RPN_SF_reshaped.npy')[y_var:y_var+1,:,:,:] - mu_error_out) / sigma_error_out
+std_rpn_SF = np.array(std_rpn_SF,dtype=np.float64)
+mean_rpn_SF = np.array(mean_rpn_SF,dtype=np.float64)
+
+MAE_MF = np.abs( test-mean_rpn_MF )
+MAE_LF = np.abs( test-mean_rpn_LF )
+MAE_SF = np.abs( test-mean_rpn_SF )
+
+N_frame = std_rpn_MF.shape[1]
+
+fps = 5
+duration = N_frame / fps 
+
+fig = plt.figure(figsize=(31.5, 14))
+
+def create_fr(t):
+    print(t,int(t*fps))
+    fig.clf()
+    
+    ax1 = fig.add_subplot(231)
+    ax1.set_title("MF-RPN - MAE")
+    m = Basemap(projection='robin',lon_0=-180)
+    contour_plot = m.pcolormesh(X, Y, MAE_MF[0,int(t*fps),:,:], latlon = True,cmap='Blues_r')
+    m.drawcoastlines(linewidth=2.0, color='0.25')
+    
+    ax2 = fig.add_subplot(234)
+    ax2.set_title("MF-RPN - Uncertainty "+r'$\sigma_M$')
+    m = Basemap(projection='robin',lon_0=-180) 
+    contour_plot = m.pcolormesh(X, Y, std_rpn_MF[0,int(t*fps),:,:], latlon = True,cmap='Blues_r')
+    m.drawcoastlines(linewidth=2.0, color='0.25')
+    #############################################
+    ax1 = fig.add_subplot(232)
+    ax1.set_title("SF-RPN - MAE")
+    m = Basemap(projection='robin',lon_0=-180)
+    contour_plot = m.pcolormesh(X, Y, MAE_SF[0,int(t*fps),:,:], latlon = True,cmap='Blues_r')
+    m.drawcoastlines(linewidth=2.0, color='0.25')
+    
+    ax2 = fig.add_subplot(235)
+    ax2.set_title("SF-RPN - Uncertainty "+r'$\sigma_M$')
+    m = Basemap(projection='robin',lon_0=-180)
+    contour_plot = m.pcolormesh(X, Y, std_rpn_SF[0,int(t*fps),:,:], latlon = True,cmap='Blues_r')
+    m.drawcoastlines(linewidth=2.0, color='0.25')
+    #############################################
+    ax1 = fig.add_subplot(233)
+    ax1.set_title("LF-RPN - MAE")
+    m = Basemap(projection='robin',lon_0=-180)
+    contour_plot = m.pcolormesh(X, Y, MAE_LF[0,int(t*fps),:,:], latlon = True,cmap='Blues_r')
+    m.drawcoastlines(linewidth=2.0, color='0.25')
+    
+    ax2 = fig.add_subplot(236)
+    ax2.set_title("LF-RPN - Uncertainty "+r'$\sigma_M$')
+    m = Basemap(projection='robin',lon_0=-180)
+    contour_plot = m.pcolormesh(X, Y, std_rpn_LF[0,int(t*fps),:,:], latlon = True,cmap='Blues_r')
+    m.drawcoastlines(linewidth=2.0, color='0.25')
+      
+    imonths = np.argmax(hours>int(t*fps)) 
+    nhour = int(t*fps) % 24
+    if nhour<10:
+        nhour = '0'+str(nhour)
+    else:
+        nhour = str(nhour)
+        
+    if imonths == 0:
+        nday = 1+int(t*fps)//24
+    else:
+        nday = int(t*fps)//24-days[imonths-1]+1
+    
+    if nday<10:
+        nday = '0'+str(nday)
+    else:
+        nday = str(nday)
+    if imonths == 11:
+        ty = '2004'
+    else:
+        ty = '2003'
+        
+    fig.suptitle(ttl + ' ; '+nday+' '+months[imonths]+' '+ty+' ; '+nhour+':00')
+
+    plt.margins(x=0)
+    plt.margins(y=0)
+    plt.subplots_adjust(hspace=-0.3)
+    fig.subplots_adjust(top=0.85)
+    plt.tight_layout()
+    
+    fig.canvas.draw()
+    cbar_ax = fig.add_axes([0.05, 0.02, 0.9, 0.05])
+    cbar = fig.colorbar(contour_plot, orientation='horizontal', cax=cbar_ax)
+    cbar.set_ticks([])
+    
+    return mplfig_to_npimage(fig)
+ 
+animation = VideoClip(create_fr, duration = duration)
+
+animation.write_videofile(ttl_s,fps=fps,threads=16,
+                          logger=None,codec="mpeg4",preset="slow",ffmpeg_params=['-b:v','10000k'])
+    

9_uncertainty_video_daily.py

@@ -0,0 +1,191 @@
+#!/usr/bin/env python3
+# -*- coding: utf-8 -*-
+"""
+Created on Fri Sep 8 08:12:39 2023
+
+@author: mohamedazizbhouri
+"""
+from matplotlib import pyplot as plt
+import numpy as np
+from mpl_toolkits.basemap import Basemap
+from moviepy.editor import VideoClip
+from moviepy.video.io.bindings import mplfig_to_npimage
+
+plt.rcParams.update(plt.rcParamsDefault)
+plt.rc('font', family='serif')
+plt.rcParams.update({'font.size': 16,
+                     'lines.linewidth': 2,
+                     'axes.labelsize': 20,
+                     'axes.titlesize': 20,
+                     'xtick.labelsize': 16,
+                     'ytick.labelsize': 16,
+                     'legend.fontsize': 20,
+                     'axes.linewidth': 2,
+                     "pgf.texsystem": "pdflatex"
+                     })
+
+lat = 96
+lon = 144
+
+x = np.linspace(0, 360-360/144, lon)
+y = np.linspace(-90, 90, lat)
+X, Y = np.meshgrid(x, y)
+
+dim_heat = 26
+dim_moist = 22
+mu_error_out = np.concatenate((np.zeros((1,dim_heat),dtype=np.float32),
+                               np.zeros((1,dim_moist),dtype=np.float32)),axis=1)
+mu_error_out = mu_error_out.T[:,:,None,None]
+sigma_error_out = np.concatenate((1/1004.6*np.ones((1,dim_heat),dtype=np.float32),
+                                    1/2.26e6*np.ones((1,dim_moist),dtype=np.float32)),axis=1)
+sigma_error_out = sigma_error_out.T[:,:,None,None]
+
+y_var = 43 # 14, 18, 21, 36, 40, 43
+
+if y_var == 14:
+    ttl = 'Heat tendency at 259 hPa'
+    ttl_s = 'videos/daily_heat_tend_259.mp4'
+elif y_var == 18:
+    ttl = 'Heat tendency at 494 hPa'
+    ttl_s = 'videos/daily_heat_tend_494.mp4'
+elif y_var == 21:
+    ttl = 'Heat tendency at 761 hPa'
+    ttl_s = 'videos/daily_heat_tend_761.mp4'
+elif y_var == 36:
+    ttl = 'Moisture tendency at 259 hPa'
+    ttl_s = 'videos/daily_moist_tend_259.mp4'
+elif y_var == 40:
+    ttl = 'Moisture tendency at 494 hPa'
+    ttl_s = 'videos/daily_moist_tend_494.mp4'
+elif y_var == 43:
+    ttl = 'Moisture tendency at 761 hPa'
+    ttl_s = 'videos/daily_moist_tend_761.mp4'
+    
+test = (np.load('data_SPCAM5_4K/all_outputs_reshaped.npy')[y_var:y_var+1,:,:,:] - mu_error_out) / sigma_error_out
+test = np.array(test,dtype=np.float64)
+
+N_dt_day = 24 # we have a dt=1hour
+def daily_avg(test):
+    test_daily = []
+    N_time_steps = test.shape[1]
+    for i in range(test.shape[0]):
+        test_daily.append( np.mean( test[i,:,:,:].reshape( (N_time_steps//N_dt_day, N_dt_day, lat, lon) ), axis=1 ) )
+    return np.array(test_daily)
+
+months = ['Feb', 'Mar', 'Apr', 'May', 'Jun', 'Jul', 'Aug', 'Sep', 'Oct', 'Nov', 'Dec', 'Jan']
+days = np.array([28, 28+31, 28+31+30, 28+31+30+31, 28+31+30+31+30, 28+31+30+31+30+31,
+                28+31+30+31+30+31+31, 28+31+30+31+30+31+31+30, 28+31+30+31+30+31+31+30+31,
+                28+31+30+31+30+31+31+30+31+30, 28+31+30+31+30+31+31+30+31+30+31,
+                28+31+30+31+30+31+31+30+31+30+31+31])
+
+std_rpn_MF = np.load('MF_param/mean_RPN_MF_reshaped.npy')[y_var:y_var+1,:,:,:]/ sigma_error_out
+mean_rpn_MF = (np.load('MF_param/std_RPN_MF_reshaped.npy')[y_var:y_var+1,:,:,:] - mu_error_out) / sigma_error_out
+mean_rpn_MF = np.array(mean_rpn_MF,dtype=np.float64)
+std_rpn_MF = np.array(std_rpn_MF,dtype=np.float64)
+
+std_rpn_LF = np.load('MF_param/mean_RPN_LF_reshaped.npy')[y_var:y_var+1,:,:,:]/ sigma_error_out
+mean_rpn_LF = (np.load('MF_param/std_RPN_LF_reshaped.npy')[y_var:y_var+1,:,:,:] - mu_error_out) / sigma_error_out
+mean_rpn_LF = np.array(mean_rpn_LF,dtype=np.float64)
+std_rpn_LF = np.array(std_rpn_LF,dtype=np.float64)
+
+std_rpn_SF = np.load('SF_param/mean_RPN_SF_reshaped.npy')[y_var:y_var+1,:,:,:]/ sigma_error_out
+mean_rpn_SF = (np.load('SF_param/std_RPN_SF_reshaped.npy')[y_var:y_var+1,:,:,:] - mu_error_out) / sigma_error_out
+std_rpn_SF = np.array(std_rpn_SF,dtype=np.float64)
+mean_rpn_SF = np.array(mean_rpn_SF,dtype=np.float64)
+
+test = daily_avg(test)
+
+mean_rpn_MF = daily_avg(mean_rpn_MF)
+MAE_MF = np.abs( test-mean_rpn_MF )
+std_rpn_MF = daily_avg(std_rpn_MF )
+
+mean_rpn_LF = daily_avg(mean_rpn_LF)
+MAE_LF = np.abs( test-mean_rpn_LF )
+std_rpn_LF = daily_avg(std_rpn_LF )
+
+mean_rpn_SF = daily_avg(mean_rpn_SF)
+MAE_SF = np.abs( test-mean_rpn_SF )
+std_rpn_SF = daily_avg(std_rpn_SF )
+
+N_frame = std_rpn_MF.shape[1]
+
+fps = 5
+duration = N_frame / fps
+
+fig = plt.figure(figsize=(31.5, 14))
+
+def create_fr(t):
+    print(t,int(t*fps))
+    fig.clf()
+    
+    ax1 = fig.add_subplot(231)
+    ax1.set_title("MF-RPN - MAE")
+    m = Basemap(projection='robin',lon_0=-180) 
+    contour_plot = m.pcolormesh(X, Y, MAE_MF[0,int(t*fps),:,:], latlon = True,cmap='Blues_r')
+    m.drawcoastlines(linewidth=2.0, color='0.25')
+    
+    ax2 = fig.add_subplot(234)
+    ax2.set_title("MF-RPN - Uncertainty "+r'$\sigma_M$')
+    m = Basemap(projection='robin',lon_0=-180) 
+    contour_plot = m.pcolormesh(X, Y, std_rpn_MF[0,int(t*fps),:,:], latlon = True,cmap='Blues_r')
+    m.drawcoastlines(linewidth=2.0, color='0.25')
+    #############################################
+    ax1 = fig.add_subplot(232)
+    ax1.set_title("SF-RPN - MAE")
+    m = Basemap(projection='robin',lon_0=-180)
+    contour_plot = m.pcolormesh(X, Y, MAE_SF[0,int(t*fps),:,:], latlon = True,cmap='Blues_r')
+    m.drawcoastlines(linewidth=2.0, color='0.25')
+    
+    ax2 = fig.add_subplot(235)
+    ax2.set_title("SF-RPN - Uncertainty "+r'$\sigma_M$')
+    m = Basemap(projection='robin',lon_0=-180)
+    contour_plot = m.pcolormesh(X, Y, std_rpn_SF[0,int(t*fps),:,:], latlon = True,cmap='Blues_r')
+    m.drawcoastlines(linewidth=2.0, color='0.25')
+    #############################################
+    ax1 = fig.add_subplot(233)
+    ax1.set_title("LF-RPN - MAE")
+    m = Basemap(projection='robin',lon_0=-180)
+    contour_plot = m.pcolormesh(X, Y, MAE_LF[0,int(t*fps),:,:], latlon = True,cmap='Blues_r')
+    m.drawcoastlines(linewidth=2.0, color='0.25')
+    
+    ax2 = fig.add_subplot(236)
+    ax2.set_title("LF-RPN - Uncertainty "+r'$\sigma_M$')
+    m = Basemap(projection='robin',lon_0=-180)
+    contour_plot = m.pcolormesh(X, Y, std_rpn_LF[0,int(t*fps),:,:], latlon = True,cmap='Blues_r')
+    m.drawcoastlines(linewidth=2.0, color='0.25')
+                
+    imonths = np.argmax(days>int(t*fps)) 
+    if imonths == 0:
+        nday = 1+int(t*fps)
+    else:
+        nday = int(t*fps)-days[imonths-1]+1
+    
+    if nday<10:
+        nday = '0'+str(nday)
+    else:
+        nday = str(nday)
+    if imonths == 11:
+        ty = '2004'
+    else:
+        ty = '2003'
+        
+    fig.suptitle(ttl + ' ; '+nday+' '+months[imonths]+' '+ty)
+
+    plt.margins(x=0)
+    plt.margins(y=0)
+    plt.subplots_adjust(hspace=-0.3)
+    fig.subplots_adjust(top=0.85)
+    plt.tight_layout()
+    
+    fig.canvas.draw()
+    cbar_ax = fig.add_axes([0.05, 0.02, 0.9, 0.05])
+    cbar = fig.colorbar(contour_plot, orientation='horizontal', cax=cbar_ax)
+    cbar.set_ticks([])
+    
+    return mplfig_to_npimage(fig)
+ 
+animation = VideoClip(create_fr, duration = duration)
+
+animation.write_videofile(ttl_s,fps=fps,threads=16,
+                          logger=None,codec="mpeg4",preset="slow",ffmpeg_params=['-b:v','10000k'])
+    

glob_errors/MAE_det.npy

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

glob_errors/MAE_rpn_LF.npy

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

glob_errors/MAE_rpn_MF.npy

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

glob_errors/MAE_rpn_SF.npy

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

glob_errors/crps_rpn_LF.npy

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

glob_errors/crps_rpn_MF.npy

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

glob_errors/crps_rpn_SF.npy

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

glob_errors/r2_det.npy

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

glob_errors/r2_rpn_LF.npy

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

glob_errors/r2_rpn_MF.npy

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

glob_errors/r2_rpn_SF.npy

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