def st_loocv(df_train, df_test, bitrate_model_handle, trainer_handle):
"""Validate spatio-temporal parameter performance using loocv"""
trainer_loo = trainer_handle(df_train, bitrate_model_handle, ModelParameter())
p_loo = trainer_loo.train_cf()
p_expected = trainer_handle(
df_test, bitrate_model_handle, ModelParameter()
).train_cf()
return trainer_handle(df_test, bitrate_model_handle, ModelParameter()).validate_st(
p_expected, trainer_loo.train_st(p_loo)
)
def e_st_loocv_handle(df_train, df_test, bitrate_model_handle):
"""Validate spatio-temporal parameter performance of e using loocv"""
trainer_loo = NCFTrainer(df_train, bitrate_model_handle, ModelParameter())
e_loo = NCFTrainer.split_c_d_e(trainer_loo.train_cf())[2]
e_expected = NCFTrainer.split_c_d_e(
NCFTrainer(df_test, bitrate_model_handle, ModelParameter()).train_cf()
)[2]
return NCFTrainer(df_test, bitrate_model_handle, ModelParameter()).validate_e_st(
e_expected, trainer_loo.train_e_st(e_loo)
)
def v_st_loocv_handle(df_train, df_test, bitrate_model_handle):
"""Validate spatio-temporal parameter performance of v using loocv"""
trainer_loo = SDCFTrainer(df_train, bitrate_model_handle, ModelParameter())
v_loo = SDCFTrainer.split_t_u_v(trainer_loo.train_cf())[2]
v_expected = SDCFTrainer.split_t_u_v(
SDCFTrainer(df_test, bitrate_model_handle, ModelParameter()).train_cf()
)[2]
return SDCFTrainer(df_test, bitrate_model_handle, ModelParameter()).validate_v_st(
v_expected, trainer_loo.train_v_st(v_loo)
)
def o_st_loocv_handle(df_train, df_test, bitrate_model_handle):
"""Validate spatio-temporal parameter performance of o using loocv"""
trainer_loo = GCFTrainer(df_train, bitrate_model_handle, ModelParameter())
o_loo = GCFTrainer.split_l_m_o(trainer_loo.train_cf())[2]
o_expected = GCFTrainer.split_l_m_o(
GCFTrainer(df_test, bitrate_model_handle, ModelParameter()).train_cf()
)[2]
return GCFTrainer(df_test, bitrate_model_handle, ModelParameter()).validate_o_st(
o_expected, trainer_loo.train_o_st(o_loo)
)
class ModelDictAction(argparse.Action):
"""Map the bitrate model and parameter to a simple text that can used with the CLI"""
VALUE_DICT = {
"x264": (BitrateModel, ModelParameter()),
"lottermann": (
LottermannBitrateModel1,
ModelParameter(
alpha=[2.0129, -0.0004, -4.6158],
beta=[0.1334, -0.3072],
rho=[0.8149, 139.4017],
),
),
"lottermann-gop": (
LottermannBitrateModel2,
ModelParameter(
alpha=[-0.0492, 4.8648, -14.3861],
beta=[1],
gamma=[-0.0108, 0.9473],
delta=[1],
epsilon=[0.0011, 1.0200, -0.0598],
rho=[1.3190, 31.7481, -210.6505],
),
),
"ma": (
MaBitrateModel,
ModelParameter(
alpha=[1.1406, -0.0330, -0.0611, 0.1408],
beta=[0.4462, 0.0112, 0.0680, -0.0667],
rho=[67.73, 49.45, 281.7, -245.6],
),
),
}
def __call__(self, arg_parser, namespace, values, option_string=None):
setattr(namespace, self.dest, self.VALUE_DICT.get(values))
def r_max_loocv_handle(df_train, df_test, bitrate_model_handle):
"""Validate rmax performance using loocv"""
rho_loo = RMaxTrainer(df_train, bitrate_model_handle, ModelParameter()).train()
return RMaxTrainer(df_test, bitrate_model_handle, ModelParameter()).validate(
rho_loo
)
def train(dfw, model_handle, init_model_parameter):
"""
Train all supported correction factors
"""
print("Starting training...")
rho_min = train_correction_factor("Rmax", dfw.include(), RMaxTrainer,
model_handle, init_model_parameter)
alpha_min = train_correction_factor(
"SCF",
dfw.include(variable_qp=True),
SCFTrainer,
model_handle,
init_model_parameter,
)
beta_min = train_correction_factor(
"TCF",
dfw.include(variable_rate=True),
TCFTrainer,
model_handle,
init_model_parameter,
)
gop_param_min = train_correction_factor(
"NCF",
dfw.include(variable_gop=True),
NCFTrainer,
model_handle,
init_model_parameter,
)
phi_min = train_correction_factor(
"RCF",
dfw.include(variable_res=True),
RCFTrainer,
model_handle,
init_model_parameter,
)
gauss_param_min = train_correction_factor(
"GCF",
dfw.include(variable_k_size=True),
GCFTrainer,
model_handle,
init_model_parameter,
)
df_gauss = dfw.include(variable_k_size=True, variable_sigma=True)
sigma_param_min = train_correction_factor(
"SSCF",
df_gauss.loc[df_gauss[KEYS.KSIZE] == 3],
SDCFTrainer,
model_handle,
init_model_parameter,
)
return ModelParameter(
rho=rho_min,
alpha=alpha_min,
beta=beta_min,
gamma=gop_param_min[0],
delta=gop_param_min[1],
epsilon=gop_param_min[2],
phi=phi_min,
lambda_=gauss_param_min[0],
mu=gauss_param_min[1],
omega=gauss_param_min[2],
tau=sigma_param_min[0],
upsilon=sigma_param_min[1],
nu=sigma_param_min[2],
)