def load_my_data(data_path=None, ret_extras=False):
if data_path is None:
data_path = data_in
cc = utils.loadmat(os.path.join(data_path, 'C_raw.mat'))
nw = utils.loadmat(os.path.join(data_path, 'NW_raw.mat'))
ne = utils.loadmat(os.path.join(data_path, 'NE_raw.mat'))
se = utils.loadmat(os.path.join(data_path, 'SE_raw.mat'))
sw = utils.loadmat(os.path.join(data_path, 'SW_raw.mat'))
moorings = [cc, nw, ne, se, sw]
for m in moorings:
m['tdt'] = utils.datenum_to_datetime(m['t'])
if ret_extras:
dt_min = 15.
extras = {
"dt_min": dt_min,
"dt_sec": dt_min*60.,
"dt_day": dt_min/1440.,
"N_per_day": 96,
}
return moorings, extras
else:
return moorings
def load_my_data_alt(data_path=None):
if data_path is None:
data_path = data_in
ca = utils.loadmat(os.path.join(data_path, 'C_alt.mat'))
cw = utils.loadmat(os.path.join(data_path, 'C_altw.mat'))
ca['tdt'] = utils.datenum_to_datetime(ca['t'])
cw['tdt'] = utils.datenum_to_datetime(cw['t'])
return ca, cw
def __getitem__(self, index):
name = self.img_names[index]
# LOAD IMG, POINT, and ROI
image = imread(self.path + "/images/" + name)
if image.ndim == 2:
image = image[:, :, None].repeat(3, 2)
pointList = ut.loadmat(self.path + "/ground-truth/GT_" +
name.replace(".jpg", "") + ".mat")
pointList = pointList["image_info"][0][0][0][0][0]
points = np.zeros(image.shape[:2], "uint8")[:, :, None]
for x, y in pointList:
points[int(y), int(x)] = 1
counts = torch.LongTensor(np.array([pointList.shape[0]]))
collection = list(map(FT.to_pil_image, [image, points]))
if self.transform_function is not None:
image, points = self.transform_function(collection)
return {
"images": image,
"points": points,
"counts": counts,
"index": index,
"image_path": self.path + "/images/" + name
}
def return_datasets(filename):
data = utils.loadmat('../data/{}'.format(filename))
trainSet, testSet, valSet = 1, 2, 3
x_train = reformat(data['x'][:, :, data['set'] == trainSet])
y_train = (data['y'][data['set'] == trainSet])
x_val = reformat(data['x'][:, :, data['set'] == valSet])
y_val = (data['y'][data['set'] == valSet])
x_test = reformat(data['x'][:, :, data['set'] == testSet])
y_test = (data['y'][data['set'] == testSet])
x_train, y_train = get_random_data(x_train, y_train, 0, x_train.shape[0],
x_train.shape[0])
x_val, y_val = get_random_data(x_val, y_val, 0, x_val.shape[0],
x_val.shape[0])
x_test, y_test = get_random_data(x_test, y_test, 0, x_test.shape[0],
x_test.shape[0])
return (x_train, y_train, x_val, y_val, x_test, y_test)
import scipy.io as io import utils import TKED as tked import gsw import seawater from oceans.sw_extras import gamma_GP_from_SP_pt import utm import mixsea as mx data_in = "../raw_data" glob1 = glob.glob(os.path.join(data_in, "sp14-towyo-*")) glob2 = glob.glob(os.path.join(data_in, "rr1209_gridded_towyo*")) towyo_files = np.sort(np.hstack((glob1, glob2))) TOWYOs = [utils.loadmat(file)["tm"] for file in towyo_files] # %% # Sill lat boundaries (very roughly) P5_lat = -8.5 # Greater than this P2_lat = -9.5 # Less than this # P4 is between these # Reprocessing parameters acc = 5e-4 R0 = 0.25 save_dir = "../proc_data" Nsq_method = "bulk" c1 = 0.9 # The coefficient that multiplies the Thorpe scales... e.g. 0.64, 0.9 sig4b = 1045.9 # The potential density used in the buoyancy estimate
############### PRELIMINARIES ################
# Parse command line arguments
args = clargs.parse_check_args()
sdroot = args.save
files = utils.find_files(args, "sep2018kayak")
params = utils.load_parameters()
print("Loading data may trigger Dropbox download!")
############### LOAD DATA ################
print("Loading kayak data.")
kayak = utils.loadmat(files.kayak, check_arrays=True)
adcps = kayak["adcp"]
ctds = kayak["ctd"]
secs = kayak["xsec"]
############### CTD ################
print("Processing CTD")
ctd_depth_min = params.kayak.ctd_depth_min
ctd_depth_max = params.kayak.ctd_depth_max
ctd_depth_spacing = params.kayak.ctd_depth_spacing
ctd_datasets = []
sec_tstart = []
sec_tend = []
npfls = []
# %%
import xarray as xr
import matplotlib.pyplot as plt
import numpy as np
import munch
import utils
import glob
# %% [markdown]
# Load data.
# %%
# Towyos separate
data_files = glob.glob("../proc_data/TY*.mat")
TYs = np.asarray([munch.munchify(utils.loadmat(file)) for file in data_files])
P5TYs = [TY for TY in TYs if ((TY.sill == "P5") and (TY.year == 2014))]
# Bathymetry
bathy = xr.open_dataset("../raw_data/merged_200_-171.5_-167.5_-11_-6.5.nc")
bathyP5 = bathy.isel(lon=(bathy.lon < -168.5) & (bathy.lon > -168.8),
lat=(bathy.lat > -8.3) & (bathy.lat < -7.9))
# Towyos together
ds = xr.open_dataset("../proc_data/stacked_towyos.nc")
ds
# %% [markdown]
# Single layer Froude number,
#
# \begin{equation}
# Fr = \frac{U}{\sqrt{g'h}},
# \end{equation}
############### PRELIMINARIES ################
# Parse command line arguments
args = clargs.parse_check_args()
sdroot = args.save
files = utils.find_files(args, "sep2018")
params = utils.load_parameters()
print("Loading data may trigger Dropbox download!")
############### LOAD DATA ################
print("Loading sections.")
secs = utils.loadmat(files.vmp_sections, check_arrays=True,
mat_dtype=True)["vmp"]
secs = np.array([munchify(ds) for ds in secs])
print("Loading VMP.")
ds = utils.loadmat(files.vmp, check_arrays=True, mat_dtype=True)
vmp = munchify(ds["vmp"])
gps = munchify(ds["gps"])
print("Loading SADCP.")
sadcp = munchify(mat73.loadmat(files.sadcp)["adcp"])
############### CTD ################
print("Processing CTD")
bin_width = params.ctd.adiabatic_level_bin_width
depth_min = params.ctd.depth_min
depth_max = params.ctd.depth_max
depth_spacing = params.ctd.depth_spacing
############### PRELIMINARIES ################
# Parse command line arguments
args = clargs.parse_check_args()
sdroot = args.save
files = utils.find_files(args, "aug2016")
params = utils.load_parameters()
print("Loading data may trigger Dropbox download!")
############### CTD ################
print("Loading CTD")
ctds = utils.loadmat(files.ctd, check_arrays=True, mat_dtype=True)["ctd"]
ctds = [munchify(ctd) for ctd in ctds]
print("Processing CTD")
bin_width = params.ctd.adiabatic_level_bin_width
depth_min = params.ctd.depth_min
depth_max = params.ctd.depth_max
depth_spacing = params.ctd.depth_spacing
ctd = CTD.generate_CTD_Munch_from_list(ctds,
depth_min=depth_min,
depth_max=depth_max,
depth_spacing=depth_spacing)
ctd = CTD.apply_thermodynamics(ctd)
ctd = CTD.apply_adiabatic_level(ctd, bin_width)
save_figs = True
pdd = "../data"
fsd = "../figures"
data_in = pdd
moorings = load_data.load_my_data()
ca, cw = load_data.load_my_data_alt()
ca = munch.munchify(ca)
cw = munch.munchify(cw)
moorings = [munch.munchify(m) for m in moorings]
cc, nw, ne, se, sw = moorings
VMP = utils.loadmat(os.path.join(data_in, "VMP.mat"))
VMP = munch.munchify(VMP)
# %% [markdown]
# ## Total flux full time series cumulative
# %%
rho0 = 1025.0
m = ca
#####################################
fig = plt.figure(figsize=(6.5, 4.5))
gs = GridSpec(ca.N_levels * 2, 2, width_ratios=[5, 1], hspace=0.1, wspace=0.06)
axs = [plt.subplot(gs[i * 2 : (i + 1) * 2, 0]) for i in range(ca.N_levels)]
axp = plt.subplot(gs[:, 1])
axp.yaxis.set_ticks_position("right")
def main():
# root_dir for the files
root_dir = '../../data/AVA/files/'
# Erase previous models from GPU memory
K.clear_session()
# Load list of action classes and separate them (from utils_stream)
classes = utils.get_AVA_classes(root_dir + 'ava_action_list_custom.csv')
# Parameters for training (batch size 32 is supposed to be the best?)
params = {
'dim': (224, 224),
'batch_size': 64,
'n_classes': len(classes['label_id']),
'n_channels': 10,
'nb_epochs': 157,
'model': "inceptionv3",
'email': True,
'freeze_all': True,
'conv_fusion': False,
'train_chunk_size': 2**10,
'validation_chunk_size': 2**10
}
minValLoss = 9999990.0
soft_sigmoid = True
warp = False # TODO Use warped (camera motion corrected) flow or not
crop = False # TODO Use crop flow or not
encoding = "rgb" # TODO Are flows stored as rgb or as 2 grayscales
# Get ID's and labels from the actual dataset
partition = {}
partition['train'] = get_AVA_set(
classes=classes,
filename=root_dir + "AVA_Train_Custom_Corrected.csv",
soft_sigmoid=soft_sigmoid) # IDs for training
partition['validation'] = get_AVA_set(
classes=classes,
filename=root_dir + "AVA_Val_Custom_Corrected.csv",
soft_sigmoid=soft_sigmoid) # IDs for validation
# Labels
labels_train = get_AVA_labels(classes,
partition,
"train",
filename=root_dir +
"AVA_Train_Custom_Corrected.csv",
soft_sigmoid=soft_sigmoid)
labels_val = get_AVA_labels(classes,
partition,
"validation",
filename=root_dir +
"AVA_Val_Custom_Corrected.csv",
soft_sigmoid=soft_sigmoid)
# Create + compile model, load saved weights if they exist
# saved_weights = "saved_models/RGB_Stream_Softmax_inceptionv3.hdf5"
saved_weights = "../models/flow_kineticsinit_inceptionv3_1808282350.hdf5"
ucf_weights = "../models/ucf_keras/keras-ucf101-TVL1flow-" + params[
'model'] + "-newsplit.hdf5" # Outdated model
# ucf_weights = None
# ucf_weights = None
model, keras_layer_names = flow_create_model(
classes=classes['label_id'],
model_name=params['model'],
soft_sigmoid=soft_sigmoid,
image_shape=(224, 224),
opt_flow_len=10,
freeze_all=params['freeze_all'],
conv_fusion=params['conv_fusion'])
model = compile_model(model, soft_sigmoid=soft_sigmoid)
# TODO Experiment: 1. no initialization, 2. ucf initialization 3. kinetics initialization
initialization = True # Set to True to use initialization
kinetics_weights = None
ucf_weights = ""
if saved_weights is not None:
model.load_weights(saved_weights)
else:
if initialization is True:
if kinetics_weights is None:
if params['model'] == "inceptionv3":
print("Loading kinetics weights: ")
keras_weights = [
"../models/kinetics_keras/tsn_flow_params_names.pkl",
"../models/kinetics_keras/tsn_flow_params.pkl"
]
utils.convert_inceptionv3(model, keras_weights,
keras_layer_names)
model.save(
"../models/kinetics_keras/keras-kinetics-flow-inceptionv3.hdf5"
)
if ucf_weights is None:
print("Loading UCF weights: ")
if params['model'] == "resnet50":
# TODO Better initialization, average UCF models overt he 3 splits provided
ucf_weights = utils.loadmat(
"../models/ucf_matconvnet/ucf101-TVL1flow-resnet-50-split1.mat"
)
utils.convert_resnet(model, ucf_weights)
model.save(
"../models/ucf_keras/keras-ucf101-TVL1flow-resnet50-newsplit.hdf5"
)
else:
if ucf_weights != "":
model.load_weights(ucf_weights)
# Try to train on more than 1 GPU if possible
# try:
# print("Trying MULTI-GPU")
# model = multi_gpu_model(model)
print("Training set size: " + str(len(partition['train'])))
# Load first train_size of partition{'train'}
train_splits = utils.make_chunks(original_list=partition['train'],
size=len(partition['train']),
chunk_size=params['train_chunk_size'])
val_splits = utils.make_chunks(original_list=partition['validation'],
size=len(partition['validation']),
chunk_size=params['validation_chunk_size'])
time_str = time.strftime("%y%m%d%H%M", time.localtime())
if crop is True:
bestModelPath = "../models/flowcrop_" + params[
'model'] + "_" + time_str + ".hdf5"
traincsvPath = "../loss_acc_plots/flowcrop_customcsv_train_plot_" + params[
'model'] + "_" + time_str + ".csv"
valcsvPath = "../loss_acc_plots/flowcrop_customcsv_val_plot_" + params[
'model'] + "_" + time_str + ".csv"
else:
if warp is True:
bestModelPath = "../models/flow_warp_" + params[
'model'] + "_" + time_str + ".hdf5"
traincsvPath = "../loss_acc_plots/flow_warp_customcsv_train_plot_" + params[
'model'] + "_" + time_str + ".csv"
valcsvPath = "../loss_acc_plots/flow_warp_customcsv_val_plot_" + params[
'model'] + "_" + time_str + ".csv"
else:
bestModelPath = "../models/flow_kineticsinit_" + params[
'model'] + "_" + time_str + ".hdf5"
traincsvPath = "../loss_acc_plots/flow_kineticsinit_customcsv_train_plot_" + params[
'model'] + "_" + time_str + ".csv"
valcsvPath = "../loss_acc_plots/flow_kineticsinit_customcsv_val_plot_" + params[
'model'] + "_" + time_str + ".csv"
first_epoch = True
with tf.device('/gpu:0'): # TODO Multi GPU
for epoch in range(params['nb_epochs']):
epoch_chunks_count = 0
if epoch > 0:
first_epoch = False
for trainIDS in train_splits:
start_time = timeit.default_timer()
# -----------------------------------------------------------
x_val = y_val_pose = y_val_object = y_val_human = x_train = y_train_pose = y_train_object = y_train_human = None
x_train, y_train_pose, y_train_object, y_train_human = load_split(
trainIDS,
labels_train,
params['dim'],
params['n_channels'],
"train",
5,
first_epoch,
encoding=encoding,
soft_sigmoid=soft_sigmoid,
crop=True)
y_t = []
y_t.append(
to_categorical(y_train_pose,
num_classes=utils.POSE_CLASSES))
y_t.append(
utils.to_binary_vector(y_train_object,
size=utils.OBJ_HUMAN_CLASSES,
labeltype='object-human'))
y_t.append(
utils.to_binary_vector(y_train_human,
size=utils.HUMAN_HUMAN_CLASSES,
labeltype='human-human'))
history = model.fit(x_train,
y_t,
batch_size=params['batch_size'],
epochs=1,
verbose=0)
utils.learning_rate_schedule(model, epoch, params['nb_epochs'])
# ------------------------------------------------------------
elapsed = timeit.default_timer() - start_time
print("Epoch " + str(epoch) + " chunk " +
str(epoch_chunks_count) + " (" + str(elapsed) +
") acc[pose,obj,human] = [" +
str(history.history['pred_pose_categorical_accuracy']) +
"," +
str(history.
history['pred_obj_human_categorical_accuracy']) +
"," +
str(history.
history['pred_human_human_categorical_accuracy']) +
"] loss: " + str(history.history['loss']))
with open(traincsvPath, 'a') as f:
writer = csv.writer(f)
avg_acc = (
history.history['pred_pose_categorical_accuracy'][0] +
history.history['pred_obj_human_categorical_accuracy']
[0] + history.history[
'pred_human_human_categorical_accuracy'][0]) / 3
writer.writerow([
str(avg_acc),
history.history['pred_pose_categorical_accuracy'],
history.history['pred_obj_human_categorical_accuracy'],
history.
history['pred_human_human_categorical_accuracy'],
history.history['loss']
])
epoch_chunks_count += 1
# Load val_data
print("Validating data: ")
loss_acc_list = [0.0, 0.0, 0.0, 0.0, 0.0, 0.0, 0.0]
for valIDS in val_splits:
x_val = y_val_pose = y_val_object = y_val_human = x_train = y_train_pose = y_train_object = y_train_human = None
x_val, y_val_pose, y_val_object, y_val_human = load_split(
valIDS,
labels_val,
params['dim'],
params['n_channels'],
"val",
5,
first_epoch,
encoding=encoding,
soft_sigmoid=soft_sigmoid,
crop=True)
y_v = []
y_v.append(
to_categorical(y_val_pose, num_classes=utils.POSE_CLASSES))
y_v.append(
utils.to_binary_vector(y_val_object,
size=utils.OBJ_HUMAN_CLASSES,
labeltype='object-human'))
y_v.append(
utils.to_binary_vector(y_val_human,
size=utils.HUMAN_HUMAN_CLASSES,
labeltype='human-human'))
vglobal_loss, vpose_loss, vobject_loss, vhuman_loss, vpose_acc, vobject_acc, vhuman_acc = model.evaluate(
x_val, y_v, batch_size=params['batch_size'])
loss_acc_list[0] += vglobal_loss
loss_acc_list[1] += vpose_loss
loss_acc_list[2] += vobject_loss
loss_acc_list[3] += vhuman_loss
loss_acc_list[4] += vpose_acc
loss_acc_list[5] += vobject_acc
loss_acc_list[6] += vhuman_acc
loss_acc_list = [x / len(val_splits) for x in loss_acc_list]
with open(valcsvPath, 'a') as f:
writer = csv.writer(f)
acc = (loss_acc_list[4] + loss_acc_list[5] +
loss_acc_list[6]) / 3
writer.writerow([
str(acc), loss_acc_list[4], loss_acc_list[5],
loss_acc_list[6], loss_acc_list[0], loss_acc_list[1],
loss_acc_list[2], loss_acc_list[3]
])
if loss_acc_list[0] < minValLoss:
print("New best loss " + str(loss_acc_list[0]))
model.save(bestModelPath)
minValLoss = loss_acc_list[0]
if params['email']:
utils.sendemail(from_addr='*****@*****.**',
to_addr_list=['*****@*****.**'],
subject='Finished training OF-stream ',
message='Training OF with following params: ' +
str(params),
login='******',
password='******')
import numpy as np
import scipy.io as io
import utils
import TKED as tked
import gsw
import seawater
from oceans.sw_extras import gamma_GP_from_SP_pt
M_dir = '../raw_data/m*_original_data.mat'
Mmoorings_paths = np.sort(glob.glob(M_dir))
P_dir = '../raw_data/p*_original_data.mat'
Pmoorings_paths = np.sort(glob.glob(P_dir))
T_dir = '../raw_data/t*_original_data.mat'
Tmoorings_paths = np.sort(glob.glob(T_dir))
Mmoorings = [utils.loadmat(file) for file in Mmoorings_paths]
Pmoorings = [utils.loadmat(file) for file in Pmoorings_paths]
Tmoorings = [utils.loadmat(file) for file in Tmoorings_paths]
for array in [Mmoorings, Pmoorings, Tmoorings]:
for i, m in enumerate(array):
keys = m.keys()
k = [k for k in keys if '__' not in k][0]
array[i] = m[k]
MMPs = [Mmoorings[4]['mp'], Mmoorings[5]['mp']]
PMPs = [m['mp'] for m in Pmoorings if m['name'] != 'P2']
TMPs = [m['mp'] for m in Tmoorings]
MPs = MMPs + PMPs + TMPs
altMPs = utils.loadmat('../raw_data/sp_process_moorings_mp.mat',
check_arrays=True)['mp']
# %% [markdown]
# # Low mode phase speed
#
# The analysis is performed in matlab 'low_mode_criticality_all.m'.
# %%
import xarray as xr
import matplotlib.pyplot as plt
import numpy as np
import munch
import utils
import glob
# %%
# Matlab analysis
dm = utils.loadmat("../proc_data/TG_phase_speed.mat")
angles = dm["angles"]
cp_us = dm["cp_us"]
cp_ds = dm["cp_ds"]
# Towyos separate
data_files = glob.glob("../proc_data/TY*.mat")
TYs = np.asarray([munch.munchify(utils.loadmat(file)) for file in data_files])
P5TYs = [TY for TY in TYs if ((TY.sill == "P5") and (TY.year == 2014))]
# Bathymetry
bathy = xr.open_dataset("../raw_data/merged_200_-171.5_-167.5_-11_-6.5.nc")
bathyP5 = bathy.isel(lon=(bathy.lon < -168.5) & (bathy.lon > -168.8),
lat=(bathy.lat > -8.3) & (bathy.lat < -7.9))
# Towyos together
ds = xr.open_dataset("../proc_data/stacked_towyos.nc")
ds
# Parse command line arguments
args = clargs.parse_check_args()
sdroot = args.save
files = utils.find_files(args, "sep2018moorings")
params = utils.load_parameters()
print("Loading data may trigger Dropbox download!")
############### COMBINE ################
print("Combining ADCP and CTD datasets")
print("Loading ADCP data")
adcp = munchify(
utils.loadmat(files.deep_adcp, check_arrays=True, mat_dtype=True)["V"])
print("Loading CTD data")
ctd = munchify(
utils.loadmat(files.deep_ctd, check_arrays=True,
mat_dtype=True)["mooring"])
print("Loading coordinates")
coords = munchify(
utils.loadmat(files.coords, check_arrays=True,
mat_dtype=True)["mooringCoord"])
rho0 = 1025.
g = 9.81
ctd.p = np.flipud(ctd.pop("P"))
ctd.lon = coords.moorD[1]
ctd.lat = coords.moorD[0]
def main():
# root_dir = '../../../AVA2.1/' # root_dir for the files
root_dir = '../../data/AVA/files/'
# Erase previous models from GPU memory
K.clear_session()
# Load list of action classes and separate them
classes = utils.get_AVA_classes(root_dir + 'ava_action_list_custom.csv')
# Parameters for training
params = {
'dim': (224, 224),
'batch_size': 32,
'n_classes': len(classes['label_id']),
'n_channels': 3,
'shuffle': False,
'nb_epochs': 200,
'model': 'inceptionv3',
'email': True,
'freeze_all': True,
'conv_fusion': False,
'train_chunk_size': 2**12,
'validation_chunk_size': 2**12
}
soft_sigmoid = True
minValLoss = 9999990.0
# Get ID's and labels from the actual dataset
partition = {}
partition['train'] = get_AVA_set(
classes=classes,
filename=root_dir + "AVA_Train_Custom_Corrected.csv",
soft_sigmoid=soft_sigmoid) # IDs for training
partition['validation'] = get_AVA_set(
classes=classes,
filename=root_dir + "AVA_Val_Custom_Corrected.csv",
soft_sigmoid=soft_sigmoid) # IDs for validation
# Labels
labels_train = get_AVA_labels(classes,
partition,
"train",
filename=root_dir +
"AVA_Train_Custom_Corrected.csv",
soft_sigmoid=soft_sigmoid)
labels_val = get_AVA_labels(classes,
partition,
"validation",
filename=root_dir +
"AVA_Val_Custom_Corrected.csv",
soft_sigmoid=soft_sigmoid)
# Create + compile model, load saved weights if they exist
saved_weights = None
# saved_weights = "../models/rgbextra_gauss_resnet50_1807250030.hdf5"
model, keras_layer_names = rgb_create_model(
classes=classes['label_id'],
soft_sigmoid=soft_sigmoid,
model_name=params['model'],
freeze_all=params['freeze_all'],
conv_fusion=params['conv_fusion'])
model = compile_model(model, soft_sigmoid=soft_sigmoid)
# TODO Experiment: 1. no initialization, 2. ucf initialization 3. kinetics initialization
initialization = True # Set to True to use initialization
kinetics_weights = None
ucf_weights = "a"
if saved_weights is not None:
model.load_weights(saved_weights)
else:
if initialization is True:
if ucf_weights is None:
print("Loading MConvNet weights: ")
if params['model'] == "resnet50":
ucf_weights = utils.loadmat(
"../models/ucf_matconvnet/ucf101-img-resnet-50-split1.mat"
)
utils.convert_resnet(model, ucf_weights)
model.save(
"../models/ucf_keras/keras-ucf101-rgb-resnet50-newsplit.hdf5"
)
if kinetics_weights is None:
if params['model'] == "inceptionv3":
print("Loading Keras weights: ")
keras_weights = [
"../models/kinetics_keras/tsn_rgb_params_names.pkl",
"../models/kinetics_keras/tsn_rgb_params.pkl"
]
utils.convert_inceptionv3(model, keras_weights,
keras_layer_names)
model.save(
"../models/kinetics_keras/keras-kinetics-rgb-inceptionv3.hdf5"
)
# Try to train on more than 1 GPU if possible
# try:
# print("Trying MULTI-GPU")
# model = multi_gpu_model(model)
print("Training set size: " + str(len(partition['train'])))
# Make spltis
train_splits = utils.make_chunks(original_list=partition['train'],
size=len(partition['train']),
chunk_size=params['train_chunk_size'])
val_splits = utils.make_chunks(original_list=partition['validation'],
size=len(partition['validation']),
chunk_size=params['validation_chunk_size'])
time_str = time.strftime("%y%m%d%H%M", time.localtime())
# TODO Don't forget to change your names :)
filter_type = "gauss"
bestModelPath = "../models/rgb_kininit_" + filter_type + \
"_" + params['model'] + "_" + time_str + ".hdf5"
traincsvPath = "../loss_acc_plots/rgb_kininit_train_" + filter_type + \
"_plot_" + params['model'] + "_" + time_str + ".csv"
valcsvPath = "../loss_acc_plots/rgb_kininit_val_" + filter_type + \
"_plot_" + params['model'] + "_" + time_str + ".csv"
with tf.device('/gpu:0'): # NOTE Not using multi gpu
for epoch in range(params['nb_epochs']):
epoch_chunks_count = 0
for trainIDS in train_splits:
# Load and train
start_time = timeit.default_timer()
# -----------------------------------------------------------
x_val = y_val_pose = y_val_object = y_val_human = x_train = y_train_pose = y_train_object = y_train_human = None
x_train, y_train_pose, y_train_object, y_train_human = load_split(
trainIDS,
labels_train,
params['dim'],
params['n_channels'],
"train",
filter_type,
soft_sigmoid=soft_sigmoid)
y_t = []
y_t.append(
to_categorical(y_train_pose,
num_classes=utils.POSE_CLASSES))
y_t.append(
utils.to_binary_vector(y_train_object,
size=utils.OBJ_HUMAN_CLASSES,
labeltype='object-human'))
y_t.append(
utils.to_binary_vector(y_train_human,
size=utils.HUMAN_HUMAN_CLASSES,
labeltype='human-human'))
history = model.fit(x_train,
y_t,
batch_size=params['batch_size'],
epochs=1,
verbose=0)
utils.learning_rate_schedule(model, epoch, params['nb_epochs'])
# TODO Repeat samples of unrepresented classes?
# ------------------------------------------------------------
elapsed = timeit.default_timer() - start_time
print("Epoch " + str(epoch) + " chunk " +
str(epoch_chunks_count) + " (" + str(elapsed) +
") acc[pose,obj,human] = [" +
str(history.history['pred_pose_categorical_accuracy']) +
"," +
str(history.
history['pred_obj_human_categorical_accuracy']) +
"," +
str(history.
history['pred_human_human_categorical_accuracy']) +
"] loss: " + str(history.history['loss']))
with open(traincsvPath, 'a') as f:
writer = csv.writer(f)
avg_acc = (
history.history['pred_pose_categorical_accuracy'][0] +
history.history['pred_obj_human_categorical_accuracy']
[0] + history.history[
'pred_human_human_categorical_accuracy'][0]) / 3
writer.writerow([
str(avg_acc),
history.history['pred_pose_categorical_accuracy'],
history.history['pred_obj_human_categorical_accuracy'],
history.
history['pred_human_human_categorical_accuracy'],
history.history['loss']
])
epoch_chunks_count += 1
# Load val_data
print("Validating data: ")
# global_loss, pose_loss, object_loss, human_loss, pose_acc, object_acc, human_acc
loss_acc_list = [0.0, 0.0, 0.0, 0.0, 0.0, 0.0, 0.0]
for valIDS in val_splits:
x_val = y_val_pose = y_val_object = y_val_human = x_train = y_train_pose = y_train_object = y_train_human = None
x_val, y_val_pose, y_val_object, y_val_human = load_split(
valIDS,
labels_val,
params['dim'],
params['n_channels'],
"val",
filter_type,
soft_sigmoid=soft_sigmoid)
y_v = []
y_v.append(
to_categorical(y_val_pose, num_classes=utils.POSE_CLASSES))
y_v.append(
utils.to_binary_vector(y_val_object,
size=utils.OBJ_HUMAN_CLASSES,
labeltype='object-human'))
y_v.append(
utils.to_binary_vector(y_val_human,
size=utils.HUMAN_HUMAN_CLASSES,
labeltype='human-human'))
vglobal_loss, vpose_loss, vobject_loss, vhuman_loss, vpose_acc, vobject_acc, vhuman_acc = model.evaluate(
x_val, y_v, batch_size=params['batch_size'])
loss_acc_list[0] += vglobal_loss
loss_acc_list[1] += vpose_loss
loss_acc_list[2] += vobject_loss
loss_acc_list[3] += vhuman_loss
loss_acc_list[4] += vpose_acc
loss_acc_list[5] += vobject_acc
loss_acc_list[6] += vhuman_acc
# Average over all validation chunks
loss_acc_list = [x / len(val_splits) for x in loss_acc_list]
with open(valcsvPath, 'a') as f:
writer = csv.writer(f)
# We consider accuracy as the average accuracy over the three
# types of accuracy
acc = (loss_acc_list[4] + loss_acc_list[5] +
loss_acc_list[6]) / 3
writer.writerow([
str(acc), loss_acc_list[4], loss_acc_list[5],
loss_acc_list[6], loss_acc_list[0], loss_acc_list[1],
loss_acc_list[2], loss_acc_list[3]
])
if loss_acc_list[0] < minValLoss:
print("New best loss " + str(loss_acc_list[0]))
model.save(bestModelPath)
minValLoss = loss_acc_list[0]
if params['email']:
utils.sendemail(from_addr='*****@*****.**',
to_addr_list=['*****@*****.**'],
subject='Finished training RGB-stream ',
message='Training RGB with following params: ' +
str(params),
login='******',
password='******')
# Tidal frequencies (cpd)
M2 = 24.0 / 12.4206012
S2 = 24.0 / 12.0
K1 = 24.0 / 23.93447213
moorings = load_data.load_my_data()
ca, cw = load_data.load_my_data_alt()
ca = munch.munchify(ca)
cw = munch.munchify(cw)
moorings = [munch.munchify(m) for m in moorings]
cc, nw, ne, se, sw = moorings
ADCP = utils.loadmat(os.path.join(data_in, "ADCP.mat"))
ADCP = munch.munchify(ADCP)
topo = utils.loadmat(os.path.join(data_in, "topo_info.mat"))
topo = munch.munchify(topo)
VMP = utils.loadmat(os.path.expanduser("../data/jc054_vmp_cleaned.mat"))["d"]
VMP = munch.munchify(VMP)
alt_file = os.path.expanduser(
"../data/dataset-duacs-rep-global-merged-allsat-phy-l4-v3_1514910227973.nc"
)
alt = xr.open_dataset(alt_file)
# %% [markdown]
# ## Map
mm = (60 * (hh % 1)).astype(int)
hh = np.floor(hh).astype(int)
w[:, i] = W / 100
dates = []
for j in range(len(YY)):
dates.append(datetime.datetime(YY[j], MM[j], DD[j], hh[j], mm[j]))
dates = np.asarray(dates)
datenum[:, i] = utils.datetime_to_datenum(dates)
idx_start = np.searchsorted(datenum[:, 0], t_start)
w = w[idx_start:idx_start + max_len]
# Start prepping raw data from the mat file.
print("Loading raw data file.")
data_path = os.path.join(data_in, raw_data_file)
ds = utils.loadmat(data_path)
cc = ds.pop("c")
nw = ds.pop("nw")
ne = ds.pop("ne")
se = ds.pop("se")
sw = ds.pop("sw")
cc["id"] = "cc"
nw["id"] = "nw"
ne["id"] = "ne"
se["id"] = "se"
sw["id"] = "sw"
moorings = [cc, nw, ne, se, sw]
import utils
############### PRELIMINARIES ################
# Parse command line arguments
args = clargs.parse_check_args()
sdroot = args.save
files = utils.find_files(args, "bathymetry")
params = utils.load_parameters()
############### LOAD DATA ################
print("Loading data. (---> This may trigger Dropbox download <---)")
print("Loading September 2018 bathymetry.")
b18 = munchify(utils.loadmat(files.sep2018, check_arrays=True, mat_dtype=True)["bathy"])
print("Loading September 2017 bathymetry.")
b17 = munchify(utils.loadmat(files.sep2017, check_arrays=True, mat_dtype=True)["bathy"])
print("Loading August 2016 bathymetry.")
b16 = munchify(utils.loadmat(files.aug2016, check_arrays=True, mat_dtype=True)["bathy"])
############### SEP 2018 ################
print("Processing September 2018.")
datavars = {
"H": (["lat", "lon"], b18.z, {"Variable": "Bottom depth"}),
}
coords = {
"lon": (["lon"], b18.lon),
"lat": (["lat"], b18.lat),
"x": (["lat", "lon"], b18.x, {"Variable": "UTM zonal distance"}),
def maybe_preprocess(config, data_path, sample_path=None):
if config.max_synthetic_num < 0:
max_synthetic_num = None
else:
max_synthetic_num = config.max_synthetic_num
# MPIIGaze dataset(real data)
base_path = os.path.join(
data_path, '{}/Data/Normalized'.format(config.real_image_dir))
npz_path = os.path.join(data_path, DATA_FNAME)
if not os.path.exists(npz_path):
mat_paths = []
for root, dirnames, filenames in os.walk(base_path):
for filename in fnmatch.filter(filenames, '*.mat'):
mat_paths.append(os.path.join(root, filename))
print("[*] Preprocessing real `gaze` data...")
real_images = []
for mat_path in tqdm(mat_paths):
mat = loadmat(mat_path)
# Left eye (batch_size, height, width)
real_images.extend(mat['data'][0][0][0][0][0][1])
# Right eye
real_images.extend(mat['data'][0][0][1][0][0][1])
#join a sequence of arrays along a new axis
real_data = np.stack(real_images, axis=0)
#save several arrays into a single file in uncompressed .npz format
np.savez(npz_path, real=real_data)
#====================End of processing real images================================
# UnityEyes dataset(synthetic data)
synthetic_image_path_candidates = [
config.synthetic_image_dir,
os.path.join(data_path, config.synthetic_image_dir),
]
for synthetic_image_path in synthetic_image_path_candidates:
#glob module finds all the pathnames matching a specified pattern according to
#the rules used by the Unix shell
jpg_paths = glob(os.path.join(synthetic_image_path, '*.jpg'))
cropped_jpg_paths = glob(
os.path.join(synthetic_image_path, '*_cropped.png'))
if len(jpg_paths) == 0:
print("[!] No images in ./{}. Skip.".format(synthetic_image_path))
continue
else:
print("[!] Found images in ./{}.".format(synthetic_image_path))
#enter this if statement only if number of jpg and cropped jpg are equal
if len(cropped_jpg_paths) != len(jpg_paths):
json_paths = glob(
os.path.join(
data_path,
'{}/*.json'.format(config.synthetic_image_dir)))
assert len(jpg_paths) >= max_synthetic_num, \
"[!] # of synthetic data ({}) is smaller than max_synthetic_num ({})". \
format(len(jpg_paths), max_synthetic_num)
json_paths = json_paths[:max_synthetic_num]
for json_path in tqdm(json_paths):
#replace 'json' to 'jpg'
jpg_path = json_path.replace('json', 'jpg')
#skip iteration if path name is not found
if not os.path.exists(jpg_path):
continue
with open(json_path) as json_f:
#read jpg file
img = imread(jpg_path)
#load information stored in json file
j = json.loads(json_f.read())
key = "interior_margin_2d"
j[key] = process_json_list(j[key], img)
x_min, x_max = int(min(j[key][:, 0])), int(
max(j[key][:, 0]))
y_min, y_max = int(min(j[key][:, 1])), int(
max(j[key][:, 1]))
x_center, y_center = (x_min + x_max) / 2, (y_min +
y_max) / 2
cropped_img = img[y_center - 42:y_center + 42,
x_center - 70:x_center + 70]
img_path = jpg_path.replace(".jpg", "_cropped.png")
save_array_to_grayscale_image(cropped_img, img_path)
jpg_paths = glob(os.path.join(synthetic_image_path, '*.jpg'))
cropped_jpg_paths = glob(
os.path.join(synthetic_image_path, '*_cropped.png'))
print("[*] # of synthetic data: {}, # of cropped_data: {}". \
format(len(jpg_paths), len(cropped_jpg_paths)))
print("[*] Finished preprocessing synthetic `gaze` data.")
return synthetic_image_path
raise Exception("[!] Failed to found proper synthetic_image_path in {}" \
.format(synthetic_image_path_candidates))
out = self.fc2(out)
return out
# Hyperparameters
num_epochs = 6
num_classes = 10
batch_size = 100
learning_rate = 0.001
#dataTypes = ['digits-normal.mat', 'digits-scaled.mat', 'digits-jitter.mat']
dataTypes = ['digits-normal.mat']
MODEL_STORE_PATH = '../data/'
for dataType in dataTypes:
path = os.path.join('..', 'data', dataType)
data = loadmat(path)
# Data loader
train_loader = DataLoader(dataset=train_dataset,
batch_size=batch_size,
shuffle=True)
test_loader = DataLoader(dataset=test_dataset,
batch_size=batch_size,
shuffle=False)
model = ConvNet()
# Loss and optimizer
criterion = nn.CrossEntropyLoss()
optimizer = torch.optim.Adam(model.parameters(), lr=learning_rate)
# Train the model
total_step = len(train_loader)
# You have to implement three types of features
#featureTypes = ['pixel', 'hog', 'lbp']
featureTypes = ['hog']
# Accuracy placeholder
accuracy = np.zeros((len(dataTypes), len(featureTypes)))
trainSet = 1
valSet = 2
testSet = 3
for i in range(len(dataTypes)):
dataType = dataTypes[i]
#Load data
path = os.path.join('..', 'data', dataType)
data = utils.loadmat(path)
print('+++ Loading digits of dataType: {}'.format(dataType))
print(data['x'].shape, data['y'].shape)
#data['x'] = (data['x'] - np.mean(data['x'], axis = 2,
# keepdims= True))/(np.std(data['x'], axis = 2, keepdims=True)+0.0001)
print(data['x'].shape)
# Optionally montage the digits in the val set
#montageDigits(data['x'][:, :, data['set']==2])
for j in range(len(featureTypes)):
featureType = featureTypes[j]
# Extract features
tic = time.time()
import matplotlib
import matplotlib.pyplot as plt
import numpy as np
import munch
import utils
import glob
import utm
import os
fig_dir = "../figures"
matplotlib.rc("font", size=7)
# %%
# Towyos separate
data_files = glob.glob("../proc_data/TY*.mat")
TYs = np.asarray([munch.munchify(utils.loadmat(file)) for file in data_files])
P5TYs = [TY for TY in TYs if ((TY.sill == "P5") and (TY.year == 2014))]
# Bathymetry
bathy = xr.open_dataset("../raw_data/merged_200_-171.5_-167.5_-11_-6.5.nc")
bathyP5 = bathy.isel(lon=(bathy.lon < -168.5) & (bathy.lon > -168.8), lat=(bathy.lat > -8.3) & (bathy.lat < -7.9))
data_file = "../raw_data/samoan_passage_bathymetry_200m_merged.mat"
B = munch.munchify(utils.loadmat(data_file)["bathy2"])
long, latg = np.meshgrid(B.lon, B.lat)
B.xg, B.yg, _, _ = utm.from_latlon(latg, long)
# Towyos together
ds = xr.open_dataset("../proc_data/stacked_towyos.nc")
OI = xr.open_dataset("../raw_data/non_divergent_OI_fields.nc")
# TG long wave analysis
pdd = "../data" fsd = "../figures" data_in = pdd M2 = 24.0 / 12.4206012 moorings = load_data.load_my_data() ca, cw = load_data.load_my_data_alt() ca = munch.munchify(ca) cw = munch.munchify(cw) moorings = [munch.munchify(m) for m in moorings] cc, nw, ne, se, sw = moorings ADCP = utils.loadmat(os.path.join(data_in, "ADCP.mat")) ADCP = munch.munchify(ADCP) topo = utils.loadmat(os.path.join(data_in, "topo_info.mat")) topo = munch.munchify(topo) # %% [markdown] # ## Time series and time mean of horizontal energy flux # %% Horizontal energy flux estimates t0 = 734619 t1 = 734639 ##################################### m = ca fig = plt.figure(figsize=(6.5, 4.5))
def main():
# root_dir = '../../../AVA2.1/' # root_dir for the files
root_dir = '../../data/AVA/files/'
# Erase previous models from GPU memory
K.clear_session()
# Load list of action classes and separate them
classes = utils.get_AVA_classes(root_dir + 'ava_action_list_custom.csv')
# Parameters for training
params = {
'dim': (224, 224),
'batch_size': 32,
'n_classes': len(classes['label_id']),
'n_channels': 3,
'shuffle': False,
'nb_epochs': 200,
'model': 'resnet50',
'email': True,
'freeze_all': True,
'conv_fusion': False,
'train_chunk_size': 2**12,
'validation_chunk_size': 2**12
}
soft_sigmoid = True
minValLoss = 9999990.0
# Get ID's and labels from the actual dataset
partition = {}
partition['train'] = get_AVA_set(
classes=classes,
filename=root_dir + "AVA_Train_Custom_Corrected.csv",
soft_sigmoid=soft_sigmoid) # IDs for training
partition['validation'] = get_AVA_set(
classes=classes,
filename=root_dir + "AVA_Val_Custom_Corrected.csv",
soft_sigmoid=soft_sigmoid) # IDs for validation
# Labels
labels_train = get_AVA_labels(classes,
partition,
"train",
filename=root_dir +
"AVA_Train_Custom_Corrected.csv",
soft_sigmoid=soft_sigmoid)
labels_val = get_AVA_labels(classes,
partition,
"validation",
filename=root_dir +
"AVA_Val_Custom_Corrected.csv",
soft_sigmoid=soft_sigmoid)
# http://scikit-learn.org/stable/modules/generated/sklearn.utils.class_weight.compute_class_weight.html
# Logistic Regression in Rare Events Data, Gary King, Langche Zeng
# Keras needs a dict though
# From documentation: class_weight: Optional dictionary mapping class indices (integers) to a weight (float) value, used for weighting the loss function (during training only).
# This can be useful to tell the model to "pay more attention" to samples from an under-represented class.
y = labels_to_numpy(labels_train)
penalizing_method = 'balanced'
mu = 0.7
# penalizing_method = 'weighted_log'
class_weights = np.zeros(30)
for i in y:
class_weights[i] += 1
max_class = max(class_weights)
for i in range(len(class_weights)):
if class_weights[i] != 0.0:
if penalizing_method == 'balanced':
print(
str(i) + " " + str(class_weights[i]) + " " +
str(len(y) / (class_weights[i])))
#class_weights[i] = len(y) / (class_weights[i])
class_weights[i] = max_class / (class_weights[i])
elif penalizing_method == 'weighted_log':
print(
str(i) + " " + str(class_weights[i]) + " " +
str(math.log(mu * len(y) / (class_weights[i]))))
class_weights[i] = math.log(mu * len(y) / (class_weights[i]))
else:
print(str(i) + " " + str(class_weights[i]) + " inf ")
class_weights[i] = 0.0
g = sns.barplot(x=[str(i) for i in range(len(class_weights))],
y=class_weights)
plt.xticks(rotation=-90)
plt.title("Class weights " + penalizing_method)
plt.grid(True)
plt.show()
class_dictionary = {}
print(len(class_weights))
for i in range(len(class_weights)):
class_dictionary[i] = class_weights[i]
print(class_dictionary)
it = iter(class_weights)
seclist = [
utils.POSE_CLASSES, utils.OBJ_HUMAN_CLASSES, utils.HUMAN_HUMAN_CLASSES
]
class_lists = [list(islice(it, 0, i)) for i in seclist]
print(class_lists)
# Create + compile model, load saved weights if they exist
saved_weights = None
# saved_weights = "../models/rgbextra_gauss_resnet50_1807250030.hdf5"
model, keras_layer_names = rgb_create_model(
classes=classes['label_id'],
soft_sigmoid=soft_sigmoid,
model_name=params['model'],
freeze_all=params['freeze_all'],
conv_fusion=params['conv_fusion'])
model = compile_model(model, soft_sigmoid=soft_sigmoid)
# TODO Experiment: 1. no initialization, 2. ucf initialization 3. kinetics initialization
initialization = True # Set to True to use initialization
kinetics_weights = ""
ucf_weights = "../models/ucf_keras/keras-ucf101-rgb-resnet50-newsplit.hdf5"
if saved_weights is not None:
model.load_weights(saved_weights)
else:
if initialization is True:
if ucf_weights is None:
print("Loading MConvNet weights: ")
if params['model'] == "resnet50":
ucf_weights = utils.loadmat(
"../models/ucf_matconvnet/ucf101-img-resnet-50-split1.mat"
)
utils.convert_resnet(model, ucf_weights)
model.save(
"../models/ucf_keras/keras-ucf101-rgb-resnet50-newsplit.hdf5"
)
if kinetics_weights is None:
if params['model'] == "inceptionv3":
print("Loading Keras weights: ")
keras_weights = [
"../models/kinetics_keras/tsn_rgb_params_names.pkl",
"../models/kinetics_keras/tsn_rgb_params.pkl"
]
utils.convert_inceptionv3(model, keras_weights,
keras_layer_names)
model.save(
"../models/kinetics_keras/keras-kinetics-rgb-inceptionv3.hdf5"
)
# Try to train on more than 1 GPU if possible
# try:
# print("Trying MULTI-GPU")
# model = multi_gpu_model(model)
print("Training set size: " + str(len(partition['train'])))
# Make spltis
train_splits = utils.make_chunks(original_list=partition['train'],
size=len(partition['train']),
chunk_size=params['train_chunk_size'])
val_splits = utils.make_chunks(original_list=partition['validation'],
size=len(partition['validation']),
chunk_size=params['validation_chunk_size'])
time_str = time.strftime("%y%m%d%H%M", time.localtime())
# TODO Don't forget to change your names :)
filter_type = "gauss"
bestModelPath = "../models/rgb_weightsfinal_" + filter_type + "_" + params[
'model'] + "_" + time_str + ".hdf5"
traincsvPath = "../loss_acc_plots/rgb_weightsfinal_train_" + filter_type + "_plot_" + params[
'model'] + "_" + time_str + ".csv"
valcsvPath = "../loss_acc_plots/rgb_weightsfinal_val_" + filter_type + "_plot_" + params[
'model'] + "_" + time_str + ".csv"
for epoch in range(params['nb_epochs']):
epoch_chunks_count = 0
for trainIDS in train_splits:
# Load and train
start_time = timeit.default_timer()
# -----------------------------------------------------------
x_val = y_val_pose = y_val_object = y_val_human = x_train = y_train_pose = y_train_object = y_train_human = None
x_train, y_train_pose, y_train_object, y_train_human = load_split(
trainIDS,
labels_train,
params['dim'],
params['n_channels'],
"train",
filter_type,
soft_sigmoid=soft_sigmoid)
y_t = []
y_t.append(
to_categorical(y_train_pose, num_classes=utils.POSE_CLASSES))
y_t.append(
utils.to_binary_vector(y_train_object,
size=utils.OBJ_HUMAN_CLASSES,
labeltype='object-human'))
y_t.append(
utils.to_binary_vector(y_train_human,
size=utils.HUMAN_HUMAN_CLASSES,
labeltype='human-human'))
history = model.fit(x_train,
y_t,
class_weight=class_lists,
batch_size=params['batch_size'],
epochs=1,
verbose=0)
utils.learning_rate_schedule(model, epoch, params['nb_epochs'])
# ------------------------------------------------------------
elapsed = timeit.default_timer() - start_time
print(
"Epoch " + str(epoch) + " chunk " + str(epoch_chunks_count) +
" (" + str(elapsed) + ") acc[pose,obj,human] = [" +
str(history.history['pred_pose_categorical_accuracy']) + "," +
str(history.history['pred_obj_human_categorical_accuracy']) +
"," +
str(history.history['pred_human_human_categorical_accuracy']) +
"] loss: " + str(history.history['loss']))
with open(traincsvPath, 'a') as f:
writer = csv.writer(f)
avg_acc = (
history.history['pred_pose_categorical_accuracy'][0] +
history.history['pred_obj_human_categorical_accuracy'][0] +
history.history['pred_human_human_categorical_accuracy'][0]
) / 3
writer.writerow([
str(avg_acc),
history.history['pred_pose_categorical_accuracy'],
history.history['pred_obj_human_categorical_accuracy'],
history.history['pred_human_human_categorical_accuracy'],
history.history['loss']
])
epoch_chunks_count += 1
# Load val_data
print("Validating data: ")
# global_loss, pose_loss, object_loss, human_loss, pose_acc, object_acc, human_acc
loss_acc_list = [0.0, 0.0, 0.0, 0.0, 0.0, 0.0, 0.0]
for valIDS in val_splits:
x_val = y_val_pose = y_val_object = y_val_human = x_train = y_train_pose = y_train_object = y_train_human = None
x_val, y_val_pose, y_val_object, y_val_human = load_split(
valIDS,
labels_val,
params['dim'],
params['n_channels'],
"val",
filter_type,
soft_sigmoid=soft_sigmoid)
y_v = []
y_v.append(
to_categorical(y_val_pose, num_classes=utils.POSE_CLASSES))
y_v.append(
utils.to_binary_vector(y_val_object,
size=utils.OBJ_HUMAN_CLASSES,
labeltype='object-human'))
y_v.append(
utils.to_binary_vector(y_val_human,
size=utils.HUMAN_HUMAN_CLASSES,
labeltype='human-human'))
# NOTE Can't have weights on validation
vglobal_loss, vpose_loss, vobject_loss, vhuman_loss, vpose_acc, vobject_acc, vhuman_acc = model.evaluate(
x_val, y_v, batch_size=params['batch_size'])
loss_acc_list[0] += vglobal_loss
loss_acc_list[1] += vpose_loss
loss_acc_list[2] += vobject_loss
loss_acc_list[3] += vhuman_loss
loss_acc_list[4] += vpose_acc
loss_acc_list[5] += vobject_acc
loss_acc_list[6] += vhuman_acc
# Average over all validation chunks
loss_acc_list = [x / len(val_splits) for x in loss_acc_list]
with open(valcsvPath, 'a') as f:
writer = csv.writer(f)
# We consider accuracy as the average accuracy over the three
# types of accuracy
acc = (loss_acc_list[4] + loss_acc_list[5] + loss_acc_list[6]) / 3
writer.writerow([
str(acc), loss_acc_list[4], loss_acc_list[5], loss_acc_list[6],
loss_acc_list[0], loss_acc_list[1], loss_acc_list[2],
loss_acc_list[3]
])
if loss_acc_list[0] < minValLoss:
print("New best loss " + str(loss_acc_list[0]))
model.save(bestModelPath)
minValLoss = loss_acc_list[0]
if params['email']:
utils.sendemail(
from_addr='*****@*****.**',
to_addr_list=['*****@*****.**'],
subject='Finished training RGB-stream with class_weights ' +
penalizing_method,
message='Training RGB with following params: ' + str(params),
login='******',
password='******')
def maybe_preprocess(config, data_path, sample_path=None):
if config.max_synthetic_num < 0:
max_synthetic_num = None
else:
max_synthetic_num = config.max_synthetic_num
# MPIIGaze dataset
base_path = os.path.join(
data_path, '{}/Data/Normalized'.format(config.real_image_dir))
npz_path = os.path.join(data_path, DATA_FNAME)
if not os.path.exists(npz_path):
mat_paths = []
for root, dirnames, filenames in os.walk(base_path):
for filename in fnmatch.filter(filenames, '*.mat'):
mat_paths.append(os.path.join(root, filename))
print("[*] Preprocessing real `gaze` data...")
real_images = []
for mat_path in tqdm(mat_paths):
mat = loadmat(mat_path)
# Left eye (batch_size, height, width)
real_images.extend(mat['data'][0][0][0][0][0][1])
# Right eye
real_images.extend(mat['data'][0][0][1][0][0][1])
real_data = np.stack(real_images, axis=0)
np.savez(npz_path, real=real_data)
# UnityEyes dataset
synthetic_image_path_candidates = [
config.synthetic_image_dir,
os.path.join(data_path, config.synthetic_image_dir),
]
for synthetic_image_path in synthetic_image_path_candidates:
jpg_paths = glob(os.path.join(synthetic_image_path, '*.jpg'))
cropped_jpg_paths = glob(
os.path.join(synthetic_image_path, '*_cropped.png'))
if len(jpg_paths) == 0:
print("[!] No images in ./{}. Skip.".format(synthetic_image_path))
continue
else:
print("[!] Found images in ./{}.".format(synthetic_image_path))
if len(cropped_jpg_paths) != len(jpg_paths):
json_paths = glob(
os.path.join(
data_path,
'{}/*.json'.format(config.synthetic_image_dir)))
#assert len(jpg_paths) >= max_synthetic_num, \
#"[!] # of synthetic data ({}) is smaller than max_synthetic_num ({})". \
#format(len(jpg_paths), max_synthetic_num)
json_paths = json_paths[:max_synthetic_num]
for json_path in tqdm(json_paths):
jpg_path = json_path.replace('json', 'jpg')
if not os.path.exists(jpg_path):
continue
with open(json_path) as json_f:
img = imread(jpg_path)
j = json.loads(json_f.read())
key = "interior_margin_2d"
j[key] = process_json_list(j[key], img)
x_min, x_max = int(min(j[key][:, 0])), int(
max(j[key][:, 0]))
y_min, y_max = int(min(j[key][:, 1])), int(
max(j[key][:, 1]))
x_center, y_center = int((x_min + x_max) / 2), int(
(y_min + y_max) / 2)
cropped_img = img[y_center - 42:y_center + 42,
x_center - 70:x_center + 70]
img_path = jpg_path.replace(".jpg", "_cropped.png")
save_array_to_grayscale_image(cropped_img, img_path)
jpg_paths = glob(os.path.join(synthetic_image_path, '*.jpg'))
cropped_jpg_paths = glob(
os.path.join(synthetic_image_path, '*_cropped.png'))
print("[*] # of synthetic data: {}, # of cropped_data: {}". \
format(len(jpg_paths), len(cropped_jpg_paths)))
print("[*] Finished preprocessing synthetic `gaze` data.")
return synthetic_image_path
raise Exception("[!] Failed to found proper synthetic_image_path in {}" \
.format(synthetic_image_path_candidates))
[-z0, -z1
]) # Minus needed because z array is monotonically decreasing.
# Fill stacked array, the +1 is needed because of the way searchsorted returns indices on the left.
vara[i0:i1 + 1, j0:j1] = TY[var]
j0 = j1
return vara
if __name__ == "__main__":
# Load processed towyos.
data_dir = "../proc_data"
data_files = glob.glob(data_dir + "/TY*.mat")
TYs = np.asarray(
[munch.munchify(utils.loadmat(file)) for file in data_files])
# Get P5 towyos from 2014.
TYs_ = [TY for TY in TYs if ((TY.sill == "P5") and (TY.year == 2014))]
zmin = np.min([TY.z.min() for TY in TYs_])
zmax = np.max([TY.z.max() for TY in TYs_])
npfls = np.sum([TY.mlon.shape[0] for TY in TYs_])
idxa = np.arange(npfls)
dz = -1.
z = np.arange(zmax, zmin + dz, dz)
nz = len(z)
datavars = {}
