Select Git revision
cloud_opd_fcn_abi.py
cloud_opd_fcn_abi.py 46.60 KiB
import contextlib
import tensorflow as tf
from deeplearning.cloud_fraction_fcn_abi import get_label_data_5cat
from util.augment import augment_image
from util.setup_cloud_products import logdir, modeldir, now, ancillary_path
from util.util import EarlyStop, normalize, denormalize, scale, scale2, descale, \
get_grid_values_all, make_tf_callable_generator
import glob
import os
import datetime
import numpy as np
import pickle
import h5py
import xarray as xr
import gc
import time
AUTOTUNE = tf.data.AUTOTUNE
LOG_DEVICE_PLACEMENT = False
PROC_BATCH_SIZE = 4
PROC_BATCH_BUFFER_SIZE = 5000
NumClasses = 5
if NumClasses == 2:
NumLogits = 1
else:
NumLogits = NumClasses
BATCH_SIZE = 128
NUM_EPOCHS = 100
EARLY_STOP = True
PATIENCE = 7
NOISE_TRAINING = False
NOISE_STDDEV = 0.01
DO_AUGMENT = True
DO_SMOOTH = False
SIGMA = 1.0
DO_ZERO_OUT = False
# CACHE_FILE = '/scratch/long/rink/cld_opd_abi_128x128_cache'
CACHE_FILE = ''
USE_EMA = False
EMA_OVERWRITE_FREQUENCY = 5
EMA_MOMENTUM = 0.99
BETA_1 = 0.9
BETA_2 = 0.999
# setup scaling parameters dictionary
mean_std_dct = {}
mean_std_file = ancillary_path+'mean_std_lo_hi_l2.pkl'
f = open(mean_std_file, 'rb')
mean_std_dct_l2 = pickle.load(f)
f.close()
mean_std_file = ancillary_path+'mean_std_lo_hi_l1b.pkl'
f = open(mean_std_file, 'rb')
mean_std_dct_l1b = pickle.load(f)
f.close()
mean_std_dct.update(mean_std_dct_l1b)
mean_std_dct.update(mean_std_dct_l2)
IMG_DEPTH = 1
label_param = 'cld_opd_dcomp'
params = ['temp_11_0um_nom', 'refl_0_65um_nom', 'refl_submin_ch01', 'refl_submax_ch01', 'refl_substddev_ch01', 'cloud_probability', label_param]
params_i = ['temp_11_0um_nom', 'refl_0_65um_nom', 'cloud_probability', label_param]
data_params_half = ['temp_11_0um_nom', 'refl_0_65um_nom']
sub_fields = ['refl_submin_ch01', 'refl_submax_ch01', 'refl_substddev_ch01']
data_params_full = ['refl_0_65um_nom']
label_idx_i = params_i.index(label_param)
label_idx = params.index(label_param)
print('data_params_half: ', data_params_half)
print('data_params_full: ', data_params_full)
print('label_param: ', label_param)
KERNEL_SIZE = 3
X_LEN = Y_LEN = 128
if KERNEL_SIZE == 3:
slc_x = slice(0, X_LEN // 4 + 2)
slc_y = slice(0, Y_LEN // 4 + 2)
x_64 = slice(4, X_LEN + 4)
y_64 = slice(4, Y_LEN + 4)
elif KERNEL_SIZE == 1:
slc_x = slice(1, X_LEN // 4 + 1)
slc_y = slice(1, Y_LEN // 4 + 1)
x_64 = slice(4, X_LEN + 4)
y_64 = slice(4, Y_LEN + 4)
# ----------------------------------------
@contextlib.contextmanager
def options(options):
old_opts = tf.config.optimizer.get_experimental_options()
tf.config.optimizer.set_experimental_options(options)
try:
yield
finally:
tf.config.optimizer.set_experimental_options(old_opts)
def build_residual_conv2d_block(conv, num_filters, block_name, activation=tf.nn.relu, padding='SAME',
kernel_initializer='he_uniform', scale=None, kernel_size=3,
do_drop_out=True, drop_rate=0.5, do_batch_norm=True):
with tf.name_scope(block_name):
skip = tf.keras.layers.Conv2D(num_filters, kernel_size=kernel_size, padding=padding, kernel_initializer=kernel_initializer, activation=activation)(conv)
skip = tf.keras.layers.Conv2D(num_filters, kernel_size=kernel_size, padding=padding, activation=None)(skip)
if scale is not None:
skip = tf.keras.layers.Lambda(lambda x: x * scale)(skip)
if do_drop_out:
skip = tf.keras.layers.Dropout(drop_rate)(skip)
if do_batch_norm:
skip = tf.keras.layers.BatchNormalization()(skip)
conv = conv + skip
print(block_name+':', conv.shape)
return conv
def upsample_mean(grd):
bsize, ylen, xlen = grd.shape
up = np.zeros((bsize, ylen*2, xlen*2))
up[:, ::4, ::4] = grd[:, ::4, ::4]
up[:, 1::4, ::4] = grd[:, ::4, ::4]
up[:, ::4, 1::4] = grd[:, ::4, ::4]
up[:, 1::4, 1::4] = grd[:, ::4, ::4]
return up
def get_grid_cell_mean(grd_k):
mean = np.nanmean([grd_k[:, 0::4, 0::4], grd_k[:, 1::4, 0::4], grd_k[:, 2::4, 0::4], grd_k[:, 3::4, 0::4],
grd_k[:, 0::4, 1::4], grd_k[:, 1::4, 1::4], grd_k[:, 2::4, 1::4], grd_k[:, 3::4, 1::4],
grd_k[:, 0::4, 2::4], grd_k[:, 1::4, 2::4], grd_k[:, 2::4, 2::4], grd_k[:, 3::4, 2::4],
grd_k[:, 0::4, 3::4], grd_k[:, 1::4, 3::4], grd_k[:, 2::4, 3::4], grd_k[:, 3::4, 3::4]], axis=0)
# For an all-Nan slice
np.where(np.isnan(mean), 0, mean)
return mean
def get_min_max_std(grd_k):
lo = np.nanmin([grd_k[:, 0::4, 0::4], grd_k[:, 1::4, 0::4], grd_k[:, 2::4, 0::4], grd_k[:, 3::4, 0::4],
grd_k[:, 0::4, 1::4], grd_k[:, 1::4, 1::4], grd_k[:, 2::4, 1::4], grd_k[:, 3::4, 1::4],
grd_k[:, 0::4, 2::4], grd_k[:, 1::4, 2::4], grd_k[:, 2::4, 2::4], grd_k[:, 3::4, 2::4],
grd_k[:, 0::4, 3::4], grd_k[:, 1::4, 3::4], grd_k[:, 2::4, 3::4], grd_k[:, 3::4, 3::4]], axis=0)
hi = np.nanmax([grd_k[:, 0::4, 0::4], grd_k[:, 1::4, 0::4], grd_k[:, 2::4, 0::4], grd_k[:, 3::4, 0::4],
grd_k[:, 0::4, 1::4], grd_k[:, 1::4, 1::4], grd_k[:, 2::4, 1::4], grd_k[:, 3::4, 1::4],
grd_k[:, 0::4, 2::4], grd_k[:, 1::4, 2::4], grd_k[:, 2::4, 2::4], grd_k[:, 3::4, 2::4],
grd_k[:, 0::4, 3::4], grd_k[:, 1::4, 3::4], grd_k[:, 2::4, 3::4], grd_k[:, 3::4, 3::4]], axis=0)
std = np.nanstd([grd_k[:, 0::4, 0::4], grd_k[:, 1::4, 0::4], grd_k[:, 2::4, 0::4], grd_k[:, 3::4, 0::4],
grd_k[:, 0::4, 1::4], grd_k[:, 1::4, 1::4], grd_k[:, 2::4, 1::4], grd_k[:, 3::4, 1::4],
grd_k[:, 0::4, 2::4], grd_k[:, 1::4, 2::4], grd_k[:, 2::4, 2::4], grd_k[:, 3::4, 2::4],
grd_k[:, 0::4, 3::4], grd_k[:, 1::4, 3::4], grd_k[:, 2::4, 3::4], grd_k[:, 3::4, 3::4]], axis=0)
avg = np.nanmean([grd_k[:, 0::4, 0::4], grd_k[:, 1::4, 0::4], grd_k[:, 2::4, 0::4], grd_k[:, 3::4, 0::4],
grd_k[:, 0::4, 1::4], grd_k[:, 1::4, 1::4], grd_k[:, 2::4, 1::4], grd_k[:, 3::4, 1::4],
grd_k[:, 0::4, 2::4], grd_k[:, 1::4, 2::4], grd_k[:, 2::4, 2::4], grd_k[:, 3::4, 2::4],
grd_k[:, 0::4, 3::4], grd_k[:, 1::4, 3::4], grd_k[:, 2::4, 3::4], grd_k[:, 3::4, 3::4]], axis=0)
# For an all-NaN slice
np.where(np.isnan(lo), 0, lo)
np.where(np.isnan(hi), 0, hi)
np.where(np.isnan(std), 0, std)
np.where(np.isnan(avg), 0, avg)
return lo, hi, std, avg
def get_cldy_frac_opd(cld_prob, opd):
cld_prob = np.where(np.isnan(cld_prob), 0.0, cld_prob)
cld = np.where(cld_prob < 0.5, 0, 1)
opd = np.where(np.isnan(opd), 0.0, opd)
cnt_cld = cld[:, 0::4, 0::4] + cld[:, 1::4, 0::4] + cld[:, 2::4, 0::4] + cld[:, 3::4, 0::4] + \
cld[:, 0::4, 1::4] + cld[:, 1::4, 1::4] + cld[:, 2::4, 1::4] + cld[:, 3::4, 1::4] + \
cld[:, 0::4, 2::4] + cld[:, 1::4, 2::4] + cld[:, 2::4, 2::4] + cld[:, 3::4, 2::4] + \
cld[:, 0::4, 3::4] + cld[:, 1::4, 3::4] + cld[:, 2::4, 3::4] + cld[:, 3::4, 3::4]
opd_sum = np.sum([opd[:, 0::4, 0::4], opd[:, 1::4, 0::4], opd[:, 2::4, 0::4], opd[:, 3::4, 0::4],
opd[:, 0::4, 1::4], opd[:, 1::4, 1::4], opd[:, 2::4, 1::4], opd[:, 3::4, 1::4],
opd[:, 0::4, 2::4], opd[:, 1::4, 2::4], opd[:, 2::4, 2::4], opd[:, 3::4, 2::4],
opd[:, 0::4, 3::4], opd[:, 1::4, 3::4], opd[:, 2::4, 3::4], opd[:, 3::4, 3::4]], axis=0)
opd[cld == 0] = 0.0
cld_opd_sum = np.sum([opd[:, 0::4, 0::4], opd[:, 1::4, 0::4], opd[:, 2::4, 0::4], opd[:, 3::4, 0::4],
opd[:, 0::4, 1::4], opd[:, 1::4, 1::4], opd[:, 2::4, 1::4], opd[:, 3::4, 1::4],
opd[:, 0::4, 2::4], opd[:, 1::4, 2::4], opd[:, 2::4, 2::4], opd[:, 3::4, 2::4],
opd[:, 0::4, 3::4], opd[:, 1::4, 3::4], opd[:, 2::4, 3::4], opd[:, 3::4, 3::4]], axis=0)
cldy_opd = np.zeros(cnt_cld.shape, dtype=opd.dtype)
cldy_opd[cnt_cld == 0] = opd_sum[cnt_cld == 0] / 16
cldy_opd[cnt_cld != 0] = cld_opd_sum[cnt_cld != 0] / cnt_cld[cnt_cld != 0]
return cldy_opd
class SRCNN:
def __init__(self):
self.train_data = None
self.train_label = None
self.test_data = None
self.test_label = None
self.test_data_denorm = None
self.train_dataset = None
self.inner_train_dataset = None
self.test_dataset = None
self.eval_dataset = None
self.X_img = None
self.X_prof = None
self.X_u = None
self.X_v = None
self.X_sfc = None
self.inputs = []
self.y = None
self.handle = None
self.inner_handle = None
self.in_mem_batch = None
self.h5f_l1b_trn = None
self.h5f_l1b_tst = None
self.h5f_l2_trn = None
self.h5f_l2_tst = None
self.logits = None
self.predict_data = None
self.predict_dataset = None
self.mean_list = None
self.std_list = None
self.training_op = None
self.correct = None
self.accuracy = None
self.loss = None
self.pred_class = None
self.variable_averages = None
self.global_step = None
self.writer_train = None
self.writer_valid = None
self.writer_train_valid_loss = None
self.OUT_OF_RANGE = False
self.model = None
self.optimizer = None
self.ema = None
self.train_loss = None
self.train_accuracy = None
self.test_loss = None
self.test_accuracy = None
self.test_auc = None
self.test_recall = None
self.test_precision = None
self.test_confusion_matrix = None
self.test_true_pos = None
self.test_true_neg = None
self.test_false_pos = None
self.test_false_neg = None
self.test_labels = []
self.test_preds = []
self.test_probs = None
self.test_input = []
self.test_cat_cf = []
self.learningRateSchedule = None
self.num_data_samples = None
self.initial_learning_rate = None
self.data_dct = None
self.train_data_files = None
self.train_label_files = None
self.test_data_files = None
self.test_label_files = None
# self.n_chans = len(data_params_half) + len(data_params_full) + 1
self.n_chans = 6
# Testing/Evaluation mode
# self.X_img = tf.keras.Input(shape=(None, None, self.n_chans + 2))
self.X_img = tf.keras.Input(shape=(None, None, self.n_chans))
self.inputs.append(self.X_img)
tf.debugging.set_log_device_placement(LOG_DEVICE_PLACEMENT)
def get_in_mem_data_batch(self, idxs, is_training):
if is_training:
data_files = self.train_data_files
label_files = self.train_label_files
else:
data_files = self.test_data_files
label_files = self.test_label_files
data_s = []
label_s = []
for k in idxs:
f = data_files[k]
nda = np.load(f)
data_s.append(nda)
f = label_files[k]
nda = np.load(f)
label_s.append(nda)
input_data = np.concatenate(data_s)
input_label = np.concatenate(label_s)
# refl_i = input_label[:, params_i.index('refl_0_65um_nom'), :, :]
# rlo, rhi, rstd, rmean = get_min_max_std(refl_i)
# rmean = rmean[:, slc_y, slc_x]
# rmean = scale2(rmean, -2.0, 120.0)
# rlo = rlo[:, slc_y, slc_x]
# rlo = scale2(rlo, -2.0, 120.0)
# rhi = rhi[:, slc_y, slc_x]
# rhi = scale2(rhi, -2.0, 120.0)
# refl_rng = rhi - rlo
# rstd = rstd[:, slc_y, slc_x]
# rstd = scale2(rstd, 0.0, 20.0)
data_norm = []
# for param in data_params_half:
# idx = params.index(param)
# tmp = input_data[:, idx, :, :]
# tmp = tmp[:, slc_y, slc_x]
# # tmp = normalize(tmp, param, mean_std_dct)
# tmp = scale(tmp, param, mean_std_dct)
# data_norm.append(tmp)
bt = input_data[:, params.index('temp_11_0um_nom'), :, :]
bt = bt[:, slc_y, slc_x]
# bt = normalize(bt, 'temp_11_0um_nom', mean_std_dct)
bt = scale(bt, 'temp_11_0um_nom', mean_std_dct)
data_norm.append(bt)
tmp = input_label[:, params_i.index('cloud_probability'), :, :]
cld_prob = tmp.copy()
tmp = get_grid_cell_mean(tmp)
tmp = tmp[:, slc_y, slc_x]
data_norm.append(tmp)
refl = input_data[:, params.index('refl_0_65um_nom'), :, :]
refl = refl[:, slc_y, slc_x]
# refl = normalize(refl, 'refl_0_65um_nom', mean_std_dct)
refl = scale(refl, 'refl_0_65um_nom', mean_std_dct)
data_norm.append(refl)
# for param in sub_fields:
# idx = params.index(param)
# tmp = input_data[:, idx, :, :]
# tmp = tmp[:, slc_y, slc_x]
# if param != 'refl_substddev_ch01':
# # tmp = normalize(tmp, 'refl_0_65um_nom', mean_std_dct)
# tmp = scale(tmp, 'refl_0_65um_nom', mean_std_dct)
# else:
# # tmp = np.where(np.isnan(tmp), 0, tmp)
# tmp = scale2(tmp, 0.0, 20.0)
# data_norm.append(tmp)
refl_lo = input_data[:, params.index(sub_fields[0]), :, :]
refl_lo = refl_lo[:, slc_y, slc_x]
refl_lo = scale2(refl_lo, -2.0, 120.0)
refl_hi = input_data[:, params.index(sub_fields[1]), :, :]
refl_hi = refl_hi[:, slc_y, slc_x]
refl_hi = scale2(refl_hi, -2.0, 120.0)
refl_rng = refl_hi - refl_lo
data_norm.append(refl_rng)
refl_std = input_data[:, params.index(sub_fields[2]), :, :]
refl_std = refl_std[:, slc_y, slc_x]
refl_std = scale2(refl_std, 0.0, 30.0)
data_norm.append(refl_std)
tmp = input_label[:, label_idx_i, :, :]
tmp = get_grid_cell_mean(tmp)
tmp = scale(tmp, label_param, mean_std_dct)
tmp = tmp[:, slc_y, slc_x]
data_norm.append(tmp)
# ---------
# data = np.stack(data_norm, axis=3)
# data = data.astype(np.float32)
# -----------------------------------------------------
# -----------------------------------------------------
label = input_label[:, label_idx_i, :, :]
label = label[:, y_64, x_64]
cld_prob = cld_prob[:, y_64, x_64]
cat_cf = get_label_data_5cat(cld_prob)
_, _, cp_std, _ = get_min_max_std(cld_prob)
if KERNEL_SIZE != 1:
cat_cf = np.pad(cat_cf, pad_width=[(0, 0), (1, 1), (1, 1)])
cp_std = np.pad(cp_std, pad_width=[(0, 0), (1, 1), (1, 1)])
data_norm.append(cat_cf)
data_norm.append(cp_std)
data = np.stack(data_norm, axis=3)
label = get_cldy_frac_opd(cld_prob, label)
# label = scale(label, label_param, mean_std_dct)
label = np.where(np.isnan(label), 0, label)
label = np.expand_dims(label, axis=3)
data = data.astype(np.float32)
label = label.astype(np.float32)
# if is_training and DO_AUGMENT:
# data_ud = np.flip(data, axis=1)
# label_ud = np.flip(label, axis=1)
#
# data_lr = np.flip(data, axis=2)
# label_lr = np.flip(label, axis=2)
#
# data = np.concatenate([data, data_ud, data_lr])
# label = np.concatenate([label, label_ud, label_lr])
return data, label
def get_in_mem_data_batch_train(self, idxs):
return self.get_in_mem_data_batch(idxs, True)
def get_in_mem_data_batch_test(self, idxs):
return self.get_in_mem_data_batch(idxs, False)
@tf.function(input_signature=[tf.TensorSpec(None, tf.int32)])
def data_function(self, indexes):
out = tf.numpy_function(self.get_in_mem_data_batch_train, [indexes], [tf.float32, tf.float32])
return out
@tf.function(input_signature=[tf.TensorSpec(None, tf.int32)])
def data_function_test(self, indexes):
out = tf.numpy_function(self.get_in_mem_data_batch_test, [indexes], [tf.float32, tf.float32])
return out
def get_train_dataset(self, num_files):
def integer_gen(limit):
n = 0
while n < limit:
yield n
n += 1
num_gen = integer_gen(num_files)
gen = make_tf_callable_generator(num_gen)
dataset = tf.data.Dataset.from_generator(gen, output_types=tf.int32)
dataset = dataset.batch(PROC_BATCH_SIZE)
dataset = dataset.map(self.data_function, num_parallel_calls=8)
dataset = dataset.cache(filename=CACHE_FILE)
dataset = dataset.shuffle(PROC_BATCH_BUFFER_SIZE, reshuffle_each_iteration=True)
if DO_AUGMENT:
dataset = dataset.map(augment_image(), num_parallel_calls=8)
dataset = dataset.prefetch(buffer_size=1)
self.train_dataset = dataset
def get_test_dataset(self, num_files):
def integer_gen(limit):
n = 0
while n < limit:
yield n
n += 1
num_gen = integer_gen(num_files)
gen = make_tf_callable_generator(num_gen)
dataset = tf.data.Dataset.from_generator(gen, output_types=tf.int32)
dataset = dataset.batch(PROC_BATCH_SIZE)
dataset = dataset.map(self.data_function_test, num_parallel_calls=8)
dataset = dataset.cache()
self.test_dataset = dataset
def setup_pipeline(self, train_data_files, train_label_files, test_data_files, test_label_files, num_train_samples):
self.train_data_files = train_data_files
self.train_label_files = train_label_files
self.test_data_files = test_data_files
self.test_label_files = test_label_files
self.get_train_dataset(len(train_data_files))
self.get_test_dataset(len(test_data_files))
self.num_data_samples = num_train_samples # approximately
print('datetime: ', now)
print('training and test data: ')
print('---------------------------')
print('num train files: ', len(train_data_files))
print('BATCH SIZE: ', BATCH_SIZE)
print('num test files: ', len(test_data_files))
print('setup_pipeline: Done')
def setup_test_pipeline(self, test_data_files, test_label_files):
self.test_data_files = test_data_files
self.test_label_files = test_label_files
self.get_test_dataset(len(test_data_files))
print('setup_test_pipeline: Done')
def build_srcnn(self, do_drop_out=False, do_batch_norm=False, drop_rate=0.5, factor=2):
print('build_cnn')
padding = "SAME"
# activation = tf.nn.relu
# activation = tf.nn.elu
activation = tf.nn.relu
momentum = 0.99
num_filters = 64
input_2d = self.inputs[0]
input_2d = input_2d[:, :, :, 0:self.n_chans]
print('input: ', input_2d.shape)
conv = conv_b = tf.keras.layers.Conv2D(num_filters, kernel_size=KERNEL_SIZE, kernel_initializer='he_uniform', activation=activation, padding='VALID')(input_2d)
print(conv.shape)
# if NOISE_TRAINING:
# conv = conv_b = tf.keras.layers.GaussianNoise(stddev=NOISE_STDDEV)(conv)
scale = 0.2
conv_b = build_residual_conv2d_block(conv_b, num_filters, 'Residual_Block_1', kernel_size=KERNEL_SIZE, scale=scale)
conv_b = build_residual_conv2d_block(conv_b, num_filters, 'Residual_Block_2', kernel_size=KERNEL_SIZE, scale=scale)
conv_b = build_residual_conv2d_block(conv_b, num_filters, 'Residual_Block_3', kernel_size=KERNEL_SIZE, scale=scale)
conv_b = build_residual_conv2d_block(conv_b, num_filters, 'Residual_Block_4', kernel_size=KERNEL_SIZE, scale=scale)
conv_b = build_residual_conv2d_block(conv_b, num_filters, 'Residual_Block_5', kernel_size=KERNEL_SIZE, scale=scale)
conv_b = build_residual_conv2d_block(conv_b, num_filters, 'Residual_Block_6', kernel_size=KERNEL_SIZE, scale=scale)
conv_b = tf.keras.layers.Conv2D(num_filters, kernel_size=KERNEL_SIZE, strides=1, activation=activation, kernel_initializer='he_uniform', padding=padding)(conv_b)
# conv = conv + conv_b
conv = conv_b
print(conv.shape)
# This is effectively a Dense layer
self.logits = tf.keras.layers.Conv2D(1, kernel_size=1, strides=1, padding=padding, name='regression')(conv)
print(self.logits.shape)
def build_training(self):
# self.loss = tf.keras.losses.MeanSquaredError() # Regression
self.loss = tf.keras.losses.MeanAbsoluteError() # Regression
# decayed_learning_rate = learning_rate * decay_rate ^ (global_step / decay_steps)
initial_learning_rate = 0.001
decay_rate = 0.95
steps_per_epoch = int(self.num_data_samples/BATCH_SIZE) # one epoch
decay_steps = int(steps_per_epoch) * 2
print('initial rate, decay rate, steps/epoch, decay steps: ', initial_learning_rate, decay_rate, steps_per_epoch, decay_steps)
self.learningRateSchedule = tf.keras.optimizers.schedules.ExponentialDecay(initial_learning_rate, decay_steps, decay_rate)
optimizer = tf.keras.optimizers.Adam(learning_rate=self.learningRateSchedule,
beta_1=BETA_1, beta_2=BETA_2,
use_ema=USE_EMA,
ema_momentum=EMA_MOMENTUM,
ema_overwrite_frequency=EMA_OVERWRITE_FREQUENCY)
self.optimizer = optimizer
self.initial_learning_rate = initial_learning_rate
def build_evaluation(self):
self.train_accuracy = tf.keras.metrics.MeanAbsoluteError(name='train_accuracy')
self.test_accuracy = tf.keras.metrics.MeanAbsoluteError(name='test_accuracy')
self.train_loss = tf.keras.metrics.Mean(name='train_loss')
self.test_loss = tf.keras.metrics.Mean(name='test_loss')
@tf.function(input_signature=[tf.TensorSpec(None, tf.float32), tf.TensorSpec(None, tf.float32)])
def train_step(self, inputs, labels):
labels = tf.squeeze(labels, axis=[3])
with tf.GradientTape() as tape:
pred = self.model([inputs], training=True)
loss = self.loss(labels, pred)
total_loss = loss
if len(self.model.losses) > 0:
reg_loss = tf.math.add_n(self.model.losses)
total_loss = loss + reg_loss
gradients = tape.gradient(total_loss, self.model.trainable_variables)
self.optimizer.apply_gradients(zip(gradients, self.model.trainable_variables))
self.train_loss(loss)
self.train_accuracy(labels, pred)
return loss
@tf.function(input_signature=[tf.TensorSpec(None, tf.float32), tf.TensorSpec(None, tf.float32)])
def test_step(self, inputs, labels):
labels = tf.squeeze(labels, axis=[3])
pred = self.model([inputs], training=False)
t_loss = self.loss(labels, pred)
self.test_loss(t_loss)
self.test_accuracy(labels, pred)
# @tf.function(input_signature=[tf.TensorSpec(None, tf.float32), tf.TensorSpec(None, tf.float32)])
# decorator commented out because pred.numpy(): pred not evaluated yet.
def predict(self, inputs, labels):
pred = self.model([inputs], training=False)
# t_loss = self.loss(tf.squeeze(labels, axis=[3]), pred)
t_loss = self.loss(labels, pred)
self.test_labels.append(labels)
self.test_preds.append(pred.numpy())
self.test_input.append(inputs)
self.test_cat_cf.append(inputs[:, :, :, self.n_chans])
self.test_loss(t_loss)
self.test_accuracy(labels, pred)
def reset_test_metrics(self):
self.test_loss.reset_states()
self.test_accuracy.reset_states()
def get_metrics(self):
recall = self.test_recall.result()
precsn = self.test_precision.result()
f1 = 2 * (precsn * recall) / (precsn + recall)
tn = self.test_true_neg.result()
tp = self.test_true_pos.result()
fn = self.test_false_neg.result()
fp = self.test_false_pos.result()
mcc = ((tp * tn) - (fp * fn)) / np.sqrt((tp + fp) * (tp + fn) * (tn + fp) * (tn + fn))
return f1, mcc
def do_training(self, ckpt_dir=None):
if ckpt_dir is None:
if not os.path.exists(modeldir):
os.mkdir(modeldir)
ckpt = tf.train.Checkpoint(step=tf.Variable(1), model=self.model)
ckpt_manager = tf.train.CheckpointManager(ckpt, modeldir, max_to_keep=3)
else:
ckpt = tf.train.Checkpoint(step=tf.Variable(1), model=self.model)
ckpt_manager = tf.train.CheckpointManager(ckpt, ckpt_dir, max_to_keep=3)
ckpt.restore(ckpt_manager.latest_checkpoint)
self.writer_train = tf.summary.create_file_writer(os.path.join(logdir, 'plot_train'))
self.writer_valid = tf.summary.create_file_writer(os.path.join(logdir, 'plot_valid'))
self.writer_train_valid_loss = tf.summary.create_file_writer(os.path.join(logdir, 'plot_train_valid_loss'))
step = 0
total_time = 0
best_test_loss = np.finfo(dtype=np.float64).max
if EARLY_STOP:
es = EarlyStop(patience=PATIENCE)
for epoch in range(NUM_EPOCHS):
self.train_loss.reset_states()
self.train_accuracy.reset_states()
t0 = datetime.datetime.now().timestamp()
proc_batch_cnt = 0
n_samples = 0
for data, label in self.train_dataset:
trn_ds = tf.data.Dataset.from_tensor_slices((data, label))
trn_ds = trn_ds.batch(BATCH_SIZE)
for mini_batch in trn_ds:
if self.learningRateSchedule is not None:
loss = self.train_step(mini_batch[0], mini_batch[1])
if (step % 100) == 0:
with self.writer_train.as_default():
tf.summary.scalar('loss_trn', loss.numpy(), step=step)
tf.summary.scalar('learning_rate', self.optimizer.lr.numpy(), step=step)
tf.summary.scalar('num_train_steps', step, step=step)
tf.summary.scalar('num_epochs', epoch, step=step)
self.reset_test_metrics()
for data_tst, label_tst in self.test_dataset:
tst_ds = tf.data.Dataset.from_tensor_slices((data_tst, label_tst))
tst_ds = tst_ds.batch(BATCH_SIZE)
for mini_batch_test in tst_ds:
self.test_step(mini_batch_test[0], mini_batch_test[1])
with self.writer_valid.as_default():
tf.summary.scalar('loss_val', self.test_loss.result(), step=step)
tf.summary.scalar('acc_val', self.test_accuracy.result(), step=step)
with self.writer_train_valid_loss.as_default():
tf.summary.scalar('loss_trn', loss.numpy(), step=step)
tf.summary.scalar('loss_val', self.test_loss.result(), step=step)
print('****** test loss, acc, lr: ', self.test_loss.result().numpy(), self.test_accuracy.result().numpy(),
self.optimizer.lr.numpy())
step += 1
print('train loss: ', loss.numpy())
proc_batch_cnt += 1
n_samples += data.shape[0]
print('proc_batch_cnt: ', proc_batch_cnt, n_samples)
t1 = datetime.datetime.now().timestamp()
print('End of Epoch: ', epoch+1, 'elapsed time: ', (t1-t0))
total_time += (t1-t0)
self.reset_test_metrics()
for data, label in self.test_dataset:
ds = tf.data.Dataset.from_tensor_slices((data, label))
ds = ds.batch(BATCH_SIZE)
for mini_batch in ds:
self.test_step(mini_batch[0], mini_batch[1])
print('loss, acc: ', self.test_loss.result().numpy(), self.test_accuracy.result().numpy())
print('------------------------------------------------------')
tst_loss = self.test_loss.result().numpy()
if tst_loss < best_test_loss:
best_test_loss = tst_loss
ckpt_manager.save()
if EARLY_STOP and es.check_stop(tst_loss):
break
print('total time: ', total_time)
self.writer_train.close()
self.writer_valid.close()
self.writer_train_valid_loss.close()
def build_model(self):
with options({'layout': False}):
print(tf.config.optimizer.get_experimental_options())
self.build_srcnn()
self.model = tf.keras.Model(self.inputs, self.logits)
def restore(self, ckpt_dir):
ckpt = tf.train.Checkpoint(step=tf.Variable(1), model=self.model)
ckpt_manager = tf.train.CheckpointManager(ckpt, ckpt_dir, max_to_keep=3)
ckpt.restore(ckpt_manager.latest_checkpoint)
self.reset_test_metrics()
for data, label in self.test_dataset:
ds = tf.data.Dataset.from_tensor_slices((data, label))
ds = ds.batch(BATCH_SIZE)
for mini_batch_test in ds:
self.predict(mini_batch_test[0], mini_batch_test[1])
print('loss, acc: ', self.test_loss.result().numpy(), self.test_accuracy.result().numpy())
labels = np.concatenate(self.test_labels)
preds = np.concatenate(self.test_preds)
inputs = np.concatenate(self.test_input)
# labels = denormalize(labels, label_param, mean_std_dct)
# preds = denormalize(preds, label_param, mean_std_dct)
# labels = descale(labels, label_param, mean_std_dct)
# preds = descale(preds, label_param, mean_std_dct)
return labels, preds, inputs
def do_evaluate(self, inputs, ckpt_dir):
ckpt = tf.train.Checkpoint(step=tf.Variable(1), model=self.model)
ckpt_manager = tf.train.CheckpointManager(ckpt, ckpt_dir, max_to_keep=3)
ckpt.restore(ckpt_manager.latest_checkpoint)
self.reset_test_metrics()
pred = self.model([inputs], training=False)
self.test_probs = pred
pred = pred.numpy()
return pred
def run(self, directory, ckpt_dir=None, num_data_samples=50000):
train_data_files = glob.glob(directory+'train*mres*.npy')
valid_data_files = glob.glob(directory+'valid*mres*.npy')
train_label_files = glob.glob(directory+'train*ires*.npy')
valid_label_files = glob.glob(directory+'valid*ires*.npy')
self.setup_pipeline(train_data_files, train_label_files, valid_data_files, valid_label_files, num_data_samples)
self.build_model()
self.build_training()
self.build_evaluation()
self.do_training(ckpt_dir=ckpt_dir)
def run_restore(self, directory, ckpt_dir):
self.num_data_samples = 1000
valid_data_files = glob.glob(directory + 'valid*mres*.npy')
valid_label_files = [f.replace('mres', 'ires') for f in valid_data_files]
self.setup_test_pipeline(valid_data_files, valid_label_files)
self.build_model()
self.build_training()
self.build_evaluation()
return self.restore(ckpt_dir)
def run_evaluate(self, data, ckpt_dir):
# data = tf.convert_to_tensor(data, dtype=tf.float32)
self.num_data_samples = 80000
self.build_model()
self.build_training()
self.build_evaluation()
return self.do_evaluate(data, ckpt_dir)
def setup_inference(self, ckpt_dir):
self.num_data_samples = 80000
self.build_model()
self.build_training()
self.build_evaluation()
ckpt = tf.train.Checkpoint(step=tf.Variable(1), model=self.model)
ckpt_manager = tf.train.CheckpointManager(ckpt, ckpt_dir, max_to_keep=3)
ckpt.restore(ckpt_manager.latest_checkpoint)
def do_inference(self, inputs):
self.reset_test_metrics()
pred = self.model([inputs], training=False)
self.test_probs = pred
pred = pred.numpy()
return pred
def run_inference(self, in_file, out_file):
gc.collect()
h5f = h5py.File(in_file, 'r')
bt = get_grid_values_all(h5f, 'temp_11_0um_nom')
y_len, x_len = bt.shape
refl = get_grid_values_all(h5f, 'refl_0_65um_nom')
refl_lo = get_grid_values_all(h5f, 'refl_0_65um_nom_min_sub')
refl_hi = get_grid_values_all(h5f, 'refl_0_65um_nom_max_sub')
refl_std = get_grid_values_all(h5f, 'refl_0_65um_nom_stddev_sub')
cp = get_grid_values_all(h5f, 'cloud_probability')
opd = get_grid_values_all(h5f, label_param)
cldy_frac_opd = self.run_inference_(bt, refl, refl_lo, refl_hi, refl_std, cp, opd)
cldy_frac_opd_out = np.full((y_len, x_len), -1.0, dtype=np.float32)
border = int((KERNEL_SIZE - 1) / 2)
cldy_frac_opd_out[border:y_len - border, border:x_len - border] = cldy_frac_opd[0, :, :, 0]
# Use this hack for now.
off_earth = (bt <= 161.0)
night = np.isnan(refl)
cldy_frac_opd_out[off_earth] = -1
cldy_frac_opd_out[np.invert(off_earth) & night] = -1
# --- Make a DataArray ----------------------------------------------------
# var_names = ['cloud_fraction', 'temp_11_0um', 'refl_0_65um']
# dims = ['num_params', 'y', 'x']
# da = xr.DataArray(np.stack([cld_frac_out, bt, refl], axis=0), dims=dims)
# da.assign_coords({
# 'num_params': var_names,
# 'lat': (['y', 'x'], lats),
# 'lon': (['y', 'x'], lons)
# })
# ---------------------------------------------------------------------------
h5f.close()
if out_file is not None:
np.save(out_file, (cldy_frac_opd_out, bt, refl, cp))
else:
# return [cld_frac_out, bt, refl, cp, lons, lats]
return cldy_frac_opd_out, opd
def run_inference_full_disk(self, in_file, out_file):
gc.collect()
t0 = time.time()
h5f = h5py.File(in_file, 'r')
bt = get_grid_values_all(h5f, 'temp_11_0um_nom')
y_len, x_len = bt.shape
h_y_len = int(y_len / 2)
refl = get_grid_values_all(h5f, 'refl_0_65um_nom')
refl_lo = get_grid_values_all(h5f, 'refl_0_65um_nom_min_sub')
refl_hi = get_grid_values_all(h5f, 'refl_0_65um_nom_max_sub')
refl_std = get_grid_values_all(h5f, 'refl_0_65um_nom_stddev_sub')
cp = get_grid_values_all(h5f, 'cloud_probability')
opd = get_grid_values_all(h5f, label_param)
t1 = time.time()
print(' read time:', (t1-t0))
bt_nh = bt[0:h_y_len + 1, :]
refl_nh = refl[0:h_y_len + 1, :]
refl_lo_nh = refl_lo[0:h_y_len + 1, :]
refl_hi_nh = refl_hi[0:h_y_len + 1, :]
refl_std_nh = refl_std[0:h_y_len + 1, :]
cp_nh = cp[0:h_y_len + 1, :]
opd_nh = opd[0:h_y_len + 1, :]
bt_sh = bt[h_y_len - 1:y_len, :]
refl_sh = refl[h_y_len - 1:y_len, :]
refl_lo_sh = refl_lo[h_y_len - 1:y_len, :]
refl_hi_sh = refl_hi[h_y_len - 1:y_len, :]
refl_std_sh = refl_std[h_y_len - 1:y_len, :]
cp_sh = cp[h_y_len - 1:y_len, :]
opd_sh = opd[h_y_len - 1:y_len, :]
t0 = time.time()
cldy_frac_opd_nh = self.run_inference_(bt_nh, refl_nh, refl_lo_nh, refl_hi_nh, refl_std_nh, cp_nh, opd_nh)
cldy_frac_opd_sh = self.run_inference_(bt_sh, refl_sh, refl_lo_sh, refl_hi_sh, refl_std_sh, cp_sh, opd_sh)
t1 = time.time()
print(' inference time: ', (t1-t0))
cldy_frac_opd_out = np.full((y_len, x_len), -1.0, dtype=np.float32)
border = int((KERNEL_SIZE - 1) / 2)
cldy_frac_opd_out[border:h_y_len, border:x_len - border] = cldy_frac_opd_nh[0, :, :, 0]
cldy_frac_opd_out[h_y_len:y_len - border, border:x_len - border] = cldy_frac_opd_sh[0, :, :, 0]
# Use this hack for now.
off_earth = (bt <= 161.0)
night = np.isnan(refl)
cldy_frac_opd_out[off_earth] = -1.0
cldy_frac_opd_out[np.invert(off_earth) & night] = -1.0
# --- Make DataArray -------------------------------------------------
# var_names = ['cloud_fraction', 'temp_11_0um', 'refl_0_65um']
# dims = ['num_params', 'y', 'x']
# da = xr.DataArray(np.stack([cld_frac_out, bt, refl], axis=0), dims=dims)
# da.assign_coords({
# 'num_params': var_names,
# 'lat': (['y', 'x'], lats),
# 'lon': (['y', 'x'], lons)
# })
# ------------------------------------------------------------------------
h5f.close()
if out_file is not None:
np.save(out_file, (cldy_frac_opd_out, bt, refl, cp))
else:
# return [cld_frac_out, bt, refl, cp, lons, lats]
return cldy_frac_opd_out, opd
def run_inference_(self, bt, refl, refl_lo, refl_hi, refl_std, cp, opd):
bt = scale(bt, 'temp_11_0um_nom', mean_std_dct)
refl = scale(refl, 'refl_0_65um_nom', mean_std_dct)
refl_lo = scale(refl_lo, 'refl_0_65um_nom', mean_std_dct)
refl_hi = scale(refl_hi, 'refl_0_65um_nom', mean_std_dct)
refl_rng = refl_hi - refl_lo
refl_std = scale2(refl_std, 0.0, 30.0)
cp = np.where(np.isnan(cp), 0, cp)
opd = scale(opd, label_param, mean_std_dct)
data = np.stack([bt, cp, refl, refl_rng, refl_std, opd], axis=2)
data = np.expand_dims(data, axis=0)
opd = self.do_inference(data)
return opd
def run_restore_static(directory, ckpt_dir, out_file=None):
nn = SRCNN()
labels, preds, inputs = nn.run_restore(directory, ckpt_dir)
print(np.histogram(labels))
print(np.histogram(preds))
if out_file is not None:
y_hi, x_hi = (Y_LEN // 4) + 1, (X_LEN // 4) + 1
np.save(out_file,
[labels[:, :, :, 0],
preds[:, :, :, 0],
descale(inputs[:, 1:y_hi, 1:x_hi, 0], 'temp_11_0um_nom', mean_std_dct),
inputs[:, 1:y_hi, 1:x_hi, 1],
descale(inputs[:, 1:y_hi, 1:x_hi, 2], 'refl_0_65um_nom', mean_std_dct),
descale(inputs[:, 1:y_hi, 1:x_hi, 3], 'refl_0_65um_nom', mean_std_dct),
inputs[:, 1:y_hi, 1:x_hi, 4],
descale(inputs[:, 1:y_hi, 1:x_hi, 5], label_param, mean_std_dct),
inputs[:, 1:y_hi, 1:x_hi, 6],
inputs[:, 1:y_hi, 1:x_hi, 7]])
def run_evaluate_static(in_file, out_file, ckpt_dir):
gc.collect()
h5f = h5py.File(in_file, 'r')
bt = get_grid_values_all(h5f, 'temp_11_0um_nom')
y_len, x_len = bt.shape
refl = get_grid_values_all(h5f, 'refl_0_65um_nom')
refl_lo = get_grid_values_all(h5f, 'refl_0_65um_nom_min_sub')
refl_hi = get_grid_values_all(h5f, 'refl_0_65um_nom_max_sub')
refl_std = get_grid_values_all(h5f, 'refl_0_65um_nom_stddev_sub')
cp = get_grid_values_all(h5f, label_param)
# lons = get_grid_values_all(h5f, 'longitude')
# lats = get_grid_values_all(h5f, 'latitude')
cld_frac = run_evaluate_static_(bt, refl, refl_lo, refl_hi, refl_std, cp, ckpt_dir)
cld_frac_out = np.zeros((y_len, x_len), dtype=np.int8)
border = int((KERNEL_SIZE - 1)/2)
cld_frac_out[border:y_len-border, border:x_len - border] = cld_frac[0, :, :]
# Use this hack for now.
off_earth = (bt <= 161.0)
night = np.isnan(refl)
cld_frac_out[off_earth] = -1
cld_frac_out[np.invert(off_earth) & night] = -1
# --- Make a DataArray ----------------------------------------------------
# var_names = ['cloud_fraction', 'temp_11_0um', 'refl_0_65um']
# dims = ['num_params', 'y', 'x']
# da = xr.DataArray(np.stack([cld_frac_out, bt, refl], axis=0), dims=dims)
# da.assign_coords({
# 'num_params': var_names,
# 'lat': (['y', 'x'], lats),
# 'lon': (['y', 'x'], lons)
# })
# ---------------------------------------------------------------------------
h5f.close()
if out_file is not None:
np.save(out_file, (cld_frac_out, bt, refl, cp))
else:
# return [cld_frac_out, bt, refl, cp, lons, lats]
return cld_frac_out
def run_evaluate_static_full_disk(in_file, out_file, ckpt_dir):
gc.collect()
h5f = h5py.File(in_file, 'r')
bt = get_grid_values_all(h5f, 'temp_11_0um_nom')
y_len, x_len = bt.shape
h_y_len = int(y_len/2)
refl = get_grid_values_all(h5f, 'refl_0_65um_nom')
refl_lo = get_grid_values_all(h5f, 'refl_0_65um_nom_min_sub')
refl_hi = get_grid_values_all(h5f, 'refl_0_65um_nom_max_sub')
refl_std = get_grid_values_all(h5f, 'refl_0_65um_nom_stddev_sub')
cp = get_grid_values_all(h5f, label_param)
# lons = get_grid_values_all(h5f, 'longitude')
# lats = get_grid_values_all(h5f, 'latitude')
bt_nh = bt[0:h_y_len+1, :]
refl_nh = refl[0:h_y_len+1, :]
refl_lo_nh = refl_lo[0:h_y_len+1, :]
refl_hi_nh = refl_hi[0:h_y_len+1, :]
refl_std_nh = refl_std[0:h_y_len+1, :]
cp_nh = cp[0:h_y_len+1, :]
bt_sh = bt[h_y_len-1:y_len, :]
refl_sh = refl[h_y_len-1:y_len, :]
refl_lo_sh = refl_lo[h_y_len-1:y_len, :]
refl_hi_sh = refl_hi[h_y_len-1:y_len, :]
refl_std_sh = refl_std[h_y_len-1:y_len, :]
cp_sh = cp[h_y_len-1:y_len, :]
cld_frac_nh = run_evaluate_static_(bt_nh, refl_nh, refl_lo_nh, refl_hi_nh, refl_std_nh, cp_nh, ckpt_dir)
cld_frac_sh = run_evaluate_static_(bt_sh, refl_sh, refl_lo_sh, refl_hi_sh, refl_std_sh, cp_sh, ckpt_dir)
cld_frac_out = np.zeros((y_len, x_len), dtype=np.int8)
border = int((KERNEL_SIZE - 1)/2)
cld_frac_out[border:h_y_len, border:x_len - border] = cld_frac_nh[0, :, :]
cld_frac_out[h_y_len:y_len - border, border:x_len - border] = cld_frac_sh[0, :, :]
# Use this hack for now.
off_earth = (bt <= 161.0)
night = np.isnan(refl)
cld_frac_out[off_earth] = -1
cld_frac_out[np.invert(off_earth) & night] = -1
# --- Make DataArray -------------------------------------------------
# var_names = ['cloud_fraction', 'temp_11_0um', 'refl_0_65um']
# dims = ['num_params', 'y', 'x']
# da = xr.DataArray(np.stack([cld_frac_out, bt, refl], axis=0), dims=dims)
# da.assign_coords({
# 'num_params': var_names,
# 'lat': (['y', 'x'], lats),
# 'lon': (['y', 'x'], lons)
# })
# ------------------------------------------------------------------------
h5f.close()
if out_file is not None:
np.save(out_file, (cld_frac_out, bt, refl, cp))
else:
# return [cld_frac_out, bt, refl, cp, lons, lats]
return cld_frac_out
def run_evaluate_static_valid(in_file, out_file, ckpt_dir):
gc.collect()
h5f = h5py.File(in_file, 'r')
bt = get_grid_values_all(h5f, 'orig/temp_ch38')
y_len, x_len = bt.shape
refl = get_grid_values_all(h5f, 'orig/refl_ch01')
refl_lo = get_grid_values_all(h5f, 'orig/refl_submin_ch01')
refl_hi = get_grid_values_all(h5f, 'orig/refl_submax_ch01')
refl_std = get_grid_values_all(h5f, 'orig/refl_substddev_ch01')
cp = get_grid_values_all(h5f, 'orig/'+label_param)
lons = get_grid_values_all(h5f, 'orig/longitude')
lats = get_grid_values_all(h5f, 'orig/latitude')
cp_sres = get_grid_values_all(h5f, 'super/'+label_param)
mean_cp_sres = get_grid_cell_mean(np.expand_dims(cp_sres, axis=0))[0]
# cld_frac_truth = get_label_data_5cat(np.expand_dims(cp_sres, axis=0))[0]
cld_frac_truth = None
h5f.close()
cld_frac = run_evaluate_static_(bt, refl, refl_lo, refl_hi, refl_std, cp, ckpt_dir)
cld_frac_out = np.zeros((y_len, x_len), dtype=np.int8)
border = int((KERNEL_SIZE - 1)/2)
cld_frac_out[border:y_len-border, border:x_len - border] = cld_frac[0, :, :]
var_names = ['cloud_fraction', 'temp_11_0um', 'refl_0_65um']
dims = ['num_params', 'y', 'x']
da = xr.DataArray(np.stack([cld_frac_out, bt, refl], axis=0), dims=dims)
da.assign_coords({
'num_params': var_names,
'lat': (['y', 'x'], lats),
'lon': (['y', 'x'], lons)
})
if out_file is not None:
np.save(out_file, (cld_frac_out, bt, refl, cp, lons, lats, mean_cp_sres, cld_frac_truth))
else:
return [cld_frac_out, bt, refl, cp, lons, lats]
def run_evaluate_static_(bt, refl, refl_lo, refl_hi, refl_std, cp, ckpt_dir):
bt = normalize(bt, 'temp_11_0um_nom', mean_std_dct)
refl = normalize(refl, 'refl_0_65um_nom', mean_std_dct)
refl_lo = normalize(refl_lo, 'refl_0_65um_nom', mean_std_dct)
refl_hi = normalize(refl_hi, 'refl_0_65um_nom', mean_std_dct)
refl_std = np.where(np.isnan(refl_std), 0, refl_std)
cp = np.where(np.isnan(cp), 0, cp)
data = np.stack([bt, refl, refl_lo, refl_hi, refl_std, cp], axis=2)
data = np.expand_dims(data, axis=0)
nn = SRCNN()
probs = nn.run_evaluate(data, ckpt_dir)
cld_frac = probs.argmax(axis=3)
cld_frac = cld_frac.astype(np.int8)
return cld_frac
def analyze(directory, outfile):
train_data_files = glob.glob(directory + 'train*mres*.npy')
valid_data_files = glob.glob(directory + 'valid*mres*.npy')
train_label_files = glob.glob(directory + 'train*ires*.npy')
valid_label_files = glob.glob(directory + 'valid*ires*.npy')
data_s = []
label_s = []
for idx, data_f in enumerate(valid_data_files):
nda = np.load(data_f)
data_s.append(nda)
f = valid_label_files[idx]
nda = np.load(f)
label_s.append(nda)
input_data = np.concatenate(data_s)
input_label = np.concatenate(label_s)
refl_i = input_label[:, params_i.index('refl_0_65um_nom'), :, :]
rlo, rhi, rstd, rmean = get_min_max_std(refl_i)
rmean_i = rmean[:, slc_y, slc_x]
rlo_i = rlo[:, slc_y, slc_x]
rhi_i = rhi[:, slc_y, slc_x]
rstd_i = rstd[:, slc_y, slc_x]
rlo_m = input_data[:, params.index('refl_submin_ch01'), :, :]
rlo_m = rlo_m[:, slc_y, slc_x]
rhi_m = input_data[:, params.index('refl_submax_ch01'), :, :]
rhi_m = rhi_m[:, slc_y, slc_x]
rstd_m = input_data[:, params.index('refl_substddev_ch01'), :, :]
rstd_m = rstd_m[:, slc_y, slc_x]
rmean = input_data[:, params.index('refl_0_65um_nom'), :, :]
rmean_m = rmean[:, slc_y, slc_x]
# ------------------------
cp_i = input_label[:, params_i.index('cloud_probability'), :, :]
_, _, _, mean = get_min_max_std(cp_i)
cp_mean_i = mean[:, slc_y, slc_x]
mean = input_data[:, params.index('cloud_probability'), :, :]
cp_mean_m = mean[:, slc_y, slc_x]
# -----------------------------
opd_i = input_label[:, params_i.index('cld_opd_dcomp'), :, :]
_, _, _, mean = get_min_max_std(opd_i)
opd_mean_i = mean[:, slc_y, slc_x]
mean = input_data[:, params.index('cld_opd_dcomp'), :, :]
opd_mean_m = mean[:, slc_y, slc_x]
np.save(outfile, (rmean_i, rmean_m, cp_mean_i, cp_mean_m, opd_mean_i, opd_mean_m, rlo_i, rlo_m, rhi_i, rhi_m, rstd_i, rstd_m))
if __name__ == "__main__":
nn = SRCNN()
nn.run('matchup_filename')